micro-models-agent 1.7.0 → 2.0.0

package/dist/main.js

@@ -2804,6 +2804,10 @@ Fix the error and re-edit the file (a clean write clears the failure), or mark t
     "cli.list_sessions": "List all sessions",
     "cli.show_details": "Show session details",
     "cli.delete_session": "Delete a session",
+    "cli.export_session": "Export a session to a file (md, json, or jsonl)",
+    "cli.export_format": "Output format: md|json|jsonl (default md)",
+    "cli.export_out": "Output path ('-' for stdout)",
+    "cli.export_no_redact": "Do not redact secrets",
     "cli.first_run": "First run detected. Running setup wizard...",
     "cli.first_run_oneshot": "No configuration found — running with defaults. Run `mma` (no arguments) once to set up the wizard.",
     "cli.setup_saved_restart": "Settings saved. Restarting with the new configuration...",
@@ -2872,20 +2876,21 @@ Available commands:`,
     "repl.exit_usage": "Usage: /exit",
     "repl.clear": "Clear the screen",
     "repl.clear_usage": "Usage: /clear",
+    "repl.clear_hint": "Screen cleared. To start a fresh session and context: /new",
     "repl.run": "Run a prompt through the agent",
     "repl.run_usage": "Usage: /run <prompt>",
-    "repl.config": "Show current configuration",
-    "repl.config_usage": "Usage: /config",
-    "repl.reasoning": "Toggle showing model reasoning/thinking",
-    "repl.reasoning_usage": "Usage: /reasoning [auto|none|low|medium|high|max]",
+    "repl.config": "Show or change settings (get / set / reset)",
+    "repl.config_usage": "Usage: /config [<key> [value]] | /config reset <key> | /config reset --all [--yes] | /config migrate",
+    "repl.reasoning": "Show reasoning status, toggle display, or set effort level",
+    "repl.reasoning_usage": "Usage: /reasoning [show|hide|level <auto|default|none|low|medium|high|max>]",
     "repl.reasoning_level_set": "Reasoning level set to: {level}",
     "repl.reasoning_invalid_level": "Invalid level '{level}'. Valid: {valid}",
-    "repl.verbose": "Chat verbosity: quiet, normal, or verbose",
+    "repl.verbose": "Chat verbosity (quiet, normal, verbose)",
     "repl.verbose_usage": "Usage: /verbose [quiet|normal|verbose]",
     "repl.verbose_set": "Chat verbosity: {level}",
     "repl.verbose_invalid_level": "Invalid level '{level}'. Valid: {valid}",
     "repl.last_action_none": "No recent action to show.",
-    "repl.status": "Show agent status",
+    "repl.status": "Show a compact status line",
     "repl.status_usage": "Usage: /status",
     "repl.plugins": "List loaded plugins",
     "repl.plugins_usage": "Usage: /plugins [--all]",
@@ -2925,11 +2930,13 @@ Available commands:`,
     "repl.context": "Context:",
     "repl.sysprompt_label": "System prompt:",
     "repl.sysprompt_size": "{used} / {budget} tokens",
-    "repl.sysprompt_desc": "Show system prompt",
+    "repl.sysprompt_desc": "System prompt size and blocks (use --full for the text)",
+    "repl.sysprompt_usage": "Usage: /sysprompt [--full]",
+    "repl.sysprompt_full_hint": "Full prompt text hidden — run /sysprompt --full to print it.",
     "repl.sysprompt_tokens": "System prompt ({count} tokens):",
     "repl.excluded_blocks": `
 Excluded blocks: {count}`,
-    "repl.context_usage": "Usage: /context [<size> | system <fraction> | reserve <fraction>]  (min 1024; fractions 0.05–0.9)",
+    "repl.context_usage": "Usage: /context [<size, min 1024> | system <share> | reserve <share>]  (share 0.05–0.9 or e.g. 10%; system+reserve ≤ 0.95)",
     "repl.msgs": "msgs",
     "repl.max_iters": "Max iters:",
     "repl.stuck_thresh": "Stuck thresh:",
