micro-models-agent 1.6.0 → 2.0.0

package/dist/main.js

@@ -2312,6 +2312,7 @@ var init_defaults = __esm(() => {
         description: "browser + file reading for visual tasks"
       }
     },
+    modelCapabilities: {},
     contextWindow: 32768,
     contextBudget: {
       systemPrompt: 0.1,
@@ -2803,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...",
@@ -2871,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]",
@@ -2924,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:",
@@ -2972,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",
@@ -3676,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": "Настройки сохранены. Перезапуск с новой конфигурацией...",
@@ -3744,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]",
@@ -3797,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": "Порог зависания:",
@@ -3845,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": "Перезагрузка агента...",
@@ -5118,7 +5317,7 @@ var init_domains = __esm(() => {
       "reasoning",
       "hallucination"
     ],
-    provider: ["provider", "orchestrator", "retry", "pricing"],
+    provider: ["provider", "orchestrator", "retry", "pricing", "modelCapabilities"],
     moe: ["moe", "experts"],
     security: ["security"],
     browser: ["browser"],
@@ -6605,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,
@@ -6871,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,
@@ -7047,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();
@@ -7547,7 +7746,7 @@ var init_factory = __esm(() => {
 });
 
 // src/llm/model-loader.ts
-async function getLoadedContextLength(baseUrl, model, timeoutMs = 3000) {
+async function probeModel(baseUrl, model, timeoutMs = 3000) {
   const base = baseUrl.replace(/\/$/, "").replace(/\/v1\/?$/, "");
   try {
     const response = await fetch(`${base}/api/v1/models`, {
@@ -7561,10 +7760,18 @@ async function getLoadedContextLength(baseUrl, model, timeoutMs = 3000) {
     if (!found)
       return null;
     const loadedInstance = (found.loaded_instances ?? [])[0];
-    const actual = loadedInstance?.config?.context_length ?? found.max_context_length;
-    if (typeof actual !== "number" || actual <= 0)
+    const contextLength = loadedInstance?.config?.context_length ?? found.max_context_length;
+    if (typeof contextLength !== "number" || contextLength <= 0)
       return null;
-    return { model: found.key ?? found.name ?? model, actual };
+    const raw = found.capabilities;
+    let capabilities;
+    if (raw && typeof raw.vision === "boolean") {
+      capabilities = { vision: raw.vision };
+      if (typeof raw.trained_for_tool_use === "boolean") {
+        capabilities.tools = raw.trained_for_tool_use;
+      }
+    }
+    return { model: found.key ?? found.name ?? model, contextLength, capabilities };
   } catch {
     return null;
   }
@@ -15436,6 +15643,15 @@ var init_tool_output = __esm(() => {
   init_i18n();
 });
 
+// src/core/agent/tool-images.ts
+function queueToolImages(sink, images) {
+  if (!sink || !images || images.length === 0)
+    return;
+  for (const image of images) {
+    sink.addPendingImage(image);
+  }
+}
+
 // src/core/agent/tool-batch.ts
 class ToolBatchExecutor {
   deps;
@@ -15565,6 +15781,7 @@ class ToolBatchExecutor {
         arguments: call.arguments
       });
       answeredToolCallIds.add(call.id);
+      queueToolImages(contextManager, result.images);
       const tokensAfterTool = contextManager.getEstimatedTokens();
       const costAfterTool = this.deps.costTracker.total;
       onTool?.({
@@ -21290,6 +21507,119 @@ var init_session = __esm(() => {
   init_i18n();
 });
 
+// src/llm/image-utils.ts
+var exports_image_utils = {};
+__export(exports_image_utils, {
+  readClipboardImage: () => readClipboardImage,
+  loadUrlAsDataUrl: () => loadUrlAsDataUrl,
+  loadFileAsDataUrl: () => loadFileAsDataUrl,
+  detectMime: () => detectMime,
+  bufferToDataUrl: () => bufferToDataUrl
+});
+import { readFileSync as readFileSync20 } from "fs";
+import { extname as extname4 } from "path";
+function detectMime(filePath) {
+  const ext = extname4(filePath).toLowerCase();
+  return MIME_MAP[ext] ?? "image/png";
+}
+async function readClipboardImage() {
+  if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+    try {
+      const img = Bun.Image.fromClipboard();
+      if (img) {
+        const buf = await img.resize(800, 800, { fit: "inside" }).jpeg({ quality: 60 }).buffer();
+        return Buffer.from(buf);
+      }
+    } catch {}
+  }
+  return readClipboardFallback();
+}
+async function readClipboardFallback() {
+  const { platform: platform7 } = await import("os");
+  const { execSync } = await import("child_process");
+  const { readFileSync: readFileSync21, unlinkSync: unlinkSync5 } = await import("fs");
+  const { join: join29 } = await import("path");
+  if (platform7() !== "linux")
+    return null;
+  const tmpPath = join29(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
+  const commands = [
+    `wl-paste --type image/png > "${tmpPath}" 2>/dev/null`,
+    `xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`
+  ];
+  for (const cmd of commands) {
+    try {
+      execSync(cmd, { timeout: 5000 });
+      const buf = readFileSync21(tmpPath);
+      unlinkSync5(tmpPath);
+      if (buf.length > 0)
+        return buf;
+    } catch {}
+  }
+  try {
+    unlinkSync5(tmpPath);
+  } catch {}
+  return null;
+}
+async function loadFileAsDataUrl(filePath) {
+  const buf = readFileSync20(filePath);
+  if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+    try {
+      const img = new Bun.Image(buf);
+      const { width } = await img.metadata();
+      const targetWidth = Math.min(800, width || 800);
+      const dataUrl = await img.resize(targetWidth, 800, { fit: "inside" }).jpeg({ quality: 60 }).dataurl();
+      return { dataUrl };
+    } catch {}
+  }
+  const b64 = buf.toString("base64");
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  const mime = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "webp" ? "image/webp" : "image/png";
+  return { dataUrl: `data:${mime};base64,${b64}` };
+}
+async function loadUrlAsDataUrl(url) {
+  const resp = await fetch(url);
+  if (!resp.ok) {
+    throw new Error(`Failed to fetch image: ${resp.status} ${resp.statusText}`);
+  }
+  const buf = Buffer.from(await resp.arrayBuffer());
+  if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+    try {
+      const img = new Bun.Image(buf);
+      const { width } = await img.metadata();
+      const targetWidth = Math.min(800, width || 800);
+      const dataUrl = await img.resize(targetWidth, 800, { fit: "inside" }).jpeg({ quality: 60 }).dataurl();
+      return { dataUrl };
+    } catch {}
+  }
+  const b64 = buf.toString("base64");
+  return { dataUrl: `data:image/png;base64,${b64}` };
+}
+async function bufferToDataUrl(buf) {
+  if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+    try {
+      const img = new Bun.Image(buf);
+      const { width } = await img.metadata();
+      const targetWidth = Math.min(800, width || 800);
+      const dataUrl = await img.resize(targetWidth, 800, { fit: "inside" }).jpeg({ quality: 60 }).dataurl();
+      return { dataUrl };
+    } catch {}
+  }
+  const b64 = buf.toString("base64");
+  return { dataUrl: `data:image/png;base64,${b64}` };
+}
+var MIME_MAP;
+var init_image_utils = __esm(() => {
+  MIME_MAP = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".svg": "image/svg+xml"
+  };
+});
+
 // src/tools/browser.ts
 import { join as join29 } from "path";
 import { mkdirSync as mkdirSync16 } from "fs";
@@ -21326,18 +21656,9 @@ function formatScreenshotForTextModel(snapshot) {
 
 ${snapshot}`;
 }
-function modelSupportsVision(model) {
-  const m = model.toLowerCase();
-  return /vision|\bvl\b|qwen.*vl|gpt-4|claude|gemini|llava|pixtral/.test(m);
-}
-function formatScreenshotResult(snapshot, screenshot, supportsVision) {
-  if (!supportsVision) {
-    return formatScreenshotForTextModel(snapshot);
-  }
-  const base642 = screenshot.toString("base64");
-  return `${snapshot}
-
-[Screenshot: data:image/png;base64,${base642}]`;
+async function screenshotToImagePart(screenshot) {
+  const { dataUrl } = await bufferToDataUrl(screenshot);
+  return { type: "image_url", image_url: { url: dataUrl } };
 }
 function createBrowserTool() {
   return {
@@ -21402,12 +21723,15 @@ function createBrowserTool() {
       }
       const s = getSession(ctx);
       const result = await serialize(() => s.execute(action, args));
-      const supportsVision = modelSupportsVision(ctx.config.model);
       if (result.screenshot) {
-        return {
-          success: result.success,
-          output: formatScreenshotResult(result.output, result.screenshot, supportsVision)
-        };
+        if (ctx.capabilities?.vision) {
+          return {
+            success: result.success,
+            output: result.output,
+            images: [await screenshotToImagePart(result.screenshot)]
+          };
+        }
+        return { success: result.success, output: formatScreenshotForTextModel(result.output) };
       }
       return { success: result.success, output: result.output };
     }
@@ -21426,125 +21750,13 @@ var session = null, sessionFactory, actionChain;
 var init_browser = __esm(() => {
   init_session();
   init_types();
+  init_image_utils();
   init_i18n();
   init_output();
   init_utils();
   actionChain = Promise.resolve();
 });
 
-// src/llm/image-utils.ts
-var exports_image_utils = {};
-__export(exports_image_utils, {
-  readClipboardImage: () => readClipboardImage,
-  loadUrlAsDataUrl: () => loadUrlAsDataUrl,
-  loadFileAsDataUrl: () => loadFileAsDataUrl,
-  detectMime: () => detectMime,
-  bufferToDataUrl: () => bufferToDataUrl
-});
-import { readFileSync as readFileSync20 } from "fs";
-import { extname as extname4 } from "path";
-function detectMime(filePath) {
-  const ext = extname4(filePath).toLowerCase();
-  return MIME_MAP[ext] ?? "image/png";
-}
-async function readClipboardImage() {
-  if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-    try {
-      const img = Bun.Image.fromClipboard();
-      if (img) {
-        const buf = await img.resize(800, 800, { fit: "inside" }).jpeg({ quality: 60 }).buffer();
-        return Buffer.from(buf);
-      }
-    } catch {}
-  }
-  return readClipboardFallback();
-}
-async function readClipboardFallback() {
-  const { platform: platform7 } = await import("os");
-  const { execSync } = await import("child_process");
-  const { readFileSync: readFileSync21, unlinkSync: unlinkSync5 } = await import("fs");
-  const { join: join30 } = await import("path");
-  if (platform7() !== "linux")
-    return null;
-  const tmpPath = join30(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
-  const commands = [
-    `wl-paste --type image/png > "${tmpPath}" 2>/dev/null`,
-    `xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`
-  ];
-  for (const cmd of commands) {
-    try {
-      execSync(cmd, { timeout: 5000 });
-      const buf = readFileSync21(tmpPath);
-      unlinkSync5(tmpPath);
-      if (buf.length > 0)
-        return buf;
-    } catch {}
-  }
-  try {
-    unlinkSync5(tmpPath);
-  } catch {}
-  return null;
-}
-async function loadFileAsDataUrl(filePath) {
-  const buf = readFileSync20(filePath);
-  if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-    try {
-      const img = new Bun.Image(buf);
-      const { width } = await img.metadata();
-      const targetWidth = Math.min(800, width || 800);
-      const dataUrl = await img.resize(targetWidth, 800, { fit: "inside" }).jpeg({ quality: 60 }).dataurl();
-      return { dataUrl };
-    } catch {}
-  }
-  const b64 = buf.toString("base64");
-  const ext = filePath.split(".").pop()?.toLowerCase();
-  const mime = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "webp" ? "image/webp" : "image/png";
-  return { dataUrl: `data:${mime};base64,${b64}` };
-}
-async function loadUrlAsDataUrl(url) {
-  const resp = await fetch(url);
-  if (!resp.ok) {
-    throw new Error(`Failed to fetch image: ${resp.status} ${resp.statusText}`);
-  }
-  const buf = Buffer.from(await resp.arrayBuffer());
-  if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-    try {
-      const img = new Bun.Image(buf);
-      const { width } = await img.metadata();
-      const targetWidth = Math.min(800, width || 800);
-      const dataUrl = await img.resize(targetWidth, 800, { fit: "inside" }).jpeg({ quality: 60 }).dataurl();
-      return { dataUrl };
-    } catch {}
-  }
-  const b64 = buf.toString("base64");
-  return { dataUrl: `data:image/png;base64,${b64}` };
-}
-async function bufferToDataUrl(buf) {
-  if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-    try {
-      const img = new Bun.Image(buf);
-      const { width } = await img.metadata();
-      const targetWidth = Math.min(800, width || 800);
-      const dataUrl = await img.resize(targetWidth, 800, { fit: "inside" }).jpeg({ quality: 60 }).dataurl();
-      return { dataUrl };
-    } catch {}
-  }
-  const b64 = buf.toString("base64");
-  return { dataUrl: `data:image/png;base64,${b64}` };
-}
-var MIME_MAP;
-var init_image_utils = __esm(() => {
-  MIME_MAP = {
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-    ".bmp": "image/bmp",
-    ".svg": "image/svg+xml"
-  };
-});
-
 // src/tools/attach-image.ts
 import { existsSync as existsSync35 } from "fs";
 import { resolve as resolve17 } from "path";
@@ -24550,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;
@@ -24686,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 });
@@ -24882,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;
@@ -25291,7 +25527,7 @@ class BrowserModule {
         "Workflow: open(url) → read snapshot → click/type on element numbers → read updated snapshot.",
         'Each snapshot includes a "Content" section with the visible page text, a "Console" section with browser messages, and network errors. Use these to understand the page, detect JS errors, and verify the result of your actions.',
         'Always start with "open" action. Use element numbers from snapshot for click/type targets.',
-        'Use "screenshot" action only if the model supports vision. Otherwise rely on the text snapshot.'
+        'The "screenshot" action is delivered automatically: a vision model receives the image, a text-only model receives the text snapshot instead. You do not need to decide — just call it and read what you get.'
       ].join(`
 `),
       priority: "normal",
@@ -27704,6 +27940,19 @@ var init_context_log = __esm(() => {
   SEP2 = "─".repeat(78);
 });
 
+// src/modules/providers/capabilities.ts
+function resolveModelCapabilities(preset, probe, override) {
+  const base = preset ? { vision: preset.vision, tools: preset.tools } : { ...DEFAULT_MODEL_CAPABILITIES };
+  return { ...base, ...probe ?? {}, ...override ?? {} };
+}
+var DEFAULT_MODEL_CAPABILITIES;
+var init_capabilities = __esm(() => {
+  DEFAULT_MODEL_CAPABILITIES = {
+    vision: false,
+    tools: false
+  };
+});
+
 // src/core/environment.ts
 import { existsSync as existsSync50, readFileSync as readFileSync32, readdirSync as readdirSync16 } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
@@ -28335,7 +28584,9 @@ function buildSystemInfo(config, baseDir, profileCompressed) {
   lines.push(`Runtime verification: when a bug is described in terms of runtime behavior (what happens when the app runs), reproduce it — run the app / build / browser tool — and confirm the fix against actual runtime output before calling "plan update step=N status=done". Check existing servers first with process_list/process_log: a stale dev server started BEFORE your change still runs the old pipeline and keeps failing even after the files on disk are fixed. Restart or kill it (process_kill) and verify the exact endpoint/port the user reported — a fresh server on a new port does NOT prove the user's error is gone.`);
   const sec = config.security;
   if (sec?.enabled) {
-    const secLines = [`SECURITY RESTRICTIONS (enforced — blocked calls return "[SECURITY BLOCKED]", do not retry them):`];
+    const secLines = [
+      `SECURITY RESTRICTIONS (enforced — blocked calls return "[SECURITY BLOCKED]", do not retry them):`
+    ];
     if (sec.bash?.enabled && sec.bash.blacklist.length > 0) {
       const cmds = sec.bash.blacklist.slice(0, 15).join(", ");
       secLines.push(`Forbidden bash commands: ${cmds}${sec.bash.blacklist.length > 15 ? ", …" : ""}.`);
@@ -28417,19 +28668,23 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete, reas
       logger4.info(t("env.model_loaded", { model: config.model, seconds: String(loadResult.loadTime) }));
     }
   }
+  const capabilitiesRef = {};
   const contextProbePromise = (async () => {
     try {
-      const probe = await getLoadedContextLength(config.provider.baseUrl, config.model);
+      const probe = await probeModel(config.provider.baseUrl, config.model);
       if (!probe)
         return null;
-      if (probe.actual < config.contextWindow) {
-        logger4.logSilent("warn", `Context probe: model "${probe.model}" is loaded with ${probe.actual} tokens, but contextWindow is configured as ${config.contextWindow} — overflow/429 risk. Lower contextWindow or reload the model with a larger context.`);
-      } else if (probe.actual > config.contextWindow) {
-        logger4.logSilent("info", `Context probe: model "${probe.model}" supports ${probe.actual} tokens — consider "mma context ${probe.actual}" to use the full window.`);
+      if (probe.capabilities)
+        capabilitiesRef.probe = probe.capabilities;
+      const contextProbe = { model: probe.model, actual: probe.contextLength };
+      if (probe.contextLength < config.contextWindow) {
+        logger4.logSilent("warn", `Context probe: model "${probe.model}" is loaded with ${probe.contextLength} tokens, but contextWindow is configured as ${config.contextWindow} — overflow/429 risk. Lower contextWindow or reload the model with a larger context.`);
+      } else if (probe.contextLength > config.contextWindow) {
+        logger4.logSilent("info", `Context probe: model "${probe.model}" supports ${probe.contextLength} tokens — consider "mma context ${probe.contextLength}" to use the full window.`);
       } else {
-        logger4.logSilent("debug", `Context probe: configured contextWindow matches loaded context (${probe.actual})`);
+        logger4.logSilent("debug", `Context probe: configured contextWindow matches loaded context (${probe.contextLength})`);
       }
-      return probe;
+      return contextProbe;
     } catch {
       return null;
     }
@@ -28608,6 +28863,14 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete, reas
     get: () => sessionManager,
     configurable: true
   });
+  Object.defineProperty(toolCtx, "capabilities", {
+    get: () => {
+      const cfg = configRef.current;
+      const spec = BUILTIN_PROVIDERS.find((p) => p.type === cfg.provider.type);
+      return resolveModelCapabilities(spec?.capabilities, capabilitiesRef.probe, cfg.modelCapabilities?.[cfg.model]);
+    },
+    configurable: true
+  });
   const toolExecutor = new ToolExecutor(toolRegistry, toolCtx, pluginManager);
   toolCtx.llmProvider = llmProvider;
   toolCtx.toolExecutor = toolExecutor;
@@ -28831,6 +29094,7 @@ var init_bootstrap = __esm(() => {
   init_i18n();
   init_agent();
   init_context_log();
+  init_capabilities();
   init_version();
   init_environment();
   init_utils();
@@ -29719,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 () => {
@@ -38008,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, {
@@ -38015,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);
@@ -38027,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",
@@ -38042,6 +38787,7 @@ function registerBuiltinCommands(ctx) {
     usage: t("repl.clear_usage"),
     action: () => {
       ctx.output.clearScreen();
+      ctx.output.writeLine(pc.dim(t("repl.clear_hint")));
     }
   });
 }
@@ -38117,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) })));
+        }
       }
     }
   });
