> For the complete documentation index, see [llms.txt](https://docs.onerpa.ru/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.onerpa.ru/mcp-servery-1c/servery/syntax-check-server.md).

# SyntaxCheckServer

Проверка синтаксиса кода 1С через bsl-analyzer.

## Назначение

SyntaxCheckServer проверяет код 1С на синтаксические ошибки, используя bsl-analyzer. Это самый простой в установке MCP-сервер — он не требует данных конфигурации или embedding модели.

Сервер поддерживает два режима проверки:

* `syntaxcheck` — проверка текста BSL, переданного прямо в MCP-вызове.
* `syntaxcheck_file` — проверка файла из подключённого каталога. Инструмент регистрируется только если задана переменная `FILES_DIR` и каталог существует внутри контейнера.

## Доступные инструменты MCP

ИИ получает следующие инструменты:

| Инструмент         | Описание                                                                      |
| ------------------ | ----------------------------------------------------------------------------- |
| `syntaxcheck`      | Проверка синтаксиса переданного текста BSL через bsl-analyzer                 |
| `syntaxcheck_file` | Проверка BSL-файла из подключённого каталога; доступен только при `FILES_DIR` |
| `plugin_state`     | Состояние загруженных плагинов, hooks, таблиц и ошибок                        |
| `plugin_reload`    | Атомарно перечитать каталог плагинов без перезапуска сервера                  |

У каждого инструмента есть заголовок и аннотации MCP. `syntaxcheck` (Check BSL code), `syntaxcheck_file` (Check a BSL file), `plugin_state` (Plugin state) — `readOnlyHint: true`, `openWorldHint: false`. `plugin_reload` (Reload plugins) — `readOnlyHint: false`, `destructiveHint: false`, `idempotentHint: false`, `openWorldHint: false`. `initialize` сообщает `serverInfo.name` = `BslSyntaxChecker` и `serverInfo.version` — версию выпуска образа, например `1.1.25-20261111.amd64`.

### syntaxcheck

Анализирует BSL-код на синтаксические ошибки с помощью bsl-analyzer. Код сохраняется во временный файл, передаётся на анализ, результат возвращается структурированно и, для совместимости, текстом.

| Параметр       | Тип    | По умолчанию | Описание                                                                                                                                                                                                                              |
| -------------- | ------ | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `code`         | string | —            | Код на языке 1С (BSL) для анализа                                                                                                                                                                                                     |
| `file_name`    | string | `""`         | Логическое имя модуля для переданного кода, например `ObjectModule.bsl`. Только имя файла с расширением `.bsl` — никогда не путь. Пустое значение анализирует код под служебным именем                                                |
| `min_severity` | string | `""`         | Необязательный нижний порог важности: `Blocker`, `Critical`, `Error` (то же, что `Critical`), `Major`, `Warning`, `Minor`, `Information`, `Hint`. Пустое значение возвращает все диагностики. См. [Фильтр важности](#фильтр-важности) |

`file_name` говорит анализатору, чем является код: с `ObjectModule.bsl` он видит модуль объекта под этим именем, и каждая позиция в ответе названа этим именем, а не временным путём сервера. Имя, которое не является именем — разделитель пути, переход к родительскому каталогу, абсолютная или дисковая форма, управляющий символ, пустая основа или неизвестное расширение — приводит к ошибке вызова с указанием причины, а не молча заменяется.

**Возврат**: две части.

* **Структурированная часть** — то, что следует читать: `diagnostics` (типизированные записи), `diagnostic_asides` (значения, вынесенные из диагностики, см. ниже), `summary` с `total` (сколько диагностик выдал анализатор), `returned` (сколько попало в ответ) и `truncated`; `filters` — объявляет, что сузило список (фильтр строк, фильтр важности, таблица подавлений или плагин); блок `provenance`; и `request_rewrite`.
* **Текстовая часть** — один документ [TOON](https://github.com/toon-format/toon) под ключом `events`. Он несёт те же события, значения и порядок, что прежний JSONL, но повторяющиеся поля диагностик записываются одной табличной шапкой. Клиентам следует читать неизменившийся structured content; парсер прежней JSONL-части с TOON несовместим.

{% hint style="warning" %}
В поставляемом `bsl-analyzer.toml` отключены `UnresolvedMethodCall`, `UnresolvedField` и `QueryToMissingMetadata`. При проверке отдельного временного файла анализатор не видит контекст всей конфигурации, поэтому эти межмодульные диагностики давали ложные ошибки на типичном коде 1С. Они не проходят через таблицу подавлений сервера и потому не меняют `filters.suppression_applied`. Сервер проверяет синтаксис и включённые локальные правила, но не доказывает корректность разрешения методов, полей и метаданных запроса во всём проекте.

Эти три проверки можно получить обратно — не включением их в анализаторе, а из индекса всей конфигурации: см. [Режим полного индекса](#режим-полного-индекса).
{% endhint %}

#### `diagnostic_asides`

Табличная форма TOON возможна только тогда, когда каждая диагностика — строка из примитивных значений одних и тех же полей. Анализатор пишет `tags` только у части диагностик и списком, и одного этого достаточно, чтобы таблица не состоялась: первая сборка с TOON (24.08.2026) не давала экономии вовсе.

Поэтому непримитивное значение выносится **рядом** с диагностиками — в `diagnostic_asides`: по одной записи на значение, каждая называет свою диагностику индексом в `diagnostics`:

| Поле записи  | Что означает                                                       |
| ------------ | ------------------------------------------------------------------ |
| `diagnostic` | Индекс диагностики в `diagnostics`, считая с `0`                   |
| `field`      | Имя поля, которым это значение было записано                       |
| `value`      | Одно значение этого поля (список из двух значений даёт две записи) |

Поля, объявленные схемой ответа — `code`, `message`, `severity` и четыре поля диапазона — не выносятся никогда. Структурированная часть объявляет `diagnostic_asides` всегда и несёт пустой список, когда выносить было нечего; текстовая часть в этом случае ключ опускает. Хуки плагинов работают как раньше: вынос происходит после последнего хука, поэтому плагину диагностика приходит такой, какой её написал анализатор.

Замер на одном общем модуле конфигурации ЗУП (101 диагностика, токенизатор `o200k_base`): **3601 токен против 6685 у прежнего JSONL — на 46 % меньше**, 16,4 КБ против 25,7 КБ.

Все диапазоны в обеих частях 1-based, и отчёт это объявляет: событие `start` несёт `"line_base": 1`, структурированная часть — `"provenance": {"line_base": 1}`. Метрики события `file` описывают весь проанализированный файл, а не соседние диагностики: `"provenance": {"file_metrics_scope": "whole_file"}`.

Блок `provenance` полностью описывает, чем и как получен результат:

| Поле                    | Что означает                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `tool`                  | Имя инструмента, ответившего на вызов                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `analyzer_version`      | Версия `bsl-analyzer`, произведшая отчёт. Читается из `/app/bsl_analyzer_nix/installed-release.json` и меняется после самообновления (см. [Самообновление анализатора](#самообновление-анализатора))                                                                                                                                                                                                                                                                                                                   |
| `bundled_configuration` | Работал ли анализатор со встроенным `bsl-analyzer.toml`                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `source_encoding`       | Кодировка, в которой прочитан анализируемый текст                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `line_base`             | База нумерации строк (всегда `1`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `file_metrics_scope`    | Область метрик события `file` (`whole_file`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `index`                 | Состояние полнотекстового индекса конфигурации: `absent`, `building`, `ready` или `failed` (см. [Режим полного индекса](#режим-полного-индекса))                                                                                                                                                                                                                                                                                                                                                                       |
| `cross_module_checks`   | Ответил ли индекс по файлу этого вызова: `ran` — межмодульные проверки выполнены; `not_in_index` — индекс готов, но файла в нём нет, межмодульных проверок для файла не было; `not_run` — нет готового индекса, индекс не ответил за 20 с или проверялся код, переданный текстом (с 17.10.2026)                                                                                                                                                                                                                        |
| `platform_names`        | Проверены ли имена платформы: `ready`, `loading` или `unavailable` (см. [Проверка имён платформы](#проверка-имён-платформы))                                                                                                                                                                                                                                                                                                                                                                                           |
| `compatibility_mode`    | Режим совместимости конфигурации, к которой относится файл, например `8.3.21`; по нему проверены имена платформы (см. [Режим совместимости](#режим-совместимости-и-окружение-модуля-с-17112026)). `unknown` — код передан текстом, файл вне конфигурации, расширение или режим `DontUse` (с 17.11.2026). Ещё `unknown` бывает на анализаторе старше 0.4.6: на образе `arm64` — всегда (в нём 0.2.81), на `latest` до 1.1.29 — пока самообновление не прошло. С 1.1.29 в `latest` анализатор 0.4.6 стоит в самом образе |

Блок `request_rewrite` сообщает, менял ли плагин аргументы вызова: `applied`, что было запрошено (`requested`), что использовано (`used`) и какие файлы плагинов это сделали (`changed_by`).

#### Предел размера ответа

Обе части ответа вместе не превышают `RESPONSE_MAX_CHARS` байт — по умолчанию 32768. Раньше уходили все находки модуля: на модуле 100 КБ — 250 находок и около 94 тысяч символов, на модулях в несколько мегабайт — мегабайты, которые клиент обрезал сам и молча. Если находки не помещаются:

* остаются самые серьёзные — `Blocker`, `Critical`, `Major`, затем предупреждения, информационные находки и подсказки — в том порядке, в каком их выдал анализатор;
* `summary.truncated` равен `true`, `summary.total` — сколько нашёл анализатор, `summary.returned` и `done.total_diagnostics` — сколько вошло в ответ; флаги `filters` предел не выставляет;
* в текстовой части сразу после `start` идёт событие `response_budget` с `complete: false`, пределом и подсказкой сузить вызов.

Остальные находки читаются суженными вызовами `syntaxcheck_file` с `lines`. `RESPONSE_MAX_CHARS=0` снимает предел.

#### Фильтр важности

`min_severity` оставляет в ответе только диагностики не ниже заданной важности. Порядок — от самой серьёзной: `Blocker`, `Critical` (и `Error`), `Major`, `Warning`, `Minor`, `Information`, `Hint`; важность, которой нет в этом списке, стоит между `Warning` и `Minor`. Синтаксическая ошибка (`ParseError`) и неизвестные имена платформы — `Critical`, поэтому для проверки «есть ли ошибки» достаточно `min_severity: "Error"`. `"Warning"` добавляет к ним `Major` и `Warning`.

Фильтр применяется после `lines`, до предела размера ответа. Отброшенное не пропадает бесследно:

* `filters.severity_filter_applied` равен `true`, `summary.total` — сколько выдал анализатор, `summary.returned` и `done.total_diagnostics` — сколько вошло в ответ;
* `summary.by_severity` — всё, что выдал анализатор, по важности, например `{"Major": 6, "Warning": 13, "Information": 109, "Hint": 3}`;
* в текстовой части сразу после `start` идёт событие `severity_filter` с `min_severity` и теми же счётчиками в `produced_by_severity`.

Замер на общем модуле ЗУП со 131 диагностикой: без порога текстовая часть — 11,6 КБ, и ответ упирается в предел размера; с `min_severity: "Error"` — 569 байт: пустой список и сводка выше. С `"Warning"` — 19 диагностик, 4,7 КБ.

Без `min_severity` ответ тот же, что раньше, в обеих частях: `summary.by_severity` и событие `severity_filter` появляются только при заданном пороге. Недопустимое значение отклоняется по схеме инструмента до анализа.

### syntaxcheck\_file

Анализирует файл из каталога, указанного в `FILES_DIR`. Путь передаётся относительно этого каталога. Можно ограничить выдачу диагностик конкретными строками.

| Параметр       | Тип    | По умолчанию | Описание                                                                                                                                                                                                                              |
| -------------- | ------ | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `file_path`    | string | —            | Относительный путь к `.bsl`-файлу внутри `FILES_DIR`                                                                                                                                                                                  |
| `lines`        | string | `""`         | Необязательный список строк и диапазонов, например `5, 10-20, 35`. Пустое значение проверяет весь файл                                                                                                                                |
| `min_severity` | string | `""`         | Необязательный нижний порог важности: `Blocker`, `Critical`, `Error` (то же, что `Critical`), `Major`, `Warning`, `Minor`, `Information`, `Hint`. Пустое значение возвращает все диагностики. См. [Фильтр важности](#фильтр-важности) |

**Возврат**: те же две части, что у `syntaxcheck`, по той же схеме. Отличие — в том, что они говорят о суженном вызове: при заданном `lines` в `summary` поле `total` — это диагностики всего файла, а `returned` — сколько из них пересекается с запрошенными строками, и `filters` несёт `"line_filter_applied": true`. Файл с двенадцатью диагностиками, суженный до одной строки, читается как «двенадцать выдано, одна возвращена», а не как файл с одной диагностикой. Метрики события `file` по-прежнему описывают весь файл.

Ответ ограничен тем же пределом, что у `syntaxcheck` (см. [Предел размера ответа](#предел-размера-ответа)): большой файл читается частями через `lines`.

Путь в ответе выражен в терминах вызывающей стороны: событие `file` называет файл относительно корня проекта в POSIX-форме, и ни в одном поле — включая полезную нагрузку отказа — не появляется собственный путь сервера.

#### Несколько проектов в одном FILES\_DIR

Без режима полного индекса один контейнер проверяет файлы нескольких проектов: в `FILES_DIR` монтируется по каталогу на проект (`/files/project_a`, `/files/project_b`, …), и путь начинается с каталога проекта — `project_a/CommonModules/<Имя>/Ext/Module.bsl`. Режим полного индекса работает с одним проектом на `FILES_DIR` (см. [Режим полного индекса](#режим-полного-индекса)).

Агент, работающий в репозитории одного проекта, часто передаёт путь от корня своего репозитория или путь своего хоста. Тогда отказ `file_not_found` подсказывает, как устроен `FILES_DIR`:

* `detail.files_dir_entries` — имена каталогов верхнего уровня `FILES_DIR`, до 50, без путей сервера; при большем числе — `detail.files_dir_entries_truncated: true`;
* `detail.candidates` — до 5 путей, по которым файл есть: путь вызова внутри каждого каталога верхнего уровня (не хватало каталога проекта) и путь вызова от сегмента, совпадающего с каталогом верхнего уровня (лишний префикс хоста, например `C:\Work\…`).

Те же сведения есть в тексте `message`, поэтому со второго вызова агент передаёт путь из `candidates` без изменений. Абсолютный путь хоста (`/home/…`) получает отказ `path_outside_files_dir`; если такой файл есть внутри `FILES_DIR`, в отказе тоже есть `detail.candidates`. Каталог, ссылка которого ведёт за пределы `FILES_DIR`, не называется и не предлагается; имена в журнал сервера не попадают.

### Ошибки инструментов

Если анализ не удалось выполнить, оба инструмента возвращают ошибку инструмента (а не успешный результат) с полезной нагрузкой `{"error": {"code", "message", "retryable"}}`. Коды:

`files_dir_unavailable`, `invalid_lines`, `invalid_file_name`, `path_outside_files_dir`, `file_not_found`, `file_unreadable`, `analyzer_not_found`, `analyzer_timeout`, `analyzer_failed`, `analyzer_no_output`, `malformed_output`, `internal_error`.

Код `invalid_file_name` принадлежит только `syntaxcheck`: `syntaxcheck_file` берёт имя из самого файла.

## Проверка имён платформы

Анализатор при проверке одного модуля не сверяет, существует ли в платформе имя, которое использует код. `Массив.ДобавитьЭлемент()`, `Структура.Ключи()`, `ВидДвиженияНакопления.Поступление` и `Новый НесуществующийТип` проходят чисто, хотя каждое из них — ошибка во время выполнения. Модель платформы у анализатора при этом есть, поэтому при старте контейнер читает её у своего же анализатора (около 10 секунд в фоне, повторно — после обновления анализатора) и проверяет эти имена сам. Новых данных в образ не добавляется.

Находки приходят в общем списке диагностик, как находки анализатора:

| Код                              | Важность   | Когда сообщается                                                                                                                |
| -------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `UnknownPlatformMethod`          | `Critical` | у локальной переменной, созданной через `Новый <Тип>` и больше ничем в методе не заполняемой, вызван метод, которого у типа нет |
| `UnknownPlatformProperty`        | `Critical` | у такой переменной прочитано свойство, а у типа свойств нет совсем (`Массив`, `Соответствие`, `ФиксированныйМассив`)            |
| `UnknownSystemEnumValue`         | `Critical` | у системного перечисления нет такого значения                                                                                   |
| `UnknownPlatformType`            | `Critical` | после `Новый` указан тип, которого в платформе нет                                                                              |
| `PlatformApiUnavailableOnClient` | `Major`    | только `syntaxcheck`: серверный тип или глобальная функция в методе `&НаКлиенте` вне `#Если`                                    |

`syntaxcheck_file` доступность на клиенте не проверяет сам: анализатор сообщает её как `UnavailableInEnvironment`, когда по пути файла видно, что это модуль формы. У кода, переданного текстом, пути нет, поэтому для `syntaxcheck` эту проверку делает сервер.

С образа 1.1.27 от 17.11.2026 модуль с BOM (так Конфигуратор выгружает каждый модуль) анализируется на месте: анализатор видит, что это модуль формы, проверяет `&НаКлиенте`-методы и читает соседний `Form.xml`. Раньше такой модуль копировался во временный каталог под одним именем файла, без пути и без файлов рядом: проверка доступности на клиенте для него не работала, каждый обработчик события формы приходил как `UnusedLocalMethod` с `UnusedParameters`, а реквизиты формы — как неиспользуемые переменные (на двух формах ЗУП — 163 лишние находки). Колонки находок первой строки поправляются на BOM. Модуль в CP1251 по-прежнему перекодируется, но кладётся под тем же относительным путём.

Проверка срабатывает только там, где модель платформы отвечает однозначно, и сознательно не трогает:

* вызовы без объекта вроде `КонецТранзакции()` — их не отличить от экспортных методов глобальных общих модулей и методов объектов конфигурации (на ЗУП такая проверка дала 438 ложных находок);
* свойства типов, у которых свойства есть: модель анализатора знает не все прежние имена свойств;
* члены `Структура`, `ФиксированнаяСтруктура`, `COMОбъект`, `WSПрокси`, `XBase` — они определяются во время выполнения;
* коллекции, которые наполняет конфигурация: `ЦветаСтиля`, `ШрифтыСтиля`, `БиблиотекаКартинок`.

На всех 10185 модулях ЗУП проверка дала три находки. Две из них — реальная ошибка: у `Соответствие` читается `.Значение` вместо переменной цикла. Третья — устаревшее имя `ПреобразованиеXSL.ЗагрузитьИзСтроки`, которое платформа по-прежнему принимает. Медиана затрат — около 1 мс на модуль.

Каждый ответ сообщает в `provenance.platform_names`, была ли модель готова: `ready` — имена проверены, `loading` — модель ещё читалась, `unavailable` — прочитать её не удалось, и эти имена не проверялись. Неудачное чтение записывается в журнал одной записью `server.platform_names` с причиной. Любой из этих кодов плагин может подавить через `SUPPRESSED_DIAGNOSTICS`, как любой другой.

## Режим полного индекса

По умолчанию контейнер анализирует один модуль за раз и ничего не знает об остальной конфигурации. Именно поэтому в `bsl-analyzer.toml` выключены `UnresolvedMethodCall`, `UnresolvedField` и `QueryToMissingMetadata`: вызов, который не может разрешить межмодульную ссылку, помечает неразрешённым всё подряд. На одном общем модуле конфигурации ЗУП это было 167 ложных находок из 268.

`FULLINDEX=true` вместе со смонтированным `FILES_DIR` индексирует этот каталог при старте и отвечает на эти три проверки из индекса:

```powershell
docker run -d --name 1c_syntaxcheck_mcp `
  -e LICENSE_KEY=YOUR_LICENSE_KEY `
  -e FILES_DIR=/files -e FULLINDEX=true `
  -v "C:/path/to/sources:/files:ro" `
  -v 1c_syntaxcheck_index:/index `
  -p 8002:8002 `
  comol/1c_syntaxcheck_mcp:latest
```

### Вызовы других модулей (с 15.11.2026)

Проверку одного модуля индекс дополняет тем, что можно решить только по всей конфигурации:

| Код                       | Что находит                                                                                                                                                                               |
| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `MismatchedArgCount`      | Число аргументов вызова не совпадает с сигнатурой метода другого модуля: `ОбщегоНазначения.ЗначениеРеквизитаОбъекта(1, "Код", Ложь, Неопределено, 5)` — «ожидалось от 2 до 4, передано 5» |
| `MissedRequiredParameter` | В вызове метода другого модуля пропущен обязательный параметр, с его именем                                                                                                               |
| `ModuleAccessibility`     | Код вызывает модуль, недоступный в его контексте: серверный общий модуль без флага «Вызов сервера» из клиентского кода                                                                    |

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

Три группы находок индекса в ответ не попадают, потому что индекс ошибается в них на типовом коде:

* вызов через экспортную переменную модуля приложения, например `ПараметрыПриложения.Удалить(…)` в клиентском коде (переменная объявлена в `МодульУправляемогоПриложения` как `Перем ПараметрыПриложения Экспорт;`). Индекс сообщал «Не удалось разрешить получателя вызова», хотя такая переменная — глобальное имя клиента;
* поле строки таблицы формы, которое форма добавляет к табличной части объекта (дополнительные колонки `<AdditionalColumns>` в `Form.xml`). На выборке из 41 модуля ЗУП это 9 из 11 находок `UnresolvedField`;
* поле `Регистратор` у отбора регистра, подчинённого регистратору (`Отбор.<Регистр>`).

### Режим совместимости и окружение модуля (с 17.11.2026)

`syntaxcheck_file` проверяет имена платформы по режиму совместимости конфигурации, к которой относится файл. Режим читается из `<CompatibilityMode>` в `Configuration.xml` или из `<compatibilityMode>` в `Configuration.mdo` (EDT) и передаётся анализатору. Проверка идёт и с `FULLINDEX`, и без него; время вызова не меняется. Новой переменной окружения нет.

| Код                                       | Что находит                                                                                                    |
| ----------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
| `PlatformMemberHiddenByCompatibilityMode` | Имя, которое режим скрывает: `СтрШаблон` и `СтрНайти` ниже 8.3.6, побитовые функции ниже 8.3.11                |
| `PlatformMemberNewerThanMinVersion`       | Метод, которого ещё нет в платформе версии режима: `СтрНайтиПоРегулярномуВыражению` (с 8.3.23) в режиме 8.3.21 |

Имя, которое режим скрывает, сообщается один раз — как `PlatformMemberHiddenByCompatibilityMode`, без второй находки в том же месте. В ответе — `provenance.compatibility_mode` (например `8.3.21`). Значение `unknown` — код передан текстом, это расширение (оно работает в режиме расширяемой конфигурации), файл вне конфигурации, режим `DontUse` или анализатор старше 0.4.6, который этих настроек не знает. С образа 1.1.29 от 17.11.2026 в `latest` анализатор 0.4.6 стоит в самом образе, так что режим проверяется с первого вызова; образы `latest` до 1.1.29 несли 0.2.81 от 04.10.2026 и получали 0.4.6 самообновлением через несколько десятков секунд после старта. **На `arm64` режим совместимости не работает:** upstream не публикует для него сборок, самообновления нет, а образ `arm64`, включая 1.1.29, несёт анализатор 0.2.81 — сборка 0.4.6 из исходников не уместилась в память сборочной машины. Там `provenance.compatibility_mode` всегда `unknown`. Минимальной платформой считается версия режима. Свой `bsl-analyzer.toml` с `compatibility_mode` или `min_platform_version` используется как написан. Плагин выключает любую из этих проверок через `SUPPRESSED_DIAGNOSTICS`.

До образа 1.1.27 этих находок в ответе не было: режим конфигурации анализатору не передавался. Теперь обе проверки делает анализ самого модуля. На 300 модулях ЗУП (режим 8.3.21) находок ноль; на проверочной конфигурации в режиме 8.2.16 `СтрШаблон` и `СтрНайти` найдены.

С 17.11.2026 режим полного индекса отдаёт также `UnavailableInEnvironment` для глобальной функции, глобального свойства или типа, которых нет в окружении модуля (`НачатьТранзакцию()` или `Новый Запрос` в клиентском общем модуле, `Справочники` на тонком клиенте). Такая же находка про метод или свойство значения из индекса не берётся: она зависит от типа, который индекс вывел для значения, и на 341 модуле ЗУП все 14 таких были ложными. `UnresolvedBareCall` и `UnresolvedMetadataPath` в этот режим по-прежнему не входят. Версию, с которой доступен метод платформы, по-прежнему показывает HelpSearchServer (`docinfo`, поле `since`).

### Конфигурация и её расширения

`FILES_DIR` в режиме полного индекса — один проект: основная конфигурация и, при необходимости, её расширения. Анализатор находит их сам одним из двух способов.

По раскладке каталогов, без настроек:

```
FILES_DIR/
  src/cf/                  выгрузка основной конфигурации (каталог с Configuration.xml)
  src/cfe/<ИмяРасширения>/ выгрузка каждого расширения
```

Так же работает раскладка `cf/` и `cfe/<ИмяРасширения>/` без `src`.

Каталоги с любыми именами перечисляются в файле `bsl-analyzer.toml` в корне `FILES_DIR`, пути — относительно него:

```toml
[source]
root = "УТ"
extensions = ["Расширение1", "Расширение2"]
```

Если каталог смонтирован только для чтения, файл кладётся в него на стороне хоста.

Тогда файл расширения проверяется в контексте основной конфигурации, и его межмодульные ссылки разрешаются:

* экспортные методы основной конфигурации;
* собственные и заимствованные объекты расширения;
* реквизиты, добавленные расширением в заимствованные объекты, и реквизиты самих объектов;
* поля и таблицы в тексте запросов.

Индекс также отвечает на проверки перехватчиков расширения:

* `WeavingAnnotationNotApplicable` — аннотация неприменима, например `&Перед` или `&После` на функции;
* `WeavingSignatureMismatch` — число параметров перехватчика не совпадает с расширяемым методом.

Выгрузки, которые просто лежат рядом без `bsl-analyzer.toml` и не по раскладке, вместе не индексируются: индекс строится по одной из них. Для файлов остальных выгрузок ответ сообщает `provenance.cross_module_checks: not_in_index`, а межмодульных находок для них нет. Для нескольких независимых конфигураций с индексом заведите по контейнеру на каждую, со своим томом `/index`.

**Перестройка индекса.** Изменённые файлы анализатор подхватывает сам. Новое расширение, другая раскладка или правка `bsl-analyzer.toml` меняют набор исходников, и индекс один раз перестраивается целиком. Полная перестройка вручную: удалите том `/index` и перезапустите контейнер.

**Ограничения:**

* аннотация на несуществующий метод, например `&После("НетТакогоМетода")`, не диагностируется;
* лишние аргументы `ПродолжитьВызов` не диагностируются;
* порядок применения расширений анализатор не моделирует, перехват одного метода несколькими расширениями не проверяется;
* без `FULLINDEX` `syntaxcheck_file` проверяет один модуль, и межмодульные проверки выключены.

### Ответил ли индекс по файлу

`provenance.index: ready` говорит, что индекс построен, но не говорит, что он ответил именно по этому файлу. Это сообщает `provenance.cross_module_checks` (с 17.10.2026):

| Значение       | Что означает                                                                                                                                             |
| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ran`          | Индекс ответил по файлу: межмодульные проверки и проверки перехватчиков выполнены                                                                        |
| `not_in_index` | Индекс готов, но файла в нём нет (выгрузка вне проиндексированной конфигурации и её расширений) — межмодульных проверок для файла не было                |
| `not_run`      | Межмодульные проверки не выполнялись: индекса нет или он не готов, индекс не ответил за 20 секунд или проверялся код, переданный текстом (`syntaxcheck`) |

### Чего это стоит

Замер на 10156 модулях:

| Что                                                          | Сколько          |
| ------------------------------------------------------------ | ---------------- |
| Индексация при старте                                        | около 8 минут    |
| Проверка файла без индекса                                   | около 200 мс     |
| Первая проверка файла после того, как индекс сообщил `ready` | около 190 секунд |
| Каждая следующая проверка                                    | около 11 секунд  |

Первая цена — это индекс, отвечающий на вопрос впервые; она платится один раз на контейнер, а не на файл.

Один вызов ждёт индекс не дольше 20 секунд. Если индекс не ответил за это время, отчёт возвращается без трёх межмодульных проверок (`provenance.cross_module_checks: not_run`), а в журнале появляется предупреждение `server.index` «The index did not answer in time». Запрос к индексу при этом продолжается в фоне. Поэтому первая проверка после `ready` сначала приходит без межмодульных находок, а следующие получают их, как только индекс загрузится. Пока такой просроченный запрос не завершился, остальные проверки не ждут индекс и сразу отвечают без него. До 22.09.2026 вызов при зависшем индексе ждал до 120 секунд: 30 на `notifications/initialized` и 90 на сам запрос.

### Состояния индекса

Контейнер отвечает на вызовы всё время, пока идёт индексация. Пока индекс не готов, три проверки остаются выключенными — их ответы до этого были бы теми самыми ложными. Каждый ответ сообщает, в каком состоянии он получен, в `provenance.index`:

| Значение   | Что означает                                                                                                                                                                                                                            |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `absent`   | Режим не включён — обычное поведение сервера                                                                                                                                                                                            |
| `building` | Индекс строится; три межмодульные проверки ещё не отвечают                                                                                                                                                                              |
| `ready`    | Индекс готов; три проверки отвечают из него                                                                                                                                                                                             |
| `failed`   | Индекс не удалось построить, индексный процесс остановился или сообщил `failed` / `disabled`; ответ такой же, как без индекса. Это не всегда окончательно: построение, которое не уложилось в срок, анализатор повторяет сам (см. ниже) |

Чистый отчёт при `absent` и при `ready` означает разное — поэтому состояние объявляется в каждом ответе.

**После `failed`.** Построение, которое не уложилось в отведённое время, анализатор прерывает и сам начинает заново; на время повтора он снова сообщает, что индекс строится. С образа 1.1.28 от 17.11.2026 сервер переспрашивает индекс в состоянии `failed` через 300 секунд (если `FULLINDEX_REINDEX_INTERVAL_SEC` меньше — через него), а застав повтор, снова спрашивает каждые 5 секунд, так что `ready` замечается так же быстро, как при первом построении. До 1.1.28 индекс в состоянии `failed` переспрашивался только через `FULLINDEX_REINDEX_INTERVAL_SEC`, по умолчанию через 6 часов: всё это время ответы несли `provenance.index: failed` и `provenance.cross_module_checks: not_run`, даже если повтор давно закончился. Остановившийся индексный процесс сервер замечает за секунды, но не перезапускает: для этого нужен перезапуск контейнера.

Замер на ЗУП из каталога Windows (образ 1.1.28, bsl-analyzer 0.4.6, без `BSL_MCP_DIAG_BUILD_TIMEOUT_SECS`, 17.11.2026): контейнер с готовым индексом запущен заново. Через 600 секунд анализатор прервал построение; сервер записал `failed` с `next_check_seconds: 300` и ровно через 300 секунд застал повтор анализатора — `building`, опрос снова каждые 5 секунд. Повтор тоже не уложился в 600 секунд, и всё повторилось: второй `failed` через 10,5 минуты после первого и снова `building` через 300 секунд. Готовым такой индекс не становился, пока построение не укладывалось в срок. С 1.1.29 срок по умолчанию — 3600 секунд, см. ниже.

#### Исходники в каталоге Windows

Каталог Windows, смонтированный в Docker Desktop как bind mount (`-v "C:/…:/files:ro"`), анализатор читает через файловый мост Docker Desktop, и индекс строится в десятки раз медленнее, чем из именованного тома. Замер на ЗУП (10185 модулей, bsl-analyzer 0.4.6, 17.11.2026):

| Где исходники                                                                                           | Построение индекса                                 |
| ------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
| Именованный том Docker, новый контейнер с готовым индексом (стенд)                                      | около 15 секунд                                    |
| Каталог Windows (bind mount), пустой том `/index`                                                       | 6 мин 25 с                                         |
| Каталог Windows (bind mount), перезапуск контейнера с готовым индексом                                  | 11 мин 11 с                                        |
| Именованный том Docker, индекса 0.4.6 в томе нет (образ 1.1.29)                                         | `ready` через 34 с, индекс записан на диск за 95 с |
| Каталог Windows (bind mount), пустой том `/index`, без `BSL_MCP_DIAG_BUILD_TIMEOUT_SECS` (образ 1.1.29) | `ready` через 10 мин 53 с, без `failed`            |

Срок построения задаёт переменная самого анализатора `BSL_MCP_DIAG_BUILD_TIMEOUT_SECS`: построение, которое в него не уложилось, анализатор прерывает и начинает заново, а повтор занимает столько же. Собственное значение анализатора — 600 секунд, и на ЗУП из каталога Windows его не хватало: индекс после `docker restart` уходил в `failed`, а повтор снова не укладывался в срок. С образа 1.1.29 от 17.11.2026 сервер передаёт индексному процессу `3600` секунд, если переменная не задана или пуста. Час покрывает конфигурацию в 3–4 раза больше ЗУП в каталоге Windows; предел нужен, чтобы поймать зависшее построение, а не прервать медленное. Замер 1.1.29: ЗУП из каталога Windows в пустой том `/index` без переменной стал `ready` через 10 мин 53 с, без `failed` (с 600 секундами это построение прервалось бы). Заданное значение передаётся анализатору как есть — для ещё большей конфигурации поднимите его:

```powershell
-e BSL_MCP_DIAG_BUILD_TIMEOUT_SECS=7200
```

На образе 1.1.28 с `1800` индекс ЗУП из каталога Windows после `docker restart` был готов через 11 мин 11 с, без `failed`; на 1.1.29 то же получается без переменной.

Быстрее всего — держать исходники в именованном томе. Том заполняется один раз копированием, и изменения в каталоге Windows сами в него не попадают — после правок том нужно обновить тем же копированием:

```powershell
docker volume create 1c_syntaxcheck_files
docker run --rm -v "C:/path/to/sources:/src:ro" -v 1c_syntaxcheck_files:/dst alpine cp -a /src/. /dst/
# затем в команде сервера: -v 1c_syntaxcheck_files:/files:ro
```

Другой вариант — каталог в файловой системе WSL, смонтированный из WSL (`-v /home/<пользователь>/<каталог>:/files:ro`): его Docker Desktop читает без моста Windows. Для него замера нет.

{% hint style="info" %}
Три проверки **никогда** не включаются в собственной конфигурации анализатора — ни в каком состоянии. Это измерено: даже когда индекс в том же контейнере готов, `analyze -s <файл>` с этими проверками выдаёт те же 167 ложных находок. Процессы делят только каталог кэша, поэтому включение проверки в анализаторе не даёт ему контекста — оно лишь заставляет его отвечать неверно. Ответы приходят из индекса и сливаются с отчётом до хуков, поэтому плагин получает один список, а фильтр строк сужает их как всё остальное.
{% endhint %}

### Хранение индекса

`INDEX_DIR` задаёт, где лежит индекс; по умолчанию `/index` — этот путь образ объявляет томом, поэтому индекс переживает перезапуск даже без явного `-v`. Каталог, в который нельзя писать, не фатален: индекс тогда строится внутри контейнера и пересобирается при перезапуске, а запись о старте это сообщает.

Сервер работает от пользователя `mcpuser` (uid 1000, gid 1000), не от root, поэтому каталог индекса должен быть доступен этому пользователю на запись:

* **Именованный том** (`-v 1c_syntaxcheck_index:/index`, в том числе созданный заранее `docker volume create` или объявленный `external` в compose) Docker при первом подключении к пустому тому отдаёт `mcpuser` сам — ничего делать не нужно.
* **Каталог хоста** (`-v /srv/syntax-index:/index`) и **том, подключённый с `nocopy`** (`--mount ...,volume-nocopy`, `volume: {nocopy: true}` в compose) приходят с владельцем root, и индекс в них не пишется. Отдайте каталог пользователю: `sudo chown 1000:1000 /srv/syntax-index` на хосте или `docker run --rm -v <том>:/index alpine chown 1000:1000 /index` для тома.

Если записать нельзя, запись `server.index` с `fallback: true` называет `index_dir`, пользователя сервера `runs_as`, владельца `owner` и права `mode` каталога (с 06.10.2026).

Файл, изменившийся в смонтированном каталоге, переиндексируется без перезапуска.

### Как часто индекс перечитывается

Пока индекс строится, сервер спрашивает его состояние каждые пять секунд — три межмодульные проверки включаются сразу, как только он готов. **Готовый индекс переспрашивается раз в шесть часов** (до 14.10.2026 — раз в час); это `FULLINDEX_REINDEX_INTERVAL_SEC`. Каждый такой опрос заставляет анализатор обойти всё дерево исходников: на конфигурации 1.7 ГБ это около 11 секунд процессорного времени. Изменения между опросами подхватывает наблюдатель самого анализатора. Вернуть прежний ритм можно через `-e FULLINDEX_REINDEX_INTERVAL_SEC=3600`.

Отключить переиндексацию переменной нельзя: `0`, отрицательное значение и не-число читаются как значение по умолчанию, а положительное ограничивается диапазоном 60…86400 секунд. Раньше опрос шёл каждые пять секунд всегда, и простаивающий контейнер переиндексировал себя десятки раз в час впустую.

Медленнее при этом не стало ничего важного: остановившийся индексный процесс по-прежнему замечается за секунды, а плановый опрос, заставший пересборку, сразу возвращается к пятисекундному темпу до её завершения. Плата — `provenance.index` может сообщать `ready` в первые минуты пересборки, о которой сервер ещё не спрашивал. Индекс в состоянии `failed` с образа 1.1.28 переспрашивается через 300 секунд, а не через `FULLINDEX_REINDEX_INTERVAL_SEC` (см. [Состояния индекса](#состояния-индекса)).

{% hint style="warning" %}
Без `FULLINDEX` в контейнере не меняется ничего: индексный процесс не запускается, индексация не идёт, ответы те же, что и раньше.
{% endhint %}

С 14.10.2026 healthcheck образа не импортирует сервер: это короткий запрос на тот endpoint, который сервер реально слушает (`USESSE`, `MCP_HTTP_PATH`, `MCP_SSE_PATH`). Интервал — 60 с (раньше 30 с). Пока контейнер стартует, проверка идёт каждые 2 с на Docker Engine 25 и новее; более старый движок этот интервал игнорирует, и `healthy` появляется после первой проверки через 60 с. Любой HTTP-ответ считается успехом, отказ соединения — нет. С 1.1.25 ответ на healthcheck не пишется в access-лог: строки `GET /mcp … 200` с `127.0.0.1` больше нет, запросы клиентов пишутся как раньше.

## Самообновление анализатора

Версия `bsl-analyzer` в образе не закреплена: в образ попадает последний релиз upstream на момент сборки, а дальше контейнер сам спрашивает у upstream новую версию — при старте и далее раз в сутки — и заменяет бинарник на месте. До 1.1.29 сборка брала «последний релиз» из своего кэша, и образы с 04.10 по 17.11.2026 несли 0.2.81; с 1.1.29 сборка спрашивает релиз у GitHub перед каждой сборкой, и `latest` 1.1.29 несёт 0.4.6. `arm64` 1.1.29 остался на 0.2.81 (см. [Архитектуры и теги](#архитектуры-и-теги)).

**Индекс после обновления.** В режиме полного индекса индексный процесс с 1.1.29 перезапускается на новом анализаторе: сервер замечает смену установленной версии не позже чем через 5 секунд, останавливает процесс и запускает его заново с тем же каталогом индекса, два процесса над одним каталогом одновременно не работают. На время перезапуска `provenance.index` — `building`, в журнале — запись `server.index` с `reason: analyzer_updated`, `from_version` и `to_version`. До 1.1.29 индексный процесс продолжал работать на старом бинарнике до перезапуска контейнера, и проверки из индекса шли на старой версии, хотя `provenance.analyzer_version` называл новую.

0.4.6 хранит индекс в другом формате, чем 0.2.81 (`/index/workspaces/v1/…`), и индекс 0.2.81 не читает: после перехода с 0.2.81 (на `latest`; `arm64` остаётся на 0.2.81, и его индекс не перестраивается) индекс строится заново, а файлы 0.2.81 (`/index/bsl-graph.db`, `/index/bsl-search.db`, на ЗУП 1,8 ГБ) остаются в томе. Когда контейнер работает на 0.4.6 и индекс готов, их можно удалить (каталог `workspaces` не трогать — это индекс 0.4.6):

```bash
docker exec 1c_syntaxcheck_mcp sh -c 'rm -f /index/bsl-graph.db* /index/bsl-search.db*'
```

Замер на ЗУП в именованном томе (17.11.2026): контейнер с анализатором 0.2.81 и его готовым индексом через 27 секунд после старта получил 0.4.6, ещё через 2 секунды перезапустил индексный процесс; новый процесс сообщил `ready` через 18 секунд и достроил индекс (1,2 ГБ граф и 0,9 ГБ поиск) ещё за 2,5 минуты. Индекс, построенный 0.4.6, новый контейнер читает как есть: `ready` через 5 секунд, файлы не переписываются.

Обновление не останавливает сервер: проверка идёт в отдельном потоке, замена — это переименование на тот же путь, поэтому уже идущий анализ работает с тем файлом, который открыл. Контейнер без доступа к GitHub отвечает тем анализатором, который у него есть, и повторяет попытку позже.

Каждая проверка пишет в журнал одну запись `server.analyzer` с итогом из закрытого списка: `installed`, `up_to_date`, `unreachable`, `unpublished_platform`, `failed`, `disabled`. Какой релиз установлен сейчас:

```bash
docker exec 1c_syntaxcheck_mcp cat /app/bsl_analyzer_nix/installed-release.json
```

Та же версия попадает в `provenance.analyzer_version` каждого ответа, так что отчёт называет анализатор, который его действительно построил, а не тот, с которым собирался образ.

Лицензионные тексты upstream в `/app/licenses/bsl-analyzer/` обновляются раньше бинарника. `LICENSE-MIT`, `NOTICE` и `LICENSING.md` обязательны: если один из них не скачался, обновление не выполняется. `LICENSE-LGPL`, `LICENSE-GPL` и `LICENSE-APACHE` забираются, пока тег их публикует. Ответ 404 по этим трём означает, что релиз их больше не содержит (так у upstream с 0.4.2): старые копии удаляются только после того, как новый бинарник уже на месте. В журнале при отказе указаны имя файла и адрес.

Загруженный бинарник сверяется с размером и SHA-256, которые GitHub публикует для файла релиза. Оборванная или подменённая загрузка не устанавливается: запись `server.analyzer` получает итог `failed`, прежний анализатор остаётся на месте, попытка повторяется при следующей проверке. До 22.09.2026 такой сверки не было, и обрыв соединения мог оставить в контейнере недокачанный бинарник, на котором каждая проверка падала с кодом `-11`. Теперь при очередной проверке контейнер сверяет с релизом и уже установленный бинарник той же версии, и повреждённый файл скачивается заново.

{% hint style="warning" %}
Новый релиз анализатора может поменять идентификаторы правил, уровни важности, тексты сообщений и диапазоны — сервер не удерживает новый релиз в рамках находок старого. Где это важно, ставьте `BSL_ANALYZER_AUTO_UPDATE=0` и обновляйтесь осознанно, вытягивая новый образ.
{% endhint %}

Переменные окружения, управляющие этим, — в [установке](https://docs.onerpa.ru/pages/U84jx5SE4PNdpFQvwXfS#%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5-%D0%BE%D0%BA%D1%80%D1%83%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F).

## Возможности

ИИ получает инструменты для:

* Проверки синтаксиса кода 1С
* Проверки файлов конфигурации из подключённого каталога
* Обнаружения ошибок до выполнения
* Анализа конструкций языка

## Примеры использования

ИИ может проверить код перед предложением:

* "Проверь синтаксис этой процедуры"
* "Есть ли ошибки в этом коде?"
* "Проанализируй этот модуль на ошибки"

## Требования

* Docker Engine или Docker Desktop с поддержкой Linux-контейнеров
* Лицензионный ключ

{% hint style="success" %}
Этот сервер можно запустить сразу — он не требует подготовки данных или настройки embedding.
{% endhint %}

## Порт

**8002**

## Образ Docker

```
comol/1c_syntaxcheck_mcp:latest
```

### Архитектуры и теги

| Тег      | Платформа   | Анализатор                                                                                                                                                                                                                                                                                   |
| -------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `latest` | linux/amd64 | Не закреплён: в образ попадает последний релиз upstream на момент сборки, дальше контейнер обновляет его сам                                                                                                                                                                                 |
| `arm64`  | linux/arm64 | Собирается из исходников: upstream не публикует arm64-бинарник, поэтому самообновления здесь нет и новый анализатор приходит только с новым образом. В 1.1.29 — по-прежнему 0.2.81: сборка 0.4.6 не уместилась в память сборочной машины, поэтому режим совместимости на `arm64` не работает |

У SyntaxCheckServer нет тега `light`. Полная таблица: [Теги и ключи образов](https://docs.onerpa.ru/mcp-servery-1c/kanaly-obrazov.md).

{% hint style="warning" %}
На arm64-хосте (Apple Silicon, ARM-серверы) используйте нативный `arm64`. Его анализатор собран из исходников во время сборки самого образа, но не воспроизводим побайтно, не имеет attestation upstream и не проверялся на реальном arm64-железе. Кроме того, upstream не публикует Linux arm64-артефакт, поэтому обновляться такому контейнеру не до чего: ежедневная проверка записывает `unpublished_platform` и ничего не скачивает.

Если нужен официальный бинарник upstream, `latest` запускается на arm64-хосте через эмуляцию:

```bash
docker run -d -p 8002:8002 --platform linux/amd64 `
  -e LICENSE_KEY=YOUR_LICENSE_KEY `
  comol/1c_syntaxcheck_mcp:latest
```

{% endhint %}

## Быстрый старт

```powershell
docker run -d -p 8002:8002 `
  --name 1c_syntaxcheck_mcp `
  -e LICENSE_KEY=YOUR_LICENSE_KEY `
  comol/1c_syntaxcheck_mcp:latest
```

### Проверка файлов

```powershell
docker run -d -p 8002:8002 `
  --name 1c_syntaxcheck_mcp `
  -e LICENSE_KEY=YOUR_LICENSE_KEY `
  -e FILES_DIR=/app/files `
  -v "E:/1C_Export/Files:/app/files" `
  comol/1c_syntaxcheck_mcp:latest
```

По умолчанию используется `streamable-http` на `/mcp`. Для SSE включите `-e USESSE=true`: поток событий будет доступен на `/sse`, а сообщения отправляются на `/messages/`. Старое размещение SSE-потока на `/mcp` можно временно сохранить через `MCP_SSE_PATH=/mcp`.

### Границы Streamable HTTP-сессий

| Переменная                          | Назначение                                                        | По умолчанию |
| ----------------------------------- | ----------------------------------------------------------------- | ------------ |
| `MCP_SESSION_IDLE_TTL_SECONDS`      | Освободить неактивную сессию через N секунд                       | `1800`       |
| `MCP_SESSION_MAX_LIFETIME_SECONDS`  | Абсолютный срок жизни даже активной сессии                        | `28800`      |
| `MCP_SESSION_MAX_CONCURRENT`        | Максимум одновременных сессий; сверх лимита — временный отказ 503 | `64`         |
| `MCP_SESSION_REAP_INTERVAL_SECONDS` | Период уборки просроченных сессий                                 | `30`         |

Эти границы действуют только для Streamable HTTP. SSE живёт столько же, сколько открывшее его соединение, и отдельным реестром не управляется.

Место под лимитом `MCP_SESSION_MAX_CONCURRENT` занимает только сессия, которую открыл успешный `initialize`. Запрос без заголовка `Mcp-Session-Id`, получивший отказ (`GET`, уведомление, `DELETE`), места не занимает. Сессия освобождает место, когда клиент закрывает её запросом `DELETE` (сразу) или когда она простаивает дольше `MCP_SESSION_IDLE_TTL_SECONDS`. Если лимит заполнен, `initialize` сначала освобождает сессии, уже вышедшие за границы, и только потом получает отказ `503` с `Retry-After` и полем `diagnostic`: `mcp-session-cap`. Действующую сессию сервер ради новой не закрывает. Счётчики видны в журнале контейнера, в записях `server.sessions`: `active`, `created`, `idle_expired`, `lifetime_expired`, `cap_refused`.

Клиенту лучше открыть одну сессию, работать в ней и закрыть её `DELETE` по окончании. Автоматический клиент, который открывает сессию на каждое задание и не закрывает её, держит место весь срок простоя: при 100 таких заданиях в час и сроке 1800 с занято около 50 мест из 64. Если контейнером пользуется много таких клиентов, уменьшите срок простоя (например, `-e MCP_SESSION_IDLE_TTL_SECONDS=300`) или поднимите лимит (`-e MCP_SESSION_MAX_CONCURRENT=256`). Клиент, чья сессия истекла, получает `404 Session not found` и должен выполнить `initialize` заново.

## Конфигурация Cursor

```json
{
  "mcpServers": {
    "1c-syntax-checker-mcp": {
      "url": "http://localhost:8002/mcp",
      "connection_id": "1c_lsp_service_001"
    }
  }
}
```

## Структура раздела

* [Установка](https://docs.onerpa.ru/mcp-servery-1c/servery/syntax-check-server/ustanovka.md) — команды запуска

## Доработка

Сервер расширяется плагинами: четыре hooks (`on_startup`, `on_request`, `on_diagnostics`, `on_result`) и таблица `SUPPRESSED_DIAGNOSTICS`. Производного состояния нет — все хуки действуют в рамках вызова. См. [Систему плагинов](https://docs.onerpa.ru/mcp-servery-1c/sistema-pluginov.md) и [Установку](https://docs.onerpa.ru/mcp-servery-1c/servery/syntax-check-server/ustanovka.md).
