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

package/dist/node/index.js

@@ -31,6 +31,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(module) {
     for (const source of module.commandSources ?? []) {
       this.addSource(source);
@@ -71,138 +77,222 @@ var CommandRegistry = class {
   }
 };
 
-// src/commands/builtin-source.ts
-import { CLAUDE_MODELS, formatTokenCount } from "@robota-sdk/agent-core";
-function buildModelSubcommands() {
-  const seen = /* @__PURE__ */ new Set();
-  const commands = [];
-  for (const model of Object.values(CLAUDE_MODELS)) {
-    if (seen.has(model.name)) continue;
-    seen.add(model.name);
-    commands.push({
-      name: model.id,
-      description: `${model.name} (${formatTokenCount(model.contextWindow).toUpperCase()})`,
-      source: "builtin"
-    });
-  }
-  return commands;
-}
-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 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" }
-  ];
-}
-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 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"
+// 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 [];
 }
-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" }
-  ];
+
+// 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() {
-    this.commands = createBuiltinCommands();
+  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
+import { findProviderDefinition as findProviderDefinition2 } from "@robota-sdk/agent-core";
+
+// src/command-api/provider/provider-settings.ts
+import { findProviderDefinition } from "@robota-sdk/agent-core";
+
+// 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;
+  }
+  const envName = value.slice(ENV_REFERENCE_PREFIX.length).trim();
+  if (envName.length === 0) {
+    return void 0;
+  }
+  return process.env[envName];
+}
+function hasUsableSecretReference(value) {
+  if (value === void 0 || value.length === 0) {
+    return false;
+  }
+  return resolveEnvReference(value) !== void 0;
+}
+
+// src/command-api/provider/provider-settings.ts
+function upsertProviderProfile(settings, profileName, profile) {
+  return {
+    ...settings,
+    providers: {
+      ...settings.providers ?? {},
+      [profileName]: profile
+    }
+  };
+}
+function setCurrentProvider(settings, profileName) {
+  if (!settings.providers?.[profileName]) {
+    throw new Error(`Provider profile "${profileName}" was not found`);
+  }
+  return {
+    ...settings,
+    currentProvider: profileName
+  };
+}
+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 = 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 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 }
+  };
+}
+function mergeProviderPatch(settings, patch) {
+  const [profileName, profile] = Object.entries(patch.providers)[0] ?? [];
+  if (!profileName || !profile) {
+    return settings;
+  }
+  const withProfile = upsertProviderProfile(settings, profileName, profile);
+  return patch.currentProvider ? setCurrentProvider(withProfile, patch.currentProvider) : withProfile;
+}
+function getProviderDefaults(type, providerDefinitions) {
+  return 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 ? findProviderDefinition2(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
 import { readdirSync, readFileSync, existsSync } from "fs";
@@ -357,66 +447,523 @@ var PluginCommandSource = class {
   }
 };
 
-// src/commands/background-command.ts
+// src/command-api/context/context-command-api.ts
+import { AUTO_COMPACT_THRESHOLD } from "@robota-sdk/agent-sessions";
+var DEFAULT_AUTO_COMPACT_THRESHOLD = 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
+import { findProviderDefinition as findProviderDefinition3, formatSupportedProviderTypes } from "@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: ${formatSupportedProviderTypes(providerDefinitions)}`
+    );
+  }
+  const definition = findProviderDefinition3(providerDefinitions, selectedValue);
+  if (definition === void 0) {
+    throw new Error(
+      `Unknown provider: ${selectedValue}. Currently supported: ${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 = findProviderDefinition3(providerDefinitions, type);
+  if (definition === void 0) {
+    throw new Error(
+      `Unknown provider: ${type}. Currently supported: ${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
+import { CLAUDE_MODELS, formatTokenCount } from "@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(CLAUDE_MODELS)) {
+    if (seen.has(model.name)) continue;
+    seen.add(model.name);
+    commands.push({
+      name: model.id,
+      description: `${model.name} (${formatTokenCount(model.contextWindow).toUpperCase()})`,
+      source
+    });
+  }
+  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;
+  }
+  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.");
   }
-  if (action === "cancel" || action === "stop") {
-    await session.cancelBackgroundTask(taskId, reasonParts.join(" ") || void 0);
-    return { message: `Background task cancelled: ${taskId}`, success: true, data: { taskId } };
+  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;
   }
-  if (action === "close" || action === "dismiss") {
-    await session.closeBackgroundTask(taskId);
-    return { message: `Background task closed: ${taskId}`, success: true, data: { taskId } };
+  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 { message: `Unknown background action: ${action}`, success: false };
+  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
@@ -616,529 +1163,52 @@ var ProjectMemoryStore = class {
   }
 };
 
