> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Справочник CLI

> Полный справочник по интерфейсу командной строки Claude Code, включая команды и флаги.

<h2 id="cli-commands">
  Команды CLI
</h2>

Вы можете запускать сеансы, передавать содержимое, возобновлять беседы и управлять обновлениями с помощью этих команд:

| Команда                         | Описание                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Пример                                                      |
| :------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------- |
| `claude`                        | Запустить интерактивный сеанс                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `claude`                                                    |
| `claude "query"`                | Запустить интерактивный сеанс с начальным запросом                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `claude "explain this project"`                             |
| `claude -p "query"`             | Запрос через SDK, затем выход                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `claude -p "explain this function"`                         |
| `cat file \| claude -p "query"` | Обработка переданного содержимого                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `cat logs.txt \| claude -p "explain"`                       |
| `claude -c`                     | Продолжить самую последнюю беседу в текущем каталоге                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `claude -c`                                                 |
| `claude -c -p "query"`          | Продолжить через SDK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `claude -c -p "Check for type errors"`                      |
| `claude -r "<session>" "query"` | Возобновить сеанс по ID или имени                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `claude -r "auth-refactor" "Finish this PR"`                |
| `claude update`                 | Обновить до последней версии                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `claude update`                                             |
| `claude gateway`                | Запустить сервер самостоятельно размещаемого [Claude apps gateway](/ru/claude-apps-gateway), для администраторов, развертывающих SSO и политику перед Claude Code на Bedrock, Vertex AI или Foundry. Требует `--config`, указывающий на [`gateway.yaml`](/ru/claude-apps-gateway-config). Доступно в Claude Code v2.1.195 и позже.                                                                                                                                                                                                                                                                                                                                                                           | `claude gateway --config gateway.yaml`                      |
| `claude install [version]`      | Установить или переустановить собственный двоичный файл. Принимает версию, такую как `2.1.118`, или `stable`, или `latest`. См. [Установить конкретную версию](/ru/setup#install-a-specific-version)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `claude install stable`                                     |
| `claude auth login`             | Войти в свою учетную запись Anthropic. Используйте `--email` для предварительного заполнения адреса электронной почты, `--sso` для принудительной аутентификации SSO и `--console` для входа с помощью Anthropic Console для выставления счетов за использование API вместо подписки Claude                                                                                                                                                                                                                                                                                                                                                                                                                  | `claude auth login --console`                               |
| `claude auth logout`            | Выйти из своей учетной записи Anthropic                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `claude auth logout`                                        |
| `claude auth status`            | Показать статус аутентификации в формате JSON. Используйте `--text` для удобочитаемого вывода. Выходит с кодом 0, если вы вошли, 1, если нет                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `claude auth status`                                        |
| `claude agents`                 | Открыть [представление агентов](/ru/agent-view) для мониторинга и отправки параллельных фоновых сеансов. Используйте `--cwd <path>` для отображения только сеансов, запущенных в этом каталоге, или `--json` для вывода активных сеансов в виде массива JSON для написания скриптов (`--json --all` также включает завершенные фоновые сеансы). Передайте `--permission-mode`, `--model`, `--effort` или `--agent` для установки [значений по умолчанию для отправленных сеансов](/ru/agent-view#permission-mode-model-and-effort). Принимает `--settings`, `--add-dir`, `--plugin-dir` и `--mcp-config` как команда верхнего уровня `claude`. Открытие представления агентов требует интерактивный терминал | `claude agents --json`                                      |
| `claude attach <id>`            | Подключиться к [фоновому сеансу](/ru/agent-view#manage-sessions-from-the-shell) в этом терминале                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `claude attach 7c5dcf5d`                                    |
| `claude auto-mode defaults`     | Вывести встроенные правила классификатора [auto mode](/ru/permission-modes#eliminate-prompts-with-auto-mode) в формате JSON. Используйте `claude auto-mode config` для просмотра вашей эффективной конфигурации с применяемыми параметрами                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `claude auto-mode defaults > rules.json`                    |
| `claude daemon status`          | Вывести состояние [супервизора](/ru/agent-view#the-supervisor-process) фонового сеанса, версию, каталог сокета и количество рабочих процессов для диагностики. Выходит с кодом 1, если супервизор не запущен                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `claude daemon status`                                      |
| `claude daemon stop --any`      | Остановить [супервизора](/ru/agent-view#the-supervisor-process) фонового сеанса и размещаемые им сеансы. Передайте `--keep-workers` для сохранения работающих фоновых сеансов, чтобы следующий супервизор переподключился к ним. `--any` подтверждает остановку супервизора по требованию, который используется по умолчанию. Используйте это для восстановления после [неответчивого супервизора](/ru/agent-view#agent-view-says-the-background-service-did-not-respond)                                                                                                                                                                                                                                    | `claude daemon stop --any --keep-workers`                   |
| `claude logs <id>`              | Вывести недавний вывод из [фонового сеанса](/ru/agent-view#manage-sessions-from-the-shell)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `claude logs 7c5dcf5d`                                      |
| `claude mcp`                    | Настроить серверы Model Context Protocol (MCP)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | См. [документацию Claude Code MCP](/ru/mcp).                |
| `claude mcp login <name>`       | {/* min-version: 2.1.186 */}Запустить поток OAuth настроенного сервера MCP без открытия интерактивной панели `/mcp`. Работает для HTTP, SSE и серверов соединителя claude.ai. Добавьте `--no-browser` через SSH для вывода URL авторизации вместо открытия браузера, затем вставьте URL перенаправления обратно в приглашение. Требует Claude Code версии 2.1.186 или позже. См. [Аутентификация из командной строки](/ru/mcp#authenticate-from-the-command-line)                                                                                                                                                                                                                                            | `claude mcp login sentry`                                   |
| `claude mcp logout <name>`      | {/* min-version: 2.1.186 */}Очистить сохраненные учетные данные OAuth для сервера MCP. Требует Claude Code версии 2.1.186 или позже                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `claude mcp logout sentry`                                  |
| `claude plugin`                 | Управлять Claude Code [plugins](/ru/plugins). Псевдоним: `claude plugins`. См. [справочник plugins](/ru/plugins-reference#cli-commands-reference) для подкоманд                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `claude plugin install code-review@claude-plugins-official` |
| `claude project purge [path]`   | Удалить все локальное состояние Claude Code для проекта: стенограммы, списки задач, журналы отладки, историю редактирования файлов, строки истории подсказок и запись проекта в `~/.claude.json`. Опустите `[path]` для выбора из интерактивного списка. Флаги: `--dry-run` для предпросмотра, `-y`/`--yes` для пропуска подтверждения, `-i`/`--interactive` для подтверждения каждого элемента, `--all` для каждого проекта. См. [Очистить локальные данные](/ru/claude-directory#clear-local-data)                                                                                                                                                                                                         | `claude project purge ~/work/repo --dry-run`                |
| `claude remote-control`         | Запустить сервер [Remote Control](/ru/remote-control) для управления Claude Code из Claude.ai или приложения Claude. Работает в режиме сервера (без локального интерактивного сеанса). См. [флаги режима сервера](/ru/remote-control#start-a-remote-control-session)                                                                                                                                                                                                                                                                                                                                                                                                                                         | `claude remote-control --name "My Project"`                 |
| `claude respawn <id>`           | Перезапустить [фоновый сеанс](/ru/agent-view#manage-sessions-from-the-shell), работающий или остановленный, с сохранением его беседы. Используйте `--all` для перезапуска каждого работающего сеанса, например для применения обновленного двоичного файла Claude Code                                                                                                                                                                                                                                                                                                                                                                                                                                       | `claude respawn 7c5dcf5d`                                   |
| `claude rm <id>`                | Удалить [фоновый сеанс](/ru/agent-view#manage-sessions-from-the-shell) из списка. Стенограмма беседы остается на вашем локальном компьютере, доступная через `claude --resume`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `claude rm 7c5dcf5d`                                        |
| `claude setup-token`            | Создать долгоживущий OAuth токен для CI и скриптов. Выводит токен в терминал без сохранения. Требует подписку Claude. См. [Создать долгоживущий токен](/ru/authentication#generate-a-long-lived-token)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `claude setup-token`                                        |
| `claude stop <id>`              | Остановить [фоновый сеанс](/ru/agent-view#manage-sessions-from-the-shell). Также принимает `claude kill`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `claude stop 7c5dcf5d`                                      |
| `claude ultrareview [target]`   | Запустить [ultrareview](/ru/ultrareview#run-ultrareview-non-interactively) неинтерактивно. Выводит результаты в stdout и выходит с кодом 0 при успехе или 1 при ошибке. Используйте `--json` для необработанного полезного груза и `--timeout <minutes>` для переопределения 30-минутного значения по умолчанию                                                                                                                                                                                                                                                                                                                                                                                              | `claude ultrareview 1234 --json`                            |

Если вы неправильно введете подкоманду, Claude Code предложит ближайшее совпадение и выйдет без запуска сеанса. Например, `claude udpate` выводит `Did you mean claude update?`.

<h2 id="cli-flags">
  Флаги CLI
</h2>

Настройте поведение Claude Code с помощью этих флагов командной строки. `claude --help` не выводит каждый флаг, поэтому отсутствие флага в `--help` не означает, что он недоступен.

| Флаг                                            | Описание                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Пример                                                                                              |
| :---------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------- |
| `--add-dir`                                     | Добавить дополнительные рабочие каталоги для Claude для чтения и редактирования файлов. Предоставляет доступ к файлам; большинство конфигурации `.claude/` [не обнаруживается](/ru/permissions#additional-directories-grant-file-access-not-configuration) из этих каталогов. Проверяет, что каждый путь существует как каталог. Чтобы сохранить эти каталоги между сеансами, установите [`permissions.additionalDirectories`](/ru/settings#permission-settings) в параметрах                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `claude --add-dir ../apps ../lib`                                                                   |
| `--advisor <model>`                             | {/* min-version: 2.1.98 */}Включить инструмент [advisor](/ru/advisor) на стороне сервера для этого сеанса с псевдонимом модели: `opus`, `sonnet` или `fable` ({/* min-version: 2.1.170 */}v2.1.170+), или полный ID модели. Имеет приоритет над параметром `advisorModel` для сеанса. Требует Claude Code v2.1.98 или позже                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `claude --advisor opus`                                                                             |
| `--agent`                                       | Указать агента для текущего сеанса (переопределяет параметр `agent`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `claude --agent my-custom-agent`                                                                    |
| `--agents`                                      | Определить пользовательские subagents динамически через JSON. Использует те же имена полей, что и subagent [frontmatter](/ru/sub-agents#supported-frontmatter-fields), плюс поле `prompt` для инструкций агента                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `claude --agents '{"reviewer":{"description":"Reviews code","prompt":"You are a code reviewer"}}'`  |
| `--allow-dangerously-skip-permissions`          | Добавить `bypassPermissions` в цикл режима `Shift+Tab` без немедленной активации. Позволяет начать в другом режиме, таком как `plan`, и переключиться на `bypassPermissions` позже. См. [режимы разрешения](/ru/permission-modes#skip-all-checks-with-bypasspermissions-mode)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `claude --permission-mode plan --allow-dangerously-skip-permissions`                                |
| `--allowedTools`, `--allowed-tools`             | Инструменты, которые выполняются без запроса разрешения. См. [синтаксис правила разрешения](/ru/settings#permission-rule-syntax) для сопоставления шаблонов. Чтобы ограничить доступные инструменты, используйте `--tools` вместо этого                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `"Bash(git log *)" "Bash(git diff *)" "Read"`                                                       |
| `--append-system-prompt`                        | Добавить пользовательский текст в конец системного приглашения по умолчанию                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `claude --append-system-prompt "Always use TypeScript"`                                             |
| `--append-system-prompt-file`                   | Загрузить дополнительный текст системного приглашения из файла и добавить к приглашению по умолчанию                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `claude --append-system-prompt-file ./extra-rules.txt`                                              |
| `--ax-screen-reader`                            | {/* min-version: 2.1.181 */}Отрендерить вывод, удобный для программ чтения с экрана: плоский текст без декоративных границ или анимаций. Принудительно использует классический рендерер, поэтому параметр [`tui`](/ru/settings#available-settings) не имеет эффекта для сеанса. Имеет приоритет над [`CLAUDE_AX_SCREEN_READER`](/ru/env-vars) и параметром [`axScreenReader`](/ru/settings#available-settings). Требует Claude Code v2.1.181 или позже                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `claude --ax-screen-reader`                                                                         |
| `--bare`                                        | Минимальный режим: пропустить автоматическое обнаружение hooks, skills, plugins, MCP серверов, автоматической памяти и CLAUDE.md, чтобы скриптовые вызовы начинались быстрее. Claude имеет доступ к инструментам Bash, чтения файлов и редактирования файлов. Устанавливает [`CLAUDE_CODE_SIMPLE`](/ru/env-vars). См. [bare mode](/ru/headless#start-faster-with-bare-mode)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `claude --bare -p "query"`                                                                          |
| `--betas`                                       | Заголовки бета-версии для включения в запросы API (только для пользователей API-ключей)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `claude --betas interleaved-thinking`                                                               |
| `--bg`, `--background`                          | Запустить сеанс как [фоновый агент](/ru/agent-view) и вернуться немедленно. Выводит ID сеанса и команды управления. Комбинируйте с `--exec` для запуска команды shell как фонового задания вместо сеанса Claude, или с `--agent` для запуска конкретного subagent                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `claude --bg "investigate the flaky test"`                                                          |
| `--channels`                                    | (Исследовательский предпросмотр) MCP серверы, чьи уведомления [channel](/ru/channels) Claude должен слушать в этом сеансе. Разделенный пробелом список записей `plugin:<name>@<marketplace>`. Требует аутентификацию Claude.ai                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `claude --channels plugin:my-notifier@my-marketplace`                                               |
| `--chrome`                                      | Включить [интеграцию браузера Chrome](/ru/chrome) для веб-автоматизации и тестирования                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `claude --chrome`                                                                                   |
| `--continue`, `-c`                              | Загрузить самую последнюю беседу в текущем каталоге. Включает сеансы, которые добавили этот каталог с помощью `/add-dir`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `claude --continue`                                                                                 |
| `--dangerously-load-development-channels`       | Включить [channels](/ru/channels-reference#test-during-the-research-preview), которые не находятся в утвержденном списке разрешений, для локальной разработки. Принимает записи `plugin:<name>@<marketplace>` и `server:<name>`. Запрашивает подтверждение                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `claude --dangerously-load-development-channels server:webhook`                                     |
| `--dangerously-skip-permissions`                | Пропустить запросы разрешения. Эквивалентно `--permission-mode bypassPermissions`. См. [режимы разрешения](/ru/permission-modes#skip-all-checks-with-bypasspermissions-mode) для информации о том, что это пропускает и что не пропускает                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `claude --dangerously-skip-permissions`                                                             |
| `--debug`                                       | Включить режим отладки с дополнительной фильтрацией категорий (например, `"api,hooks"` или `"!statsig,!file"`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `claude --debug "api,mcp"`                                                                          |
| `--debug-file <path>`                           | Записать журналы отладки в конкретный путь файла. Неявно включает режим отладки. Имеет приоритет над `CLAUDE_CODE_DEBUG_LOGS_DIR`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `claude --debug-file /tmp/claude-debug.log`                                                         |
| `--disable-slash-commands`                      | Отключить все skills и команды для этого сеанса                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `claude --disable-slash-commands`                                                                   |
| `--disallowedTools`, `--disallowed-tools`       | Правила отрицания. Простое имя инструмента удаляет соответствующие инструменты из контекста модели: `"Edit"` удаляет Edit, `"*"` удаляет каждый инструмент, и `"mcp__*"` удаляет каждый MCP инструмент. Правило с областью действия, такое как `Bash(rm *)`, оставляет инструмент доступным и отрицает только совпадающие вызовы                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `"Bash(git log *)" "Bash(git diff *)" "Edit"`                                                       |
| `--effort`                                      | Установить [уровень усилий](/ru/model-config#adjust-effort-level) для текущего сеанса. Опции: `low`, `medium`, `high`, `xhigh`, `max`; доступные уровни зависят от модели. Переопределяет параметр [`effortLevel`](/ru/settings#available-settings) для этого сеанса и не сохраняется                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `claude --effort high`                                                                              |
| `--enable-auto-mode`                            | {/* max-version: 2.1.110 */}Удалено в v2.1.111. Auto mode теперь находится в цикле `Shift+Tab` по умолчанию; используйте `--permission-mode auto` для запуска в нем                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `claude --permission-mode auto`                                                                     |
| `--exclude-dynamic-system-prompt-sections`      | Переместить разделы для каждой машины из системного приглашения (рабочий каталог, информация об окружении, пути памяти, флаг git-repo) в первое пользовательское сообщение. Улучшает повторное использование prompt-cache на разных пользователях и машинах, запускающих одну и ту же задачу. Применяется только с системным приглашением по умолчанию; игнорируется, когда установлены `--system-prompt` или `--system-prompt-file`. Используйте с `-p` для скриптовых многопользовательских рабочих нагрузок                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `claude -p --exclude-dynamic-system-prompt-sections "query"`                                        |
| `--exec`                                        | Запустить команду shell как фоновое задание с поддержкой PTY вместо запуска сеанса Claude. Используйте с `--bg` для запуска из shell                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `claude --bg --exec 'pytest -x'`                                                                    |
| `--fallback-model`                              | Включить автоматический переход на указанную модель (модели) при перегрузке или недоступности основной модели, например снятая с производства модель. Принимает разделенный запятыми список, пробуемый по порядку. См. [Цепочки резервных моделей](/ru/model-config#fallback-model-chains). Чтобы сохранить цепочку между сеансами, используйте параметр [`fallbackModel`](/ru/settings#available-settings), который этот флаг переопределяет                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `claude --fallback-model sonnet,haiku`                                                              |
| `--fork-session`                                | При возобновлении создать новый ID сеанса вместо повторного использования исходного (используйте с `--resume` или `--continue`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `claude --resume abc123 --fork-session`                                                             |
| `--from-pr`                                     | Возобновить сеансы, связанные с конкретным pull request. Принимает номер PR, URL GitHub или GitHub Enterprise PR, URL GitLab merge request или URL Bitbucket pull request. Сеансы автоматически связываются при создании Claude pull request                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `claude --from-pr 123`                                                                              |
| `--ide`                                         | Автоматически подключиться к IDE при запуске, если доступна ровно одна действительная IDE                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `claude --ide`                                                                                      |
| `--init`                                        | Запустить [Setup hooks](/ru/hooks#setup) с помощью matcher `init` перед сеансом (только режим печати)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `claude -p --init "query"`                                                                          |
| `--init-only`                                   | Запустить [Setup](/ru/hooks#setup) и `SessionStart` hooks, затем выйти без запуска беседы                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `claude --init-only`                                                                                |
| `--include-hook-events`                         | Включить все события жизненного цикла hook в выходной поток. Требует `--output-format stream-json`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `claude -p --output-format stream-json --verbose --include-hook-events "query"`                     |
| `--include-partial-messages`                    | Включить частичные события потоковой передачи в вывод. Требует `--print` и `--output-format stream-json`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `claude -p --output-format stream-json --verbose --include-partial-messages "query"`                |
| `--input-format`                                | Указать формат входных данных для режима печати (опции: `text`, `stream-json`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `claude -p --output-format json --input-format stream-json`                                         |
| `--json-schema`                                 | Получить проверенный вывод JSON, соответствующий JSON Schema после завершения рабочего процесса агента (только режим печати, см. [структурированные выходы](/ru/agent-sdk/structured-outputs))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `claude -p --json-schema '{"type":"object","properties":{...}}' "query"`                            |
| `--maintenance`                                 | Запустить [Setup hooks](/ru/hooks#setup) с помощью matcher `maintenance` перед сеансом (только режим печати)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `claude -p --maintenance "query"`                                                                   |
| `--max-budget-usd`                              | Максимальная сумма в долларах для расходования на вызовы API перед остановкой (только режим печати)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `claude -p --max-budget-usd 5.00 "query"`                                                           |
| `--max-turns`                                   | Ограничить количество агентских ходов (только режим печати). Выходит с ошибкой при достижении лимита. По умолчанию нет лимита                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `claude -p --max-turns 3 "query"`                                                                   |
| `--mcp-config`                                  | Загрузить MCP серверы из JSON файлов или строк (разделенные пробелом)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `claude --mcp-config ./mcp.json`                                                                    |
| `--model`                                       | Устанавливает модель для текущего сеанса с псевдонимом для последней модели (`sonnet`, `opus`, `haiku` или `fable`) или полным именем модели. Переопределяет параметр [`model`](/ru/settings#available-settings) и [`ANTHROPIC_MODEL`](/ru/model-config#environment-variables)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `claude --model claude-sonnet-5`                                                                    |
| `--name`, `-n`                                  | Установить отображаемое имя для сеанса, показываемое в `/resume` и в заголовке терминала. Вы можете возобновить именованный сеанс с помощью `claude --resume <name>`. <br /><br />[`/rename`](/ru/commands) изменяет имя во время сеанса и также показывает его на панели приглашения                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `claude -n "my-feature-work"`                                                                       |
| `--no-chrome`                                   | Отключить [интеграцию браузера Chrome](/ru/chrome) для этого сеанса                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `claude --no-chrome`                                                                                |
| `--no-session-persistence`                      | Отключить сохранение сеанса, чтобы сеансы не сохранялись на диск и не могли быть возобновлены. Только режим печати. Переменная окружения [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/ru/env-vars) делает то же самое в любом режиме                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `claude -p --no-session-persistence "query"`                                                        |
| `--output-format`                               | Указать формат вывода для режима печати (опции: `text`, `json`, `stream-json`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `claude -p "query" --output-format json`                                                            |
| `--permission-mode`                             | Начать в указанном [режиме разрешения](/ru/permission-modes). Принимает `default`, `acceptEdits`, `plan`, `auto`, `dontAsk` или `bypassPermissions`. Переопределяет `defaultMode` из файлов параметров                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `claude --permission-mode plan`                                                                     |
| `--permission-prompt-tool`                      | Указать инструмент MCP для обработки запросов разрешения в неинтерактивном режиме                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `claude -p --permission-prompt-tool mcp_auth_tool "query"`                                          |
| `--plugin-dir`                                  | Загрузить plugin из каталога или архива `.zip` только для этого сеанса. Каждый флаг принимает один путь. Повторите флаг для нескольких plugins: `--plugin-dir A --plugin-dir B.zip`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `claude --plugin-dir ./my-plugin`                                                                   |
| `--plugin-url`                                  | Получить plugin архив `.zip` из URL только для этого сеанса. Повторите флаг для нескольких plugins или передайте разделенные пробелом URL в одном значении в кавычках                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `claude --plugin-url https://example.com/plugin.zip`                                                |
| `--print`, `-p`                                 | Вывести ответ без интерактивного режима (см. [документацию Agent SDK](/ru/agent-sdk/overview) для деталей программного использования)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `claude -p "query"`                                                                                 |
| `--prompt-suggestions`                          | Выдать сообщение `prompt_suggestion` после каждого хода с предсказанным следующим приглашением пользователя. Требует `--print`, `--output-format stream-json` и `--verbose`. См. [Предложения приглашений](/ru/interactive-mode#prompt-suggestions)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `claude -p --prompt-suggestions --output-format stream-json --verbose "query"`                      |
| `--remote`                                      | Создать новый [веб-сеанс](/ru/claude-code-on-the-web) на claude.ai с предоставленным описанием задачи                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `claude --remote "Fix the login bug"`                                                               |
| `--remote-control`, `--rc`                      | Запустить интерактивный сеанс с включенным [Remote Control](/ru/remote-control#start-a-remote-control-session), чтобы вы также могли управлять им из claude.ai или приложения Claude. Опционально передайте имя для сеанса                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `claude --remote-control "My Project"`                                                              |
| `--remote-control-session-name-prefix <prefix>` | Префикс для автоматически генерируемых имен сеансов [Remote Control](/ru/remote-control) при отсутствии явного имени. По умолчанию используется имя хоста вашей машины, создавая имена вроде `myhost-graceful-unicorn`. Установите `CLAUDE_REMOTE_CONTROL_SESSION_NAME_PREFIX` для того же эффекта                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `claude remote-control --remote-control-session-name-prefix dev-box`                                |
| `--replay-user-messages`                        | Повторно отправить пользовательские сообщения из stdin обратно на stdout для подтверждения. Требует `--input-format stream-json` и `--output-format stream-json`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `claude -p --input-format stream-json --output-format stream-json --verbose --replay-user-messages` |
| `--resume`, `-r`                                | Возобновить конкретный сеанс по ID или имени, или показать интерактивный выбор для выбора сеанса. Выбор и поиск по имени включают сеансы, которые добавили этот каталог с помощью `/add-dir`; передача ID сеанса ищет только текущий каталог проекта и его git worktrees. Начиная с v2.1.144, [фоновые сеансы](/ru/agent-view) появляются в выборе, отмеченные как `bg`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `claude --resume auth-refactor`                                                                     |
| `--safe-mode`                                   | {/* min-version: 2.1.169 */}Запустить со всеми отключенными настройками для устранения неполадок в нарушенной конфигурации: CLAUDE.md, skills, plugins, hooks, MCP серверы, пользовательские команды и агенты, стили вывода, рабочие процессы, пользовательские темы, пользовательские сочетания клавиш, строка состояния и команды предложения файлов, LSP серверы и автоматическая память не загружаются. Аутентификация, выбор модели, встроенные инструменты и разрешения работают нормально, что отличается от [`--bare`](/ru/headless#start-faster-with-bare-mode). Политика управляемых параметров все еще применяется, включая настроенные политикой hooks, строку состояния и команды предложения файлов; управляемые plugins, управляемые skills, управляемый CLAUDE.md и настроенные политикой MCP серверы не загружаются. Полезно для проверки того, является ли настройка причиной [автоматического переключения с Fable 5](/ru/model-config#automatic-model-fallback). Устанавливает [`CLAUDE_CODE_SAFE_MODE`](/ru/env-vars) | `claude --safe-mode`                                                                                |
| `--session-id`                                  | Использовать конкретный ID сеанса для беседы (должен быть действительным UUID)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `claude --session-id "550e8400-e29b-41d4-a716-446655440000"`                                        |
| `--setting-sources`                             | Разделенный запятыми список источников параметров для загрузки (`user`, `project`, `local`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `claude --setting-sources user,project`                                                             |
| `--settings`                                    | Путь к файлу параметров JSON или встроенная строка JSON. Значения, которые вы устанавливаете здесь, переопределяют те же ключи в ваших файлах `settings.json` для этого сеанса. Ключи, которые вы опускаете, сохраняют свои значения на основе файла. См. [приоритет параметров](/ru/settings#settings-precedence)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `claude --settings ./settings.json`                                                                 |
| `--strict-mcp-config`                           | Использовать только MCP серверы из `--mcp-config`, игнорируя все остальные конфигурации MCP                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `claude --strict-mcp-config --mcp-config ./mcp.json`                                                |
| `--system-prompt`                               | Заменить весь системный запрос пользовательским текстом                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `claude --system-prompt "You are a Python expert"`                                                  |
| `--system-prompt-file`                          | Загрузить системный запрос из файла, заменяя приглашение по умолчанию                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `claude --system-prompt-file ./custom-prompt.txt`                                                   |
| `--teleport`                                    | Возобновить [веб-сеанс](/ru/claude-code-on-the-web) в вашем локальном терминале                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `claude --teleport`                                                                                 |
| `--teammate-mode`                               | Установить способ отображения товарищей по [команде агентов](/ru/agent-teams): `in-process` (по умолчанию), `auto`, `tmux` или {/* min-version: 2.1.186 */}`iterm2` (добавлено в v2.1.186). Значение по умолчанию изменилось с `auto` в v2.1.179. Переопределяет параметр [`teammateMode`](/ru/settings#available-settings) для этого сеанса. См. [выбор режима отображения](/ru/agent-teams#choose-a-display-mode)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `claude --teammate-mode auto`                                                                       |
| `--tmux`                                        | Создать сеанс tmux для worktree. Требует `--worktree`. Использует встроенные панели iTerm2, если доступны; передайте `--tmux=classic` для традиционного tmux                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `claude -w feature-auth --tmux`                                                                     |
| `--tools`                                       | Ограничить, какие встроенные инструменты может использовать Claude. Используйте `""` для отключения всех, `"default"` для всех или имена инструментов, такие как `"Bash,Edit,Read"`. MCP инструменты не затронуты; чтобы отрицать и их, используйте `--disallowedTools "mcp__*"` или передайте `--strict-mcp-config` без `--mcp-config`, чтобы не загружались MCP серверы                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `claude --tools "Bash,Edit,Read"`                                                                   |
| `--verbose`                                     | Включить подробное логирование, показывает полный вывод по ходам. Переопределяет параметр [`viewMode`](/ru/settings#available-settings) для этого сеанса                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `claude --verbose`                                                                                  |
| `--version`, `-v`                               | Вывести номер версии                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `claude -v`                                                                                         |
| `--worktree`, `-w`                              | Запустить Claude в изолированном [git worktree](/ru/worktrees) в `<repo>/.claude/worktrees/<name>`. Если имя не указано, оно генерируется автоматически. Передайте `#<number>` или URL GitHub pull request для получения этого PR из `origin` и ветвления worktree из него                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `claude -w feature-auth`                                                                            |

<h3 id="system-prompt-flags">
  Флаги системного приглашения
</h3>

Claude Code предоставляет четыре флага для настройки системного приглашения. Все четыре работают как в интерактивном, так и в неинтерактивном режимах.

| Флаг                          | Поведение                                             | Пример                                                  |
| :---------------------------- | :---------------------------------------------------- | :------------------------------------------------------ |
| `--system-prompt`             | Заменяет весь приглашение по умолчанию                | `claude --system-prompt "You are a Python expert"`      |
| `--system-prompt-file`        | Заменяет содержимым файла                             | `claude --system-prompt-file ./prompts/review.txt`      |
| `--append-system-prompt`      | Добавляет к приглашению по умолчанию                  | `claude --append-system-prompt "Always use TypeScript"` |
| `--append-system-prompt-file` | Добавляет содержимое файла к приглашению по умолчанию | `claude --append-system-prompt-file ./style-rules.txt`  |

`--system-prompt` и `--system-prompt-file` являются взаимоисключающими. Флаги добавления можно комбинировать с любым флагом замены.

Выбирайте в зависимости от того, подходит ли стандартная идентичность Claude Code для вашей задачи. Используйте флаг добавления, когда Claude должен оставаться помощником по кодированию, который также следует вашим дополнительным правилам: инструкции для каждого вызова, форматирование вывода или контекст домена для скрипта `-p`. Добавление сохраняет стандартное руководство по инструментам, инструкции безопасности и соглашения кодирования, поэтому вы предоставляете только то, что отличается. Используйте флаг замены, когда поверхность, идентичность или модель разрешения отличаются от Claude Code, например некодирующий агент в конвейере, который не смотрит ни один человек. Замена удаляет весь стандартный запрос, включая руководство по инструментам и инструкции безопасности, поэтому вы берете на себя ответственность за все, что вашей задаче все еще нужно.

Эти флаги применяются только к текущему вызову. Для постоянных персон, которые вы можете переключать и делиться между проектом, используйте [стили вывода](/ru/output-styles). Для соглашений проекта, которые Claude должен всегда соблюдать, используйте [CLAUDE.md](/ru/memory). [Руководство Agent SDK по системным приглашениям](/ru/agent-sdk/modifying-system-prompts#decide-on-a-starting-point) охватывает то же решение более подробно.

<h2 id="see-also">
  См. также
</h2>

* [Расширение Chrome](/ru/chrome) - Веб-автоматизация и веб-тестирование
* [Интерактивный режим](/ru/interactive-mode) - Сочетания клавиш, режимы ввода и интерактивные функции
* [Руководство быстрого старта](/ru/quickstart) - Начало работы с Claude Code
* [Общие рабочие процессы](/ru/common-workflows) - Продвинутые рабочие процессы и шаблоны
* [Параметры](/ru/settings) - Опции конфигурации
* [Документация Agent SDK](/ru/agent-sdk/overview) - Программное использование и интеграции