@@ -2973,13 +2980,105 @@ Excluded blocks: {count}`,
     "repl.provider_list": "List configured providers or hot-swap the active one",
     "repl.provider_current": "Current provider",
     "repl.provider_set": "Provider set to: {name}",
-    "repl.provider_usage": "/provider list - show entries (* = active, prio = fallback order) | /provider use <name> - switch without restart | /provider add <name> [--url <url>] [--key <key>] [--priority <n>] [--context-window <n>] [--rpm <n>] [--parallel <n>] - add to config",
+    "repl.provider_usage": `Usage: /provider list | /provider use <name> | /provider add <name> [flags]
+    --url <url>            base API URL (fallback: known presets)
+    --key <key>            API key
+    --priority <n>         fallback order; lower = tried first
+    --context-window <n>   per-provider context window (tokens)
+    --rpm <n>              max requests/minute (default 60)
+    --parallel <n>         max parallel tasks (default 1)`,
     "repl.provider_add_missing_value": "Missing value for {flag}",
+    "repl.provider_add_invalid_number": "Invalid number for {flag}: '{value}'",
     "repl.provider_switch_hint": "Switch to it with: /provider use {name}",
+    "repl.provider_flag_url": "Base API URL (fallback: known presets)",
+    "repl.provider_flag_key": "API key",
+    "repl.provider_flag_priority": "Fallback order; lower = tried first",
+    "repl.provider_flag_context_window": "Per-provider context window (tokens)",
+    "repl.provider_flag_rpm": "Max requests per minute (default 60)",
+    "repl.provider_flag_parallel": "Max parallel tasks (default 1)",
     "repl.model_list": "List models of the active provider or switch the model",
     "repl.model_current": "Current model",
     "repl.model_set": "Model set to: {name}",
-    "repl.model_usage": "/model list - fetch models from the active provider | /model use <name> - switch model",
+    "repl.model_usage": "Usage: /model list | /model use <name>",
+    "repl.unknown_sub": "Unknown subcommand '{sub}' for /{cmd}. See usage below.",
+    "repl.help_unknown": "Unknown command '/{name}'",
+    "repl.help_aliases": "Aliases: {names}",
+    "repl.help_examples": "Examples:",
+    "repl.export": "Export a session to a file",
+    "repl.export_usage": "Usage: /export [<id|name>] [--format md|json|jsonl] [--out <path>] [--no-redact]",
+    "config.header": "Managed settings",
+    "config.col_setting": "Setting",
+    "config.col_value": "Value",
+    "config.col_domain": "Domain",
+    "config.col_change": "Change with",
+    "config.session_line": "Session: {name} ({id}) — {count} messages",
+    "config.usage_hint": "Get: /config <key> · Set: /config <key> <value> · Reset: /config reset <key>",
+    "config.saved": "saved · reset: /config reset {key}",
+    "config.read_only_hint": "read-only",
+    "config.read_only": "'{key}' is read-only",
+    "config.unknown_key": "Unknown key '{key}'. {suggestion}",
+    "config.suggest": "Did you mean '{name}'?",
+    "config.valid_keys": "Valid keys: {keys}",
+    "config.invalid_value": "Invalid value for {key}. {hint}",
+    "config.range": "Value out of range for {key}",
+    "config.combined": "system + reserve must stay below 0.95",
+    "config.hint_string": "Expected a non-empty string",
+    "config.hint_enum": "Allowed: {values}",
+    "config.hint_bool": "Expected on/off",
+    "config.hint_share": "Expected 0.05–0.9 or a percentage (e.g. 10%)",
+    "config.hint_int": "Expected an integer ≥ {min}",
+    "config.reset_ok": "{key} restored to session-start value: {value} · saved",
+    "config.reset_unchanged": "{key} already at session value",
+    "config.reset_none": "No settings changed this session",
+    "config.reset_all_confirm": "Reset {count} changed setting(s) to session-start values? [y/N] ",
+    "config.reset_all_done": "Restored {count} setting(s) · saved",
+    "config.reset_all_needs_yes": "Refusing to reset without confirmation in non-interactive mode; pass --yes",
+    "config.reset_cancelled": "Reset cancelled",
+    "config.reset_usage": "Usage: /config reset <key> | /config reset --all [--yes]",
+    "config.alias_label": "alias of",
+    "config.group_label": "group",
+    "reasoning.status": "Reasoning: display {display} · effort {level} {auto}",
+    "reasoning.on": "on",
+    "reasoning.off": "off",
+    "reasoning.auto_on": "(auto policy)",
+    "reasoning.auto_off": "(auto policy off)",
+    "reasoning.auto_off_hint": "Auto policy off. Restore with: /config reset reasoning.mode",
+    "reasoning.display_set": "Reasoning display: {state}",
+    "reasoning.unknown_sub": "Unknown argument '{sub}'.",
+    "reasoning.sub_show": "Show reasoning content",
+    "reasoning.sub_hide": "Hide reasoning content",
+    "reasoning.sub_level": "Set reasoning effort level",
+    "verbose.status": "Verbosity: {level}",
+    "verbose.sub_quiet": "One line per action",
+    "verbose.sub_normal": "Add short result summaries",
+    "verbose.sub_verbose": "Full per-action detail",
+    "context.unknown_arg": "Unknown argument '{arg}'.",
+    "context.sub_system": "System-prompt share",
+    "context.sub_reserve": "Response-reserve share",
+    "model.not_in_list": "Note: '{name}' is not in the known model list",
+    "model.sub_list": "List models of the active provider",
+    "model.sub_use": "Switch model",
+    "provider.sub_list": "List configured providers",
+    "provider.sub_use": "Switch active provider",
+    "provider.sub_add": "Add a provider",
+    "map.sub_summary": "Show the project map summary",
+    "map.sub_refresh": "Rebuild the project index",
+    "map.sub_find": "Search the project map",
+    "lsp.sub_status": "Show LSP server status",
+    "lsp.sub_restart": "Reset disabled servers",
+    "lsp.sub_check": "Run an LSP check on a path",
+    "skill.sub_list": "List available skills",
+    "skill.sub_loaded": "List loaded skills",
+    "skill.sub_load": "Load a skill",
+    "skill.sub_unload": "Unload a skill",
+    "skill.sub_search": "Search skills",
+    "export.written": "Exported to {path}",
+    "export.redacted": "secrets redacted (--no-redact to disable)",
+    "export.raw": "secrets NOT redacted",
+    "export.empty": "session has no messages — nothing exported",
+    "export.invalid_format": "Unknown format '{format}'. Use md|json|jsonl",
+    "export.missing_value": "Missing value for {flag}",
+    "export.write_failed": "Failed to write export: {error}",
     "repl.group.general": "General",
     "repl.group.agent": "Agent",
     "repl.group.session": "Sessions",
@@ -3677,6 +3776,10 @@ var init_ru = __esm(() => {
     "cli.list_sessions": "Список всех сессий",
     "cli.show_details": "Показать детали сессии",
     "cli.delete_session": "Удалить сессию",
+    "cli.export_session": "Экспортировать сессию в файл (md, json или jsonl)",
+    "cli.export_format": "Формат вывода: md|json|jsonl (по умолчанию md)",
+    "cli.export_out": "Путь вывода ('-' для stdout)",
+    "cli.export_no_redact": "Не скрывать секреты",
     "cli.first_run": "Первый запуск. Запускаем мастер настройки...",
     "cli.first_run_oneshot": "Конфигурация не найдена — запуск с настройками по умолчанию. Запустите `mma` без аргументов один раз для настройки.",
     "cli.setup_saved_restart": "Настройки сохранены. Перезапуск с новой конфигурацией...",
@@ -3745,20 +3848,21 @@ var init_ru = __esm(() => {
     "repl.exit_usage": "Использование: /exit",
     "repl.clear": "Очистить экран",
     "repl.clear_usage": "Использование: /clear",
+    "repl.clear_hint": "Экран очищен. Новая сессия и контекст: /new",
     "repl.run": "Выполнить запрос через агента",
     "repl.run_usage": "Использование: /run <запрос>",
-    "repl.config": "Показать текущую конфигурацию",
-    "repl.config_usage": "Использование: /config",
-    "repl.reasoning": "Переключить показ рассуждений модели",
-    "repl.reasoning_usage": "Использование: /reasoning [auto|none|low|medium|high|max]",
+    "repl.config": "Показать или изменить настройки (get / set / reset)",
+    "repl.config_usage": "Использование: /config [<ключ> [значение]] | /config reset <ключ> | /config reset --all [--yes] | /config migrate",
+    "repl.reasoning": "Показать статус рассуждений, переключить показ или уровень",
+    "repl.reasoning_usage": "Использование: /reasoning [show|hide|level <auto|default|none|low|medium|high|max>]",
     "repl.reasoning_level_set": "Уровень рассуждений установлен: {level}",
     "repl.reasoning_invalid_level": "Неверный уровень '{level}'. Допустимые: {valid}",
-    "repl.verbose": "Подробность вывода: quiet, normal или verbose",
+    "repl.verbose": "Подробность вывода (quiet, normal, verbose)",
     "repl.verbose_usage": "Использование: /verbose [quiet|normal|verbose]",
     "repl.verbose_set": "Подробность вывода: {level}",
     "repl.verbose_invalid_level": "Неверный уровень '{level}'. Допустимые: {valid}",
     "repl.last_action_none": "Нет недавнего действия для показа.",
-    "repl.status": "Показать статус агента",
+    "repl.status": "Показать компактную строку статуса",
     "repl.status_usage": "Использование: /status",
     "repl.plugins": "Список загруженных плагинов",
     "repl.plugins_usage": "Использование: /plugins [--all]",
@@ -3798,11 +3902,13 @@ var init_ru = __esm(() => {
     "repl.context": "Контекст:",
     "repl.sysprompt_label": "Системный промпт:",
     "repl.sysprompt_size": "{used} / {budget} токенов",
-    "repl.sysprompt_desc": "Показать системный промпт",
+    "repl.sysprompt_desc": "Размер системного промпта и блоки (текст — через --full)",
+    "repl.sysprompt_usage": "Использование: /sysprompt [--full]",
+    "repl.sysprompt_full_hint": "Полный текст промпта скрыт — выполните /sysprompt --full.",
     "repl.sysprompt_tokens": "Системный промпт ({count} токенов):",
     "repl.excluded_blocks": `
 Исключённые блоки: {count}`,
-    "repl.context_usage": "Использование: /context [<размер> | system <доля> | reserve <доля>]  (мин 1024; доли 0.05–0.9)",
+    "repl.context_usage": "Использование: /context [<размер, мин 1024> | system <доля> | reserve <доля>]  (доля 0.05–0.9 или напр. 10%; system+reserve ≤ 0.95)",
     "repl.msgs": "сообщ.",
     "repl.max_iters": "Макс итераций:",
     "repl.stuck_thresh": "Порог зависания:",
@@ -3846,13 +3952,105 @@ var init_ru = __esm(() => {
     "repl.provider_list": "Список настроенных провайдеров или горячая смена активного",
     "repl.provider_current": "Текущий провайдер",
     "repl.provider_set": "Провайдер установлен: {name}",
-    "repl.provider_usage": "/provider list — записи (* = активный, prio = порядок fallback) | /provider use <имя> — смена без перезапуска | /provider add <имя> [--url <url>] [--key <ключ>] [--priority <n>] [--context-window <n>] [--rpm <n>] [--parallel <n>] — добавить в конфиг",
+    "repl.provider_usage": `Использование: /provider list | /provider use <имя> | /provider add <имя> [флаги]
+    --url <url>            базовый URL API (иначе — из пресетов)
+    --key <ключ>           API-ключ
+    --priority <n>         порядок fallback; меньше = раньше
+    --context-window <n>   окно контекста провайдера (токены)
+    --rpm <n>              запросов/мин (по умолчанию 60)
+    --parallel <n>         параллельных задач (по умолчанию 1)`,
     "repl.provider_add_missing_value": "Нет значения для {flag}",
+    "repl.provider_add_invalid_number": "Неверное число для {flag}: '{value}'",
     "repl.provider_switch_hint": "Переключитесь на него: /provider use {name}",
+    "repl.provider_flag_url": "Базовый URL API (иначе — из пресетов)",
+    "repl.provider_flag_key": "API-ключ",
+    "repl.provider_flag_priority": "Порядок fallback; меньше = раньше",
+    "repl.provider_flag_context_window": "Окно контекста провайдера (токены)",
+    "repl.provider_flag_rpm": "Запросов в минуту (по умолчанию 60)",
+    "repl.provider_flag_parallel": "Параллельных задач (по умолчанию 1)",
     "repl.model_list": "Список моделей активного провайдера или смена модели",
     "repl.model_current": "Текущая модель",
     "repl.model_set": "Модель установлена: {name}",
-    "repl.model_usage": "/model list — получить модели активного провайдера | /model use <имя> — сменить модель",
+    "repl.model_usage": "Использование: /model list | /model use <имя>",
+    "repl.unknown_sub": "Неизвестная подкоманда '{sub}' для /{cmd}. См. использование ниже.",
+    "repl.help_unknown": "Неизвестная команда '/{name}'",
+    "repl.help_aliases": "Алиасы: {names}",
+    "repl.help_examples": "Примеры:",
+    "repl.export": "Экспортировать сессию в файл",
+    "repl.export_usage": "Использование: /export [<id|имя>] [--format md|json|jsonl] [--out <путь>] [--no-redact]",
+    "config.header": "Управляемые настройки",
+    "config.col_setting": "Настройка",
+    "config.col_value": "Значение",
+    "config.col_domain": "Домен",
+    "config.col_change": "Как менять",
+    "config.session_line": "Сессия: {name} ({id}) — {count} сообщений",
+    "config.usage_hint": "Чтение: /config <ключ> · Запись: /config <ключ> <значение> · Сброс: /config reset <ключ>",
+    "config.saved": "сохранено · сброс: /config reset {key}",
+    "config.read_only_hint": "только чтение",
+    "config.read_only": "'{key}' — только чтение",
+    "config.unknown_key": "Неизвестный ключ '{key}'. {suggestion}",
+    "config.suggest": "Возможно, вы имели в виду '{name}'?",
+    "config.valid_keys": "Допустимые ключи: {keys}",
+    "config.invalid_value": "Неверное значение для {key}. {hint}",
+    "config.range": "Значение вне диапазона для {key}",
+    "config.combined": "system + reserve должны оставаться ниже 0.95",
+    "config.hint_string": "Ожидается непустая строка",
+    "config.hint_enum": "Допустимые: {values}",
+    "config.hint_bool": "Ожидается on/off",
+    "config.hint_share": "Ожидается 0.05–0.9 или процент (напр. 10%)",
+    "config.hint_int": "Ожидается целое ≥ {min}",
+    "config.reset_ok": "{key} восстановлен к значению на старте сессии: {value} · сохранено",
+    "config.reset_unchanged": "{key} уже соответствует значению сессии",
+    "config.reset_none": "В этой сессии настройки не менялись",
+    "config.reset_all_confirm": "Сбросить {count} изменённых настроек к значениям на старте сессии? [y/N] ",
+    "config.reset_all_done": "Восстановлено настроек: {count} · сохранено",
+    "config.reset_all_needs_yes": "Отказ от сброса без подтверждения в неинтерактивном режиме; укажите --yes",
+    "config.reset_cancelled": "Сброс отменён",
+    "config.reset_usage": "Использование: /config reset <ключ> | /config reset --all [--yes]",
+    "config.alias_label": "алиас",
+    "config.group_label": "группа",
+    "reasoning.status": "Рассуждения: показ {display} · усилие {level} {auto}",
+    "reasoning.on": "вкл",
+    "reasoning.off": "выкл",
+    "reasoning.auto_on": "(авто-политика)",
+    "reasoning.auto_off": "(авто-политика выключена)",
+    "reasoning.auto_off_hint": "Авто-политика выключена. Вернуть: /config reset reasoning.mode",
+    "reasoning.display_set": "Показ рассуждений: {state}",
+    "reasoning.unknown_sub": "Неизвестный аргумент '{sub}'.",
+    "reasoning.sub_show": "Показывать рассуждения",
+    "reasoning.sub_hide": "Скрыть рассуждения",
+    "reasoning.sub_level": "Установить уровень рассуждений",
+    "verbose.status": "Подробность: {level}",
+    "verbose.sub_quiet": "Одна строка на действие",
+    "verbose.sub_normal": "Плюс короткие сводки результатов",
+    "verbose.sub_verbose": "Полная деталь по действиям",
+    "context.unknown_arg": "Неизвестный аргумент '{arg}'.",
+    "context.sub_system": "Доля системного промпта",
+    "context.sub_reserve": "Доля резерва ответа",
+    "model.not_in_list": "Примечание: '{name}' нет в списке известных моделей",
+    "model.sub_list": "Список моделей активного провайдера",
+    "model.sub_use": "Сменить модель",
+    "provider.sub_list": "Список настроенных провайдеров",
+    "provider.sub_use": "Сменить активного провайдера",
+    "provider.sub_add": "Добавить провайдера",
+    "map.sub_summary": "Показать сводку карты проекта",
+    "map.sub_refresh": "Перестроить индекс проекта",
+    "map.sub_find": "Поиск по карте проекта",
+    "lsp.sub_status": "Статус LSP-серверов",
+    "lsp.sub_restart": "Сбросить отключённые серверы",
+    "lsp.sub_check": "Запустить LSP-проверку пути",
+    "skill.sub_list": "Список доступных скиллов",
+    "skill.sub_loaded": "Список загруженных скиллов",
+    "skill.sub_load": "Загрузить скилл",
+    "skill.sub_unload": "Выгрузить скилл",
+    "skill.sub_search": "Поиск скиллов",
+    "export.written": "Экспортировано в {path}",
+    "export.redacted": "секреты скрыты (--no-redact чтобы отключить)",
+    "export.raw": "секреты НЕ скрыты",
+    "export.empty": "в сессии нет сообщений — экспорт не создан",
+    "export.invalid_format": "Неизвестный формат '{format}'. Используйте md|json|jsonl",
+    "export.missing_value": "Нет значения для {flag}",
+    "export.write_failed": "Не удалось записать экспорт: {error}",
     "repl.reload": "Перезагрузить агента с текущим конфигом",
     "repl.reload_usage": "Использование: /reload",
     "repl.reloading": "Перезагрузка агента...",
@@ -6606,7 +6804,7 @@ class OpenAICompatProvider {
     }
   }
   async* streamOnce(messages, tools, signal, options, onEmit, idleTimeoutMs) {
-    const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096;
+    const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? DEFAULT_MAX_COMPLETION_TOKENS;
     const body = buildRequestBody({
       model: this.model,
       messages,
@@ -6872,7 +7070,7 @@ class OpenAICompatProvider {
     };
   }
   async doNonStreaming(messages, tools, signal, options) {
-    const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096;
+    const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? DEFAULT_MAX_COMPLETION_TOKENS;
     const body = buildRequestBody({
       model: this.model,
       messages,
@@ -7048,7 +7246,7 @@ class OpenAICompatProvider {
     });
   }
 }
-var REQUEST_TIMEOUT_MS = 120000, MAX_RATE_WAIT_MS = 30000, cachedUserAgent = null;
+var REQUEST_TIMEOUT_MS = 120000, MAX_RATE_WAIT_MS = 30000, DEFAULT_MAX_COMPLETION_TOKENS = 8192, cachedUserAgent = null;
 var init_openai_compat = __esm(() => {
   init_token_counter();
   init_i18n();
@@ -24564,7 +24762,7 @@ import {
   appendFileSync as appendFileSync6
 } from "fs";
 import { join as join34 } from "path";
-import { gzipSync } from "zlib";
+import { gzipSync, gunzipSync } from "zlib";
 
 class SessionStore {
   baseDir;
@@ -24700,6 +24898,24 @@ class SessionStore {
       return [];
     }
   }
+  loadRotatedHistory(id) {
+    const gzPath = join34(this.baseDir, `${id}.jsonl.gz`);
+    if (!existsSync41(gzPath))
+      return [];
+    try {
+      const content = gunzipSync(readFileSync25(gzPath)).toString("utf-8");
+      return content.split(`
+`).filter(Boolean).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter((m) => m !== null);
+    } catch {
+      return [];
+    }
+  }
   appendSessionLog(id, entry) {
     const dir = this.sessionDir(id);
     mkdirSync18(dir, { recursive: true, mode: 448 });
@@ -24896,6 +25112,12 @@ class SessionManager {
       return [];
     return this.store.loadHistory(this.activeId);
   }
+  getHistory(id) {
+    const live = this.store.loadHistory(id);
+    if (live.length > 0)
+      return live;
+    return this.store.loadRotatedHistory(id);
+  }
   getSessionContext() {
     if (!this.activeId)
       return;
@@ -29761,6 +29983,87 @@ var init_setup_order = __esm(() => {
   ];
 });
 
+// src/modules/session/export.ts
+function roleHeading(role) {
+  switch (role) {
+    case "user":
+      return "User";
+    case "assistant":
+      return "Assistant";
+    case "tool":
+      return "Tool";
+    case "system":
+      return "System";
+    default:
+      return role;
+  }
+}
+function renderSessionMarkdown(meta, messages) {
+  const lines = [];
+  const name = meta?.name ?? "session";
+  const id = meta?.id ?? "unknown";
+  lines.push(`# ${name} (${id})`);
+  lines.push("");
+  if (meta) {
+    lines.push(`- Model: ${meta.model}`);
+    lines.push(`- Created: ${meta.createdAt}`);
+    lines.push(`- Updated: ${meta.updatedAt}`);
+    lines.push(`- Messages: ${meta.messageCount}`);
+    if (meta.projectDir)
+      lines.push(`- Project: ${meta.projectDir}`);
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  for (const msg of messages) {
+    const heading = roleHeading(msg.role);
+    const nameSuffix = msg.name ? ` (${msg.name})` : "";
+    lines.push(`## ${heading}${nameSuffix}`);
+    lines.push("");
+    const text = getMessageText(msg.content);
+    lines.push(text.length > 0 ? text : "_(empty)_");
+    lines.push("");
+    if (Array.isArray(msg.tool_calls)) {
+      for (const tc of msg.tool_calls) {
+        lines.push(`- tool_call: \`${tc.function.name}\` ${tc.function.arguments}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
+function buildSessionJson(meta, messages) {
+  return JSON.stringify({ meta, messages }, null, 2);
+}
+function buildSessionJsonl(log2) {
+  return log2.map((e) => JSON.stringify(e)).join(`
+`);
+}
+function formatExport(bundle, format) {
+  switch (format) {
+    case "md":
+      return renderSessionMarkdown(bundle.meta, bundle.messages);
+    case "json":
+      return buildSessionJson(bundle.meta, bundle.messages);
+    case "jsonl":
+      return buildSessionJsonl(bundle.log);
+  }
+}
+function redactExport(text, redact) {
+  return redact ? redactContextSecrets(text) : text;
+}
+function sanitizeFileName(name) {
+  const cleaned = name.replace(/[<>:"/\\|?*\u0000-\u001f]/g, "-").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+  return cleaned.length > 0 ? cleaned.slice(0, 60) : "session";
+}
+function extensionFor(format) {
+  return format === "jsonl" ? "jsonl" : format;
+}
+var init_export = __esm(() => {
+  init_context_log();
+});
+
 // src/modules/indexer/map-command.ts
 async function runMapAction(module, action, query) {
   const summary = async () => {
@@ -38050,6 +38353,404 @@ var init_cli = __esm(() => {
   MMA_ROOT = findMmaRoot(HERE);
 });
 
+// src/config/registry.ts
+function shareField(key, canonical) {
+  const field = key === "system" ? "systemPrompt" : "responseReserve";
+  const other = key === "system" ? "responseReserve" : "systemPrompt";
+  return {
+    key: canonical,
+    aliases: [`context.${key}`],
+    domain: "budget",
+    valueType: "share",
+    reconfigure: true,
+    get: (c) => c.contextBudget[field],
+    set: (c, v) => setBudgetShare(c, key, v),
+    extraValidate: (c, v) => {
+      const n = v;
+      const total = n + c.contextBudget[other];
+      return total > MAX_COMBINED2 ? "combined" : null;
+    }
+  };
+}
+function resolveConfigKey(name) {
+  return BY_NAME.get(name) ?? null;
+}
+function configDefs() {
+  return DEFINITIONS;
+}
+function canonicalKeys() {
+  return DEFINITIONS.map((d) => d.key);
+}
+function keysForGroup(prefix) {
+  return DEFINITIONS.filter((d) => d.key.startsWith(prefix + "."));
+}
+function allConfigNames() {
+  const out = [];
+  for (const def of DEFINITIONS) {
+    out.push({ name: def.key, def, alias: false });
+    for (const a of def.aliases)
+      out.push({ name: a, def, alias: true });
+  }
+  return out;
+}
+function formatConfigValue(value) {
+  if (typeof value === "boolean")
+    return value ? "on" : "off";
+  return String(value);
+}
+function parseBool(raw) {
+  const v = raw.trim().toLowerCase();
+  if (["on", "true", "1", "yes", "y", "enable", "enabled"].includes(v))
+    return { ok: true, value: true };
+  if (["off", "false", "0", "no", "n", "disable", "disabled"].includes(v))
+    return { ok: true, value: false };
+  return { ok: false, reason: "invalid" };
+}
+function parseConfigValue(def, raw) {
+  const trimmed = raw.trim();
+  switch (def.valueType) {
+    case "string":
+      return trimmed.length > 0 ? { ok: true, value: trimmed } : { ok: false, reason: "invalid" };
+    case "bool":
+      return parseBool(trimmed);
+    case "enum": {
+      const v = trimmed.toLowerCase();
+      if (def.enumValues && !def.enumValues.includes(v))
+        return { ok: false, reason: "invalid" };
+      return { ok: true, value: v };
+    }
+    case "int": {
+      if (!/^-?\d+$/.test(trimmed))
+        return { ok: false, reason: "invalid" };
+      const n = Number(trimmed);
+      if (!Number.isFinite(n))
+        return { ok: false, reason: "invalid" };
+      if (def.min !== undefined && n < def.min)
+        return { ok: false, reason: "invalid" };
+      if (def.max !== undefined && n > def.max)
+        return { ok: false, reason: "invalid" };
+      return { ok: true, value: n };
+    }
+    case "share": {
+      const isPct = trimmed.endsWith("%");
+      const body = isPct ? trimmed.slice(0, -1).trim() : trimmed;
+      if (!/^-?\d+(\.\d+)?$/.test(body))
+        return { ok: false, reason: "invalid" };
+      let n = Number(body);
+      if (isPct)
+        n = n / 100;
+      if (!Number.isFinite(n) || n < MIN_SHARE2 || n > MAX_SHARE2)
+        return { ok: false, reason: "invalid" };
+      return { ok: true, value: n };
+    }
+  }
+}
+function getConfigValue(config, name) {
+  const def = resolveConfigKey(name);
+  if (!def)
+    return { ok: false, reason: "unknown-key", input: name };
+  const value = def.get(config);
+  return { ok: true, key: def.key, def, value, display: formatConfigValue(value) };
+}
+function setConfigValue(config, name, raw) {
+  const def = resolveConfigKey(name);
+  if (!def)
+    return { ok: false, reason: "unknown-key", input: name };
+  if (def.readOnly)
+    return { ok: false, reason: "read-only", input: name, key: def.key, def };
+  const parsed = parseConfigValue(def, raw);
+  if (!parsed.ok)
+    return { ok: false, reason: "invalid-value", input: name, key: def.key, def };
+  const extra = def.extraValidate?.(config, parsed.value);
+  if (extra)
+    return { ok: false, reason: extra, input: name, key: def.key, def };
+  def.set(config, parsed.value);
+  return {
+    ok: true,
+    key: def.key,
+    def,
+    value: parsed.value,
+    display: formatConfigValue(parsed.value),
+    reconfigure: def.reconfigure,
+    reasoningChanged: def.key === "reasoning.mode"
+  };
+}
+function captureConfigSnapshot(config) {
+  const snapshot = new Map;
+  for (const def of DEFINITIONS) {
+    try {
+      snapshot.set(def.key, structuredClone(def.get(config)));
+    } catch {}
+  }
+  return snapshot;
+}
+var REASONING_LEVELS, LOG_LEVELS, VERBOSITY_LEVELS, LOCALES, MIN_SHARE2 = 0.05, MAX_SHARE2 = 0.9, MAX_COMBINED2 = 0.95, DEFINITIONS, BY_NAME;
+var init_registry2 = __esm(() => {
+  init_defaults();
+  init_budget();
+  REASONING_LEVELS = [
+    "auto",
+    "default",
+    "none",
+    "low",
+    "medium",
+    "high",
+    "max"
+  ];
+  LOG_LEVELS = ["silent", "error", "warn", "info", "debug"];
+  VERBOSITY_LEVELS = ["quiet", "normal", "verbose"];
+  LOCALES = ["en", "ru"];
+  DEFINITIONS = [
+    {
+      key: "model",
+      aliases: [],
+      domain: "agent",
+      valueType: "string",
+      reconfigure: true,
+      get: (c) => c.model,
+      set: (c, v) => {
+        c.model = String(v);
+      }
+    },
+    {
+      key: "provider.active",
+      aliases: [],
+      domain: "provider",
+      valueType: "string",
+      reconfigure: true,
+      get: (c) => c.provider.active ?? c.provider.type,
+      set: (c, v) => {
+        c.provider.active = String(v);
+      },
+      extraValidate: (c, v) => {
+        const entries = c.provider.entries ?? [];
+        if (entries.length === 0)
+          return null;
+        const name = String(v);
+        const found = entries.some((e) => e.label === name || e.type === name);
+        return found ? null : "invalid";
+      }
+    },
+    {
+      key: "contextWindow",
+      aliases: ["context.window"],
+      domain: "budget",
+      valueType: "int",
+      min: 1024,
+      reconfigure: true,
+      get: (c) => c.contextWindow,
+      set: (c, v) => {
+        c.contextWindow = v;
+      }
+    },
+    shareField("system", "contextBudget.systemPrompt"),
+    shareField("reserve", "contextBudget.responseReserve"),
+    {
+      key: "showReasoning",
+      aliases: ["reasoning.show"],
+      domain: "reasoning",
+      valueType: "bool",
+      reconfigure: false,
+      get: (c) => c.showReasoning,
+      set: (c, v) => {
+        c.showReasoning = v;
+      }
+    },
+    {
+      key: "reasoning.mode",
+      aliases: ["reasoning.level"],
+      domain: "reasoning",
+      valueType: "enum",
+      enumValues: REASONING_LEVELS,
+      reconfigure: true,
+      get: (c) => c.reasoning?.mode ?? "auto",
+      set: (c, v) => {
+        const base = c.reasoning ?? structuredClone(DEFAULTS.reasoning);
+        c.reasoning = { ...base, mode: v };
+      }
+    },
+    {
+      key: "ui.verbosity",
+      aliases: ["verbosity"],
+      domain: "ui",
+      valueType: "enum",
+      enumValues: VERBOSITY_LEVELS,
+      reconfigure: false,
+      get: (c) => c.ui.verbosity ?? (c.ui.verbose ? "verbose" : "quiet"),
+      set: (c, v) => {
+        c.ui.verbosity = v;
+      }
+    },
+    {
+      key: "maxToolIterations",
+      aliases: [],
+      domain: "agent",
+      valueType: "int",
+      min: 1,
+      reconfigure: false,
+      get: (c) => c.maxToolIterations,
+      set: (c, v) => {
+        c.maxToolIterations = v;
+      }
+    },
+    {
+      key: "stuckThreshold",
+      aliases: [],
+      domain: "agent",
+      valueType: "int",
+      min: 1,
+      reconfigure: false,
+      get: (c) => c.stuckThreshold,
+      set: (c, v) => {
+        c.stuckThreshold = v;
+      }
+    },
+    {
+      key: "logLevel",
+      aliases: [],
+      domain: "agent",
+      valueType: "enum",
+      enumValues: LOG_LEVELS,
+      reconfigure: false,
+      get: (c) => c.logLevel,
+      set: (c, v) => {
+        c.logLevel = String(v);
+      }
+    },
+    {
+      key: "locale",
+      aliases: [],
+      domain: "i18n",
+      valueType: "enum",
+      enumValues: LOCALES,
+      reconfigure: false,
+      get: (c) => c.locale,
+      set: (c, v) => {
+        c.locale = String(v);
+      }
+    },
+    {
+      key: "version",
+      aliases: [],
+      domain: "agent",
+      valueType: "string",
+      reconfigure: false,
+      readOnly: true,
+      get: (c) => c.version
+    }
+  ];
+  BY_NAME = new Map;
+  for (const def of DEFINITIONS) {
+    BY_NAME.set(def.key, def);
+    for (const alias of def.aliases)
+      BY_NAME.set(alias, def);
+  }
+});
+
+// src/ui/theme.ts
+function resolveVerbosity(ui) {
+  if (ui?.verbosity)
+    return ui.verbosity;
+  return ui?.verbose ? "verbose" : "quiet";
+}
+function toolCategory(tool) {
+  for (const [category, tools] of Object.entries(CATEGORY_TOOLS)) {
+    if (tools.has(tool))
+      return category;
+  }
+  return "meta";
+}
+function toolAccent(tool) {
+  switch (toolCategory(tool)) {
+    case "recon":
+      return pc.cyan;
+    case "mutate":
+      return pc.magenta;
+    case "execute":
+      return pc.blue;
+    case "meta":
+    default:
+      return pc.dim;
+  }
+}
+function actionMarkFor(tool) {
+  return toolAccent(tool)(glyph.action);
+}
+function successMark() {
+  return pc.green(glyph.success);
+}
+function failureMark() {
+  return pc.red(glyph.failure);
+}
+function formatDuration(ms) {
+  if (ms < 1000)
+    return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+var glyph, CATEGORY_TOOLS;
+var init_theme = __esm(() => {
+  init_colors();
+  glyph = {
+    action: "◇",
+    success: "✓",
+    failure: "✗",
+    warning: "⚠",
+    thinking: "✦",
+    question: "?",
+    user: "↵",
+    detail: "↳",
+    group: "│",
+    metric: "⟡",
+    compact: "⟳"
+  };
+  CATEGORY_TOOLS = {
+    recon: new Set([
+      "read_file",
+      "list_dir",
+      "glob",
+      "grep",
+      "file_info",
+      "project_map",
+      "chunk_query",
+      "web_search",
+      "web_fetch",
+      "web_browse",
+      "search_history",
+      "recall",
+      "session_info",
+      "process_list",
+      "process_log"
+    ]),
+    mutate: new Set([
+      "write_file",
+      "edit_file",
+      "create_dir",
+      "delete_file",
+      "move_file",
+      "attach_image"
+    ]),
+    execute: new Set([
+      "bash",
+      "process_kill",
+      "pipeline_run",
+      "browser",
+      "download_file",
+      "subagent",
+      "mcp_call"
+    ]),
+    meta: new Set([
+      "plan",
+      "todo",
+      "verify",
+      "lsp_check",
+      "enable_tools",
+      "set_thinking",
+      "load_skill",
+      "remember"
+    ])
+  };
+});
+
 // src/cli/repl-commands.ts
 var exports_repl_commands = {};
 __export(exports_repl_commands, {
@@ -38057,7 +38758,8 @@ __export(exports_repl_commands, {
   COMMAND_GROUPS: () => COMMAND_GROUPS
 });
 import { join as join55, dirname as dirname25 } from "path";
-import { existsSync as existsSync60 } from "fs";
+import { existsSync as existsSync60, writeFileSync as writeFileSync25, mkdirSync as mkdirSync26 } from "fs";
+import { homedir as homedir18 } from "os";
 function registerAllCommands(ctx) {
   registerBuiltinCommands(ctx);
   registerMmaCommands(ctx);
@@ -38069,7 +38771,8 @@ function registerBuiltinCommands(ctx) {
     name: "help",
     description: t("repl.help"),
     usage: t("repl.help_usage"),
-    action: () => ctx.showHelp()
+    examples: ["/help", "/help config"],
+    action: (args) => ctx.showHelp(args[0])
   });
   ctx.registerCommand({
     name: "exit",
@@ -38084,6 +38787,7 @@ function registerBuiltinCommands(ctx) {
     usage: t("repl.clear_usage"),
     action: () => {
       ctx.output.clearScreen();
+      ctx.output.writeLine(pc.dim(t("repl.clear_hint")));
     }
   });
 }
@@ -38159,36 +38863,267 @@ function registerRunCommands(ctx) {
     }
   });
 }
+function changeHint(def) {
+  if (def.readOnly)
+    return t("config.read_only_hint");
+  return SUGAR_HINTS[def.key] ?? `/config ${def.key} <value>`;
+}
+function configValueHint(def) {
+  if (!def)
+    return "";
+  switch (def.valueType) {
+    case "enum":
+      return t("config.hint_enum", { values: (def.enumValues ?? []).join(", ") });
+    case "bool":
+      return t("config.hint_bool");
+    case "share":
+      return t("config.hint_share");
+    case "int":
+      return t("config.hint_int", { min: String(def.min ?? 1) });
+    default:
+      return t("config.hint_string");
+  }
+}
+function editDistance(a, b) {
+  const dp = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1;i <= a.length; i++) {
+    let prev = dp[0];
+    dp[0] = i;
+    for (let j = 1;j <= b.length; j++) {
+      const tmp = dp[j];
+      dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+      prev = tmp;
+    }
+  }
+  return dp[b.length];
+}
+function nearestConfigKey(input) {
+  const names = canonicalKeys();
+  let best = null;
+  for (const name of names) {
+    const d = editDistance(input.toLowerCase(), name.toLowerCase());
+    if (best === null || d < best.dist)
+      best = { name, dist: d };
+  }
+  if (!best)
+    return null;
+  const threshold = Math.max(2, Math.floor(best.name.length / 3));
+  return best.dist <= threshold ? best.name : null;
+}
+function renderConfigError(ctx, result) {
+  const key = result.key ?? result.input;
+  switch (result.reason) {
+    case "unknown-key": {
+      const suggestion = nearestConfigKey(result.input);
+      const suffix = suggestion ? t("config.suggest", { name: suggestion }) : t("config.valid_keys", { keys: canonicalKeys().join(", ") });
+      ctx.output.writeLine(pc.yellow(t("config.unknown_key", { key: result.input, suggestion: suffix })), "stderr");
+      return;
+    }
+    case "read-only":
+      ctx.output.writeLine(pc.yellow(t("config.read_only", { key })), "stderr");
+      return;
+    case "range":
+      ctx.output.writeLine(pc.yellow(t("config.range", { key })), "stderr");
+      return;
+    case "combined":
+      ctx.output.writeLine(pc.yellow(t("config.combined")), "stderr");
+      return;
+    default:
+      ctx.output.writeLine(pc.yellow(t("config.invalid_value", { key, hint: configValueHint(result.def) })), "stderr");
+  }
+}
+function applyConfigSideEffects(ctx, result) {
+  if (result.key === "ui.verbosity") {
+    ctx.output.setSuppressInfoLogs(result.value === "quiet");
+  } else if (result.key === "reasoning.mode") {
+    ctx.agent.setReasoningLevel(result.value);
+  } else if (result.key === "locale") {
+    setLocale(result.value);
+  }
+}
+function persistConfig(ctx) {
+  const configPath = join55(ctx.configDir, "config.json");
+  saveConfig(ctx.config, configPath, dirname25(configPath));
+}
+async function mutateConfig(ctx, key, raw) {
+  const result = setConfigValue(ctx.config, key, raw);
+  if (!result.ok)
+    return result;
+  applyConfigSideEffects(ctx, result);
+  persistConfig(ctx);
+  if (result.reconfigure)
+    await ctx.agent.reconfigure(ctx.config);
+  if (result.key === "locale")
+    ctx.reregisterCommands();
+  return result;
+}
+function reportSaved(ctx, result) {
+  ctx.output.writeLine(pc.green(t("config.saved", { key: result.key })));
+}
+function rawFromValue(value) {
+  if (typeof value === "boolean")
+    return value ? "on" : "off";
+  return String(value);
+}
+function printConfigTable(ctx, defs) {
+  const list = defs ?? configDefs();
+  const rows = list.map((def) => [
+    def.key,
+    formatConfigValue(def.get(ctx.config)),
+    def.domain,
+    changeHint(def)
+  ]);
+  ctx.output.writeLine(pc.bold(t("config.header")));
+  for (const line of renderTable([
+    t("config.col_setting"),
+    t("config.col_value"),
+    t("config.col_domain"),
+    t("config.col_change")
+  ], rows)) {
+    ctx.output.writeLine(line);
+  }
+  const meta = ctx.sessionManager?.getActiveMeta();
+  if (meta) {
+    ctx.output.writeLine(pc.dim(t("config.session_line", {
+      name: meta.name,
+      id: meta.id,
+      count: String(meta.messageCount)
+    })));
+  }
+  ctx.output.writeLine(pc.dim(t("config.usage_hint")));
+}
+function confirm(ctx, prompt) {
+  return new Promise((resolve25) => {
+    ctx.withExclusiveInput(async () => {
+      await new Promise((done) => {
+        ctx.rl.question(prompt, (answer) => {
+          resolve25(/^y(es)?$/i.test(answer.trim()));
+          done();
+        });
+      });
+    });
+  });
+}
+async function runConfigReset(ctx, rest) {
+  const snapshot = ctx.getConfigSnapshot();
+  const yes = rest.includes("--yes");
+  const all = rest.includes("--all");
+  const target = rest.find((a) => !a.startsWith("--"));
+  if (all) {
+    const changed = canonicalKeys().filter((k) => {
+      const def2 = resolveConfigKey(k);
+      if (!def2 || !snapshot.has(k))
+        return false;
+      return rawFromValue(def2.get(ctx.config)) !== rawFromValue(snapshot.get(k));
+    });
+    if (changed.length === 0) {
+      ctx.output.writeLine(t("config.reset_none"));
+      return;
+    }
+    if (!yes) {
+      if (!process.stdin.isTTY) {
+        ctx.output.writeLine(pc.yellow(t("config.reset_all_needs_yes")), "stderr");
+        return;
+      }
+      const ok = await confirm(ctx, t("config.reset_all_confirm", { count: String(changed.length) }));
+      if (!ok) {
+        ctx.output.writeLine(t("config.reset_cancelled"));
+        return;
+      }
+    }
+    let anyReconfig = false;
+    let localeChanged = false;
+    for (const k of changed) {
+      const result2 = setConfigValue(ctx.config, k, rawFromValue(snapshot.get(k)));
+      if (result2.ok) {
+        applyConfigSideEffects(ctx, result2);
+        anyReconfig = anyReconfig || result2.reconfigure;
+        localeChanged = localeChanged || result2.key === "locale";
+      }
+    }
+    persistConfig(ctx);
+    if (anyReconfig)
+      await ctx.agent.reconfigure(ctx.config);
+    if (localeChanged)
+      ctx.reregisterCommands();
+    ctx.output.writeLine(pc.green(t("config.reset_all_done", { count: String(changed.length) })));
+    return;
+  }
+  if (!target) {
+    ctx.output.writeLine(t("config.reset_usage"));
+    return;
+  }
+  const def = resolveConfigKey(target);
+  if (!def) {
+    renderConfigError(ctx, { reason: "unknown-key", input: target });
+    return;
+  }
+  if (def.readOnly || !snapshot.has(def.key)) {
+    ctx.output.writeLine(t("config.reset_unchanged", { key: def.key }));
+    return;
+  }
+  if (rawFromValue(def.get(ctx.config)) === rawFromValue(snapshot.get(def.key))) {
+    ctx.output.writeLine(t("config.reset_unchanged", { key: def.key }));
+    return;
+  }
+  const result = await mutateConfig(ctx, def.key, rawFromValue(snapshot.get(def.key)));
+  if (!result.ok) {
+    renderConfigError(ctx, result);
+    return;
+  }
+  ctx.output.writeLine(pc.green(t("config.reset_ok", { key: result.key, value: result.display })));
+}
+function printReasoningStatus(ctx) {
+  const display = ctx.config.showReasoning ? t("reasoning.on") : t("reasoning.off");
+  const mode = ctx.config.reasoning?.mode ?? "auto";
+  const auto = mode === "auto" ? t("reasoning.auto_on") : t("reasoning.auto_off");
+  ctx.output.writeLine(t("reasoning.status", { display, level: mode, auto }));
+}
 function registerConfigCommands(ctx) {
   ctx.registerCommand({
     name: "config",
     description: t("repl.config"),
     usage: t("repl.config_usage"),
-    action: (args) => {
+    examples: ["/config", "/config model", "/config reasoning.mode high", "/config reset ui.verbosity"],
+    action: async (args) => {
       if ((args[0] ?? "").trim().toLowerCase() === "migrate") {
         return runConfigMigrate(ctx);
       }
-      const cfg = ctx.config;
-      const ctxW = cfg.contextWindow;
-      const sys = Math.floor(ctxW * cfg.contextBudget.systemPrompt);
-      const res = Math.floor(ctxW * cfg.contextBudget.responseReserve);
-      ctx.output.writeLine(`${t("repl.model")}       ${cfg.model}`);
-      const providers = ctx.agent.listProviders();
-      const active = providers.find((p) => p.active);
-      if (active) {
-        ctx.output.writeLine(`${t("repl.provider")}    ${active.label} (${pc.dim(active.type)})  →  ${pc.dim(active.baseUrl)}`);
-      } else {
-        ctx.output.writeLine(`${t("repl.provider")}    ${cfg.provider.type}  →  ${cfg.provider.baseUrl}`);
-      }
-      ctx.output.writeLine(`${t("repl.context")}     ${ctxW}  (sys:${sys}  res:${res}  hist:${ctxW - sys - res})`);
-      ctx.output.writeLine(`${t("repl.max_iters")}   ${cfg.maxToolIterations}`);
-      ctx.output.writeLine(`${t("repl.stuck_thresh")} ${cfg.stuckThreshold}`);
-      ctx.output.writeLine(`${t("repl.reasoning_label")}   ${cfg.showReasoning ? pc.green(t("repl.show")) : pc.dim(t("repl.hide"))}`);
-      ctx.output.writeLine(`${t("repl.log_level")}   ${cfg.logLevel}`);
-      ctx.output.writeLine(`${t("repl.locale")}      ${cfg.locale}`);
-      const meta = ctx.sessionManager?.getActiveMeta();
-      if (meta) {
-        ctx.output.writeLine(`${t("repl.session_label")}     ${meta.name} (${meta.id})  —  ${meta.messageCount} msgs`);
+      if (args.length === 0) {
+        printConfigTable(ctx);
+        return;
+      }
+      if (args[0] === "reset") {
+        await runConfigReset(ctx, args.slice(1));
+        return;
+      }
+      const name = args[0];
+      if (args.length === 1) {
+        const group = keysForGroup(name);
+        if (group.length > 0) {
+          printConfigTable(ctx, group);
+          return;
+        }
+        const got = getConfigValue(ctx.config, name);
+        if (!got.ok) {
+          renderConfigError(ctx, got);
+          return;
+        }
+        ctx.output.writeLine(`${got.key} = ${got.display}`);
+        return;
+      }
+      const raw = args.slice(1).join(" ");
+      const result = await mutateConfig(ctx, name, raw);
+      if (!result.ok) {
+        renderConfigError(ctx, result);
+        return;
+      }
+      reportSaved(ctx, result);
+      if (result.key === "model") {
+        const known = ctx.knownModels();
+        if (known.length > 0 && !known.includes(String(result.value))) {
+          ctx.output.writeLine(pc.yellow(t("model.not_in_list", { name: String(result.value) })));
+        }
       }
     }
   });
@@ -38196,37 +39131,60 @@ function registerConfigCommands(ctx) {
     name: "reasoning",
     description: t("repl.reasoning"),
     usage: t("repl.reasoning_usage"),
-    action: (args) => {
-      const level = args[0]?.trim().toLowerCase();
-      const VALID_LEVELS2 = ["auto", "none", "low", "medium", "high", "max"];
-      if (!level) {
-        ctx.config.showReasoning = !ctx.config.showReasoning;
-        const status = ctx.config.showReasoning ? pc.green(t("repl.show")) : pc.dim(t("repl.hide"));
-        ctx.output.writeLine(t("repl.reasoning_status", { status }));
-      } else if (VALID_LEVELS2.includes(level)) {
-        ctx.agent.setReasoningLevel(level);
-        ctx.output.writeLine(pc.green(t("repl.reasoning_level_set", { level })));
-      } else {
-        ctx.output.writeLine(pc.yellow(t("repl.reasoning_invalid_level", { level, valid: VALID_LEVELS2.join(", ") })));
+    examples: ["/reasoning", "/reasoning show", "/reasoning level high"],
+    action: async (args) => {
+      const sub = args[0]?.trim().toLowerCase();
+      if (!sub) {
+        printReasoningStatus(ctx);
+        return;
       }
+      if (sub === "show" || sub === "on" || sub === "hide" || sub === "off") {
+        const on = sub === "show" || sub === "on";
+        const result = await mutateConfig(ctx, "showReasoning", on ? "on" : "off");
+        if (!result.ok) {
+          renderConfigError(ctx, result);
+          return;
+        }
+        ctx.output.writeLine(pc.green(t("reasoning.display_set", { state: on ? t("reasoning.on") : t("reasoning.off") })));
+        return;
+      }
+      if (sub === "level") {
+        const lvl = args[1]?.trim().toLowerCase();
+        if (!lvl) {
+          ctx.output.writeLine(t("repl.reasoning_usage"));
+          return;
+        }
+        const result = await mutateConfig(ctx, "reasoning.mode", lvl);
+        if (!result.ok) {
+          renderConfigError(ctx, result);
+          return;
+        }
+        ctx.output.writeLine(pc.green(t("repl.reasoning_level_set", { level: lvl })));
+        if (lvl !== "auto")
+          ctx.output.writeLine(pc.dim(t("reasoning.auto_off_hint")));
+        return;
+      }
+      ctx.output.writeLine(pc.yellow(t("reasoning.unknown_sub", { sub })));
+      ctx.output.writeLine(t("repl.reasoning_usage"));
     }
   });
   ctx.registerCommand({
     name: "verbose",
     description: t("repl.verbose"),
     usage: t("repl.verbose_usage"),
-    action: (args) => {
-      const VALID = ["quiet", "normal", "verbose"];
+    examples: ["/verbose", "/verbose normal"],
+    action: async (args) => {
       const level = args[0]?.trim().toLowerCase();
-      if (level && !VALID.includes(level)) {
-        ctx.output.writeLine(pc.yellow(t("repl.verbose_invalid_level", { level, valid: VALID.join(", ") })));
+      if (!level) {
+        ctx.output.writeLine(t("verbose.status", { level: resolveVerbosity(ctx.config.ui) }));
+        return;
+      }
+      const result = await mutateConfig(ctx, "ui.verbosity", level);
+      if (!result.ok) {
+        renderConfigError(ctx, result);
         return;
       }
-      const current = ctx.config.ui.verbosity ?? (ctx.config.ui.verbose ? "verbose" : "quiet");
-      const next = level ?? (current === "verbose" ? "quiet" : "verbose");
-      ctx.config.ui.verbosity = next;
-      ctx.output.setSuppressInfoLogs(next === "quiet");
-      ctx.output.writeLine(pc.green(t("repl.verbose_set", { level: next })));
+      ctx.output.writeLine(pc.green(t("repl.verbose_set", { level: result.display })));
     }
   });
   ctx.registerCommand({
@@ -38236,16 +39194,13 @@ function registerConfigCommands(ctx) {
     action: () => {
       const providers = ctx.agent.listProviders();
       const active = providers.find((p) => p.active);
-      ctx.output.writeLine(`${t("repl.model")} ${ctx.config.model}`);
-      if (active) {
-        ctx.output.writeLine(`${t("repl.provider")} ${active.label} (${pc.dim(active.type)}) @ ${pc.dim(active.baseUrl)}`);
-      } else {
-        ctx.output.writeLine(`${t("repl.provider")} ${ctx.config.provider.type} @ ${pc.dim(ctx.config.provider.baseUrl)}`);
-      }
+      const providerLabel = active ? active.label : ctx.config.provider.type;
+      const parts = [ctx.config.model, providerLabel];
       const meta = ctx.sessionManager?.getActiveMeta();
-      if (meta) {
-        ctx.output.writeLine(`${t("repl.session_label")} ${meta.name} (${meta.id}) — ${meta.messageCount} messages`);
-      }
+      if (meta)
+        parts.push(`${meta.name} (${meta.messageCount} ${t("repl.msgs")})`);
+      parts.push(`${ctx.config.contextWindow} tok`);
+      ctx.output.writeLine(parts.join(pc.dim(" · ")));
     }
   });
   ctx.registerCommand({
@@ -38268,22 +39223,28 @@ function registerConfigCommands(ctx) {
   ctx.registerCommand({
     name: "sysprompt",
     description: t("repl.sysprompt_desc"),
-    usage: t("repl.sysprompt_desc"),
-    action: () => {
+    usage: t("repl.sysprompt_usage"),
+    examples: ["/sysprompt", "/sysprompt --full"],
+    action: (args) => {
       const info = ctx.agent.getSystemPromptInfo();
+      const full = args.includes("--full");
       ctx.output.writeLine(pc.bold(t("repl.sysprompt_tokens", { count: String(info.tokenCount) })));
-      ctx.output.writeLine(pc.dim("─".repeat(60)));
-      for (const line of info.text.split(`
-`)) {
-        ctx.output.writeLine(line);
-      }
-      ctx.output.writeLine(pc.dim("─".repeat(60)));
       if (info.excluded.length > 0) {
         ctx.output.writeLine(pc.yellow(t("repl.excluded_blocks", { count: String(info.excluded.length) })));
         for (const e of info.excluded) {
           ctx.output.writeLine(pc.dim(`  - ${e.slice(0, 80)}${e.length > 80 ? "..." : ""}`));
         }
       }
+      if (full) {
+        ctx.output.writeLine(pc.dim("─".repeat(60)));
+        for (const line of info.text.split(`
+`)) {
+          ctx.output.writeLine(line);
+        }
+        ctx.output.writeLine(pc.dim("─".repeat(60)));
+      } else {
+        ctx.output.writeLine(pc.dim(t("repl.sysprompt_full_hint")));
+      }
     }
   });
   ctx.registerCommand({
@@ -38323,13 +39284,14 @@ function registerProviderCommands(ctx) {
       ctx.output.writeLine(t("repl.provider_usage"));
       return;
     }
-    try {
-      await ctx.agent.setProvider(name);
-      ctx.refreshModelCache();
-      ctx.output.writeLine(pc.green(t("repl.provider_set", { name })));
-    } catch (e) {
-      ctx.output.writeLine(pc.red(e.message), "stderr");
+    const result = await mutateConfig(ctx, "provider.active", name);
+    if (!result.ok) {
+      renderConfigError(ctx, result);
+      return;
     }
+    ctx.refreshModelCache();
+    ctx.output.writeLine(pc.green(t("repl.provider_set", { name })));
+    reportSaved(ctx, result);
   };
   const add = async (args) => {
     const flags = {};
@@ -38352,6 +39314,13 @@ function registerProviderCommands(ctx) {
       ctx.output.writeLine(t("repl.provider_usage"));
       return;
     }
+    for (const flag of ["priority", "context-window", "rpm", "parallel"]) {
+      const v = flags[flag];
+      if (v !== undefined && !Number.isFinite(Number(v))) {
+        ctx.output.writeLine(pc.red(t("repl.provider_add_invalid_number", { flag: `--${flag}`, value: v })), "stderr");
+        return;
+      }
+    }
     const entries = Array.isArray(ctx.config.provider.entries) ? ctx.config.provider.entries : [];
     if (entries.length === 0) {
       entries.push({
@@ -38382,8 +39351,7 @@ function registerProviderCommands(ctx) {
     });
     ctx.config.provider.entries = entries;
     ctx.config.provider.active = ctx.config.provider.active || ctx.config.provider.type;
-    const configPath = join55(ctx.configDir, "config.json");
-    saveConfig(ctx.config, configPath, dirname25(configPath));
+    persistConfig(ctx);
     await ctx.agent.reconfigure(ctx.config);
     ctx.output.writeLine(pc.green(t("cli.provider_added", { name })));
     ctx.output.writeLine(t("repl.provider_switch_hint", { name }));
@@ -38397,10 +39365,12 @@ function registerProviderCommands(ctx) {
     name: "provider",
     description: t("repl.provider_list"),
     usage: t("repl.provider_usage"),
+    examples: ["/provider list", "/provider use openrouter", "/provider add openai --key sk-..."],
     action: async (args) => {
       const subcmd = args[0];
       const handler = subcmd ? handlers[subcmd] : handlers.list;
       if (!handler) {
+        ctx.output.writeLine(pc.yellow(t("repl.unknown_sub", { cmd: "provider", sub: subcmd })));
         ctx.output.writeLine(t("repl.provider_usage"));
         return;
       }
@@ -38448,11 +39418,17 @@ function registerProviderCommands(ctx) {
       ctx.output.writeLine(t("repl.model_usage"));
       return;
     }
-    ctx.config.model = name;
-    const configPath = join55(ctx.configDir, "config.json");
-    saveConfig(ctx.config, configPath, dirname25(configPath));
-    await ctx.agent.reconfigure(ctx.config);
+    const result = await mutateConfig(ctx, "model", name);
+    if (!result.ok) {
+      renderConfigError(ctx, result);
+      return;
+    }
     ctx.output.writeLine(pc.green(t("repl.model_set", { name })));
+    const known = ctx.knownModels();
+    if (known.length > 0 && !known.includes(name)) {
+      ctx.output.writeLine(pc.yellow(t("model.not_in_list", { name })));
+    }
+    reportSaved(ctx, result);
   };
   const modelHandlers = {
     list: listModels,
@@ -38462,10 +39438,12 @@ function registerProviderCommands(ctx) {
     name: "model",
     description: t("repl.model_list"),
     usage: t("repl.model_usage"),
+    examples: ["/model list", "/model use qwen/qwen3.5-9b"],
     action: async (args) => {
       const subcmd = args[0];
       const handler = subcmd ? modelHandlers[subcmd] : modelHandlers.list;
       if (!handler) {
+        ctx.output.writeLine(pc.yellow(t("repl.unknown_sub", { cmd: "model", sub: subcmd })));
         ctx.output.writeLine(t("repl.model_usage"));
         return;
       }
@@ -38476,12 +39454,8 @@ function registerProviderCommands(ctx) {
     name: "context",
     description: t("cli.manage_context"),
     usage: t("repl.context_usage"),
+    examples: ["/context", "/context 64000", "/context system 10%", "/context reserve 0.2"],
     action: async (args) => {
-      const save = async () => {
-        const configPath = join55(ctx.configDir, "config.json");
-        saveConfig(ctx.config, configPath, dirname25(configPath));
-        await ctx.agent.reconfigure(ctx.config);
-      };
       if (args.length === 0) {
         for (const line of budgetBreakdownLines(ctx.config))
           ctx.output.writeLine(line);
@@ -38489,24 +39463,32 @@ function registerProviderCommands(ctx) {
         return;
       }
       if (args[0] === "system" || args[0] === "reserve") {
-        const key = args[0];
-        const value = Number(args[1]);
-        if (setBudgetShare(ctx.config, key, value) !== null) {
-          ctx.output.writeLine(pc.yellow(t("cli.context_invalid_fraction")));
+        const raw = args[1];
+        if (!raw) {
+          ctx.output.writeLine(t("repl.context_usage"));
           return;
         }
-        await save();
-        ctx.output.writeLine(pc.green(t("cli.context_fraction_set", { key, value })));
+        const key = args[0] === "system" ? "contextBudget.systemPrompt" : "contextBudget.responseReserve";
+        const result2 = await mutateConfig(ctx, key, raw);
+        if (!result2.ok) {
+          renderConfigError(ctx, result2);
+          return;
+        }
+        ctx.output.writeLine(pc.green(t("cli.context_fraction_set", { key: args[0], value: result2.display })));
+        return;
+      }
+      if (!/^\d+$/.test(args[0])) {
+        ctx.output.writeLine(pc.yellow(t("context.unknown_arg", { arg: args[0] })));
+        ctx.output.writeLine(t("repl.context_usage"));
         return;
       }
-      const size = parseInt(args[0], 10);
-      if (isNaN(size) || size < 1024) {
-        ctx.output.writeLine(t("cli.invalid_context_size"));
+      const result = await mutateConfig(ctx, "contextWindow", args[0]);
+      if (!result.ok) {
+        renderConfigError(ctx, result);
         return;
       }
-      ctx.config.contextWindow = size;
-      await save();
-      ctx.output.writeLine(pc.green(t("cli.context_set", { size })));
+      ctx.output.writeLine(pc.green(t("cli.context_set", { size: String(result.value) })));
+      reportSaved(ctx, result);
     }
   });
 }
@@ -38565,15 +39547,15 @@ function registerLspCommands(ctx) {
     name: "lsp",
     description: t("repl.lsp"),
     usage: t("repl.lsp_usage"),
+    examples: ["/lsp status", "/lsp restart", "/lsp check src/index.ts"],
     action: async (args) => {
-      const subcommand = args[0] || "status";
       const lspModule = ctx.agent.getModule("lsp");
       if (!lspModule) {
         ctx.output.writeLine(pc.yellow(t("repl.lsp_not_available")));
         return;
       }
-      switch (subcommand) {
-        case "status": {
+      const handlers = {
+        status: () => {
           const disabled = lspModule.getDisabledServers();
           const failures = lspModule.getFailureCounts();
           const config = ctx.config.lsp;
@@ -38591,16 +39573,14 @@ function registerLspCommands(ctx) {
           if (disabled.length === 0 && failures.size === 0) {
             ctx.output.writeLine(pc.green(t("repl.lsp_all_ok")));
           }
-          break;
-        }
-        case "restart": {
+        },
+        restart: () => {
           ctx.output.writeLine(pc.yellow(t("repl.lsp_restarting")));
           lspModule.resetDisabledServers();
           ctx.output.writeLine(pc.green(t("repl.lsp_restarted")));
-          break;
-        }
-        case "check": {
-          const path = args[1];
+        },
+        check: async (rest) => {
+          const path = rest[0];
           if (!path) {
             ctx.output.writeLine(pc.yellow(t("repl.lsp_check_usage")));
             return;
@@ -38614,13 +39594,16 @@ function registerLspCommands(ctx) {
           } catch (e) {
             ctx.output.writeLine(pc.red(t("repl.lsp_check_error", { error: errMsg(e) })), "stderr");
           }
-          break;
-        }
-        default: {
-          ctx.output.writeLine(pc.dim(t("repl.lsp_usage")));
-          break;
         }
+      };
+      const subcommand = args[0] || "status";
+      const handler = handlers[subcommand];
+      if (!handler) {
+        ctx.output.writeLine(pc.yellow(t("repl.unknown_sub", { cmd: "lsp", sub: subcommand })));
+        ctx.output.writeLine(pc.dim(t("repl.lsp_usage")));
+        return;
       }
+      await handler(args.slice(1));
     }
   });
 }
@@ -38684,8 +39667,9 @@ function registerSessionCommands(ctx) {
   ctx.registerCommand({
     name: "resume",
     description: t("repl.resume"),
-    aliases: ["switch", "use"],
+    aliases: ["switch"],
     usage: t("repl.resume_usage"),
+    examples: ["/resume", "/resume my-session"],
     action: (args) => {
       const query = args.join(" ");
       const sessions = ctx.sessionManager.list();
@@ -38772,6 +39756,77 @@ function registerSessionCommands(ctx) {
       ctx.output.writeLine(`${t("session.deleted", { id: match.id })}: ${match.name}`);
     }
   });
+  ctx.registerCommand({
+    name: "export",
+    description: t("repl.export"),
+    usage: t("repl.export_usage"),
+    examples: [
+      "/export",
+      "/export my-session --format md",
+      "/export --format json --out -"
+    ],
+    action: async (args) => {
+      let format = "md";
+      let out;
+      let redact = true;
+      const positional = [];
+      for (let i = 0;i < args.length; i++) {
+        const a = args[i];
+        if (a === "--format") {
+          const v = args[++i];
+          if (!v) {
+            ctx.output.writeLine(t("export.missing_value", { flag: a }));
+            return;
+          }
+          format = v;
+        } else if (a === "--out") {
+          const v = args[++i];
+          if (v === undefined) {
+            ctx.output.writeLine(t("export.missing_value", { flag: a }));
+            return;
+          }
+          out = v;
+        } else if (a === "--no-redact") {
+          redact = false;
+        } else {
+          positional.push(a);
+        }
+      }
+      if (format !== "md" && format !== "json" && format !== "jsonl") {
+        ctx.output.writeLine(pc.yellow(t("export.invalid_format", { format })), "stderr");
+        return;
+      }
+      const query = positional.join(" ");
+      const sessions = ctx.sessionManager.list();
+      const match = query ? sessions.find((s) => s.id === query || s.id.startsWith(query) || s.name.toLowerCase().includes(query.toLowerCase())) : sessions.find((s) => s.id === ctx.sessionManager.getActive());
+      if (!match) {
+        ctx.output.writeLine(query ? t("session.no_match", { query }) : t("session.no_active"));
+        return;
+      }
+      const messages = ctx.sessionManager.getHistory(match.id);
+      const log2 = ctx.sessionManager.loadSessionLog(match.id);
+      if (format === "jsonl" ? log2.length === 0 : messages.length === 0) {
+        ctx.output.writeLine(pc.yellow(t("export.empty")));
+        return;
+      }
+      const text = redactExport(formatExport({ meta: match, messages, log: log2 }, format), redact);
+      if (out === "-") {
+        ctx.output.writeLine(text);
+        return;
+      }
+      const baseDir = out ? dirname25(out) : join55(homedir18(), ".mma", "exports");
+      const path = out ?? join55(baseDir, `${sanitizeFileName(match.name)}-${match.id.slice(0, 8)}.${extensionFor(format)}`);
+      try {
+        mkdirSync26(baseDir, { recursive: true });
+        writeFileSync25(path, text, "utf-8");
+      } catch (e) {
+        ctx.output.writeLine(pc.red(t("export.write_failed", { error: errMsg(e) })), "stderr");
+        return;
+      }
+      ctx.output.writeLine(pc.green(t("export.written", { path })));
+      ctx.output.writeLine(pc.dim(redact ? t("export.redacted") : t("export.raw")));
+    }
+  });
 }
 function registerSkillCommands(ctx) {
   if (!ctx.skillsModule)
@@ -38862,7 +39917,7 @@ function registerSkillCommands(ctx) {
       const subcmd = args[0];
       const handler = subcmd ? skillHandlers[subcmd] : skillHandlers.list;
       if (!handler) {
-        ctx.output.writeLine(pc.red(t("repl.skill_unknown_sub", { subcmd })), "stderr");
+        ctx.output.writeLine(pc.yellow(t("repl.unknown_sub", { cmd: "skill", sub: subcmd })));
         ctx.output.writeLine(t("repl.skill_usage"));
         return;
       }
@@ -38891,9 +39946,10 @@ async function runConfigMigrate(ctx) {
   const domainFiles = readdirSync20(join55(configDir, "config")).filter((f) => f.endsWith(".json"));
   ctx.output.writeLine(pc.green(t("config.migrate_done", { count: String(domainFiles.length) })));
 }
-var version2, COMMAND_GROUPS;
+var version2, COMMAND_GROUPS, SUGAR_HINTS;
 var init_repl_commands = __esm(() => {
   init_colors();
+  init_theme();
   init_version();
   init_table();
   init_i18n();
@@ -38902,6 +39958,8 @@ var init_repl_commands = __esm(() => {
   init_config2();
   init_presets();
   init_budget();
+  init_registry2();
+  init_export();
   init_token_counter();
   init_map_command();
   init_utils();
@@ -38929,9 +39987,20 @@ var init_repl_commands = __esm(() => {
     resume: "session",
     rename: "session",
     delete: "session",
+    export: "session",
     skill: "skill",
     plugins: "agent"
   };
+  SUGAR_HINTS = {
+    model: "/model use <name>",
+    "provider.active": "/provider use <name>",
+    contextWindow: "/context <size>",
+    "contextBudget.systemPrompt": "/context system <share>",
+    "contextBudget.responseReserve": "/context reserve <share>",
+    showReasoning: "/reasoning show | hide",
+    "reasoning.mode": "/reasoning level <level>",
+    "ui.verbosity": "/verbose <level>"
+  };
 });
 
 // node_modules/commander/esm.mjs
@@ -38957,9 +40026,10 @@ init_setup();
 init_setup_order();
 init_i18n();
 init_colors();
+init_export();
 import { join as join53, dirname as dirname24 } from "path";
 import { homedir as homedir17 } from "os";
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync59, mkdirSync as mkdirSync25, writeFileSync as writeFileSync24 } from "fs";
 
 // src/cli/security-commands.ts
 init_bootstrap();
@@ -40224,6 +41294,41 @@ function buildSessionCommands(program2) {
       }
     }
   });
+  session2.command("export").argument("<id>", "Session id (or name prefix)").description(t("cli.export_session")).option("--format <format>", t("cli.export_format"), "md").option("--out <path>", t("cli.export_out")).option("--no-redact", t("cli.export_no_redact")).action(async (id, opts) => {
+    const { sessionManager } = await bootstrap();
+    const meta = sessionManager.get(id) ?? sessionManager.list().find((s) => s.id.startsWith(id)) ?? sessionManager.list().find((s) => s.name.toLowerCase().includes(id.toLowerCase()));
+    if (!meta) {
+      getDefaultChannel().writeLine(t("session.not_found", { id }));
+      return;
+    }
+    const format = opts.format;
+    if (format !== "md" && format !== "json" && format !== "jsonl") {
+      getDefaultChannel().writeLine(t("export.invalid_format", { format }));
+      return;
+    }
+    const messages = sessionManager.getHistory(meta.id);
+    const log2 = sessionManager.loadSessionLog(meta.id);
+    if (format === "jsonl" ? log2.length === 0 : messages.length === 0) {
+      getDefaultChannel().writeLine(t("export.empty"));
+      return;
+    }
+    const text = redactExport(formatExport({ meta, messages, log: log2 }, format), opts.redact);
+    if (opts.out === "-") {
+      getDefaultChannel().writeLine(text);
+      return;
+    }
+    const baseDir = opts.out ? dirname24(opts.out) : join53(homedir17(), ".mma", "exports");
+    const path = opts.out ?? join53(baseDir, `${sanitizeFileName(meta.name)}-${meta.id.slice(0, 8)}.${extensionFor(format)}`);
+    try {
+      mkdirSync25(baseDir, { recursive: true });
+      writeFileSync24(path, text, "utf-8");
+    } catch (e) {
+      getDefaultChannel().writeLine(t("export.write_failed", { error: String(e) }));
+      return;
+    }
+    getDefaultChannel().writeLine(t("export.written", { path }));
+    getDefaultChannel().writeLine(t(opts.redact ? "export.redacted" : "export.raw"));
+  });
   session2.command("delete").argument("<id>", "Session id").description(t("cli.delete_session")).action(async (id) => {
     const { sessionManager } = await bootstrap();
     sessionManager.delete(id);
@@ -41355,11 +42460,13 @@ class LineEditor {
 }
 
 // src/cli/repl.ts
-import { existsSync as existsSync61, mkdirSync as mkdirSync25, readFileSync as readFileSync42, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync61, mkdirSync as mkdirSync27, readFileSync as readFileSync42, writeFileSync as writeFileSync26 } from "fs";
 import { dirname as dirname26, join as join56 } from "path";
-import { homedir as homedir18 } from "os";
+import { homedir as homedir19 } from "os";
 
 // src/cli/completer.ts
+init_registry2();
+init_i18n();
 import { readdirSync as readdirSync19, statSync as statSync11 } from "fs";
 import { join as join54 } from "path";
 function buildSlashCompletions(commands) {
@@ -41464,11 +42571,13 @@ class ProviderArgProvider {
 class SessionNameProvider {
   name = "session-names";
   getNames;
-  constructor(getNames) {
+  commands;
+  constructor(getNames, commands = ["/resume"]) {
     this.getNames = getNames;
+    this.commands = commands;
   }
   match(ctx) {
-    return ctx.tokenIndex >= 1 && ctx.tokens[0] === "/resume";
+    return ctx.tokenIndex >= 1 && this.commands.includes(ctx.tokens[0]);
   }
   complete(ctx) {
     const names = this.getNames();
@@ -41500,6 +42609,74 @@ class SkillNameProvider {
   }
 }
 
+class ConfigKeyProvider {
+  name = "config-keys";
+  match(ctx) {
+    return ctx.tokenIndex === 1 && ctx.tokens[0] === "/config";
+  }
+  complete(ctx) {
+    const partial = ctx.partial;
+    const items = allConfigNames().map(({ name, def, alias }) => ({
+      value: name,
+      description: alias ? `${t("config.alias_label")} ${def.key}` : def.domain
+    }));
+    if (!partial.includes(".")) {
+      const groups = [...new Set(canonicalKeys().filter((k) => k.includes(".")).map((k) => k.split(".")[0]))];
+      const groupItems = groups.map((g) => ({
+        value: g,
+        description: t("config.group_label")
+      }));
+      return [...groupItems, ...items].filter((i) => i.value.startsWith(partial));
+    }
+    return items.filter((i) => i.value.startsWith(partial));
+  }
+}
+
+class ConfigValueProvider {
+  name = "config-values";
+  match(ctx) {
+    return ctx.tokenIndex === 2 && ctx.tokens[0] === "/config";
+  }
+  complete(ctx) {
+    const def = resolveConfigKey(ctx.tokens[1]);
+    if (!def?.enumValues)
+      return [];
+    return def.enumValues.filter((v) => v.startsWith(ctx.partial)).map((v) => ({ value: v }));
+  }
+}
+
+class FlagProvider {
+  name = "provider-add-flags";
+  match(ctx) {
+    return ctx.tokens[0] === "/provider" && ctx.tokens[1] === "add" && ctx.tokenIndex >= 2;
+  }
+  complete(ctx) {
+    const flags = [
+      { value: "--url", description: t("repl.provider_flag_url") },
+      { value: "--key", description: t("repl.provider_flag_key") },
+      { value: "--priority", description: t("repl.provider_flag_priority") },
+      { value: "--context-window", description: t("repl.provider_flag_context_window") },
+      { value: "--rpm", description: t("repl.provider_flag_rpm") },
+      { value: "--parallel", description: t("repl.provider_flag_parallel") }
+    ];
+    return flags.filter((f) => f.value.startsWith(ctx.partial));
+  }
+}
+
+class CommandArgProvider {
+  name = "help-command-args";
+  getNames;
+  constructor(getNames) {
+    this.getNames = getNames;
+  }
+  match(ctx) {
+    return ctx.tokenIndex === 1 && ctx.tokens[0] === "/help";
+  }
+  complete(ctx) {
+    return this.getNames().filter((n) => n.startsWith(ctx.partial)).map((n) => ({ value: n }));
+  }
+}
+
 class Completer {
   providers = [];
   registerProvider(provider) {
@@ -41534,109 +42711,7 @@ init_colors();
 init_string_width();
 init_i18n();
 init_table();
-
-// src/ui/theme.ts
-init_colors();
-var glyph = {
-  action: "◇",
-  success: "✓",
-  failure: "✗",
-  warning: "⚠",
-  thinking: "✦",
-  question: "?",
-  user: "↵",
-  detail: "↳",
-  group: "│",
-  metric: "⟡",
-  compact: "⟳"
-};
-function resolveVerbosity(ui) {
-  if (ui?.verbosity)
-    return ui.verbosity;
-  return ui?.verbose ? "verbose" : "quiet";
-}
-var CATEGORY_TOOLS = {
-  recon: new Set([
-    "read_file",
-    "list_dir",
-    "glob",
-    "grep",
-    "file_info",
-    "project_map",
-    "chunk_query",
-    "web_search",
-    "web_fetch",
-    "web_browse",
-    "search_history",
-    "recall",
-    "session_info",
-    "process_list",
-    "process_log"
-  ]),
-  mutate: new Set([
-    "write_file",
-    "edit_file",
-    "create_dir",
-    "delete_file",
-    "move_file",
-    "attach_image"
-  ]),
-  execute: new Set([
-    "bash",
-    "process_kill",
-    "pipeline_run",
-    "browser",
-    "download_file",
-    "subagent",
-    "mcp_call"
-  ]),
-  meta: new Set([
-    "plan",
-    "todo",
-    "verify",
-    "lsp_check",
-    "enable_tools",
-    "set_thinking",
-    "load_skill",
-    "remember"
-  ])
-};
-function toolCategory(tool) {
-  for (const [category, tools] of Object.entries(CATEGORY_TOOLS)) {
-    if (tools.has(tool))
-      return category;
-  }
-  return "meta";
-}
-function toolAccent(tool) {
-  switch (toolCategory(tool)) {
-    case "recon":
-      return pc.cyan;
-    case "mutate":
-      return pc.magenta;
-    case "execute":
-      return pc.blue;
-    case "meta":
-    default:
-      return pc.dim;
-  }
-}
-function actionMarkFor(tool) {
-  return toolAccent(tool)(glyph.action);
-}
-function successMark() {
-  return pc.green(glyph.success);
-}
-function failureMark() {
-  return pc.red(glyph.failure);
-}
-function formatDuration(ms) {
-  if (ms < 1000)
-    return `${ms}ms`;
-  return `${(ms / 1000).toFixed(1)}s`;
-}
-
-// src/ui/md-formatter.ts
+init_theme();
 var KW = /\b(import|export|from|const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|class|extends|implements|interface|type|enum|namespace|module|declare|abstract|async|await|yield|throw|try|catch|finally|typeof|instanceof|in|of|as|is|keyof|readonly|static|private|public|protected|get|set|constructor|this|super|void|never|any|unknown|boolean|string|number|symbol|object|true|false|null|undefined|default)\b/g;
 var STRING = /('[^']*'|"[^"]*"|`[^`]*`)/g;
 var COMMENT = /(\/\/[^\n]*|\/\*[\s\S]*?\*\/|#[^\n]*)/g;
@@ -41892,6 +42967,7 @@ function formatWarning(text) {
 
 // src/ui/renderer.ts
 init_spinner();
+init_theme();
 
 // src/ui/action-log.ts
 var last = null;
@@ -42359,9 +43435,11 @@ ${pc.dim(glyph.metric)} ${model} · ${provider} · ${pc.dim(formatDuration(durat
 }
 
 // src/cli/repl.ts
+init_theme();
 init_box();
 init_i18n();
 init_repl_commands();
+init_registry2();
 
 // src/modules/lsp/probe.ts
 init_client2();
@@ -42445,6 +43523,7 @@ init_session_logger();
 
 // src/ui/plan-view.ts
 init_colors();
+init_theme();
 init_js_identifiers();
 init_i18n();
 function currentStepIndex(plan) {
@@ -42647,6 +43726,7 @@ function createHostBridge(opts) {
 class Repl {
   completer = new Completer;
   modelCache = [];
+  configSnapshot = new Map;
   running = false;
   agentRunning = false;
   inputLocked = false;
@@ -42690,10 +43770,10 @@ class Repl {
     this.execModule = execModule;
     this.slog = new SessionLogger(sessionManager, logger4);
     this.bindSessionOutput();
-    this.configDir = configDir || join56(homedir18(), ".mma");
+    this.configDir = configDir || join56(homedir19(), ".mma");
     this.baseDir = baseDir || process.cwd();
     this.noAgentsMd = noAgentsMd === true;
-    this.historyPath = historyPath ?? join56(homedir18(), ".mma", "repl-history");
+    this.historyPath = historyPath ?? join56(homedir19(), ".mma", "repl-history");
     this.loadHistory();
     const editorCompleter = (line) => {
       const [matches, partial] = this.completer.complete(line);
@@ -42747,6 +43827,7 @@ class Repl {
     });
     this.agent.setPromptIO?.(this.promptIO);
     registerAllCommands(this);
+    this.configSnapshot = captureConfigSnapshot(this.config);
     this.setupCompleter();
     this.setupListeners();
     if (pluginManager) {
@@ -42807,9 +43888,9 @@ class Repl {
   }
   saveHistory() {
     try {
-      mkdirSync25(dirname26(this.historyPath), { recursive: true });
+      mkdirSync27(dirname26(this.historyPath), { recursive: true });
       const allHistory = this.history.slice(-this.maxHistory);
-      writeFileSync24(this.historyPath, allHistory.join(`
+      writeFileSync26(this.historyPath, allHistory.join(`
 `), "utf-8");
     } catch (e) {
       this.logger?.debug(`Failed to save REPL history: ${e.message}`);
@@ -42820,14 +43901,59 @@ class Repl {
     const slashCommands = buildSlashCompletions(this.commands);
     this.completer.registerProvider(new SlashCommandProvider(slashCommands));
     if (this.sessionManager) {
-      this.completer.registerProvider(new SessionNameProvider(() => this.sessionManager.list().map((s) => s.name)));
+      this.completer.registerProvider(new SessionNameProvider(() => this.sessionManager.list().map((s) => s.name), [
+        "/resume",
+        "/delete",
+        "/export"
+      ]));
     }
     if (this.skillsModule) {
-      this.completer.registerProvider(new SubcommandProvider("skill", ["list", "loaded", "load", "unload", "search"]));
+      this.completer.registerProvider(new SubcommandProvider("skill", [
+        { name: "list", description: t("skill.sub_list") },
+        { name: "loaded", description: t("skill.sub_loaded") },
+        { name: "load", description: t("skill.sub_load") },
+        { name: "unload", description: t("skill.sub_unload") },
+        { name: "search", description: t("skill.sub_search") }
+      ]));
       this.completer.registerProvider(new SkillNameProvider(this.skillsModule));
     }
-    this.completer.registerProvider(new SubcommandProvider("provider", ["list", "use", "add"]));
-    this.completer.registerProvider(new SubcommandProvider("model", ["list", "use"]));
+    this.completer.registerProvider(new SubcommandProvider("provider", [
+      { name: "list", description: t("provider.sub_list") },
+      { name: "use", description: t("provider.sub_use") },
+      { name: "add", description: t("provider.sub_add") }
+    ]));
+    this.completer.registerProvider(new SubcommandProvider("model", [
+      { name: "list", description: t("model.sub_list") },
+      { name: "use", description: t("model.sub_use") }
+    ]));
+    this.completer.registerProvider(new SubcommandProvider("map", [
+      { name: "summary", description: t("map.sub_summary") },
+      { name: "refresh", description: t("map.sub_refresh") },
+      { name: "find", description: t("map.sub_find") }
+    ]));
+    this.completer.registerProvider(new SubcommandProvider("context", [
+      { name: "system", description: t("context.sub_system") },
+      { name: "reserve", description: t("context.sub_reserve") }
+    ]));
+    this.completer.registerProvider(new SubcommandProvider("lsp", [
+      { name: "status", description: t("lsp.sub_status") },
+      { name: "restart", description: t("lsp.sub_restart") },
+      { name: "check", description: t("lsp.sub_check") }
+    ]));
+    this.completer.registerProvider(new SubcommandProvider("reasoning", [
+      { name: "show", description: t("reasoning.sub_show") },
+      { name: "hide", description: t("reasoning.sub_hide") },
+      { name: "level", description: t("reasoning.sub_level") }
+    ]));
+    this.completer.registerProvider(new SubcommandProvider("verbose", [
+      { name: "quiet", description: t("verbose.sub_quiet") },
+      { name: "normal", description: t("verbose.sub_normal") },
+      { name: "verbose", description: t("verbose.sub_verbose") }
+    ]));
+    this.completer.registerProvider(new ConfigKeyProvider);
+    this.completer.registerProvider(new ConfigValueProvider);
+    this.completer.registerProvider(new FlagProvider);
+    this.completer.registerProvider(new CommandArgProvider(() => Array.from(this.commands.entries()).filter(([key, cmd]) => key === cmd.name).map(([, cmd]) => cmd.name)));
     const entryLabels = this.config.provider?.entries?.map((e) => e.label || e.type) ?? [];
     if (entryLabels.length > 0) {
       this.completer.registerProvider(new ProviderArgProvider(entryLabels));
@@ -42836,6 +43962,17 @@ class Repl {
     this.completer.registerProvider(new FilePathProvider(this.baseDir));
     this.refreshModelCache();
   }
+  reregisterCommands() {
+    this.commands.clear();
+    registerAllCommands(this);
+    this.setupCompleter();
+  }
+  getConfigSnapshot() {
+    return this.configSnapshot;
+  }
+  knownModels() {
+    return this.modelCache;
+  }
   refreshModelCache() {
     (async () => {
       try {
@@ -43182,7 +44319,13 @@ ${divider()}`);
     this.runHandledPrompt = false;
     const cmd = this.commands.get(name);
     if (!cmd) {
-      this.output.writeLine(`${pc.red(t("cli.unknown_cmd", { name }))} ${t("cli.help_hint")}`);
+      const formerAliases = { use: "resume" };
+      const suggestion = formerAliases[name];
+      if (suggestion) {
+        this.output.writeLine(pc.red(t("cli.unknown_command", { input: `/${name}`, suggestion: `/${suggestion}` })));
+      } else {
+        this.output.writeLine(`${pc.red(t("cli.unknown_cmd", { name }))} ${t("cli.help_hint")}`);
+      }
       return;
     }
     try {
@@ -43193,8 +44336,29 @@ ${divider()}`);
       })), "stderr");
     }
   }
-  showHelp() {
+  showHelp(command) {
     const { COMMAND_GROUPS: COMMAND_GROUPS2 } = (init_repl_commands(), __toCommonJS(exports_repl_commands));
+    if (command) {
+      const name = command.replace(/^\//, "");
+      const cmd = this.commands.get(name);
+      if (!cmd) {
+        this.output.writeLine(pc.red(t("repl.help_unknown", { name })));
+        return;
+      }
+      this.output.writeLine(pc.bold(pc.cyan("/" + cmd.name)));
+      this.output.writeLine(`  ${cmd.description}`);
+      if (cmd.usage)
+        this.output.writeLine(`  ${pc.dim(cmd.usage)}`);
+      if (cmd.aliases?.length) {
+        this.output.writeLine(pc.dim(`  ${t("repl.help_aliases", { names: cmd.aliases.join(", ") })}`));
+      }
+      if (cmd.examples?.length) {
+        this.output.writeLine(pc.dim(`  ${t("repl.help_examples")}`));
+        for (const ex of cmd.examples)
+          this.output.writeLine(pc.dim(`    ${ex}`));
+      }
+      return;
+    }
     const order = ["general", "agent", "session", "skill"];
     const seen = new Set;
     for (const groupKey of order) {
@@ -43405,6 +44569,9 @@ ${line}`);
   }
 }
 
+// src/cli/main.ts
+init_theme();
+
 // src/cli/run-result.ts
 init_i18n();
 init_colors();
@@ -43498,7 +44665,7 @@ init_i18n();
 init_colors();
 import { existsSync as existsSync62 } from "fs";
 import { join as join58, dirname as dirname27 } from "path";
-import { homedir as homedir20 } from "os";
+import { homedir as homedir21 } from "os";
 import { fileURLToPath as fileURLToPath6 } from "url";
 
 // src/modules/updater/index.ts
@@ -43618,10 +44785,10 @@ init_environment();
 init_data_sanitizer();
 init_i18n();
 init_utils();
-import { appendFileSync as appendFileSync8, mkdirSync as mkdirSync26 } from "fs";
+import { appendFileSync as appendFileSync8, mkdirSync as mkdirSync28 } from "fs";
 import { join as join57 } from "path";
-import { homedir as homedir19 } from "os";
-var CRASH_LOG_DIR = join57(homedir19(), ".mma", "logs");
+import { homedir as homedir20 } from "os";
+var CRASH_LOG_DIR = join57(homedir20(), ".mma", "logs");
 var CRASH_LOG_FILE = "crash.jsonl";
 function formatCrashEntry(type2, err) {
   const message = errMsg(err);
@@ -43631,12 +44798,12 @@ function formatCrashEntry(type2, err) {
     type: type2,
     message: sanitizeLogMessage(message),
     stack: sanitizeLogMessage(stack),
-    environment: collectEnvironment({ configDir: homedir19(), scanTools: false })
+    environment: collectEnvironment({ configDir: homedir20(), scanTools: false })
   };
 }
 function writeCrashEntry(dir, entry) {
   try {
-    mkdirSync26(dir, { recursive: true });
+    mkdirSync28(dir, { recursive: true });
     appendFileSync8(join57(dir, CRASH_LOG_FILE), JSON.stringify(entry) + `
 `, "utf-8");
   } catch {}
@@ -43765,7 +44932,7 @@ async function main() {
     }
     const jsonSink = jsonOpt ? new JsonOutputSink(defaultOutputBus) : undefined;
     const prompt = program2.args.join(" ");
-    const mmaDir = process.env.MMA_CONFIG_DIR || join58(homedir20(), ".mma");
+    const mmaDir = process.env.MMA_CONFIG_DIR || join58(homedir21(), ".mma");
     const { hasDomainFiles: hasDomainFiles2 } = await Promise.resolve().then(() => (init_domains(), exports_domains));
     const virgin = !existsSync62(join58(mmaDir, "config.json")) && !hasDomainFiles2(mmaDir);
     const { agent, config, baseDir, legacyDetected, contextProbe } = await bootstrap(undefined, projectDir, noAgentsMd, exitOnComplete, reasoningLevel, contextLog);
@@ -43853,7 +45020,7 @@ async function main() {
     await updater?.waitForIdle();
     process.exit(exitCode);
   } else {
-    const mmaDir = process.env.MMA_CONFIG_DIR || join58(homedir20(), ".mma");
+    const mmaDir = process.env.MMA_CONFIG_DIR || join58(homedir21(), ".mma");
     const legacyConfigPath = join58(mmaDir, "config.json");
     let hasAnyConfig = existsSync62(legacyConfigPath);
     if (!hasAnyConfig) {