-// 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
+// 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";
+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: "used",
+      description: "Show memory references used in the current turn",
+      source
     }
-  };
-}
-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 createCommandProjectMemoryStore(cwd, now) {
+  return new ProjectMemoryStore(cwd, now);
 }
-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
-      };
-    }
-    const result = store.append(input);
-    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
-      }
-    };
-  }
-  return usage();
+function createCommandPendingMemoryStore(cwd, now) {
+  return new PendingMemoryStore(cwd, now);
 }
-
-// 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() {
+function createCommandMemoryStores(context, now) {
+  const cwd = context.getCwd();
   return {
-    message: "Usage: rewind [list] | rewind restore <checkpoint-id> | rewind code <checkpoint-id>",
-    success: false
+    project: createCommandProjectMemoryStore(cwd, now),
+    pending: createCommandPendingMemoryStore(cwd, now)
   };
 }
-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] }
-  };
+function isCommandMemoryType(value) {
+  return isMemoryType(value);
 }
-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) {
-    return {
-      message: error instanceof Error ? error.message : String(error),
-      success: false
-    };
-  }
+function hasSensitiveCommandMemoryContent(text) {
+  return containsSensitiveMemoryContent(text);
 }
-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]);
-  }
-  return usage2();
+function listCommandUsedMemoryReferences(context) {
+  return context.getUsedMemoryReferences();
 }
-
-// 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.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);
-  }
-};
-
-// src/commands/system-command.ts
-var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
-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() {
-  return [
-    {
-      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 }
-        };
-      }
-    }
-  ];
+function recordCommandMemoryEvent(context, event, now = () => /* @__PURE__ */ new Date()) {
+  context.recordMemoryEvent({
+    ...event,
+    at: now().toISOString()
+  });
 }
 
 // src/utils/skill-prompt.ts
