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

package/dist/node/index.cjs

@@ -30,7 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AUTO_COMPACT_THRESHOLD_SETTINGS_KEY: () => AUTO_COMPACT_THRESHOLD_SETTINGS_KEY,
   AgentExecutor: () => AgentExecutor,
+  BACKGROUND_COMMAND_DESCRIPTION: () => BACKGROUND_COMMAND_DESCRIPTION,
+  BACKGROUND_COMMAND_USAGE: () => BACKGROUND_COMMAND_USAGE,
   BUILT_IN_AGENTS: () => BUILT_IN_AGENTS,
   BackgroundJobOrchestrator: () => BackgroundJobOrchestrator,
   BackgroundTaskError: () => import_agent_runtime5.BackgroundTaskError,
@@ -38,71 +41,178 @@ __export(index_exports, {
   BuiltinCommandSource: () => BuiltinCommandSource,
   BundlePluginInstaller: () => BundlePluginInstaller,
   BundlePluginLoader: () => BundlePluginLoader,
+  CLEAR_COMMAND_DESCRIPTION: () => CLEAR_COMMAND_DESCRIPTION,
+  COST_COMMAND_DESCRIPTION: () => COST_COMMAND_DESCRIPTION,
   CommandRegistry: () => CommandRegistry,
+  DEFAULT_AUTO_COMPACT_THRESHOLD: () => DEFAULT_AUTO_COMPACT_THRESHOLD,
+  DEFAULT_STATUS_LINE_COMMAND_SETTINGS: () => DEFAULT_STATUS_LINE_COMMAND_SETTINGS,
+  EXIT_COMMAND_DESCRIPTION: () => EXIT_COMMAND_DESCRIPTION,
   EditCheckpointStore: () => EditCheckpointStore,
+  HELP_COMMAND_DESCRIPTION: () => HELP_COMMAND_DESCRIPTION,
   InteractiveSession: () => InteractiveSession,
+  LANGUAGE_COMMAND_ARGUMENT_HINT: () => LANGUAGE_COMMAND_ARGUMENT_HINT,
+  LANGUAGE_COMMAND_DESCRIPTION: () => LANGUAGE_COMMAND_DESCRIPTION,
+  MEMORY_COMMAND_ARGUMENT_HINT: () => MEMORY_COMMAND_ARGUMENT_HINT,
+  MEMORY_COMMAND_DESCRIPTION: () => MEMORY_COMMAND_DESCRIPTION,
+  MEMORY_COMMAND_USAGE: () => MEMORY_COMMAND_USAGE,
   MEMORY_INDEX_MAX_BYTES: () => MEMORY_INDEX_MAX_BYTES,
   MEMORY_INDEX_MAX_LINES: () => MEMORY_INDEX_MAX_LINES,
+  MODEL_COMMAND_ARGUMENT_HINT: () => MODEL_COMMAND_ARGUMENT_HINT,
+  MODEL_COMMAND_DESCRIPTION: () => MODEL_COMMAND_DESCRIPTION,
   MarketplaceClient: () => MarketplaceClient,
+  PERMISSIONS_COMMAND_DESCRIPTION: () => PERMISSIONS_COMMAND_DESCRIPTION,
+  PERMISSION_MODE_ARGUMENT_HINT: () => PERMISSION_MODE_ARGUMENT_HINT,
+  PERMISSION_MODE_COMMAND_DESCRIPTION: () => PERMISSION_MODE_COMMAND_DESCRIPTION,
+  PLUGIN_COMMAND_ARGUMENT_HINT: () => PLUGIN_COMMAND_ARGUMENT_HINT,
+  PLUGIN_COMMAND_DESCRIPTION: () => PLUGIN_COMMAND_DESCRIPTION,
   PluginCommandSource: () => PluginCommandSource,
   PluginSettingsStore: () => PluginSettingsStore,
   ProjectMemoryStore: () => ProjectMemoryStore,
   PromptExecutor: () => PromptExecutor,
+  RECOMMENDED_RESPONSE_LANGUAGES: () => RECOMMENDED_RESPONSE_LANGUAGES,
+  RELOAD_PLUGINS_COMMAND_DESCRIPTION: () => RELOAD_PLUGINS_COMMAND_DESCRIPTION,
+  RENAME_COMMAND_DESCRIPTION: () => RENAME_COMMAND_DESCRIPTION,
+  RENAME_COMMAND_USAGE: () => RENAME_COMMAND_USAGE,
+  RESUME_COMMAND_DESCRIPTION: () => RESUME_COMMAND_DESCRIPTION,
+  REWIND_COMMAND_ARGUMENT_HINT: () => REWIND_COMMAND_ARGUMENT_HINT,
+  REWIND_COMMAND_DESCRIPTION: () => REWIND_COMMAND_DESCRIPTION,
+  STATUSLINE_COMMAND_ARGUMENT_HINT: () => STATUSLINE_COMMAND_ARGUMENT_HINT,
+  STATUSLINE_COMMAND_DESCRIPTION: () => STATUSLINE_COMMAND_DESCRIPTION,
   SkillCommandSource: () => SkillCommandSource,
   SubagentManager: () => import_agent_runtime7.SubagentManager,
   SystemCommandExecutor: () => SystemCommandExecutor,
-  TRUST_TO_MODE: () => import_agent_core5.TRUST_TO_MODE,
+  TRUST_TO_MODE: () => import_agent_core8.TRUST_TO_MODE,
+  VALID_PERMISSION_MODES: () => VALID_PERMISSION_MODES,
   WorktreeSubagentRunner: () => import_agent_runtime8.WorktreeSubagentRunner,
   assembleSubagentPrompt: () => assembleSubagentPrompt,
+  buildBackgroundCommandSubcommands: () => buildBackgroundCommandSubcommands,
+  buildLanguageCommandSubcommands: () => buildLanguageCommandSubcommands,
+  buildMemoryCommandSubcommands: () => buildMemoryCommandSubcommands,
+  buildModelCommandSubcommands: () => buildModelCommandSubcommands,
+  buildPermissionModeSubcommands: () => buildPermissionModeSubcommands,
+  buildPluginCommandSubcommands: () => buildPluginCommandSubcommands,
+  buildProviderProfile: () => buildProviderProfile,
+  buildProviderSetupPatch: () => buildProviderSetupPatch,
+  buildRewindCommandSubcommands: () => buildRewindCommandSubcommands,
   buildSkillPrompt: () => buildSkillPrompt,
-  chatEntryToMessage: () => import_agent_core6.chatEntryToMessage,
+  buildStatusLineCommandSubcommands: () => buildStatusLineCommandSubcommands,
+  cancelCommandBackgroundTask: () => cancelCommandBackgroundTask,
+  chatEntryToMessage: () => import_agent_core9.chatEntryToMessage,
+  clearConversationHistory: () => clearConversationHistory,
+  closeCommandBackgroundTask: () => closeCommandBackgroundTask,
+  compactCommandContext: () => compactCommandContext,
   createAgentTool: () => createAgentTool,
   createBackgroundProcessTool: () => createBackgroundProcessTool,
+  createBuiltinCommandModule: () => createBuiltinCommandModule,
   createCommandExecutionTool: () => createCommandExecutionTool,
+  createCommandMemoryStores: () => createCommandMemoryStores,
+  createCommandPendingMemoryStore: () => createCommandPendingMemoryStore,
+  createCommandProjectMemoryStore: () => createCommandProjectMemoryStore,
   createDefaultTools: () => createDefaultTools,
+  createPluginRegistryReloadRequestedEffect: () => createPluginRegistryReloadRequestedEffect,
+  createPluginTuiRequestedEffect: () => createPluginTuiRequestedEffect,
+  createProviderSetupFlow: () => createProviderSetupFlow,
   createQuery: () => createQuery,
+  createSessionExitRequestedEffect: () => createSessionExitRequestedEffect,
+  createSessionPickerRequestedEffect: () => createSessionPickerRequestedEffect,
+  createSessionRenamedEffect: () => createSessionRenamedEffect,
   createSubagentLogger: () => createSubagentLogger,
   createSubagentSession: () => createSubagentSession,
   createSystemCommands: () => createSystemCommands,
   createWorktreeSubagentRunner: () => import_agent_runtime8.createWorktreeSubagentRunner,
   discoverTaskFiles: () => discoverTaskFiles,
-  evaluatePermission: () => import_agent_core7.evaluatePermission,
+  evaluatePermission: () => import_agent_core10.evaluatePermission,
+  evaluateReversibleToolSafety: () => evaluateReversibleToolSafety,
   executeSkill: () => executeSkill,
+  formatCommandBackgroundTask: () => formatCommandBackgroundTask,
+  formatCommandBackgroundTaskList: () => formatCommandBackgroundTaskList,
+  formatCommandHelpMessage: () => formatCommandHelpMessage,
+  formatCommandPermissionsMessage: () => formatCommandPermissionsMessage,
+  formatEnvReference: () => formatEnvReference,
+  formatInvalidPermissionModeMessage: () => formatInvalidPermissionModeMessage,
+  formatLanguageUsageMessage: () => formatLanguageUsageMessage,
+  formatProviderSetupChoiceLabel: () => formatProviderSetupChoiceLabel,
+  formatProviderSetupPromptLabel: () => formatProviderSetupPromptLabel,
+  formatProviderSetupSelectionPrompt: () => formatProviderSetupSelectionPrompt,
   formatTaskContext: () => formatTaskContext,
   getBackgroundTaskTransitions: () => import_agent_runtime4.getBackgroundTaskTransitions,
   getBuiltInAgent: () => getBuiltInAgent,
   getForkWorkerSuffix: () => getForkWorkerSuffix,
-  getMessagesForAPI: () => import_agent_core6.getMessagesForAPI,
+  getMessagesForAPI: () => import_agent_core9.getMessagesForAPI,
+  getProviderSetupStep: () => getProviderSetupStep,
   getSubagentSuffix: () => getSubagentSuffix,
-  isChatEntry: () => import_agent_core6.isChatEntry,
+  hasSensitiveCommandMemoryContent: () => hasSensitiveCommandMemoryContent,
+  hasUsableSecretReference: () => hasUsableSecretReference,
+  inspectCommandEditCheckpoint: () => inspectCommandEditCheckpoint,
+  isChatEntry: () => import_agent_core9.isChatEntry,
+  isCommandMemoryType: () => isCommandMemoryType,
+  isEnvReference: () => isEnvReference,
   isMemoryType: () => isMemoryType,
+  isPermissionMode: () => isPermissionMode,
+  isStatusLineCommandSettingsPatch: () => isStatusLineCommandSettingsPatch,
   isTerminalBackgroundTaskStatus: () => import_agent_runtime4.isTerminalBackgroundTaskStatus,
+  listCommandBackgroundTasks: () => listCommandBackgroundTasks,
+  listCommandEditCheckpoints: () => listCommandEditCheckpoints,
+  listCommandSessionAllowedTools: () => listCommandSessionAllowedTools,
+  listCommandUsedMemoryReferences: () => listCommandUsedMemoryReferences,
   loadTaskContext: () => loadTaskContext,
-  messageToHistoryEntry: () => import_agent_core6.messageToHistoryEntry,
+  mergeProviderPatch: () => mergeProviderPatch,
+  messageToHistoryEntry: () => import_agent_core9.messageToHistoryEntry,
+  parseCommandBackgroundLogCursor: () => parseCommandBackgroundLogCursor,
   parseFrontmatter: () => parseFrontmatter,
+  parseLanguageArgument: () => parseLanguageArgument,
+  parsePermissionModeArgument: () => parsePermissionModeArgument,
+  parseSessionNameArgument: () => parseSessionNameArgument,
   parseTaskFile: () => parseTaskFile,
   planSelfHostingVerification: () => planSelfHostingVerification,
   preprocessShellCommands: () => preprocessShellCommands,
+  probeProviderProfile: () => probeProviderProfile,
   projectPaths: () => projectPaths,
   promptForApproval: () => promptForApproval,
+  readAutoCompactThreshold: () => readAutoCompactThreshold,
+  readAutoCompactThresholdSource: () => readAutoCompactThresholdSource,
+  readCommandBackgroundTaskLog: () => readCommandBackgroundTaskLog,
+  readCommandContextState: () => readCommandContextState,
+  readCommandPermissionMode: () => readCommandPermissionMode,
+  readCommandPermissionsState: () => readCommandPermissionsState,
+  readCommandSessionInfo: () => readCommandSessionInfo,
   readCurrentGitBranch: () => readCurrentGitBranch,
+  recordCommandMemoryEvent: () => recordCommandMemoryEvent,
+  resetAutoCompactThresholdSetting: () => resetAutoCompactThresholdSetting,
+  resolveEnvReference: () => resolveEnvReference,
+  resolvePermissionModeAdapter: () => resolvePermissionModeAdapter,
+  resolvePluginCommandAdapter: () => resolvePluginCommandAdapter,
+  resolveProviderSetupSelection: () => resolveProviderSetupSelection,
   resolveSubagentLogDir: () => resolveSubagentLogDir,
+  restoreCommandEditCheckpoint: () => restoreCommandEditCheckpoint,
   retrieveAgentToolDeps: () => retrieveAgentToolDeps,
-  runHooks: () => import_agent_core8.runHooks,
+  rollbackCommandEditCheckpoint: () => rollbackCommandEditCheckpoint,
+  runHooks: () => import_agent_core11.runHooks,
+  runProviderSetupPromptFlow: () => runProviderSetupPromptFlow,
   selectRelevantTasks: () => selectRelevantTasks,
+  setCommandAutoCompactThreshold: () => setCommandAutoCompactThreshold,
+  setCurrentProvider: () => setCurrentProvider,
   storeAgentToolDeps: () => storeAgentToolDeps,
+  submitProviderSetupValue: () => submitProviderSetupValue,
   substituteVariables: () => substituteVariables,
   summarizeBackgroundJobGroup: () => summarizeBackgroundJobGroup,
+  testProviderProfileCommand: () => testProviderProfileCommand,
   transitionBackgroundTaskStatus: () => import_agent_runtime4.transitionBackgroundTaskStatus,
   transitionSelfHostingLoop: () => transitionSelfHostingLoop,
   updateTaskFileStatus: () => updateTaskFileStatus,
+  upsertProviderProfile: () => upsertProviderProfile,
   userPaths: () => userPaths,
-  wrapEditCheckpointTools: () => wrapEditCheckpointTools
+  validateProviderProfile: () => validateProviderProfile,
+  validateProviderSetupValue: () => validateProviderSetupValue,
+  wrapEditCheckpointTools: () => wrapEditCheckpointTools,
+  wrapReversibleExecutionTools: () => wrapReversibleExecutionTools,
+  writeAutoCompactThresholdSetting: () => writeAutoCompactThresholdSetting,
+  writeCommandPermissionMode: () => writeCommandPermissionMode
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/interactive/interactive-session.ts
-var import_agent_core4 = require("@robota-sdk/agent-core");
+var import_agent_core7 = require("@robota-sdk/agent-core");
 
 // src/commands/capability-descriptors.ts
 function inferKind(command) {
@@ -129,6 +239,12 @@ var CommandRegistry = class {
   addSource(source) {
     this.sources.push(source);
   }
+  replaceSource(name, source) {
+    this.sources = this.sources.filter((candidate) => candidate.name !== name);
+    if (source !== void 0) {
+      this.sources.push(source);
+    }
+  }
   addModule(module2) {
     for (const source of module2.commandSources ?? []) {
       this.addSource(source);
@@ -169,138 +285,222 @@ var CommandRegistry = class {
   }
 };
 
+// src/commands/system-command-executor.ts
+var SystemCommandExecutor = class {
+  commands;
+  constructor(commands) {
+    this.commands = /* @__PURE__ */ new Map();
+    for (const cmd of commands ?? createSystemCommands()) {
+      this.commands.set(cmd.name, cmd);
+    }
+  }
+  /** Register an additional command. */
+  register(command) {
+    this.commands.set(command.name, command);
+  }
+  /** Execute a command by name. Returns null if command not found. */
+  async execute(name, session, args) {
+    const cmd = this.getCommand(name);
+    if (!cmd) return null;
+    return await this.executeCommand(cmd, session, args);
+  }
+  getCommand(name) {
+    return this.commands.get(name);
+  }
+  async executeCommand(command, session, args) {
+    return await command.execute(session, args);
+  }
+  /** List all registered commands. */
+  listCommands() {
+    return [...this.commands.values()];
+  }
+  listModelInvocableCommands() {
+    return this.listCommands().filter((command) => command.modelInvocable === true).map((command) => ({
+      name: `/${command.name}`,
+      kind: "builtin-command",
+      description: command.description,
+      userInvocable: command.userInvocable !== false,
+      modelInvocable: true,
+      ...command.argumentHint ? { argumentHint: command.argumentHint } : {},
+      ...command.safety ? { safety: command.safety } : {}
+    }));
+  }
+  isModelInvocable(name) {
+    return this.commands.get(name)?.modelInvocable === true;
+  }
+  async executeModelInvocable(name, session, args) {
+    if (!this.isModelInvocable(name)) return null;
+    return this.execute(name, session, args);
+  }
+  /** Check if a command exists. */
+  hasCommand(name) {
+    return this.commands.has(name);
+  }
+};
+
+// src/commands/system-command.ts
+function createSystemCommands() {
+  return [];
+}
+
 // src/commands/builtin-source.ts
+function commandToPaletteEntry(command) {
+  return {
+    name: command.name,
+    description: command.description,
+    source: "builtin",
+    ...command.subcommands ? { subcommands: [...command.subcommands] } : {},
+    ...command.argumentHint ? { argumentHint: command.argumentHint } : {},
+    ...command.modelInvocable !== void 0 ? { modelInvocable: command.modelInvocable } : {},
+    ...command.userInvocable !== void 0 ? { userInvocable: command.userInvocable } : {},
+    ...command.safety ? { safety: command.safety } : {}
+  };
+}
+var BuiltinCommandSource = class {
+  name = "builtin";
+  commands;
+  constructor(systemCommands = createSystemCommands()) {
+    this.commands = systemCommands.map(commandToPaletteEntry);
+  }
+  getCommands() {
+    return this.commands;
+  }
+};
+function createBuiltinCommandModule() {
+  const systemCommands = createSystemCommands();
+  return {
+    name: "sdk-builtin",
+    commandSources: [new BuiltinCommandSource(systemCommands)],
+    systemCommands
+  };
+}
+
+// src/command-api/provider/provider-command-probe.ts
+var import_agent_core2 = require("@robota-sdk/agent-core");
+
+// src/command-api/provider/provider-settings.ts
 var import_agent_core = require("@robota-sdk/agent-core");
-function buildModelSubcommands() {
-  const seen = /* @__PURE__ */ new Set();
-  const commands = [];
-  for (const model of Object.values(import_agent_core.CLAUDE_MODELS)) {
-    if (seen.has(model.name)) continue;
-    seen.add(model.name);
-    commands.push({
-      name: model.id,
-      description: `${model.name} (${(0, import_agent_core.formatTokenCount)(model.contextWindow).toUpperCase()})`,
-      source: "builtin"
-    });
+
+// src/command-api/provider/provider-env-ref.ts
+var ENV_REFERENCE_PREFIX = "$ENV:";
+function isEnvReference(value) {
+  return value.startsWith(ENV_REFERENCE_PREFIX);
+}
+function formatEnvReference(name) {
+  return `${ENV_REFERENCE_PREFIX}${name}`;
+}
+function resolveEnvReference(value) {
+  if (!isEnvReference(value)) {
+    return value;
   }
-  return commands;
+  const envName = value.slice(ENV_REFERENCE_PREFIX.length).trim();
+  if (envName.length === 0) {
+    return void 0;
+  }
+  return process.env[envName];
 }
-function buildProviderSubcommands() {
-  return [
-    { name: "current", description: "Show current provider", source: "builtin" },
-    { name: "list", description: "List provider profiles", source: "builtin" },
-    { name: "use", description: "Switch provider profile", source: "builtin" },
-    { name: "test", description: "Test provider profile", source: "builtin" }
-  ];
+function hasUsableSecretReference(value) {
+  if (value === void 0 || value.length === 0) {
+    return false;
+  }
+  return resolveEnvReference(value) !== void 0;
 }
-function buildBackgroundSubcommands() {
-  return [
-    { name: "list", description: "List background tasks", source: "builtin" },
-    { name: "read", description: "Read a background task log page", source: "builtin" },
-    { name: "cancel", description: "Cancel a running background task", source: "builtin" },
-    { name: "close", description: "Dismiss a terminal background task", source: "builtin" }
-  ];
+
+// src/command-api/provider/provider-settings.ts
+function upsertProviderProfile(settings, profileName, profile) {
+  return {
+    ...settings,
+    providers: {
+      ...settings.providers ?? {},
+      [profileName]: profile
+    }
+  };
 }
-function buildRewindSubcommands() {
-  return [
-    { name: "list", description: "List edit checkpoints", source: "builtin" },
-    { name: "restore", description: "Restore code to a checkpoint", source: "builtin" },
-    { name: "code", description: "Restore code to a checkpoint", source: "builtin" }
-  ];
+function setCurrentProvider(settings, profileName) {
+  if (!settings.providers?.[profileName]) {
+    throw new Error(`Provider profile "${profileName}" was not found`);
+  }
+  return {
+    ...settings,
+    currentProvider: profileName
+  };
 }
-function buildMemorySubcommands() {
-  return [
-    { name: "list", description: "List project memory topics", source: "builtin" },
-    { name: "show", description: "Show project memory index or a topic", source: "builtin" },
-    { name: "add", description: "Save durable project memory", source: "builtin" },
-    { name: "pending", description: "List pending memory candidates", source: "builtin" },
-    { name: "approve", description: "Approve a pending memory candidate", source: "builtin" },
-    { name: "reject", description: "Reject a pending memory candidate", source: "builtin" },
-    {
-      name: "used",
-      description: "Show memory references used in the current turn",
-      source: "builtin"
+function validateProviderProfile(profileName, profile, options = {}) {
+  if (!profile.type) {
+    throw new Error(`Provider profile "${profileName}" is missing type`);
+  }
+  if (!profile.model) {
+    throw new Error(`Provider profile "${profileName}" is missing model`);
+  }
+  const definition = (0, import_agent_core.findProviderDefinition)(options.providerDefinitions ?? [], profile.type);
+  if (definition?.requiresApiKey === true && !hasUsableSecretReference(profile.apiKey ?? definition.defaults?.apiKey)) {
+    throw new Error(`Provider profile "${profileName}" is missing apiKey`);
+  }
+}
+function buildProviderSetupPatch(input, options = {}) {
+  const profile = buildProviderProfile(input, options);
+  validateProviderProfile(input.profile, profile, options);
+  return {
+    ...input.setCurrent && { currentProvider: input.profile },
+    providers: {
+      [input.profile]: profile
     }
-  ];
+  };
 }
-function createBuiltinCommands() {
-  return [
-    { name: "help", description: "Show available commands", source: "builtin" },
-    { name: "clear", description: "Clear conversation history", source: "builtin" },
-    {
-      name: "mode",
-      description: "Permission mode",
-      source: "builtin",
-      subcommands: [
-        { name: "plan", description: "Plan only, no execution", source: "builtin" },
-        { name: "default", description: "Ask before risky actions", source: "builtin" },
-        { name: "acceptEdits", description: "Auto-approve file edits", source: "builtin" },
-        { name: "bypassPermissions", description: "Skip all permission checks", source: "builtin" }
-      ]
-    },
-    {
-      name: "model",
-      description: "Select AI model",
-      source: "builtin",
-      subcommands: buildModelSubcommands()
-    },
-    {
-      name: "language",
-      description: "Set response language",
-      source: "builtin",
-      subcommands: [
-        { name: "ko", description: "Korean", source: "builtin" },
-        { name: "en", description: "English", source: "builtin" },
-        { name: "ja", description: "Japanese", source: "builtin" },
-        { name: "zh", description: "Chinese", source: "builtin" }
-      ]
-    },
-    { name: "compact", description: "Compress context window", source: "builtin" },
-    { name: "cost", description: "Show session info", source: "builtin" },
-    { name: "context", description: "Context window info", source: "builtin" },
-    { name: "permissions", description: "Permission rules", source: "builtin" },
-    {
-      name: "memory",
-      description: "Inspect, save, review, and audit project memory",
-      source: "builtin",
-      subcommands: buildMemorySubcommands()
-    },
-    {
-      name: "rewind",
-      description: "List and restore edit checkpoints",
-      source: "builtin",
-      subcommands: buildRewindSubcommands()
-    },
-    {
-      name: "provider",
-      description: "Manage provider profiles",
-      source: "builtin",
-      subcommands: buildProviderSubcommands()
-    },
-    { name: "resume", description: "Resume a previous session", source: "builtin" },
-    {
-      name: "background",
-      description: "List and control background tasks",
-      source: "builtin",
-      subcommands: buildBackgroundSubcommands()
-    },
-    { name: "rename", description: "Rename the current session", source: "builtin" },
-    { name: "plugin", description: "Manage plugins", source: "builtin" },
-    { name: "reload-plugins", description: "Reload all plugin resources", source: "builtin" },
-    { name: "reset", description: "Delete settings and exit", source: "builtin" },
-    { name: "exit", description: "Exit CLI", source: "builtin" }
-  ];
+function buildProviderProfile(input, options = {}) {
+  const defaults = getProviderDefaults(input.type, options.providerDefinitions ?? []);
+  const apiKey = input.apiKeyEnv !== void 0 ? formatEnvReference(input.apiKeyEnv) : input.apiKey ?? defaults.apiKey;
+  const baseURL = input.baseURL ?? defaults.baseURL;
+  return {
+    type: input.type,
+    model: input.model ?? defaults.model,
+    ...apiKey !== void 0 && { apiKey },
+    ...baseURL !== void 0 && { baseURL },
+    ...input.timeout !== void 0 && { timeout: input.timeout }
+  };
 }
-var BuiltinCommandSource = class {
-  name = "builtin";
-  commands;
-  constructor() {
-    this.commands = createBuiltinCommands();
+function mergeProviderPatch(settings, patch) {
+  const [profileName, profile] = Object.entries(patch.providers)[0] ?? [];
+  if (!profileName || !profile) {
+    return settings;
   }
-  getCommands() {
-    return this.commands;
+  const withProfile = upsertProviderProfile(settings, profileName, profile);
+  return patch.currentProvider ? setCurrentProvider(withProfile, patch.currentProvider) : withProfile;
+}
+function getProviderDefaults(type, providerDefinitions) {
+  return (0, import_agent_core.findProviderDefinition)(providerDefinitions, type)?.defaults ?? {};
+}
+
+// src/command-api/provider/provider-command-probe.ts
+async function testProviderProfileCommand(currentProvider, providers, profileArg, options) {
+  const profileName = profileArg ?? currentProvider;
+  if (!profileName) {
+    return { message: "No provider profile selected.", success: false };
   }
-};
+  const profile = providers?.[profileName];
+  if (!profile) {
+    return { message: `Provider profile "${profileName}" was not found.`, success: false };
+  }
+  try {
+    validateProviderProfile(profileName, profile, {
+      providerDefinitions: options.providerDefinitions
+    });
+  } catch (error) {
+    return { message: error instanceof Error ? error.message : String(error), success: false };
+  }
+  const definition = profile.type ? (0, import_agent_core2.findProviderDefinition)(options.providerDefinitions, profile.type) : void 0;
+  const probe = definition?.probeProfile ?? probeProviderProfile;
+  const result = await probe(profile);
+  return {
+    message: result.ok ? `Provider "${profileName}" test passed: ${result.message}` : `Provider "${profileName}" test failed: ${result.message}; manual configuration can continue.`,
+    success: true,
+    data: { providerTest: { profile: profileName } }
+  };
+}
+async function probeProviderProfile(profile) {
+  void profile;
+  return { ok: true, message: "Profile fields are valid; no endpoint probe configured." };
+}
 
 // src/commands/skill-source.ts
 var import_node_fs = require("fs");
@@ -455,66 +655,523 @@ var PluginCommandSource = class {
   }
 };
 
-// src/commands/background-command.ts
+// src/command-api/context/context-command-api.ts
+var import_agent_sessions = require("@robota-sdk/agent-sessions");
+var DEFAULT_AUTO_COMPACT_THRESHOLD = import_agent_sessions.AUTO_COMPACT_THRESHOLD;
+var AUTO_COMPACT_THRESHOLD_SETTINGS_KEY = "autoCompactThreshold";
+function readCommandContextState(context) {
+  return context.getContextState();
+}
+function readAutoCompactThreshold(context) {
+  return context.getAutoCompactThreshold();
+}
+function readAutoCompactThresholdSource(context) {
+  return context.getAutoCompactThresholdSource?.() ?? "session";
+}
+function setCommandAutoCompactThreshold(context, threshold, source) {
+  if (context.setAutoCompactThreshold) {
+    context.setAutoCompactThreshold(threshold, source);
+    return;
+  }
+  const session = context.getSession();
+  if (!session.setAutoCompactThreshold) {
+    throw new Error("Command host does not support changing auto-compact threshold.");
+  }
+  session.setAutoCompactThreshold(threshold);
+}
+function writeAutoCompactThresholdSetting(context, threshold) {
+  const settings = getSettingsAdapter(context);
+  if (!settings) return false;
+  settings.write({
+    ...settings.read(),
+    [AUTO_COMPACT_THRESHOLD_SETTINGS_KEY]: threshold
+  });
+  return true;
+}
+function resetAutoCompactThresholdSetting(context) {
+  const settings = getSettingsAdapter(context);
+  if (!settings) return false;
+  const next = { ...settings.read() };
+  delete next[AUTO_COMPACT_THRESHOLD_SETTINGS_KEY];
+  settings.write(next);
+  return true;
+}
+async function compactCommandContext(context, instructions) {
+  const before = readCommandContextState(context);
+  await context.compactContext(instructions);
+  const after = readCommandContextState(context);
+  return { before, after };
+}
+function getSettingsAdapter(context) {
+  return context.getCommandHostAdapters?.().settings;
+}
+
+// src/command-api/provider/provider-setup-flow.ts
+var import_agent_core3 = require("@robota-sdk/agent-core");
+function createProviderSetupFlow(type, providerDefinitions) {
+  return {
+    type,
+    steps: getProviderSetupSteps(type, providerDefinitions),
+    stepIndex: 0,
+    values: {}
+  };
+}
+function formatProviderSetupSelectionPrompt(providerDefinitions) {
+  if (providerDefinitions.length === 0) {
+    return "  No providers are available.";
+  }
+  const lines = [
+    "  Select provider:",
+    ...providerDefinitions.map(
+      (definition, index) => `    ${index + 1}. ${formatProviderSetupChoiceLabel(definition)}`
+    ),
+    `  Provider [1-${providerDefinitions.length}] (default: 1): `
+  ];
+  return lines.join("\n");
+}
+function resolveProviderSetupSelection(rawValue, providerDefinitions) {
+  const value = rawValue.trim();
+  const selectedValue = value.length > 0 ? value : "1";
+  const index = parseProviderSelectionIndex(selectedValue);
+  if (index !== void 0) {
+    const definition2 = providerDefinitions[index];
+    if (definition2 !== void 0) {
+      return definition2.type;
+    }
+    throw new Error(
+      `Provider selection ${selectedValue} is out of range. Currently supported: ${(0, import_agent_core3.formatSupportedProviderTypes)(providerDefinitions)}`
+    );
+  }
+  const definition = (0, import_agent_core3.findProviderDefinition)(providerDefinitions, selectedValue);
+  if (definition === void 0) {
+    throw new Error(
+      `Unknown provider: ${selectedValue}. Currently supported: ${(0, import_agent_core3.formatSupportedProviderTypes)(providerDefinitions)}`
+    );
+  }
+  return definition.type;
+}
+function getProviderSetupStep(state) {
+  const step = state.steps[state.stepIndex];
+  if (step === void 0) {
+    throw new Error(`Provider setup step ${state.stepIndex} is out of range`);
+  }
+  return step;
+}
+function submitProviderSetupValue(state, rawValue) {
+  const step = getProviderSetupStep(state);
+  const value = rawValue.trim() || step.defaultValue || "";
+  const validationMessage = validateProviderSetupValue(step, value);
+  if (validationMessage !== void 0) {
+    return { status: "error", state, message: validationMessage };
+  }
+  const nextState = {
+    ...state,
+    stepIndex: state.stepIndex + 1,
+    values: { ...state.values, [step.key]: value }
+  };
+  if (nextState.stepIndex < state.steps.length) {
+    return { status: "next", state: nextState };
+  }
+  return { status: "complete", input: buildProviderSetupInput(nextState) };
+}
+async function runProviderSetupPromptFlow(type, promptInput, providerDefinitions) {
+  let state = createProviderSetupFlow(type, providerDefinitions);
+  const stepCount = state.steps.length;
+  while (state.stepIndex < stepCount) {
+    const step = getProviderSetupStep(state);
+    const value = await promptInput(formatProviderSetupPromptLabel(step), step.masked === true);
+    const result = submitProviderSetupValue(state, value);
+    if (result.status === "complete") {
+      return result.input;
+    }
+    if (result.status === "error") {
+      throw new Error(result.message);
+    }
+    state = result.state;
+  }
+  throw new Error("Provider setup flow ended without completion");
+}
+function formatProviderSetupPromptLabel(step) {
+  const suffix = step.defaultValue !== void 0 ? ` (default: ${step.defaultValue})` : "";
+  return `  ${step.title}${suffix}: `;
+}
+function formatProviderSetupChoiceLabel(definition) {
+  const label = definition.displayName !== void 0 ? `${definition.displayName} (${definition.type})` : definition.type;
+  return definition.description !== void 0 ? `${label} - ${definition.description}` : label;
+}
+function parseProviderSelectionIndex(value) {
+  if (!/^\d+$/.test(value)) {
+    return void 0;
+  }
+  return Number(value) - 1;
+}
+function validateProviderSetupValue(step, value) {
+  if (step.required === true && value.length === 0) {
+    return "Required";
+  }
+  return void 0;
+}
+function getProviderSetupSteps(type, providerDefinitions) {
+  const definition = (0, import_agent_core3.findProviderDefinition)(providerDefinitions, type);
+  if (definition === void 0) {
+    throw new Error(
+      `Unknown provider: ${type}. Currently supported: ${(0, import_agent_core3.formatSupportedProviderTypes)(providerDefinitions)}`
+    );
+  }
+  if (definition.setupSteps !== void 0) {
+    return [...definition.setupSteps];
+  }
+  const steps = [
+    {
+      key: "model",
+      title: `${definition.type} model`,
+      defaultValue: definition.defaults?.model,
+      required: definition.defaults?.model === void 0
+    }
+  ];
+  if (definition.defaults?.baseURL !== void 0) {
+    steps.unshift({
+      key: "baseURL",
+      title: `${definition.type} base URL`,
+      defaultValue: definition.defaults.baseURL
+    });
+  }
+  if (definition.requiresApiKey === true) {
+    steps.push({
+      key: "apiKey",
+      title: `${definition.type} API key`,
+      defaultValue: definition.defaults?.apiKey,
+      required: definition.defaults?.apiKey === void 0,
+      masked: true
+    });
+  }
+  return steps;
+}
+function buildProviderSetupInput(state) {
+  return {
+    profile: state.type,
+    type: state.type,
+    model: state.values.model,
+    apiKey: state.values.apiKey,
+    ...state.values.baseURL !== void 0 && { baseURL: state.values.baseURL },
+    setCurrent: true
+  };
+}
+
+// src/command-api/help/help-command-api.ts
+var HELP_COMMAND_DESCRIPTION = "Show available commands";
+var HELP_COMMAND_NAME_COLUMN_WIDTH = 16;
+function readCommandList(context) {
+  return context.listCommands?.() ?? [];
+}
+function formatCommandHelpMessage(context) {
+  const commands = readCommandList(context);
+  return [
+    "Available commands:",
+    ...commands.map(
+      (command) => `  ${command.name.padEnd(HELP_COMMAND_NAME_COLUMN_WIDTH)} \u2014 ${command.description}`
+    )
+  ].join("\n");
+}
+
+// src/command-api/background/background-command-api.ts
 var DECIMAL_RADIX = 10;
-function parseCommandParts(args) {
-  return args.trim().split(/\s+/).filter(Boolean);
+var INLINE_METADATA_LIMIT = 160;
+var BACKGROUND_COMMAND_DESCRIPTION = "List and control background tasks";
+var BACKGROUND_COMMAND_USAGE = "Usage: background list | background read <task-id> [offset] | background cancel <task-id> | background close <task-id>";
+function buildBackgroundCommandSubcommands() {
+  return [
+    { name: "list", description: "List background tasks", source: "background" },
+    { name: "read", description: "Read a background task log page", source: "background" },
+    { name: "cancel", description: "Cancel a running background task", source: "background" },
+    { name: "close", description: "Dismiss a terminal background task", source: "background" }
+  ];
 }
-function formatBackgroundTask(task) {
+function formatCommandBackgroundTask(task) {
   const preview = task.promptPreview ?? task.commandPreview ?? "";
   const unread = task.unread ? " unread" : "";
   const action = task.currentAction ? ` (${task.currentAction})` : "";
   const timeout = task.timeoutReason ? ` timeout=${task.timeoutReason}` : "";
   const activity = task.lastActivityAt ? ` lastActivityAt=${task.lastActivityAt}` : "";
+  const worktree = formatWorktreeMetadata(task);
   const suffix = preview ? ` \u2014 ${preview}` : "";
-  return `${task.id} [${task.status}${unread}${timeout}${activity}] ${task.kind}:${task.label}${action}${suffix}`;
+  return `${task.id} [${task.status}${unread}${timeout}${activity}${worktree}] ${task.kind}:${task.label}${action}${suffix}`;
 }
-function formatBackgroundTaskList(tasks) {
+function formatCommandBackgroundTaskList(tasks) {
   if (tasks.length === 0) return "No background tasks.";
-  return ["Background tasks:", ...tasks.map((task) => `  ${formatBackgroundTask(task)}`)].join(
-    "\n"
-  );
+  return [
+    "Background tasks:",
+    ...tasks.map((task) => `  ${formatCommandBackgroundTask(task)}`)
+  ].join("\n");
 }
-function parseCursor(value) {
+function parseCommandBackgroundLogCursor(value) {
   if (!value) return void 0;
   const offset = Number.parseInt(value, DECIMAL_RADIX);
   return Number.isNaN(offset) ? void 0 : { offset };
 }
-async function executeBackgroundCommand(session, args) {
-  const [action = "list", taskId, ...reasonParts] = parseCommandParts(args);
-  if (action === "list") {
-    const tasks = session.listBackgroundTasks();
-    return {
-      message: formatBackgroundTaskList(tasks),
-      success: true,
-      data: { count: tasks.length }
-    };
+function formatWorktreeMetadata(task) {
+  const segments = [];
+  if (task.worktreePath) segments.push(`worktree=${task.worktreePath}`);
+  if (task.branchName) segments.push(`branch=${task.branchName}`);
+  if (task.worktreeStatus) {
+    segments.push(`worktreeStatus="${formatInlineMetadata(task.worktreeStatus)}"`);
   }
-  if (!taskId) {
-    return {
-      message: "Usage: background list | background read <task-id> [offset] | background cancel <task-id> | background close <task-id>",
-      success: false
-    };
+  if (task.worktreeNextAction) {
+    segments.push(`next="${formatInlineMetadata(task.worktreeNextAction)}"`);
   }
-  if (action === "read" || action === "log" || action === "open") {
-    const page = await session.readBackgroundTaskLog(taskId, parseCursor(reasonParts[0]));
-    const next = page.nextCursor ? `
-Next offset: ${page.nextCursor.offset}` : "";
-    return {
-      message: page.lines.length > 0 ? `${page.lines.join("\n")}${next}` : `No log lines: ${taskId}`,
-      success: true,
-      data: { taskId, nextOffset: page.nextCursor?.offset }
-    };
+  if (segments.length === 0) return "";
+  return ` ${segments.join(" ")}`;
+}
+function formatInlineMetadata(value) {
+  const normalized = value.trim().replace(/\s+/g, " ");
+  return normalized.length > INLINE_METADATA_LIMIT ? `${normalized.slice(0, INLINE_METADATA_LIMIT)}...` : normalized;
+}
+function listCommandBackgroundTasks(context, filter) {
+  return context.listBackgroundTasks(filter);
+}
+function readCommandBackgroundTaskLog(context, taskId, cursor) {
+  return context.readBackgroundTaskLog(taskId, cursor);
+}
+function cancelCommandBackgroundTask(context, taskId, reason) {
+  return context.cancelBackgroundTask(taskId, reason);
+}
+function closeCommandBackgroundTask(context, taskId) {
+  return context.closeBackgroundTask(taskId);
+}
+
+// src/command-api/model/model-command-api.ts
+var import_agent_core4 = require("@robota-sdk/agent-core");
+var MODEL_COMMAND_DESCRIPTION = "Change AI model";
+var MODEL_COMMAND_ARGUMENT_HINT = "<model-id>";
+function buildModelCommandSubcommands(source = "model") {
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const model of Object.values(import_agent_core4.CLAUDE_MODELS)) {
+    if (seen.has(model.name)) continue;
+    seen.add(model.name);
+    commands.push({
+      name: model.id,
+      description: `${model.name} (${(0, import_agent_core4.formatTokenCount)(model.contextWindow).toUpperCase()})`,
+      source
+    });
   }
-  if (action === "cancel" || action === "stop") {
-    await session.cancelBackgroundTask(taskId, reasonParts.join(" ") || void 0);
-    return { message: `Background task cancelled: ${taskId}`, success: true, data: { taskId } };
+  return commands;
+}
+
+// src/command-api/language/language-command-api.ts
+var LANGUAGE_COMMAND_DESCRIPTION = "Set response language";
+var LANGUAGE_COMMAND_ARGUMENT_HINT = "<code>";
+var RECOMMENDED_RESPONSE_LANGUAGES = [
+  { code: "ko", description: "Korean" },
+  { code: "en", description: "English" },
+  { code: "ja", description: "Japanese" },
+  { code: "zh", description: "Chinese" }
+];
+function buildLanguageCommandSubcommands(source = "language") {
+  return RECOMMENDED_RESPONSE_LANGUAGES.map((language) => ({
+    name: language.code,
+    description: language.description,
+    source
+  }));
+}
+function parseLanguageArgument(args) {
+  const language = args.trim().split(/\s+/)[0];
+  return language !== void 0 && language.length > 0 ? language : void 0;
+}
+function formatLanguageUsageMessage(commandName = "language") {
+  return `Usage: ${commandName} <code> (e.g., ko, en, ja, zh)`;
+}
+
+// src/command-api/permissions/permission-mode-command-api.ts
+var PERMISSION_MODE_COMMAND_DESCRIPTION = "Show/change permission mode";
+var PERMISSION_MODE_ARGUMENT_HINT = "plan | default | acceptEdits | bypassPermissions";
+var PERMISSIONS_COMMAND_DESCRIPTION = "Show permission rules";
+var VALID_PERMISSION_MODES = [
+  "plan",
+  "default",
+  "acceptEdits",
+  "bypassPermissions"
+];
+function buildPermissionModeSubcommands(source = "mode") {
+  return [
+    { name: "plan", description: "Plan only, no execution", source },
+    { name: "default", description: "Ask before risky actions", source },
+    { name: "acceptEdits", description: "Auto-approve file edits", source },
+    { name: "bypassPermissions", description: "Skip all permission checks", source }
+  ];
+}
+function parsePermissionModeArgument(args) {
+  const mode = args.trim().split(/\s+/)[0];
+  return mode !== void 0 && mode.length > 0 ? mode : void 0;
+}
+function isPermissionMode(value) {
+  return VALID_PERMISSION_MODES.includes(value);
+}
+function formatInvalidPermissionModeMessage() {
+  return `Invalid mode. Valid: ${VALID_PERMISSION_MODES.join(" | ")}`;
+}
+function resolvePermissionModeAdapter(context) {
+  const adapter = context.getCommandHostAdapters?.().permissionMode;
+  if (adapter !== void 0) {
+    return adapter;
   }
-  if (action === "close" || action === "dismiss") {
-    await session.closeBackgroundTask(taskId);
-    return { message: `Background task closed: ${taskId}`, success: true, data: { taskId } };
+  const runtime = context.getSession();
+  return {
+    getPermissionMode: () => runtime.getPermissionMode(),
+    setPermissionMode: (mode) => runtime.setPermissionMode(mode),
+    listSessionAllowedTools: () => runtime.getSessionAllowedTools()
+  };
+}
+function readCommandPermissionMode(context) {
+  return resolvePermissionModeAdapter(context).getPermissionMode();
+}
+function writeCommandPermissionMode(context, mode) {
+  resolvePermissionModeAdapter(context).setPermissionMode(mode);
+}
+function listCommandSessionAllowedTools(context) {
+  return resolvePermissionModeAdapter(context).listSessionAllowedTools();
+}
+function readCommandPermissionsState(context) {
+  return {
+    mode: readCommandPermissionMode(context),
+    sessionAllowed: listCommandSessionAllowedTools(context)
+  };
+}
+function formatCommandPermissionsMessage(state) {
+  const lines = [`Permission mode: ${state.mode}`];
+  if (state.sessionAllowed.length > 0) {
+    lines.push(`Session-approved tools: ${state.sessionAllowed.join(", ")}`);
+  } else {
+    lines.push("No session-approved tools.");
   }
-  return { message: `Unknown background action: ${action}`, success: false };
+  return lines.join("\n");
+}
+
+// src/command-api/statusline/statusline-command-api.ts
+var STATUSLINE_COMMAND_DESCRIPTION = "Configure TUI status-line visibility and fields such as model, context, tokens, session, and git branch.";
+var STATUSLINE_COMMAND_ARGUMENT_HINT = "on | off | reset | git on | git off";
+var DEFAULT_STATUS_LINE_COMMAND_SETTINGS = {
+  enabled: true,
+  gitBranch: true
+};
+function buildStatusLineCommandSubcommands(source = "statusline") {
+  return [
+    { name: "on", description: "Show the status line", source },
+    { name: "off", description: "Hide the status line", source },
+    { name: "reset", description: "Restore default status-line fields", source },
+    { name: "git", description: "Show or hide git branch field", source }
+  ];
+}
+function isStatusLineCommandSettingsPatch(value) {
+  return (value.enabled === void 0 || typeof value.enabled === "boolean") && (value.gitBranch === void 0 || typeof value.gitBranch === "boolean");
+}
+
+// src/command-api/plugin/plugin-command-api.ts
+var PLUGIN_COMMAND_DESCRIPTION = "Manage plugins";
+var PLUGIN_COMMAND_ARGUMENT_HINT = "manage | install <name@marketplace> | uninstall <name@marketplace> | enable <name@marketplace> | disable <name@marketplace> | marketplace <action>";
+var RELOAD_PLUGINS_COMMAND_DESCRIPTION = "Reload all plugin resources";
+function createPluginTuiRequestedEffect() {
+  return { type: "plugin-tui-requested" };
+}
+function createPluginRegistryReloadRequestedEffect() {
+  return { type: "plugin-registry-reload-requested" };
+}
+function resolvePluginCommandAdapter(context) {
+  return context.getCommandHostAdapters?.().plugin;
+}
+function buildPluginCommandSubcommands() {
+  return [
+    { name: "manage", description: "Open plugin manager", source: "plugin-manager" },
+    { name: "install", description: "Install a plugin", source: "plugin-manager" },
+    { name: "uninstall", description: "Uninstall a plugin", source: "plugin-manager" },
+    { name: "enable", description: "Enable a plugin", source: "plugin-manager" },
+    { name: "disable", description: "Disable a plugin", source: "plugin-manager" },
+    {
+      name: "marketplace",
+      description: "Manage plugin marketplaces",
+      source: "plugin-manager",
+      subcommands: [
+        { name: "add", description: "Add marketplace source", source: "plugin-manager" },
+        { name: "remove", description: "Remove marketplace source", source: "plugin-manager" },
+        { name: "update", description: "Update marketplace source", source: "plugin-manager" },
+        { name: "list", description: "List marketplace sources", source: "plugin-manager" }
+      ]
+    }
+  ];
+}
+
+// src/command-api/session/session-command-api.ts
+var CLEAR_COMMAND_DESCRIPTION = "Clear conversation history";
+var RENAME_COMMAND_DESCRIPTION = "Rename the current session";
+var RENAME_COMMAND_USAGE = "Usage: rename <name>";
+var RESUME_COMMAND_DESCRIPTION = "Resume a previous session";
+var COST_COMMAND_DESCRIPTION = "Show session info";
+var EXIT_COMMAND_DESCRIPTION = "Exit CLI";
+function clearConversationHistory(context) {
+  if (context.clearConversationHistory !== void 0) {
+    context.clearConversationHistory();
+    return;
+  }
+  context.getSession().clearHistory();
+}
+function parseSessionNameArgument(args) {
+  const name = args.trim();
+  return name.length > 0 ? name : void 0;
+}
+function createSessionRenamedEffect(name) {
+  return { type: "session-renamed", name };
+}
+function createSessionPickerRequestedEffect() {
+  return { type: "session-picker-requested" };
+}
+function createSessionExitRequestedEffect() {
+  return { type: "session-exit-requested" };
+}
+function readCommandSessionInfo(context) {
+  const session = context.getSession();
+  return {
+    sessionId: session.getSessionId(),
+    messageCount: session.getMessageCount()
+  };
+}
+
+// src/command-api/checkpoint/rewind-command-api.ts
+var REWIND_COMMAND_DESCRIPTION = "List, inspect, restore, or rollback edit checkpoints.";
+var REWIND_COMMAND_ARGUMENT_HINT = "list | inspect CHECKPOINT_ID | restore CHECKPOINT_ID | code CHECKPOINT_ID | rollback CHECKPOINT_ID";
+function buildRewindCommandSubcommands(source = "rewind") {
+  return [
+    { name: "list", description: "List edit checkpoints", source },
+    { name: "inspect", description: "Inspect captured files and restore plans", source },
+    { name: "restore", description: "Restore code to a checkpoint", source },
+    { name: "code", description: "Restore code to a checkpoint", source },
+    { name: "rollback", description: "Rollback code through a checkpoint", source }
+  ];
+}
+function listCommandEditCheckpoints(context) {
+  return context.listEditCheckpoints();
+}
+function inspectCommandEditCheckpoint(context, checkpointId) {
+  if (!context.inspectEditCheckpoint) {
+    throw new Error("Checkpoint inspection is not available in this command host.");
+  }
+  return context.inspectEditCheckpoint(checkpointId);
+}
+function restoreCommandEditCheckpoint(context, checkpointId) {
+  return context.restoreEditCheckpoint(checkpointId);
+}
+function rollbackCommandEditCheckpoint(context, checkpointId) {
+  return context.rollbackEditCheckpoint(checkpointId);
+}
+
+// src/memory/memory-policy-evaluator.ts
+var SENSITIVE_PATTERNS = [
+  /\b(api[_-]?key|secret|token|password|private key)\b/i,
+  /\b\d{3}-\d{2}-\d{4}\b/,
+  /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/,
+  /주민등록|비밀번호|시크릿|토큰/u
+];
+function containsSensitiveMemoryContent(text) {
+  return SENSITIVE_PATTERNS.some((pattern) => pattern.test(text));
 }
 
 // src/memory/pending-memory-store.ts
@@ -642,595 +1299,118 @@ var ProjectMemoryStore = class {
   }
   getIndexPath() {
     return (0, import_path.join)(memoryRoot2(this.cwd), INDEX_FILENAME);
-  }
-  getTopicsPath() {
-    return (0, import_path.join)(memoryRoot2(this.cwd), TOPICS_DIRNAME);
-  }
-  loadStartupMemory() {
-    const path = this.getIndexPath();
-    if (!(0, import_fs.existsSync)(path)) {
-      return { content: "", path, lineCount: 0, truncated: false };
-    }
-    const raw = (0, import_fs.readFileSync)(path, "utf8");
-    const byBytes = truncateToUtf8Bytes(raw, MEMORY_INDEX_MAX_BYTES);
-    const byteTruncated = Buffer.byteLength(raw, "utf8") > MEMORY_INDEX_MAX_BYTES;
-    const byLines = limitLines(byBytes, MEMORY_INDEX_MAX_LINES);
-    return {
-      content: byLines.content,
-      path,
-      lineCount: byLines.content.length === 0 ? 0 : byLines.content.split(/\r?\n/).length,
-      truncated: byteTruncated || byLines.truncated
-    };
-  }
-  list() {
-    const topicsPath = this.getTopicsPath();
-    const topics = (0, import_fs.existsSync)(topicsPath) ? (0, import_fs.readdirSync)(topicsPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(TOPIC_EXTENSION)).map((entry) => ({
-      name: (0, import_path.basename)(entry.name, TOPIC_EXTENSION),
-      path: (0, import_path.join)(topicsPath, entry.name)
-    })).sort((a, b) => a.name.localeCompare(b.name)) : [];
-    return {
-      indexPath: this.getIndexPath(),
-      topicsPath,
-      topics
-    };
-  }
-  readTopic(topic) {
-    const normalized = sanitizeTopic(topic);
-    const path = (0, import_path.join)(this.getTopicsPath(), `${normalized}${TOPIC_EXTENSION}`);
-    if (!(0, import_fs.existsSync)(path)) return "";
-    return (0, import_fs.readFileSync)(path, "utf8").trimEnd();
-  }
-  append(input) {
-    const topic = sanitizeTopic(input.topic);
-    const root = memoryRoot2(this.cwd);
-    const topicsPath = this.getTopicsPath();
-    (0, import_fs.mkdirSync)(topicsPath, { recursive: true });
-    const indexPath = this.getIndexPath();
-    const topicPath = (0, import_path.join)(topicsPath, `${topic}${TOPIC_EXTENSION}`);
-    const entry = formatEntry(this.now(), input, topic);
-    const topicHeader = (0, import_fs.existsSync)(topicPath) ? "" : `# ${topic}
-
-`;
-    const normalizedText = normalizeMemoryText(input.text);
-    if ((0, import_fs.existsSync)(topicPath) && (0, import_fs.readFileSync)(topicPath, "utf8").includes(`) ${normalizedText}`)) {
-      return { indexPath, topicPath, topic, deduplicated: true };
-    }
-    if (!(0, import_fs.existsSync)(indexPath)) {
-      (0, import_fs.mkdirSync)(root, { recursive: true });
-      (0, import_fs.writeFileSync)(indexPath, "# Project Memory\n\n", "utf8");
-    }
-    (0, import_fs.appendFileSync)(indexPath, `- ${entry}
-`, "utf8");
-    (0, import_fs.appendFileSync)(topicPath, `${topicHeader}- ${entry}
-`, "utf8");
-    return { indexPath, topicPath, topic, deduplicated: false };
-  }
-};
-
-// src/memory/memory-policy-evaluator.ts
-var SENSITIVE_PATTERNS = [
-  /\b(api[_-]?key|secret|token|password|private key)\b/i,
-  /\b\d{3}-\d{2}-\d{4}\b/,
-  /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/,
-  /주민등록|비밀번호|시크릿|토큰/u
-];
-function containsSensitiveMemoryContent(text) {
-  return SENSITIVE_PATTERNS.some((pattern) => pattern.test(text));
-}
-
-// src/commands/memory-command.ts
-var SUBCOMMAND_INDEX = 0;
-var TYPE_INDEX = 1;
-var TOPIC_INDEX = 2;
-var TEXT_START_INDEX = 3;
-function usage() {
-  return {
-    message: "Usage: memory list | memory show [topic] | memory add <user|feedback|project|reference> <topic> <text> | memory pending | memory approve <id> | memory reject <id> | memory used",
-    success: false
-  };
-}
-function formatList(store) {
-  const summary = store.list();
-  const topics = summary.topics.length > 0 ? summary.topics.map((topic) => `- ${topic.name}: ${topic.path}`).join("\n") : "(none)";
-  return {
-    message: [
-      `Memory index: ${summary.indexPath}`,
-      `Topics directory: ${summary.topicsPath}`,
-      "Topics:",
-      topics
-    ].join("\n"),
-    success: true,
-    data: {
-      indexPath: summary.indexPath,
-      topicsPath: summary.topicsPath,
-      topicCount: summary.topics.length
-    }
-  };
-}
-function formatShow(store, topic) {
-  if (!topic || topic === "index") {
-    const memory = store.loadStartupMemory();
-    return {
-      message: memory.content || "(empty memory index)",
-      success: true,
-      data: {
-        path: memory.path,
-        lineCount: memory.lineCount,
-        truncated: memory.truncated
-      }
-    };
-  }
-  const content = store.readTopic(topic);
-  return {
-    message: content || `(empty memory topic: ${topic})`,
-    success: true,
-    data: { topic }
-  };
-}
-function parseAdd(args) {
-  const type = args[TYPE_INDEX];
-  const topic = args[TOPIC_INDEX];
-  const text = args.slice(TEXT_START_INDEX).join(" ").trim();
-  if (!type || !isMemoryType(type) || !topic || text.length === 0) return void 0;
-  return { type, topic, text };
-}
-function formatPending(store) {
-  const records = store.list("pending");
-  const lines = records.length > 0 ? records.map(
-    (record) => `- ${record.id} ${record.type}/${record.topic} confidence=${record.confidence}: ${record.text}`
-  ) : ["(no pending memory candidates)"];
-  return {
-    message: ["Pending memory candidates:", ...lines].join("\n"),
-    success: true,
-    data: { count: records.length }
-  };
-}
-function recordEvent(session, event) {
-  session.recordMemoryEvent({
-    ...event,
-    at: (/* @__PURE__ */ new Date()).toISOString()
-  });
-}
-function approvePending(session, pendingStore, memoryStore, id) {
-  if (!id) return usage();
-  try {
-    const approved = pendingStore.mark(id, "approved", "approved-by-user");
-    const saved = memoryStore.append(approved);
-    const record = pendingStore.mark(id, "saved", "approved-and-saved");
-    recordEvent(session, {
-      type: "memory_candidate_approved",
-      candidateId: record.id,
-      topic: record.topic,
-      reason: "approved-by-user"
-    });
-    recordEvent(session, {
-      type: "memory_candidate_saved",
-      candidateId: record.id,
-      topic: record.topic,
-      reason: saved.deduplicated ? "deduplicated" : "approved-and-saved"
-    });
-    return {
-      message: saved.deduplicated ? `Saved memory candidate ${id} was already present in ${saved.topicPath}` : `Saved memory candidate ${id} to ${saved.topicPath}`,
-      success: true,
-      data: {
-        id,
-        status: record.status,
-        topic: saved.topic,
-        topicPath: saved.topicPath,
-        deduplicated: saved.deduplicated
-      }
-    };
-  } catch (error) {
-    return {
-      message: error instanceof Error ? error.message : String(error),
-      success: false
-    };
-  }
-}
-function rejectPending(session, pendingStore, id) {
-  if (!id) return usage();
-  try {
-    const record = pendingStore.mark(id, "rejected", "rejected-by-user");
-    recordEvent(session, {
-      type: "memory_candidate_rejected",
-      candidateId: record.id,
-      topic: record.topic,
-      reason: "rejected-by-user"
-    });
-    return {
-      message: `Rejected memory candidate ${id}`,
-      success: true,
-      data: { id, status: record.status }
-    };
-  } catch (error) {
-    return {
-      message: error instanceof Error ? error.message : String(error),
-      success: false
-    };
-  }
-}
-function formatUsed(session) {
-  const references = session.getUsedMemoryReferences();
-  const lines = references.length > 0 ? references.map((reference) => {
-    const suffix = reference.truncated ? " truncated=true" : "";
-    return `- ${reference.topic} score=${reference.score}${suffix}: ${reference.path}`;
-  }) : ["(no memory used in current turn)"];
-  return {
-    message: ["Used memory references:", ...lines].join("\n"),
-    success: true,
-    data: { count: references.length, references }
-  };
-}
-function executeMemoryCommand(session, rawArgs) {
-  const args = rawArgs.trim().split(/\s+/).filter(Boolean);
-  const subcommand = args[SUBCOMMAND_INDEX] ?? "list";
-  const store = new ProjectMemoryStore(session.getCwd());
-  const pendingStore = new PendingMemoryStore(session.getCwd());
-  if (subcommand === "list") return formatList(store);
-  if (subcommand === "show") return formatShow(store, args[TYPE_INDEX]);
-  if (subcommand === "pending") return formatPending(pendingStore);
-  if (subcommand === "approve")
-    return approvePending(session, pendingStore, store, args[TYPE_INDEX]);
-  if (subcommand === "reject") return rejectPending(session, pendingStore, args[TYPE_INDEX]);
-  if (subcommand === "used") return formatUsed(session);
-  if (subcommand === "add") {
-    const input = parseAdd(args);
-    if (!input) return usage();
-    if (containsSensitiveMemoryContent(input.text)) {
-      return {
-        message: "Refusing to save sensitive memory content.",
-        success: false
-      };
+  }
+  getTopicsPath() {
+    return (0, import_path.join)(memoryRoot2(this.cwd), TOPICS_DIRNAME);
+  }
+  loadStartupMemory() {
+    const path = this.getIndexPath();
+    if (!(0, import_fs.existsSync)(path)) {
+      return { content: "", path, lineCount: 0, truncated: false };
     }
-    const result = store.append(input);
+    const raw = (0, import_fs.readFileSync)(path, "utf8");
+    const byBytes = truncateToUtf8Bytes(raw, MEMORY_INDEX_MAX_BYTES);
+    const byteTruncated = Buffer.byteLength(raw, "utf8") > MEMORY_INDEX_MAX_BYTES;
+    const byLines = limitLines(byBytes, MEMORY_INDEX_MAX_LINES);
     return {
-      message: result.deduplicated ? `${input.type} memory already exists in ${result.topicPath}` : `Saved ${input.type} memory to ${result.topicPath}`,
-      success: true,
-      data: {
-        indexPath: result.indexPath,
-        topicPath: result.topicPath,
-        topic: result.topic,
-        deduplicated: result.deduplicated
-      }
+      content: byLines.content,
+      path,
+      lineCount: byLines.content.length === 0 ? 0 : byLines.content.split(/\r?\n/).length,
+      truncated: byteTruncated || byLines.truncated
     };
   }
-  return usage();
-}
-
-// src/commands/rewind-command.ts
-var SUBCOMMAND_INDEX2 = 0;
-var CHECKPOINT_ID_INDEX = 1;
-var PROMPT_PREVIEW_LENGTH = 120;
-var ELLIPSIS_LENGTH = 3;
-function usage2() {
-  return {
-    message: "Usage: rewind [list] | rewind restore <checkpoint-id> | rewind code <checkpoint-id>",
-    success: false
-  };
-}
-function formatPrompt(prompt) {
-  const compact = prompt.replace(/\s+/g, " ").trim();
-  if (compact.length <= PROMPT_PREVIEW_LENGTH) return compact;
-  return `${compact.slice(0, PROMPT_PREVIEW_LENGTH - ELLIPSIS_LENGTH)}...`;
-}
-function formatList2(checkpoints) {
-  const lines = checkpoints.length > 0 ? checkpoints.map(
-    (checkpoint) => `- ${checkpoint.id} files=${checkpoint.fileCount} ${checkpoint.createdAt} ${formatPrompt(
-      checkpoint.prompt
-    )}`
-  ) : ["(no edit checkpoints)"];
-  return {
-    message: ["Edit checkpoints:", ...lines].join("\n"),
-    success: true,
-    data: { count: checkpoints.length, checkpoints: [...checkpoints] }
-  };
-}
-async function restore(session, checkpointId) {
-  if (!checkpointId) return usage2();
-  try {
-    const result = await session.restoreEditCheckpoint(checkpointId);
-    return {
-      message: [
-        `Restored code to ${result.target.id}.`,
-        `Restored files: ${result.restoredFileCount}`,
-        `Rolled back checkpoints: ${result.restoredCheckpointCount}`
-      ].join("\n"),
-      success: true,
-      data: {
-        target: result.target,
-        restoredCheckpointCount: result.restoredCheckpointCount,
-        restoredFileCount: result.restoredFileCount,
-        removedCheckpointCount: result.removedCheckpointCount
-      }
-    };
-  } catch (error) {
+  list() {
+    const topicsPath = this.getTopicsPath();
+    const topics = (0, import_fs.existsSync)(topicsPath) ? (0, import_fs.readdirSync)(topicsPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(TOPIC_EXTENSION)).map((entry) => ({
+      name: (0, import_path.basename)(entry.name, TOPIC_EXTENSION),
+      path: (0, import_path.join)(topicsPath, entry.name)
+    })).sort((a, b) => a.name.localeCompare(b.name)) : [];
     return {
-      message: error instanceof Error ? error.message : String(error),
-      success: false
+      indexPath: this.getIndexPath(),
+      topicsPath,
+      topics
     };
   }
-}
-async function executeRewindCommand(session, rawArgs) {
-  const args = rawArgs.trim().split(/\s+/).filter(Boolean);
-  const subcommand = args[SUBCOMMAND_INDEX2] ?? "list";
-  if (subcommand === "list") {
-    return formatList2(session.listEditCheckpoints());
-  }
-  if (subcommand === "restore" || subcommand === "code") {
-    return restore(session, args[CHECKPOINT_ID_INDEX]);
+  readTopic(topic) {
+    const normalized = sanitizeTopic(topic);
+    const path = (0, import_path.join)(this.getTopicsPath(), `${normalized}${TOPIC_EXTENSION}`);
+    if (!(0, import_fs.existsSync)(path)) return "";
+    return (0, import_fs.readFileSync)(path, "utf8").trimEnd();
   }
-  return usage2();
-}
+  append(input) {
+    const topic = sanitizeTopic(input.topic);
+    const root = memoryRoot2(this.cwd);
+    const topicsPath = this.getTopicsPath();
+    (0, import_fs.mkdirSync)(topicsPath, { recursive: true });
+    const indexPath = this.getIndexPath();
+    const topicPath = (0, import_path.join)(topicsPath, `${topic}${TOPIC_EXTENSION}`);
+    const entry = formatEntry(this.now(), input, topic);
+    const topicHeader = (0, import_fs.existsSync)(topicPath) ? "" : `# ${topic}
 
-// src/commands/system-command-executor.ts
-var SystemCommandExecutor = class {
-  commands;
-  constructor(commands) {
-    this.commands = /* @__PURE__ */ new Map();
-    for (const cmd of commands ?? createSystemCommands()) {
-      this.commands.set(cmd.name, cmd);
+`;
+    const normalizedText = normalizeMemoryText(input.text);
+    if ((0, import_fs.existsSync)(topicPath) && (0, import_fs.readFileSync)(topicPath, "utf8").includes(`) ${normalizedText}`)) {
+      return { indexPath, topicPath, topic, deduplicated: true };
     }
-  }
-  /** Register an additional command. */
-  register(command) {
-    this.commands.set(command.name, command);
-  }
-  /** Execute a command by name. Returns null if command not found. */
-  async execute(name, session, args) {
-    const cmd = this.commands.get(name);
-    if (!cmd) return null;
-    return await cmd.execute(session, args);
-  }
-  /** List all registered commands. */
-  listCommands() {
-    return [...this.commands.values()];
-  }
-  listModelInvocableCommands() {
-    return this.listCommands().filter((command) => command.modelInvocable === true).map((command) => ({
-      name: `/${command.name}`,
-      kind: "builtin-command",
-      description: command.description,
-      userInvocable: command.userInvocable !== false,
-      modelInvocable: true,
-      ...command.argumentHint ? { argumentHint: command.argumentHint } : {},
-      ...command.safety ? { safety: command.safety } : {}
-    }));
-  }
-  isModelInvocable(name) {
-    return this.commands.get(name)?.modelInvocable === true;
-  }
-  async executeModelInvocable(name, session, args) {
-    if (!this.isModelInvocable(name)) return null;
-    return this.execute(name, session, args);
-  }
-  /** Check if a command exists. */
-  hasCommand(name) {
-    return this.commands.has(name);
+    if (!(0, import_fs.existsSync)(indexPath)) {
+      (0, import_fs.mkdirSync)(root, { recursive: true });
+      (0, import_fs.writeFileSync)(indexPath, "# Project Memory\n\n", "utf8");
+    }
+    (0, import_fs.appendFileSync)(indexPath, `- ${entry}
+`, "utf8");
+    (0, import_fs.appendFileSync)(topicPath, `${topicHeader}- ${entry}
+`, "utf8");
+    return { indexPath, topicPath, topic, deduplicated: false };
   }
 };
 
-// src/commands/system-command.ts
-var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+// src/command-api/memory/memory-command-api.ts
 var 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.";
 var MEMORY_COMMAND_ARGUMENT_HINT = "list | show [topic] | add <user|feedback|project|reference> <topic> <text> | pending | approve <id> | reject <id> | used";
-function createSystemCommands() {
+var 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";
+function buildMemoryCommandSubcommands(source = "memory") {
   return [
+    { name: "list", description: "List project memory topics", source },
+    { name: "show", description: "Show project memory index or a topic", source },
+    { name: "add", description: "Save durable project memory", source },
+    { name: "pending", description: "List pending memory candidates", source },
+    { name: "approve", description: "Approve a pending memory candidate", source },
+    { name: "reject", description: "Reject a pending memory candidate", source },
     {
-      name: "help",
-      description: "Show available commands",
-      execute: (_session, _args) => ({
-        message: [
-          "Available commands:",
-          "  help              \u2014 Show this help",
-          "  clear             \u2014 Clear conversation",
-          "  compact [instr]   \u2014 Compact context (optional focus instructions)",
-          "  mode [m]          \u2014 Show/change permission mode",
-          "  model <id>        \u2014 Change AI model",
-          "  language <code>   \u2014 Set response language (ko, en, ja, zh)",
-          "  cost              \u2014 Show session info",
-          "  context           \u2014 Context window info",
-          "  permissions       \u2014 Permission rules",
-          "  memory            \u2014 Manage project memory and pending candidates",
-          "  rewind            \u2014 List or restore edit checkpoints",
-          "  provider          \u2014 Provider profile status and switching",
-          "  resume            \u2014 Resume a previous session",
-          "  background        \u2014 List/cancel/close background tasks",
-          "  rename <name>     \u2014 Rename the current session",
-          "  reset             \u2014 Delete settings and exit"
-        ].join("\n"),
-        success: true
-      })
-    },
-    {
-      name: "clear",
-      description: "Clear conversation history",
-      execute: (session, _args) => {
-        const underlying = session.getSession();
-        underlying.clearHistory();
-        return { message: "Conversation cleared.", success: true };
-      }
-    },
-    {
-      name: "compact",
-      description: "Compress context window",
-      execute: async (session, args) => {
-        const underlying = session.getSession();
-        const instructions = args.trim() || void 0;
-        const before = underlying.getContextState().usedPercentage;
-        await underlying.compact(instructions);
-        const after = underlying.getContextState().usedPercentage;
-        return {
-          message: `Context compacted: ${Math.round(before)}% -> ${Math.round(after)}%`,
-          success: true,
-          data: { before, after }
-        };
-      }
-    },
-    {
-      name: "mode",
-      description: "Show/change permission mode",
-      execute: (session, args) => {
-        const underlying = session.getSession();
-        const arg = args.trim().split(/\s+/)[0];
-        if (!arg) {
-          return {
-            message: `Current mode: ${underlying.getPermissionMode()}`,
-            success: true,
-            data: { mode: underlying.getPermissionMode() }
-          };
-        }
-        if (VALID_MODES.includes(arg)) {
-          underlying.setPermissionMode(arg);
-          return {
-            message: `Permission mode set to: ${arg}`,
-            success: true,
-            data: { mode: arg }
-          };
-        }
-        return {
-          message: `Invalid mode. Valid: ${VALID_MODES.join(" | ")}`,
-          success: false
-        };
-      }
-    },
-    {
-      name: "model",
-      description: "Change AI model",
-      execute: (_session, args) => {
-        const modelId = args.trim().split(/\s+/)[0];
-        if (!modelId) {
-          return { message: "Usage: model <model-id>", success: false };
-        }
-        return {
-          message: `Model change requested: ${modelId}`,
-          success: true,
-          data: { modelId }
-        };
-      }
-    },
-    {
-      name: "language",
-      description: "Set response language",
-      execute: (_session, args) => {
-        const lang = args.trim().split(/\s+/)[0];
-        if (!lang) {
-          return { message: "Usage: language <code> (e.g., ko, en, ja, zh)", success: false };
-        }
-        return {
-          message: `Language set to "${lang}".`,
-          success: true,
-          data: { language: lang }
-        };
-      }
-    },
-    {
-      name: "cost",
-      description: "Show session info",
-      execute: (session, _args) => {
-        const underlying = session.getSession();
-        const sessionId = underlying.getSessionId();
-        const messageCount = underlying.getMessageCount();
-        return {
-          message: `Session: ${sessionId}
-Messages: ${messageCount}`,
-          success: true,
-          data: { sessionId, messageCount }
-        };
-      }
-    },
-    {
-      name: "context",
-      description: "Context window info",
-      execute: (session, _args) => {
-        const ctx = session.getContextState();
-        return {
-          message: `Context: ${ctx.usedTokens.toLocaleString()} / ${ctx.maxTokens.toLocaleString()} tokens (${Math.round(ctx.usedPercentage)}%)`,
-          success: true,
-          data: {
-            usedTokens: ctx.usedTokens,
-            maxTokens: ctx.maxTokens,
-            percentage: ctx.usedPercentage
-          }
-        };
-      }
-    },
-    {
-      name: "permissions",
-      description: "Show permission rules",
-      execute: (session, _args) => {
-        const underlying = session.getSession();
-        const mode = underlying.getPermissionMode();
-        const sessionAllowed = underlying.getSessionAllowedTools();
-        const lines = [`Permission mode: ${mode}`];
-        if (sessionAllowed.length > 0) {
-          lines.push(`Session-approved tools: ${sessionAllowed.join(", ")}`);
-        } else {
-          lines.push("No session-approved tools.");
-        }
-        return {
-          message: lines.join("\n"),
-          success: true,
-          data: { mode, sessionAllowed }
-        };
-      }
-    },
-    {
-      name: "memory",
-      description: MEMORY_COMMAND_DESCRIPTION,
-      modelInvocable: true,
-      argumentHint: MEMORY_COMMAND_ARGUMENT_HINT,
-      safety: "write",
-      execute: executeMemoryCommand
-    },
-    {
-      name: "rewind",
-      description: "List edit checkpoints or restore code to a previous checkpoint.",
-      argumentHint: "list | restore CHECKPOINT_ID | code CHECKPOINT_ID",
-      safety: "write",
-      execute: executeRewindCommand
-    },
-    {
-      name: "resume",
-      description: "Resume a previous session",
-      execute: (_session, _args) => ({
-        message: "Opening session picker...",
-        success: true,
-        data: { triggerResumePicker: true }
-      })
-    },
-    {
-      name: "background",
-      description: "List and control background tasks",
-      execute: executeBackgroundCommand
-    },
-    {
-      name: "rename",
-      description: "Rename the current session",
-      execute: (_session, args) => {
-        const name = args.trim();
-        if (!name) {
-          return { message: "Usage: rename <name>", success: false };
-        }
-        return {
-          message: `Session renamed to "${name}".`,
-          success: true,
-          data: { name }
-        };
-      }
-    },
-    {
-      name: "reset",
-      description: "Delete settings",
-      execute: (_session, _args) => {
-        return {
-          message: "Reset requested.",
-          success: true,
-          data: { resetRequested: true }
-        };
-      }
+      name: "used",
+      description: "Show memory references used in the current turn",
+      source
     }
   ];
 }
+function createCommandProjectMemoryStore(cwd, now) {
+  return new ProjectMemoryStore(cwd, now);
+}
+function createCommandPendingMemoryStore(cwd, now) {
+  return new PendingMemoryStore(cwd, now);
+}
+function createCommandMemoryStores(context, now) {
+  const cwd = context.getCwd();
+  return {
+    project: createCommandProjectMemoryStore(cwd, now),
+    pending: createCommandPendingMemoryStore(cwd, now)
+  };
+}
+function isCommandMemoryType(value) {
+  return isMemoryType(value);
+}
+function hasSensitiveCommandMemoryContent(text) {
+  return containsSensitiveMemoryContent(text);
+}
+function listCommandUsedMemoryReferences(context) {
+  return context.getUsedMemoryReferences();
+}
+function recordCommandMemoryEvent(context, event, now = () => /* @__PURE__ */ new Date()) {
+  context.recordMemoryEvent({
+    ...event,
+    at: now().toISOString()
+  });
+}
 
 // src/utils/skill-prompt.ts
 var import_node_child_process = require("child_process");
@@ -1330,7 +1510,7 @@ async function executeSkill(skill, args, callbacks, context) {
 }
 
 // src/assembly/create-subagent-session.ts
-var import_agent_sessions = require("@robota-sdk/agent-sessions");
+var import_agent_sessions2 = require("@robota-sdk/agent-sessions");
 
 // src/assembly/subagent-prompts.ts
 function getSubagentSuffix() {
@@ -1394,7 +1574,7 @@ function createSubagentSession(options) {
     isForkWorker: options.isForkWorker ?? false
   });
   const provider = options.provider;
-  return new import_agent_sessions.Session({
+  return new import_agent_sessions2.Session({
     tools,
     provider,
     systemMessage,
@@ -1561,15 +1741,149 @@ function createInProcessSubagentRunner(deps) {
   };
 }
 
+// src/tools/agent-tool-batch.ts
+function stringifyAgentBatchResult(input) {
+  const successfulJobs = input.jobs.filter((job) => job.success);
+  const agentIds = input.jobs.map((job) => job.agentId).filter((agentId) => typeof agentId === "string" && agentId.length > 0);
+  const failedJobCount = input.jobs.filter((job) => !job.success).length;
+  return JSON.stringify({
+    success: input.jobs.every((job) => job.success),
+    mode: "batch",
+    output: successfulJobs.map((job) => job.output ?? "").filter(Boolean).join("\n\n"),
+    groupId: input.groupId,
+    requestedJobCount: input.requestedJobCount,
+    startedJobCount: agentIds.length,
+    failedJobCount,
+    agentIds,
+    jobs: input.jobs,
+    provenance: {
+      source: "agent-tool-batch",
+      groupId: input.groupId,
+      requestedJobCount: input.requestedJobCount,
+      startedJobCount: agentIds.length,
+      failedJobCount
+    }
+  });
+}
+function createBatchGroupId() {
+  const idRadix = 36;
+  const randomStartIndex = 2;
+  const randomEndIndex = 10;
+  return `agent_group_${Date.now()}_${Math.random().toString(idRadix).slice(randomStartIndex, randomEndIndex)}`;
+}
+function normalizeJobLabel(label, fallback) {
+  const trimmed = label?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : fallback;
+}
+function resolveBatchJob(job, index, input) {
+  const agentType = job.subagent_type ?? "general-purpose";
+  const agentDef = input.resolveAgentDefinition(agentType, input.deps.customAgentRegistry);
+  const label = normalizeJobLabel(job.label, agentDef?.name ?? agentType);
+  return { index, job, agentType, agentDef, label };
+}
+function isValidBatchJob(job) {
+  return job.agentDef !== void 0;
+}
+function createUnknownAgentBatchResult(job, groupId) {
+  return {
+    index: job.index,
+    success: false,
+    groupId,
+    label: job.label,
+    subagent_type: job.agentType,
+    prompt: job.job.prompt,
+    error: `Unknown agent type: ${job.agentType}`
+  };
+}
+async function spawnBatchJob(job, input) {
+  try {
+    const state = await input.manager.spawn(
+      input.createSpawnRequest(job.job, job.agentType, job.agentDef, input.deps, job.label)
+    );
+    return { ...job, agentId: state.id };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ...job, spawnError: message };
+  }
+}
+function createBatchSpawnErrorResult(job, groupId) {
+  return {
+    index: job.index,
+    success: false,
+    groupId,
+    label: job.label,
+    subagent_type: job.agentType,
+    prompt: job.job.prompt,
+    error: `Sub-agent error: ${job.spawnError ?? "missing agent id"}`
+  };
+}
+function createBatchSuccessResult(job, groupId, result) {
+  return {
+    index: job.index,
+    success: true,
+    groupId,
+    label: job.label,
+    agentId: result.jobId,
+    subagent_type: job.agentType,
+    prompt: job.job.prompt,
+    output: result.output,
+    metadata: result.metadata
+  };
+}
+function createBatchWaitErrorResult(job, groupId, message) {
+  return {
+    index: job.index,
+    success: false,
+    groupId,
+    label: job.label,
+    agentId: job.agentId,
+    subagent_type: job.agentType,
+    prompt: job.job.prompt,
+    error: `Sub-agent error: ${message}`
+  };
+}
+async function waitBatchJob(job, groupId, manager) {
+  if (job.agentId === void 0) {
+    return createBatchSpawnErrorResult(job, groupId);
+  }
+  try {
+    const result = await manager.wait(job.agentId);
+    return createBatchSuccessResult({ ...job, agentId: job.agentId }, groupId, result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return createBatchWaitErrorResult({ ...job, agentId: job.agentId }, groupId, message);
+  }
+}
+async function runManagedAgentBatch(input) {
+  const groupId = createBatchGroupId();
+  const resolvedJobs = input.jobs.map((job, index) => resolveBatchJob(job, index, input));
+  const invalidJobs = resolvedJobs.filter((job) => !isValidBatchJob(job)).map((job) => createUnknownAgentBatchResult(job, groupId));
+  const startedJobs = await Promise.all(
+    resolvedJobs.filter(isValidBatchJob).map((job) => spawnBatchJob(job, input))
+  );
+  const terminalJobs = await Promise.all(
+    startedJobs.map((job) => waitBatchJob(job, groupId, input.manager))
+  );
+  const batchJobs = [...invalidJobs, ...terminalJobs].sort(
+    (left, right) => left.index - right.index
+  );
+  return stringifyAgentBatchResult({
+    groupId,
+    requestedJobCount: input.jobs.length,
+    jobs: batchJobs
+  });
+}
+
 // src/tools/agent-tool.ts
 var AGENT_TOOL_DESCRIPTION = [
   "Creates delegated subagent jobs in isolated contexts.",
   "Without jobs, one tool call creates one subagent job from prompt.",
-  "For explicit multi-agent or parallel-agent requests, use one Agent tool call with jobs containing one entry per requested role.",
+  "For explicit multi-agent or parallel-agent requests, use one Agent tool call with jobs containing one entry per requested role and a stable label for each role.",
   "When the user explicitly asks to create, run, spawn, delegate to, or use agents/subagents, start the requested subagent job immediately.",
   "Do not ask a follow-up question unless execution is impossible or unsafe.",
   "Subagent jobs run as background tasks by default.",
-  "The tool waits for a terminal result and returns completed, failed, or timed-out outcome data to the parent conversation.",
+  "The tool waits for a terminal result and returns completed, failed, or timed-out outcome data with structured requested/started job counts.",
+  "After the tool returns, base user-facing claims on returned mode and counts; do not say parallel or multiple jobs started unless the result proves those jobs started.",
   "Execution is represented by a real tool call and runtime background task event."
 ].join(" ");
 function createAgentToolPromptDescription(agentDefinitions = []) {
@@ -1577,10 +1891,11 @@ function createAgentToolPromptDescription(agentDefinitions = []) {
   return [
     "Agent \u2014 creates isolated subagent jobs.",
     "Without jobs, one Agent tool call corresponds to one subagent job.",
-    "For explicit multi-agent or parallel-agent requests, use one Agent tool call with jobs containing one entry per requested role.",
+    "For explicit multi-agent or parallel-agent requests, use one Agent tool call with jobs containing one entry per requested role and a stable label for each role.",
     "When the user explicitly asks to create, run, spawn, delegate to, or use agents/subagents, start the requested subagent job immediately.",
     "Do not ask a follow-up question unless execution is impossible or unsafe.",
-    "The tool returns terminal result data.",
+    "The tool returns terminal result data with mode, requestedJobCount, startedJobCount, failedJobCount, and provenance.",
+    "After the tool returns, base user-facing claims on returned mode and counts; do not say parallel or multiple jobs started unless the result proves those jobs started.",
     "Runtime mode is background.",
     availableAgents
   ].join(" ").replace(/\s+/g, " ").trim();
@@ -1595,6 +1910,7 @@ var AgentSchema = import_zod.z.object({
   isolation: import_zod.z.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.'),
   jobs: import_zod.z.array(
     import_zod.z.object({
+      label: import_zod.z.string().optional().describe("Stable role label for this batch job"),
       prompt: import_zod.z.string().describe("The task for this subagent to perform"),
       subagent_type: import_zod.z.string().optional().describe("Agent type for this job"),
       model: import_zod.z.string().optional().describe("Optional model override for this job"),
@@ -1623,10 +1939,10 @@ function createSubagentManager(deps) {
     runner: createInProcessSubagentRunner(deps)
   });
 }
-function createSpawnRequest(args, agentType, agentDef, deps) {
+function createSpawnRequest(args, agentType, agentDef, deps, label = agentDef.name) {
   return {
     type: agentType,
-    label: agentDef.name,
+    label,
     parentSessionId: deps.parentSessionId ?? "unknown-session",
     mode: "background",
     depth: deps.subagentDepth ?? 1,
@@ -1639,39 +1955,65 @@ function createSpawnRequest(args, agentType, agentDef, deps) {
 function stringifyUnknownAgentType(agentType) {
   return JSON.stringify({
     success: false,
+    mode: "single",
+    requestedJobCount: 1,
+    startedJobCount: 0,
+    failedJobCount: 1,
     output: "",
-    error: `Unknown agent type: ${agentType}`
+    error: `Unknown agent type: ${agentType}`,
+    provenance: {
+      source: "agent-tool-single",
+      requestedJobCount: 1,
+      startedJobCount: 0,
+      failedJobCount: 1
+    }
   });
 }
 function stringifyAgentSuccess(result) {
   const worktreePath = result.metadata?.["worktreePath"];
   const branchName = result.metadata?.["branchName"];
+  const worktreeStatus = result.metadata?.["worktreeStatus"];
+  const worktreeNextAction = result.metadata?.["worktreeNextAction"];
   return JSON.stringify({
     success: true,
+    mode: "single",
+    requestedJobCount: 1,
+    startedJobCount: 1,
+    failedJobCount: 0,
     output: result.output,
     agentId: result.jobId,
+    agentIds: [result.jobId],
+    provenance: {
+      source: "agent-tool-single",
+      requestedJobCount: 1,
+      startedJobCount: 1,
+      failedJobCount: 0
+    },
     metadata: result.metadata,
     ...typeof worktreePath === "string" ? { worktreePath } : {},
-    ...typeof branchName === "string" ? { branchName } : {}
+    ...typeof branchName === "string" ? { branchName } : {},
+    ...typeof worktreeStatus === "string" ? { worktreeStatus } : {},
+    ...typeof worktreeNextAction === "string" ? { worktreeNextAction } : {}
   });
 }
 function stringifyAgentError(message, agentId) {
+  const startedJobCount = agentId === void 0 ? 0 : 1;
   return JSON.stringify({
     success: false,
+    mode: "single",
+    requestedJobCount: 1,
+    startedJobCount,
+    failedJobCount: 1,
     output: "",
     error: `Sub-agent error: ${message}`,
-    agentId
-  });
-}
-function stringifyAgentBatchResult(input) {
-  const successfulJobs = input.jobs.filter((job) => job.success);
-  const agentIds = input.jobs.map((job) => job.agentId).filter((agentId) => typeof agentId === "string" && agentId.length > 0);
-  return JSON.stringify({
-    success: input.jobs.every((job) => job.success),
-    output: successfulJobs.map((job) => job.output ?? "").filter(Boolean).join("\n\n"),
-    groupId: input.groupId,
-    agentIds,
-    jobs: input.jobs
+    agentId,
+    ...agentId !== void 0 ? { agentIds: [agentId] } : {},
+    provenance: {
+      source: "agent-tool-single",
+      requestedJobCount: 1,
+      startedJobCount,
+      failedJobCount: 1
+    }
   });
 }
 async function runManagedAgent(args, deps, manager) {
@@ -1695,75 +2037,6 @@ async function runManagedAgent(args, deps, manager) {
     return stringifyAgentError(message, agentId);
   }
 }
-function createBatchGroupId() {
-  return `agent_group_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-}
-async function runManagedAgentBatch(jobs, deps, manager) {
-  const groupId = createBatchGroupId();
-  const resolvedJobs = jobs.map((job, index) => {
-    const agentType = job.subagent_type ?? "general-purpose";
-    const agentDef = resolveAgentDefinition2(agentType, deps.customAgentRegistry);
-    return { index, job, agentType, agentDef };
-  });
-  const invalidJobs = resolvedJobs.filter((job) => job.agentDef === void 0).map((job) => ({
-    index: job.index,
-    success: false,
-    subagent_type: job.agentType,
-    error: `Unknown agent type: ${job.agentType}`
-  }));
-  const validJobs = resolvedJobs.filter(
-    (job) => job.agentDef !== void 0
-  );
-  const startedJobs = await Promise.all(
-    validJobs.map(async (job) => {
-      try {
-        const state = await manager.spawn(
-          createSpawnRequest(job.job, job.agentType, job.agentDef, deps)
-        );
-        return { ...job, agentId: state.id, spawnError: void 0 };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { ...job, agentId: void 0, spawnError: message };
-      }
-    })
-  );
-  const terminalJobs = await Promise.all(
-    startedJobs.map(async (job) => {
-      if (job.spawnError || !job.agentId) {
-        return {
-          index: job.index,
-          success: false,
-          subagent_type: job.agentType,
-          error: `Sub-agent error: ${job.spawnError ?? "missing agent id"}`
-        };
-      }
-      try {
-        const result = await manager.wait(job.agentId);
-        return {
-          index: job.index,
-          success: true,
-          agentId: result.jobId,
-          subagent_type: job.agentType,
-          output: result.output,
-          metadata: result.metadata
-        };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-          index: job.index,
-          success: false,
-          agentId: job.agentId,
-          subagent_type: job.agentType,
-          error: `Sub-agent error: ${message}`
-        };
-      }
-    })
-  );
-  const batchJobs = [...invalidJobs, ...terminalJobs].sort(
-    (left, right) => left.index - right.index
-  );
-  return stringifyAgentBatchResult({ groupId, jobs: batchJobs });
-}
 function createAgentTool(deps) {
   const manager = createSubagentManager(deps);
   return (0, import_agent_tools.createZodFunctionTool)(
@@ -1773,7 +2046,13 @@ function createAgentTool(deps) {
     async (params) => {
       const args = params;
       if (Array.isArray(args.jobs) && args.jobs.length > 0) {
-        return runManagedAgentBatch(args.jobs, deps, manager);
+        return runManagedAgentBatch({
+          jobs: args.jobs,
+          deps,
+          manager,
+          resolveAgentDefinition: resolveAgentDefinition2,
+          createSpawnRequest
+        });
       }
       return runManagedAgent(
         {
@@ -1992,7 +2271,7 @@ function retrieveSessionBackgroundTaskManager(key) {
 
 // src/interactive/interactive-session-execution.ts
 var import_node_crypto = require("crypto");
-var import_agent_core2 = require("@robota-sdk/agent-core");
+var import_agent_core5 = require("@robota-sdk/agent-core");
 function isAbortError(err) {
   return err instanceof DOMException && err.name === "AbortError" || err instanceof Error && (err.message.includes("aborted") || err.message.includes("abort"));
 }
@@ -2010,13 +2289,13 @@ function extractToolSummaries(history, historyBefore) {
 }
 function buildResult(response, sessionHistory, interactiveHistory, historyBefore, contextState) {
   const toolSummaries = extractToolSummaries(sessionHistory, historyBefore);
-  const usage3 = extractTurnUsage(sessionHistory, historyBefore, contextState);
+  const usage = extractTurnUsage(sessionHistory, historyBefore, contextState);
   return {
     response,
     history: interactiveHistory,
     toolSummaries,
     contextState,
-    ...usage3 && { usage: usage3 }
+    ...usage && { usage }
   };
 }
 function buildInterruptedResult(sessionHistory, interactiveHistory, historyBefore, contextState) {
@@ -2026,22 +2305,22 @@ function buildInterruptedResult(sessionHistory, interactiveHistory, historyBefor
     const msg = sessionHistory[i];
     if (msg?.role === "assistant" && msg.content) parts.push(msg.content);
   }
-  const usage3 = extractTurnUsage(sessionHistory, historyBefore, contextState);
+  const usage = extractTurnUsage(sessionHistory, historyBefore, contextState);
   return {
     response: parts.join("\n\n"),
     history: interactiveHistory,
     toolSummaries,
     contextState,
-    ...usage3 && { usage: usage3 }
+    ...usage && { usage }
   };
 }
-function createUsageSummaryEntry(usage3) {
+function createUsageSummaryEntry(usage) {
   return {
     id: `usage_${(0, import_node_crypto.randomUUID)()}`,
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "usage-summary",
-    data: usage3
+    data: usage
   };
 }
 function extractTurnUsage(sessionHistory, historyBefore, contextState) {
@@ -2051,11 +2330,11 @@ function extractTurnUsage(sessionHistory, historyBefore, contextState) {
   let foundUsage = false;
   for (const message of turnMessages) {
     if (message.role !== "assistant") continue;
-    const usage3 = (0, import_agent_core2.collectAssistantUsageMetadata)(message);
-    if (!usage3) continue;
+    const usage = (0, import_agent_core5.collectAssistantUsageMetadata)(message);
+    if (!usage) continue;
     foundUsage = true;
-    promptTokens += usage3.inputTokens;
-    completionTokens += usage3.outputTokens;
+    promptTokens += usage.inputTokens;
+    completionTokens += usage.outputTokens;
   }
   if (!foundUsage) return void 0;
   return {
@@ -2385,6 +2664,7 @@ var MarketplaceSourceSchema = import_zod2.z.object({
   })
 });
 var ExtraKnownMarketplacesSchema = import_zod2.z.record(MarketplaceSourceSchema).optional().catch(void 0);
+var AutoCompactThresholdSchema = import_zod2.z.union([import_zod2.z.number().gt(0).lte(1), import_zod2.z.literal(false)]).optional();
 var SettingsSchema = import_zod2.z.object({
   /** Trust level used when no --permission-mode flag is given */
   defaultTrustLevel: import_zod2.z.enum(["safe", "moderate", "full"]).optional(),
@@ -2402,7 +2682,9 @@ var SettingsSchema = import_zod2.z.object({
   /** Plugin enablement map: plugin name -> enabled/disabled */
   enabledPlugins: EnabledPluginsSchema,
   /** Extra marketplace URLs for BundlePlugin discovery */
-  extraKnownMarketplaces: ExtraKnownMarketplacesSchema
+  extraKnownMarketplaces: ExtraKnownMarketplacesSchema,
+  /** Auto-compact threshold as a 0-1 fraction. Set false to disable automatic compaction. */
+  autoCompactThreshold: AutoCompactThresholdSchema
 });
 
 // src/config/config-loader.ts
@@ -2486,7 +2768,8 @@ function mergeSettings(layers) {
       },
       providers: merged.providers !== void 0 || layer.providers !== void 0 ? mergeProviders(merged.providers, layer.providers) : void 0,
       enabledPlugins: merged.enabledPlugins !== void 0 || layer.enabledPlugins !== void 0 ? { ...merged.enabledPlugins ?? {}, ...layer.enabledPlugins ?? {} } : void 0,
-      extraKnownMarketplaces: layer.extraKnownMarketplaces ?? merged.extraKnownMarketplaces
+      extraKnownMarketplaces: layer.extraKnownMarketplaces ?? merged.extraKnownMarketplaces,
+      autoCompactThreshold: layer.autoCompactThreshold ?? merged.autoCompactThreshold
     };
   }, {});
 }
@@ -2540,7 +2823,8 @@ function toResolvedConfig(merged) {
     env: merged.env ?? DEFAULTS.env,
     hooks: merged.hooks ?? void 0,
     enabledPlugins: merged.enabledPlugins ?? void 0,
-    extraKnownMarketplaces: merged.extraKnownMarketplaces ?? void 0
+    extraKnownMarketplaces: merged.extraKnownMarketplaces ?? void 0,
+    autoCompactThreshold: merged.autoCompactThreshold
   };
 }
 function getSettingsPaths(cwd) {
@@ -2688,7 +2972,7 @@ Respond with JSON: { "ok": boolean, "reason"?: string }`;
 };
 
 // src/assembly/create-session.ts
-var import_agent_sessions2 = require("@robota-sdk/agent-sessions");
+var import_agent_sessions3 = require("@robota-sdk/agent-sessions");
 
 // src/context/system-prompt-composer.ts
 function renderSection(section) {
@@ -2870,7 +3154,8 @@ var DEFAULT_TOOL_DESCRIPTIONS = [
   "Edit \u2014 replace a string in a file",
   "Glob \u2014 find files matching a pattern",
   "Grep \u2014 search file contents with regex",
-  "WebSearch \u2014 search the internet (Anthropic built-in)"
+  "WebFetch \u2014 fetch URL content as text",
+  "WebSearch \u2014 search the internet through the configured local tool"
 ];
 function createDefaultTools() {
   return [
@@ -3036,6 +3321,200 @@ function extractFilePath(parameters) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 
+// src/reversible-execution/reversible-execution-policy.ts
+var FILE_MUTATION_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit"]);
+var HOST_SHELL_TOOLS = /* @__PURE__ */ new Set(["Bash", "BackgroundProcess"]);
+var READ_ONLY_TOOLS = /* @__PURE__ */ new Set(["Read", "Glob", "Grep", "WebFetch", "WebSearch"]);
+function evaluateReversibleToolSafety(input) {
+  const toolName = input.toolName;
+  if (READ_ONLY_TOOLS.has(toolName)) {
+    return {
+      toolName,
+      reversible: true,
+      sideEffect: "none",
+      rollbackLayer: "none",
+      status: "read-only",
+      message: `${toolName} does not mutate the local workspace.`
+    };
+  }
+  if (FILE_MUTATION_TOOLS.has(toolName)) {
+    if (input.context.checkpointAvailable) {
+      return {
+        toolName,
+        reversible: true,
+        sideEffect: "file-mutation",
+        rollbackLayer: "edit-checkpoint",
+        status: "reversible",
+        message: `${toolName} is reversible through the active edit checkpoint.`
+      };
+    }
+    return {
+      toolName,
+      reversible: false,
+      sideEffect: "file-mutation",
+      rollbackLayer: "none",
+      status: "requires-checkpoint",
+      message: `${toolName} requires an edit checkpoint before file mutation.`
+    };
+  }
+  if (HOST_SHELL_TOOLS.has(toolName)) {
+    return evaluateIsolatedSideEffect(toolName, "shell-process", input.context);
+  }
+  if (toolName === "Agent") {
+    return evaluateAgentSafety(input.toolArgs, input.context);
+  }
+  return {
+    toolName,
+    reversible: false,
+    sideEffect: "unknown",
+    rollbackLayer: "none",
+    status: "unknown",
+    message: `${toolName} has no reversible execution contract.`
+  };
+}
+function wrapReversibleExecutionTools(tools, options) {
+  const safetyContext = {
+    checkpointAvailable: options.checkpointAvailable,
+    isolation: options.isolation ?? "none"
+  };
+  const enforceUntrackedSideEffects = options.enforceUntrackedSideEffects ?? true;
+  return tools.map(
+    (tool) => new ReversibleExecutionToolWrapper(tool, {
+      safetyContext,
+      enforceUntrackedSideEffects
+    })
+  );
+}
+var ReversibleExecutionToolWrapper = class {
+  constructor(delegate, options) {
+    this.delegate = delegate;
+    this.options = options;
+    this.schema = delegate.schema;
+  }
+  schema;
+  setEventService(eventService) {
+    this.delegate.setEventService(eventService);
+  }
+  async execute(parameters, context) {
+    const report = evaluateReversibleToolSafety({
+      toolName: this.getName(),
+      toolArgs: toToolArgs(parameters),
+      context: this.options.safetyContext
+    });
+    if (!report.reversible && this.options.enforceUntrackedSideEffects) {
+      return createBlockedResult(report);
+    }
+    return this.delegate.execute(parameters, context);
+  }
+  validate(parameters) {
+    return this.delegate.validate(parameters);
+  }
+  validateParameters(parameters) {
+    return this.delegate.validateParameters(parameters);
+  }
+  getDescription() {
+    return this.delegate.getDescription();
+  }
+  getName() {
+    return this.delegate.getName();
+  }
+};
+function evaluateIsolatedSideEffect(toolName, sideEffect, context) {
+  if (context.isolation === "worktree") {
+    return {
+      toolName,
+      reversible: true,
+      sideEffect,
+      rollbackLayer: "worktree",
+      status: "reversible",
+      message: `${toolName} side effects are contained in an isolated Git worktree.`
+    };
+  }
+  if (context.isolation === "provider-sandbox") {
+    return {
+      toolName,
+      reversible: true,
+      sideEffect,
+      rollbackLayer: "provider-sandbox",
+      status: "reversible",
+      message: `${toolName} side effects are contained in a provider sandbox snapshot.`
+    };
+  }
+  return {
+    toolName,
+    reversible: false,
+    sideEffect,
+    rollbackLayer: "none",
+    status: "requires-isolation",
+    message: `${toolName} can create host shell side effects that edit checkpoints cannot restore; use worktree or provider sandbox isolation.`
+  };
+}
+function evaluateAgentSafety(toolArgs, context) {
+  if (context.isolation === "worktree" || context.isolation === "provider-sandbox") {
+    return evaluateIsolatedSideEffect("Agent", "subagent", context);
+  }
+  if (agentRequestUsesWorktree(toolArgs)) {
+    return {
+      toolName: "Agent",
+      reversible: true,
+      sideEffect: "subagent",
+      rollbackLayer: "worktree",
+      status: "reversible",
+      message: "Agent jobs request worktree isolation, so shell side effects stay outside the parent workspace."
+    };
+  }
+  return {
+    toolName: "Agent",
+    reversible: false,
+    sideEffect: "subagent",
+    rollbackLayer: "none",
+    status: "requires-isolation",
+    message: "Agent jobs must request worktree isolation to be reversible in local-first mode."
+  };
+}
+function agentRequestUsesWorktree(toolArgs) {
+  if (!toolArgs) return false;
+  const jobs = toolArgs.jobs;
+  if (Array.isArray(jobs)) {
+    return jobs.length > 0 && jobs.every((job) => {
+      if (!isToolArgRecord(job)) return false;
+      return readIsolation(job) === "worktree";
+    });
+  }
+  return readIsolation(toolArgs) === "worktree";
+}
+function readIsolation(value) {
+  const isolation = value["isolation"];
+  return typeof isolation === "string" ? isolation : void 0;
+}
+function isToolArgRecord(value) {
+  return value !== void 0 && typeof value === "object" && !Array.isArray(value);
+}
+function toToolArgs(parameters) {
+  if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) return void 0;
+  return parameters;
+}
+function createBlockedResult(report) {
+  return {
+    success: true,
+    data: {
+      success: false,
+      output: "",
+      error: report.message,
+      reversibleSafety: {
+        toolName: report.toolName,
+        sideEffect: report.sideEffect,
+        rollbackLayer: report.rollbackLayer,
+        status: report.status
+      }
+    },
+    metadata: {
+      reversibleSafetyStatus: report.status,
+      rollbackLayer: report.rollbackLayer
+    }
+  };
+}
+
 // src/assembly/create-session.ts
 var import_agent_runtime6 = require("@robota-sdk/agent-runtime");
 
@@ -3155,7 +3634,7 @@ var AgentDefinitionLoader = class {
 };
 
 // src/assembly/background-task-hooks.ts
-var import_agent_core3 = require("@robota-sdk/agent-core");
+var import_agent_core6 = require("@robota-sdk/agent-core");
 function getSubagentHookEvent(event) {
   if (event.type === "background_task_started" && event.task.kind === "agent") {
     return "SubagentStart";
@@ -3190,7 +3669,7 @@ function fireSubagentLifecycleHook(event, cwd, hooks, hookTypeExecutors) {
       ROBOTA_AGENT_TYPE: event.task.agentType ?? event.task.label
     }
   };
-  void (0, import_agent_core3.runHooks)(hooks, hookEventName, input, hookTypeExecutors).catch(() => void 0);
+  void (0, import_agent_core6.runHooks)(hooks, hookEventName, input, hookTypeExecutors).catch(() => void 0);
 }
 
 // src/assembly/create-session.ts
@@ -3207,7 +3686,11 @@ function createSession(options) {
   const cwd = options.cwd ?? process.cwd();
   const sessionId = options.sessionId ?? createSessionId();
   const defaultTools = options.editCheckpointRecorder ? wrapEditCheckpointTools(createDefaultTools(), options.editCheckpointRecorder) : createDefaultTools();
-  const tools = [...defaultTools, ...options.additionalTools ?? []];
+  const assembledTools = [...defaultTools, ...options.additionalTools ?? []];
+  const tools = options.reversibleExecution ? wrapReversibleExecutionTools(assembledTools, {
+    ...options.reversibleExecution,
+    checkpointAvailable: options.editCheckpointRecorder !== void 0
+  }) : assembledTools;
   if (options.modelCommandExecutor && options.isModelCommandInvocable) {
     tools.push(
       createCommandExecutionTool({
@@ -3346,7 +3829,8 @@ ${options.appendSystemPrompt}` : systemMessage;
     allow: [...defaultAllow, ...options.config.permissions.allow ?? [], ...allowedToolPatterns],
     deny: options.config.permissions.deny ?? []
   };
-  const session = new import_agent_sessions2.Session({
+  const SessionWithAutoCompact = import_agent_sessions3.Session;
+  const session = new SessionWithAutoCompact({
     tools,
     provider,
     systemMessage: finalSystemMessage,
@@ -3366,7 +3850,9 @@ ${options.appendSystemPrompt}` : systemMessage;
     onToolExecution: options.onToolExecution,
     promptForApproval: options.promptForApproval,
     onCompact: options.onCompact,
+    onCompactEvent: options.onCompactEvent,
     compactInstructions: options.compactInstructions ?? options.context.compactInstructions,
+    autoCompactThreshold: options.autoCompactThreshold ?? options.config.autoCompactThreshold,
     sessionLogger: options.sessionLogger,
     hookTypeExecutors: hookTypeExecutors.length > 0 ? hookTypeExecutors : void 0
   });
@@ -3389,18 +3875,18 @@ function logBackgroundTaskEvent(logger, sessionId, event) {
 // src/assembly/subagent-logger.ts
 var import_node_fs5 = require("fs");
 var import_node_path4 = require("path");
-var import_agent_sessions3 = require("@robota-sdk/agent-sessions");
+var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
 function createSubagentLogger(parentSessionId, _agentId, baseLogsDir) {
   const subagentDir = (0, import_node_path4.join)(baseLogsDir, parentSessionId, "subagents");
   (0, import_node_fs5.mkdirSync)(subagentDir, { recursive: true });
-  return new import_agent_sessions3.FileSessionLogger(subagentDir);
+  return new import_agent_sessions4.FileSessionLogger(subagentDir);
 }
 function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
   return (0, import_node_path4.join)(baseLogsDir, parentSessionId, "subagents");
 }
 
 // src/interactive/interactive-session-init.ts
-var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
+var import_agent_sessions5 = require("@robota-sdk/agent-sessions");
 
 // src/paths.ts
 var import_node_path5 = require("path");
@@ -4617,11 +5103,12 @@ async function createInteractiveSession(options) {
     permissionMode: options.permissionMode,
     maxTurns: options.maxTurns,
     terminal: NOOP_TERMINAL,
-    sessionLogger: new import_agent_sessions4.FileSessionLogger(paths.logs),
+    sessionLogger: new import_agent_sessions5.FileSessionLogger(paths.logs),
     permissionHandler: options.permissionHandler,
     provider: options.provider,
     onTextDelta: options.onTextDelta,
     onContextUpdate: options.onContextUpdate,
+    onCompactEvent: options.onCompactEvent,
     onToolExecution: options.onToolExecution,
     sessionId,
     allowedTools: options.allowedTools,
@@ -4639,7 +5126,8 @@ async function createInteractiveSession(options) {
     } : {},
     modelCommandExecutor: options.modelCommandExecutor,
     isModelCommandInvocable: options.isModelCommandInvocable,
-    editCheckpointRecorder: options.editCheckpointRecorder
+    editCheckpointRecorder: options.editCheckpointRecorder,
+    reversibleExecution: options.reversibleExecution
   });
 }
 function injectSavedMessage(session, msg) {
@@ -4736,8 +5224,60 @@ function isRestoredTerminalStatus(status) {
 
 // src/checkpoints/edit-checkpoint-store.ts
 var import_promises = require("fs/promises");
+var import_node_fs14 = require("fs");
+var import_node_path15 = require("path");
+
+// src/checkpoints/edit-checkpoint-inspection.ts
 var import_node_fs13 = require("fs");
 var import_node_path14 = require("path");
+function buildEditCheckpointInspection(input) {
+  const later = input.manifests.filter((manifest) => manifest.sequence > input.target.sequence);
+  const rollbackRange = input.manifests.filter(
+    (manifest) => manifest.sequence >= input.target.sequence
+  );
+  return {
+    target: toSummary(input.target),
+    capturedFiles: input.target.files.map((file) => {
+      const snapshotPath = file.snapshotFile ? (0, import_node_path14.join)(input.checkpointDir(input.sessionId, input.target.id), file.snapshotFile) : void 0;
+      const snapshotStats = snapshotPath ? statSafe(snapshotPath) : void 0;
+      return {
+        originalPath: file.originalPath,
+        relativePath: (0, import_node_path14.relative)(input.cwd, file.originalPath),
+        existed: file.existed,
+        restoreAction: file.existed ? "restore-preimage" : "delete-created-file",
+        snapshotAvailable: file.existed ? snapshotStats !== void 0 : false,
+        ...snapshotStats ? { snapshotSizeBytes: snapshotStats.size } : {}
+      };
+    }),
+    restoreToCheckpoint: toInspectionPlan(later),
+    rollbackThroughCheckpoint: toInspectionPlan(rollbackRange)
+  };
+}
+function toSummary(manifest) {
+  return {
+    id: manifest.id,
+    sessionId: manifest.sessionId,
+    sequence: manifest.sequence,
+    prompt: manifest.prompt,
+    createdAt: manifest.createdAt,
+    fileCount: manifest.fileCount
+  };
+}
+function toInspectionPlan(manifests) {
+  return {
+    checkpointIds: manifests.map((manifest) => manifest.id),
+    fileCount: manifests.reduce((count, manifest) => count + manifest.fileCount, 0)
+  };
+}
+function statSafe(path) {
+  try {
+    return (0, import_node_fs13.statSync)(path);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/checkpoints/edit-checkpoint-store.ts
 var MANIFEST_FILE = "manifest.json";
 var SNAPSHOT_DIR = "files";
 var ID_PAD = 4;
@@ -4748,7 +5288,7 @@ var EditCheckpointStore = class {
   now;
   activeTurn = null;
   constructor(options) {
-    this.cwd = (0, import_node_path14.resolve)(options.cwd);
+    this.cwd = (0, import_node_path15.resolve)(options.cwd);
     this.rootDir = projectPaths(this.cwd).checkpoints;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
   }
@@ -4758,8 +5298,8 @@ var EditCheckpointStore = class {
     }
     const nextSequence = this.nextSequence(input.sessionId);
     const id = `turn-${String(nextSequence).padStart(ID_PAD, "0")}`;
-    const dir = (0, import_node_path14.join)(this.sessionDir(input.sessionId), id);
-    await (0, import_promises.mkdir)((0, import_node_path14.join)(dir, SNAPSHOT_DIR), { recursive: true });
+    const dir = (0, import_node_path15.join)(this.sessionDir(input.sessionId), id);
+    await (0, import_promises.mkdir)((0, import_node_path15.join)(dir, SNAPSHOT_DIR), { recursive: true });
     const manifest = {
       version: 1,
       id,
@@ -4775,11 +5315,11 @@ var EditCheckpointStore = class {
       dir,
       capturedPaths: /* @__PURE__ */ new Set()
     };
-    return toSummary(manifest);
+    return toSummary2(manifest);
   }
   async captureFile(filePath) {
     if (!this.activeTurn) return;
-    const originalPath = (0, import_node_path14.resolve)(this.cwd, filePath);
+    const originalPath = (0, import_node_path15.resolve)(this.cwd, filePath);
     if (this.activeTurn.capturedPaths.has(originalPath)) return;
     if (isInside(this.rootDir, originalPath)) return;
     const record = await this.createFileRecord(originalPath, this.activeTurn);
@@ -4792,10 +5332,24 @@ var EditCheckpointStore = class {
     const active = this.activeTurn;
     this.activeTurn = null;
     await this.writeManifest(active.dir, active.manifest);
-    return toSummary(active.manifest);
+    return toSummary2(active.manifest);
   }
   list(sessionId) {
-    return this.loadManifests(sessionId).map(toSummary);
+    return this.loadManifests(sessionId).map(toSummary2);
+  }
+  inspect(sessionId, checkpointId) {
+    const manifests = this.loadManifests(sessionId);
+    const target = manifests.find((manifest) => manifest.id === checkpointId);
+    if (!target) {
+      throw new Error(`Unknown edit checkpoint: ${checkpointId}`);
+    }
+    return buildEditCheckpointInspection({
+      cwd: this.cwd,
+      sessionId,
+      target,
+      manifests,
+      checkpointDir: (inputSessionId, inputCheckpointId) => this.checkpointDir(inputSessionId, inputCheckpointId)
+    });
   }
   async restoreToCheckpoint(sessionId, checkpointId) {
     const manifests = this.loadManifests(sessionId);
@@ -4815,12 +5369,36 @@ var EditCheckpointStore = class {
       await (0, import_promises.rm)(this.checkpointDir(sessionId, manifest.id), { recursive: true, force: true });
     }
     return {
-      target: toSummary(target),
+      target: toSummary2(target),
       restoredCheckpointCount: later.length,
       restoredFileCount,
       removedCheckpointCount: later.length
     };
   }
+  async rollbackThroughCheckpoint(sessionId, checkpointId) {
+    const manifests = this.loadManifests(sessionId);
+    const target = manifests.find((manifest) => manifest.id === checkpointId);
+    if (!target) {
+      throw new Error(`Unknown edit checkpoint: ${checkpointId}`);
+    }
+    const rollbackRange = manifests.filter((manifest) => manifest.sequence >= target.sequence).sort((a, b) => b.sequence - a.sequence);
+    let restoredFileCount = 0;
+    for (const manifest of rollbackRange) {
+      for (const file of manifest.files) {
+        await this.restoreFile(sessionId, manifest.id, file);
+        restoredFileCount += 1;
+      }
+    }
+    for (const manifest of rollbackRange) {
+      await (0, import_promises.rm)(this.checkpointDir(sessionId, manifest.id), { recursive: true, force: true });
+    }
+    return {
+      target: toSummary2(target),
+      restoredCheckpointCount: rollbackRange.length,
+      restoredFileCount,
+      removedCheckpointCount: rollbackRange.length
+    };
+  }
   async createFileRecord(originalPath, active) {
     const existed = await pathExists(originalPath);
     if (!existed) {
@@ -4829,11 +5407,11 @@ var EditCheckpointStore = class {
         existed: false
       };
     }
-    const snapshotFile = (0, import_node_path14.join)(
+    const snapshotFile = (0, import_node_path15.join)(
       SNAPSHOT_DIR,
       `${String(active.manifest.files.length + 1).padStart(SNAPSHOT_PAD, "0")}.content`
     );
-    await (0, import_promises.copyFile)(originalPath, (0, import_node_path14.join)(active.dir, snapshotFile));
+    await (0, import_promises.copyFile)(originalPath, (0, import_node_path15.join)(active.dir, snapshotFile));
     return {
       originalPath,
       existed: true,
@@ -4848,15 +5426,15 @@ var EditCheckpointStore = class {
     if (!record.snapshotFile) {
       throw new Error(`Checkpoint file record is missing a snapshot: ${record.originalPath}`);
     }
-    await (0, import_promises.mkdir)((0, import_node_path14.dirname)(record.originalPath), { recursive: true });
+    await (0, import_promises.mkdir)((0, import_node_path15.dirname)(record.originalPath), { recursive: true });
     await (0, import_promises.copyFile)(
-      (0, import_node_path14.join)(this.checkpointDir(sessionId, checkpointId), record.snapshotFile),
+      (0, import_node_path15.join)(this.checkpointDir(sessionId, checkpointId), record.snapshotFile),
       record.originalPath
     );
   }
   loadManifests(sessionId) {
     const dir = this.sessionDir(sessionId);
-    return readDirSyncSafe(dir).map((entry) => (0, import_node_path14.join)(dir, entry, MANIFEST_FILE)).map((manifestPath) => readJsonManifest(manifestPath)).filter((manifest) => manifest !== void 0).sort((a, b) => a.sequence - b.sequence);
+    return readDirSyncSafe(dir).map((entry) => (0, import_node_path15.join)(dir, entry, MANIFEST_FILE)).map((manifestPath) => readJsonManifest(manifestPath)).filter((manifest) => manifest !== void 0).sort((a, b) => a.sequence - b.sequence);
   }
   nextSequence(sessionId) {
     const last = this.list(sessionId).at(-1);
@@ -4864,19 +5442,19 @@ var EditCheckpointStore = class {
   }
   async writeManifest(dir, manifest) {
     await (0, import_promises.mkdir)(dir, { recursive: true });
-    const path = (0, import_node_path14.join)(dir, MANIFEST_FILE);
+    const path = (0, import_node_path15.join)(dir, MANIFEST_FILE);
     const tmp = `${path}.tmp`;
     await (0, import_promises.writeFile)(tmp, JSON.stringify(manifest, null, 2), "utf8");
     await (0, import_promises.rename)(tmp, path);
   }
   sessionDir(sessionId) {
-    return (0, import_node_path14.join)(this.rootDir, safePathSegment(sessionId));
+    return (0, import_node_path15.join)(this.rootDir, safePathSegment(sessionId));
   }
   checkpointDir(sessionId, checkpointId) {
-    return (0, import_node_path14.join)(this.sessionDir(sessionId), safePathSegment(checkpointId));
+    return (0, import_node_path15.join)(this.sessionDir(sessionId), safePathSegment(checkpointId));
   }
 };
-function toSummary(manifest) {
+function toSummary2(manifest) {
   return {
     id: manifest.id,
     sessionId: manifest.sessionId,
@@ -4890,12 +5468,12 @@ function safePathSegment(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function isInside(parent, child) {
-  const rel = (0, import_node_path14.relative)(parent, child);
+  const rel = (0, import_node_path15.relative)(parent, child);
   return rel.length === 0 || !rel.startsWith("..") && !rel.startsWith("/");
 }
 async function pathExists(path) {
   try {
-    await (0, import_promises.access)(path, import_node_fs13.constants.F_OK);
+    await (0, import_promises.access)(path, import_node_fs14.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -4903,14 +5481,14 @@ async function pathExists(path) {
 }
 function readDirSyncSafe(dir) {
   try {
-    return (0, import_node_fs13.readdirSync)(dir);
+    return (0, import_node_fs14.readdirSync)(dir);
   } catch {
     return [];
   }
 }
 function readJsonManifest(path) {
   try {
-    const raw = (0, import_node_fs13.readFileSync)(path, "utf8");
+    const raw = (0, import_node_fs14.readFileSync)(path, "utf8");
     return JSON.parse(raw);
   } catch {
     return void 0;
@@ -4949,14 +5527,19 @@ var InteractiveSession = class {
   backgroundJobUnsubscribe = null;
   backgroundJobOrchestrator = null;
   commandModules;
+  commandHostAdapters;
+  autoCompactThresholdSource = "default";
   shuttingDown = false;
   shutdownPromise = null;
   constructor(options) {
-    this.commandModules = "commandModules" in options ? options.commandModules ?? [] : [];
-    this.commandExecutor = new SystemCommandExecutor([
-      ...createSystemCommands(),
-      ...this.commandModules.flatMap((module2) => module2.systemCommands ?? [])
-    ]);
+    const sdkBuiltinModule = createBuiltinCommandModule();
+    this.commandModules = [
+      sdkBuiltinModule,
+      ..."commandModules" in options ? options.commandModules ?? [] : []
+    ];
+    this.commandExecutor = new SystemCommandExecutor(
+      this.commandModules.flatMap((module2) => module2.systemCommands ?? [])
+    );
     this.sessionStore = options.sessionStore;
     this.sessionName = options.sessionName;
     this.cwd = ("cwd" in options ? options.cwd : void 0) ?? "";
@@ -4965,8 +5548,10 @@ var InteractiveSession = class {
     }
     this.resumeSessionId = options.resumeSessionId;
     this.forkSession = options.forkSession ?? false;
+    this.commandHostAdapters = "commandHostAdapters" in options ? options.commandHostAdapters : void 0;
     if ("session" in options && options.session) {
       this.session = options.session;
+      this.autoCompactThresholdSource = "session";
       this.initialized = true;
     } else {
       const stdOpts = options;
@@ -4993,7 +5578,8 @@ var InteractiveSession = class {
     if (this.initialized) this.persistCurrentSession();
   }
   async initializeAsync(options) {
-    const config = await loadConfig(options.cwd);
+    const config = options.config ?? await loadConfig(options.cwd);
+    this.autoCompactThresholdSource = config.autoCompactThreshold === void 0 ? "default" : "settings";
     this.editCheckpointStore = new EditCheckpointStore({ cwd: options.cwd });
     this.session = await createInteractiveSession({
       cwd: options.cwd,
@@ -5006,6 +5592,7 @@ var InteractiveSession = class {
       forkSession: this.forkSession,
       onTextDelta: (delta) => this.handleTextDelta(delta),
       onContextUpdate: (state) => this.emit("context_update", state),
+      onCompactEvent: (event) => this.handleCompactEvent(event),
       onToolExecution: (event) => this.handleToolExecution(event),
       bare: options.bare,
       allowedTools: options.allowedTools,
@@ -5014,6 +5601,7 @@ var InteractiveSession = class {
       subagentRunnerFactory: options.subagentRunnerFactory,
       ...options.commandModules ? { commandModules: options.commandModules } : {},
       editCheckpointRecorder: this.editCheckpointStore,
+      ...options.reversibleExecution ? { reversibleExecution: options.reversibleExecution } : {},
       commandDescriptors: this.commandExecutor.listModelInvocableCommands(),
       ...this.commandExecutor.listModelInvocableCommands().length > 0 ? {
         modelCommandExecutor: (command, args) => this.executeModelCommand(command, args),
@@ -5060,7 +5648,18 @@ var InteractiveSession = class {
   }
   async executeCommand(name, args) {
     await this.ensureInitialized();
-    return this.commandExecutor.execute(name, this, args);
+    const command = this.commandExecutor.getCommand(name);
+    if (!command) return null;
+    if (this.executing) {
+      return {
+        success: false,
+        message: "Another prompt or command is already running. Wait for it to finish."
+      };
+    }
+    if (command.lifecycle === "blocking") {
+      return this.executeForegroundCommand(command, args);
+    }
+    return this.commandExecutor.executeCommand(command, this, args);
   }
   async executeModelCommand(name, args) {
     await this.ensureInitialized();
@@ -5153,6 +5752,30 @@ var InteractiveSession = class {
   getContextState() {
     return this.getSessionOrThrow().getContextState();
   }
+  getAutoCompactThreshold() {
+    return this.getSessionOrThrow().getAutoCompactThreshold();
+  }
+  getAutoCompactThresholdSource() {
+    return this.autoCompactThresholdSource;
+  }
+  setAutoCompactThreshold(threshold, source = "session") {
+    this.getSessionOrThrow().setAutoCompactThreshold(threshold);
+    this.autoCompactThresholdSource = source;
+    this.emit("context_update", this.getContextState());
+    this.persistCurrentSession();
+  }
+  getCommandHostAdapters() {
+    return this.commandHostAdapters ?? {};
+  }
+  clearConversationHistory() {
+    this.getSessionOrThrow().clearHistory();
+    this.history = [];
+    this.persistCurrentSession();
+    this.emit("context_update", this.getContextState());
+  }
+  async compactContext(instructions) {
+    await this.getSessionOrThrow().compact(instructions);
+  }
   getName() {
     return this.sessionName;
   }
@@ -5166,6 +5789,10 @@ var InteractiveSession = class {
     const sessionId = this.getSessionOrThrow().getSessionId();
     return this.getEditCheckpointStore().list(sessionId);
   }
+  inspectEditCheckpoint(checkpointId) {
+    const sessionId = this.getSessionOrThrow().getSessionId();
+    return this.getEditCheckpointStore().inspect(sessionId, checkpointId);
+  }
   async restoreEditCheckpoint(checkpointId) {
     await this.ensureInitialized();
     if (this.executing) {
@@ -5176,7 +5803,22 @@ var InteractiveSession = class {
       checkpointId
     );
     this.history.push(
-      (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Restored edit checkpoint: ${checkpointId}`))
+      (0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)(`Restored edit checkpoint: ${checkpointId}`))
+    );
+    this.persistCurrentSession();
+    return result;
+  }
+  async rollbackEditCheckpoint(checkpointId) {
+    await this.ensureInitialized();
+    if (this.executing) {
+      throw new Error("Cannot rollback edit checkpoint while a prompt is running.");
+    }
+    const result = await this.getEditCheckpointStore().rollbackThroughCheckpoint(
+      this.getSessionOrThrow().getSessionId(),
+      checkpointId
+    );
+    this.history.push(
+      (0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)(`Rolled back edit checkpoint: ${checkpointId}`))
     );
     this.persistCurrentSession();
     return result;
@@ -5421,7 +6063,7 @@ var InteractiveSession = class {
     this.executing = true;
     this.clearStreaming();
     this.emit("thinking", true);
-    this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createUserMessage)(displayInput)));
+    this.history.push((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createUserMessage)(displayInput)));
   }
   finishForkSkillExecution() {
     this.executing = false;
@@ -5436,7 +6078,7 @@ var InteractiveSession = class {
     }
   }
   recordForkSkillError(err) {
-    this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Error: ${err.message}`)));
+    this.history.push((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)(`Error: ${err.message}`)));
     this.emit("error", err);
   }
   resolveForkAgentDefinition(agentType, options) {
@@ -5485,15 +6127,42 @@ var InteractiveSession = class {
       toolSummaries: [],
       contextState: this.getContextState()
     };
-    this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createAssistantMessage)(result)));
+    this.history.push((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createAssistantMessage)(result)));
     this.emit("complete", executionResult);
     this.emit("context_update", this.getContextState());
   }
+  async executeForegroundCommand(command, args) {
+    this.executing = true;
+    this.clearStreaming();
+    this.emit("thinking", true);
+    try {
+      const result = await this.commandExecutor.executeCommand(command, this, args);
+      this.emit("context_update", this.getContextState());
+      return result;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        message: `Error: ${errMsg}`
+      };
+    } finally {
+      this.executing = false;
+      this.emit("thinking", false);
+      this.persistCurrentSession();
+      if (!this.shuttingDown && this.pendingPrompt) {
+        const queued = this.pendingPrompt;
+        const queuedDisplay = this.pendingDisplayInput;
+        const queuedRaw = this.pendingRawInput;
+        this.clearPendingQueue();
+        setTimeout(() => this.executePrompt(queued, queuedDisplay, queuedRaw), 0);
+      }
+    }
+  }
   async executePrompt(input, displayInput, rawInput) {
     this.executing = true;
     this.clearStreaming();
     this.emit("thinking", true);
-    this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createUserMessage)(displayInput ?? input)));
+    this.history.push((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createUserMessage)(displayInput ?? input)));
     const historyBefore = this.getSessionOrThrow().getHistory().length;
     this.usedMemoryReferences = [];
     try {
@@ -5509,7 +6178,7 @@ var InteractiveSession = class {
         historyBefore,
         this.getContextState()
       );
-      this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createAssistantMessage)(result.response)));
+      this.history.push((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createAssistantMessage)(result.response)));
       if (result.usage) this.history.push(createUsageSummaryEntry(result.usage));
       this.emit("complete", result);
       this.emit("context_update", this.getContextState());
@@ -5525,15 +6194,15 @@ var InteractiveSession = class {
         pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
         this.clearStreaming();
         if (result.response)
-          this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createAssistantMessage)(result.response)));
+          this.history.push((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createAssistantMessage)(result.response)));
         if (result.usage) this.history.push(createUsageSummaryEntry(result.usage));
-        this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Interrupted by user.")));
+        this.history.push((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)("Interrupted by user.")));
         this.emit("interrupted", result);
       } else {
         pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
         this.clearStreaming();
         const errMsg = err instanceof Error ? err.message : String(err);
-        this.history.push((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Error: ${errMsg}`)));
+        this.history.push((0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)(`Error: ${errMsg}`)));
         this.emit("error", err instanceof Error ? err : new Error(errMsg));
       }
     } finally {
@@ -5570,7 +6239,7 @@ var InteractiveSession = class {
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       this.history.push(
-        (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Checkpoint error: ${err.message}`))
+        (0, import_agent_core7.messageToHistoryEntry)((0, import_agent_core7.createSystemMessage)(`Checkpoint error: ${err.message}`))
       );
       this.emit("error", err);
     }
@@ -5584,6 +6253,19 @@ var InteractiveSession = class {
       }, STREAMING_FLUSH_INTERVAL_MS);
     }
   }
+  handleCompactEvent(event) {
+    if (event.trigger === "auto") {
+      this.history.push(
+        (0, import_agent_core7.messageToHistoryEntry)(
+          (0, import_agent_core7.createSystemMessage)(
+            `Auto compacted context: ${Math.round(event.before.usedPercentage)}% -> ${Math.round(event.after.usedPercentage)}%`
+          )
+        )
+      );
+    }
+    this.emit("compact", event);
+    this.emit("context_update", event.after);
+  }
   handleToolExecution(event) {
     const streamingState = { activeTools: this.activeTools, history: this.history };
     if (event.type === "start") {
@@ -5655,10 +6337,10 @@ function createQuery(options) {
 }
 
 // src/types.ts
-var import_agent_core5 = require("@robota-sdk/agent-core");
+var import_agent_core8 = require("@robota-sdk/agent-core");
 
 // src/index.ts
-var import_agent_core6 = require("@robota-sdk/agent-core");
+var import_agent_core9 = require("@robota-sdk/agent-core");
 
 // src/self-hosting/self-hosting-verification.ts
 var DEFAULT_BASE_REF = "origin/develop";
@@ -5780,7 +6462,7 @@ var import_agent_runtime7 = require("@robota-sdk/agent-runtime");
 var import_agent_runtime8 = require("@robota-sdk/agent-runtime");
 
 // src/index.ts
-var import_agent_core7 = require("@robota-sdk/agent-core");
+var import_agent_core10 = require("@robota-sdk/agent-core");
 
 // src/permissions/permission-prompt.ts
 var import_chalk = __toESM(require("chalk"), 1);
@@ -5803,10 +6485,13 @@ async function promptForApproval(terminal, toolName, toolArgs) {
 }
 
 // src/index.ts
-var import_agent_core8 = require("@robota-sdk/agent-core");
+var import_agent_core11 = require("@robota-sdk/agent-core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AUTO_COMPACT_THRESHOLD_SETTINGS_KEY,
   AgentExecutor,
+  BACKGROUND_COMMAND_DESCRIPTION,
+  BACKGROUND_COMMAND_USAGE,
   BUILT_IN_AGENTS,
   BackgroundJobOrchestrator,
   BackgroundTaskError,
@@ -5814,64 +6499,171 @@ var import_agent_core8 = require("@robota-sdk/agent-core");
   BuiltinCommandSource,
   BundlePluginInstaller,
   BundlePluginLoader,
+  CLEAR_COMMAND_DESCRIPTION,
+  COST_COMMAND_DESCRIPTION,
   CommandRegistry,
+  DEFAULT_AUTO_COMPACT_THRESHOLD,
+  DEFAULT_STATUS_LINE_COMMAND_SETTINGS,
+  EXIT_COMMAND_DESCRIPTION,
   EditCheckpointStore,
+  HELP_COMMAND_DESCRIPTION,
   InteractiveSession,
+  LANGUAGE_COMMAND_ARGUMENT_HINT,
+  LANGUAGE_COMMAND_DESCRIPTION,
+  MEMORY_COMMAND_ARGUMENT_HINT,
+  MEMORY_COMMAND_DESCRIPTION,
+  MEMORY_COMMAND_USAGE,
   MEMORY_INDEX_MAX_BYTES,
   MEMORY_INDEX_MAX_LINES,
+  MODEL_COMMAND_ARGUMENT_HINT,
+  MODEL_COMMAND_DESCRIPTION,
   MarketplaceClient,
+  PERMISSIONS_COMMAND_DESCRIPTION,
+  PERMISSION_MODE_ARGUMENT_HINT,
+  PERMISSION_MODE_COMMAND_DESCRIPTION,
+  PLUGIN_COMMAND_ARGUMENT_HINT,
+  PLUGIN_COMMAND_DESCRIPTION,
   PluginCommandSource,
   PluginSettingsStore,
   ProjectMemoryStore,
   PromptExecutor,
+  RECOMMENDED_RESPONSE_LANGUAGES,
+  RELOAD_PLUGINS_COMMAND_DESCRIPTION,
+  RENAME_COMMAND_DESCRIPTION,
+  RENAME_COMMAND_USAGE,
+  RESUME_COMMAND_DESCRIPTION,
+  REWIND_COMMAND_ARGUMENT_HINT,
+  REWIND_COMMAND_DESCRIPTION,
+  STATUSLINE_COMMAND_ARGUMENT_HINT,
+  STATUSLINE_COMMAND_DESCRIPTION,
   SkillCommandSource,
   SubagentManager,
   SystemCommandExecutor,
   TRUST_TO_MODE,
+  VALID_PERMISSION_MODES,
   WorktreeSubagentRunner,
   assembleSubagentPrompt,
+  buildBackgroundCommandSubcommands,
+  buildLanguageCommandSubcommands,
+  buildMemoryCommandSubcommands,
+  buildModelCommandSubcommands,
+  buildPermissionModeSubcommands,
+  buildPluginCommandSubcommands,
+  buildProviderProfile,
+  buildProviderSetupPatch,
+  buildRewindCommandSubcommands,
   buildSkillPrompt,
+  buildStatusLineCommandSubcommands,
+  cancelCommandBackgroundTask,
   chatEntryToMessage,
+  clearConversationHistory,
+  closeCommandBackgroundTask,
+  compactCommandContext,
   createAgentTool,
   createBackgroundProcessTool,
+  createBuiltinCommandModule,
   createCommandExecutionTool,
+  createCommandMemoryStores,
+  createCommandPendingMemoryStore,
+  createCommandProjectMemoryStore,
   createDefaultTools,
+  createPluginRegistryReloadRequestedEffect,
+  createPluginTuiRequestedEffect,
+  createProviderSetupFlow,
   createQuery,
+  createSessionExitRequestedEffect,
+  createSessionPickerRequestedEffect,
+  createSessionRenamedEffect,
   createSubagentLogger,
   createSubagentSession,
   createSystemCommands,
   createWorktreeSubagentRunner,
   discoverTaskFiles,
   evaluatePermission,
+  evaluateReversibleToolSafety,
   executeSkill,
+  formatCommandBackgroundTask,
+  formatCommandBackgroundTaskList,
+  formatCommandHelpMessage,
+  formatCommandPermissionsMessage,
+  formatEnvReference,
+  formatInvalidPermissionModeMessage,
+  formatLanguageUsageMessage,
+  formatProviderSetupChoiceLabel,
+  formatProviderSetupPromptLabel,
+  formatProviderSetupSelectionPrompt,
   formatTaskContext,
   getBackgroundTaskTransitions,
   getBuiltInAgent,
   getForkWorkerSuffix,
   getMessagesForAPI,
+  getProviderSetupStep,
   getSubagentSuffix,
+  hasSensitiveCommandMemoryContent,
+  hasUsableSecretReference,
+  inspectCommandEditCheckpoint,
   isChatEntry,
+  isCommandMemoryType,
+  isEnvReference,
   isMemoryType,
+  isPermissionMode,
+  isStatusLineCommandSettingsPatch,
   isTerminalBackgroundTaskStatus,
+  listCommandBackgroundTasks,
+  listCommandEditCheckpoints,
+  listCommandSessionAllowedTools,
+  listCommandUsedMemoryReferences,
   loadTaskContext,
+  mergeProviderPatch,
   messageToHistoryEntry,
+  parseCommandBackgroundLogCursor,
   parseFrontmatter,
+  parseLanguageArgument,
+  parsePermissionModeArgument,
+  parseSessionNameArgument,
   parseTaskFile,
   planSelfHostingVerification,
   preprocessShellCommands,
+  probeProviderProfile,
   projectPaths,
   promptForApproval,
+  readAutoCompactThreshold,
+  readAutoCompactThresholdSource,
+  readCommandBackgroundTaskLog,
+  readCommandContextState,
+  readCommandPermissionMode,
+  readCommandPermissionsState,
+  readCommandSessionInfo,
   readCurrentGitBranch,
+  recordCommandMemoryEvent,
+  resetAutoCompactThresholdSetting,
+  resolveEnvReference,
+  resolvePermissionModeAdapter,
+  resolvePluginCommandAdapter,
+  resolveProviderSetupSelection,
   resolveSubagentLogDir,
+  restoreCommandEditCheckpoint,
   retrieveAgentToolDeps,
+  rollbackCommandEditCheckpoint,
   runHooks,
+  runProviderSetupPromptFlow,
   selectRelevantTasks,
+  setCommandAutoCompactThreshold,
+  setCurrentProvider,
   storeAgentToolDeps,
+  submitProviderSetupValue,
   substituteVariables,
   summarizeBackgroundJobGroup,
+  testProviderProfileCommand,
   transitionBackgroundTaskStatus,
   transitionSelfHostingLoop,
   updateTaskFileStatus,
+  upsertProviderProfile,
   userPaths,
-  wrapEditCheckpointTools
+  validateProviderProfile,
+  validateProviderSetupValue,
+  wrapEditCheckpointTools,
+  wrapReversibleExecutionTools,
+  writeAutoCompactThresholdSetting,
+  writeCommandPermissionMode
 });