@@ -38154,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 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 })));
+      const result = await mutateConfig(ctx, "ui.verbosity", level);
+      if (!result.ok) {
+        renderConfigError(ctx, result);
+        return;
+      }
+      ctx.output.writeLine(pc.green(t("repl.verbose_set", { level: result.display })));
     }
   });
   ctx.registerCommand({
@@ -38194,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({
@@ -38226,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({
@@ -38281,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 = {};
@@ -38310,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({
@@ -38340,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 }));
@@ -38355,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;
       }
@@ -38406,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,
@@ -38420,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;
       }
@@ -38434,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);
@@ -38447,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);
     }
   });
 }
@@ -38523,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;
@@ -38549,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;
@@ -38572,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));
     }
   });
 }
@@ -38642,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();
@@ -38730,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)
@@ -38820,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;
       }
@@ -38849,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();
@@ -38860,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();
@@ -38887,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
@@ -38915,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();
@@ -40182,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);
@@ -41313,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) {
@@ -41422,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();
@@ -41458,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) {
@@ -41492,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;
@@ -41850,6 +42967,7 @@ function formatWarning(text) {
 
 // src/ui/renderer.ts
 init_spinner();
+init_theme();
 
 // src/ui/action-log.ts
 var last = null;
@@ -42317,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();
@@ -42403,6 +43523,7 @@ init_session_logger();
 
 // src/ui/plan-view.ts
 init_colors();
+init_theme();
 init_js_identifiers();
 init_i18n();
 function currentStepIndex(plan) {
@@ -42605,6 +43726,7 @@ function createHostBridge(opts) {
 class Repl {
   completer = new Completer;
   modelCache = [];
+  configSnapshot = new Map;
   running = false;
   agentRunning = false;
   inputLocked = false;
@@ -42648,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);
@@ -42705,6 +43827,7 @@ class Repl {
     });
     this.agent.setPromptIO?.(this.promptIO);
     registerAllCommands(this);
+    this.configSnapshot = captureConfigSnapshot(this.config);
     this.setupCompleter();
     this.setupListeners();
     if (pluginManager) {
@@ -42765,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}`);
@@ -42778,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));
@@ -42794,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 {
@@ -43140,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 {
@@ -43151,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) {
@@ -43363,6 +44569,9 @@ ${line}`);
   }
 }
 
+// src/cli/main.ts
+init_theme();
+
 // src/cli/run-result.ts
 init_i18n();
 init_colors();
@@ -43456,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
@@ -43576,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);
@@ -43589,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 {}
@@ -43723,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);
@@ -43811,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) {