@@ -1470,15 +1540,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 = []) {
@@ -1486,10 +1690,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();
@@ -1504,6 +1709,7 @@ var AgentSchema = z.object({
   isolation: z.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.'),
   jobs: z.array(
     z.object({
+      label: z.string().optional().describe("Stable role label for this batch job"),
       prompt: z.string().describe("The task for this subagent to perform"),
       subagent_type: z.string().optional().describe("Agent type for this job"),
       model: z.string().optional().describe("Optional model override for this job"),
@@ -1532,10 +1738,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,
@@ -1548,39 +1754,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) {
@@ -1604,75 +1836,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 createZodFunctionTool(
@@ -1682,7 +1845,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(
         {
@@ -1925,13 +2094,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) {
@@ -1941,22 +2110,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_${randomUUID()}`,
     timestamp: /* @__PURE__ */ new Date(),
     category: "event",
     type: "usage-summary",
-    data: usage3
+    data: usage
   };
 }
 function extractTurnUsage(sessionHistory, historyBefore, contextState) {
@@ -1966,11 +2135,11 @@ function extractTurnUsage(sessionHistory, historyBefore, contextState) {
   let foundUsage = false;
   for (const message of turnMessages) {
     if (message.role !== "assistant") continue;
-    const usage3 = collectAssistantUsageMetadata(message);
-    if (!usage3) continue;
+    const usage = 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 {
@@ -2300,6 +2469,7 @@ var MarketplaceSourceSchema = z2.object({
   })
 });
 var ExtraKnownMarketplacesSchema = z2.record(MarketplaceSourceSchema).optional().catch(void 0);
+var AutoCompactThresholdSchema = z2.union([z2.number().gt(0).lte(1), z2.literal(false)]).optional();
 var SettingsSchema = z2.object({
   /** Trust level used when no --permission-mode flag is given */
   defaultTrustLevel: z2.enum(["safe", "moderate", "full"]).optional(),
@@ -2317,7 +2487,9 @@ var SettingsSchema = z2.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
@@ -2401,7 +2573,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
     };
   }, {});
 }
@@ -2455,7 +2628,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) {
@@ -2794,7 +2968,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 [
@@ -2960,6 +3135,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
 import { BackgroundTaskManager as BackgroundTaskManager2, SubagentManager as SubagentManager2 } from "@robota-sdk/agent-runtime";
 
@@ -3131,7 +3500,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({
@@ -3270,7 +3643,8 @@ ${options.appendSystemPrompt}` : systemMessage;
     allow: [...defaultAllow, ...options.config.permissions.allow ?? [], ...allowedToolPatterns],
     deny: options.config.permissions.deny ?? []
   };
-  const session = new Session2({
+  const SessionWithAutoCompact = Session2;
+  const session = new SessionWithAutoCompact({
     tools,
     provider,
     systemMessage: finalSystemMessage,
@@ -3290,7 +3664,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
   });
@@ -4546,6 +4922,7 @@ async function createInteractiveSession(options) {
     provider: options.provider,
     onTextDelta: options.onTextDelta,
     onContextUpdate: options.onContextUpdate,
+    onCompactEvent: options.onCompactEvent,
     onToolExecution: options.onToolExecution,
     sessionId,
     allowedTools: options.allowedTools,
@@ -4563,7 +4940,8 @@ async function createInteractiveSession(options) {
     } : {},
     modelCommandExecutor: options.modelCommandExecutor,
     isModelCommandInvocable: options.isModelCommandInvocable,
-    editCheckpointRecorder: options.editCheckpointRecorder
+    editCheckpointRecorder: options.editCheckpointRecorder,
+    reversibleExecution: options.reversibleExecution
   });
 }
 function injectSavedMessage(session, msg) {
@@ -4661,7 +5039,59 @@ function isRestoredTerminalStatus(status) {
 // src/checkpoints/edit-checkpoint-store.ts
 import { access, copyFile, mkdir, rename, rm, writeFile } from "fs/promises";
 import { constants, readdirSync as readdirSync7, readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname8, join as join17, relative as relative2, resolve as resolve3 } from "path";
+import { dirname as dirname8, join as join18, relative as relative3, resolve as resolve3 } from "path";
+
+// src/checkpoints/edit-checkpoint-inspection.ts
+import { statSync as statSync2 } from "fs";
+import { join as join17, relative as relative2 } from "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 ? join17(input.checkpointDir(input.sessionId, input.target.id), file.snapshotFile) : void 0;
+      const snapshotStats = snapshotPath ? statSafe(snapshotPath) : void 0;
+      return {
+        originalPath: file.originalPath,
+        relativePath: relative2(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 statSync2(path);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/checkpoints/edit-checkpoint-store.ts
 var MANIFEST_FILE = "manifest.json";
 var SNAPSHOT_DIR = "files";
 var ID_PAD = 4;
@@ -4682,8 +5112,8 @@ var EditCheckpointStore = class {
     }
     const nextSequence = this.nextSequence(input.sessionId);
     const id = `turn-${String(nextSequence).padStart(ID_PAD, "0")}`;
-    const dir = join17(this.sessionDir(input.sessionId), id);
-    await mkdir(join17(dir, SNAPSHOT_DIR), { recursive: true });
+    const dir = join18(this.sessionDir(input.sessionId), id);
+    await mkdir(join18(dir, SNAPSHOT_DIR), { recursive: true });
     const manifest = {
       version: 1,
       id,
@@ -4699,7 +5129,7 @@ var EditCheckpointStore = class {
       dir,
       capturedPaths: /* @__PURE__ */ new Set()
     };
-    return toSummary(manifest);
+    return toSummary2(manifest);
   }
   async captureFile(filePath) {
     if (!this.activeTurn) return;
@@ -4716,10 +5146,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);
@@ -4739,12 +5183,36 @@ var EditCheckpointStore = class {
       await 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 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) {
@@ -4753,11 +5221,11 @@ var EditCheckpointStore = class {
         existed: false
       };
     }
-    const snapshotFile = join17(
+    const snapshotFile = join18(
       SNAPSHOT_DIR,
       `${String(active.manifest.files.length + 1).padStart(SNAPSHOT_PAD, "0")}.content`
     );
-    await copyFile(originalPath, join17(active.dir, snapshotFile));
+    await copyFile(originalPath, join18(active.dir, snapshotFile));
     return {
       originalPath,
       existed: true,
@@ -4774,13 +5242,13 @@ var EditCheckpointStore = class {
     }
     await mkdir(dirname8(record.originalPath), { recursive: true });
     await copyFile(
-      join17(this.checkpointDir(sessionId, checkpointId), record.snapshotFile),
+      join18(this.checkpointDir(sessionId, checkpointId), record.snapshotFile),
       record.originalPath
     );
   }
   loadManifests(sessionId) {
     const dir = this.sessionDir(sessionId);
-    return readDirSyncSafe(dir).map((entry) => join17(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) => join18(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);
@@ -4788,19 +5256,19 @@ var EditCheckpointStore = class {
   }
   async writeManifest(dir, manifest) {
     await mkdir(dir, { recursive: true });
-    const path = join17(dir, MANIFEST_FILE);
+    const path = join18(dir, MANIFEST_FILE);
     const tmp = `${path}.tmp`;
     await writeFile(tmp, JSON.stringify(manifest, null, 2), "utf8");
     await rename(tmp, path);
   }
   sessionDir(sessionId) {
-    return join17(this.rootDir, safePathSegment(sessionId));
+    return join18(this.rootDir, safePathSegment(sessionId));
   }
   checkpointDir(sessionId, checkpointId) {
-    return join17(this.sessionDir(sessionId), safePathSegment(checkpointId));
+    return join18(this.sessionDir(sessionId), safePathSegment(checkpointId));
   }
 };
-function toSummary(manifest) {
+function toSummary2(manifest) {
   return {
     id: manifest.id,
     sessionId: manifest.sessionId,
@@ -4814,7 +5282,7 @@ function safePathSegment(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function isInside(parent, child) {
-  const rel = relative2(parent, child);
+  const rel = relative3(parent, child);
   return rel.length === 0 || !rel.startsWith("..") && !rel.startsWith("/");
 }
 async function pathExists(path) {
@@ -4873,14 +5341,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((module) => module.systemCommands ?? [])
-    ]);
+    const sdkBuiltinModule = createBuiltinCommandModule();
+    this.commandModules = [
+      sdkBuiltinModule,
+      ..."commandModules" in options ? options.commandModules ?? [] : []
+    ];
+    this.commandExecutor = new SystemCommandExecutor(
+      this.commandModules.flatMap((module) => module.systemCommands ?? [])
+    );
     this.sessionStore = options.sessionStore;
     this.sessionName = options.sessionName;
     this.cwd = ("cwd" in options ? options.cwd : void 0) ?? "";
@@ -4889,8 +5362,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;
@@ -4917,7 +5392,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,
@@ -4930,6 +5406,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,
@@ -4938,6 +5415,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),
@@ -4984,7 +5462,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();
@@ -5077,6 +5566,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;
   }
@@ -5090,6 +5603,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) {
@@ -5105,6 +5622,21 @@ var InteractiveSession = class {
     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(
+      messageToHistoryEntry(createSystemMessage(`Rolled back edit checkpoint: ${checkpointId}`))
+    );
+    this.persistCurrentSession();
+    return result;
+  }
   getUsedMemoryReferences() {
     return [...this.usedMemoryReferences];
   }
@@ -5413,6 +5945,33 @@ var InteractiveSession = class {
     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();
@@ -5508,6 +6067,19 @@ var InteractiveSession = class {
       }, STREAMING_FLUSH_INTERVAL_MS);
     }
   }
+  handleCompactEvent(event) {
+    if (event.trigger === "auto") {
+      this.history.push(
+        messageToHistoryEntry(
+          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") {
@@ -5734,7 +6306,10 @@ async function promptForApproval(terminal, toolName, toolArgs) {
 // src/index.ts
 import { runHooks as runHooks2 } from "@robota-sdk/agent-core";
 export {
+  AUTO_COMPACT_THRESHOLD_SETTINGS_KEY,
   AgentExecutor,
+  BACKGROUND_COMMAND_DESCRIPTION,
+  BACKGROUND_COMMAND_USAGE,
   BUILT_IN_AGENTS,
   BackgroundJobOrchestrator,
   BackgroundTaskError,
@@ -5742,64 +6317,171 @@ export {
   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,
   SubagentManager3 as 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,
   isTerminalBackgroundTaskStatus2 as isTerminalBackgroundTaskStatus,
+  listCommandBackgroundTasks,
+  listCommandEditCheckpoints,
+  listCommandSessionAllowedTools,
+  listCommandUsedMemoryReferences,
   loadTaskContext,
+  mergeProviderPatch,
   messageToHistoryEntry2 as 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,
   runHooks2 as runHooks,
+  runProviderSetupPromptFlow,
   selectRelevantTasks,
+  setCommandAutoCompactThreshold,
+  setCurrentProvider,
   storeAgentToolDeps,
+  submitProviderSetupValue,
   substituteVariables,
   summarizeBackgroundJobGroup,
+  testProviderProfileCommand,
   transitionBackgroundTaskStatus,
   transitionSelfHostingLoop,
   updateTaskFileStatus,
+  upsertProviderProfile,
   userPaths,
-  wrapEditCheckpointTools
+  validateProviderProfile,
+  validateProviderSetupValue,
+  wrapEditCheckpointTools,
+  wrapReversibleExecutionTools,
+  writeAutoCompactThresholdSetting,
+  writeCommandPermissionMode
 };