@besales/mcp 0.48.0 → 1.0.0-beta.2

package/scripts/registry-diff.spec.mjs

@@ -0,0 +1,787 @@
+import { readFileSync } from 'node:fs';
+
+import { describe, expect, it } from 'vitest';
+
+import {
+  diffRegistries,
+  enumValuesByPath,
+  lagKey,
+  lagMetadataErrors,
+  LAG_SECTIONS,
+  reconcileWithRegistry,
+  schemaConstraints,
+  schemaRetainsPath,
+  validLagOwner,
+} from './registry-diff.mjs';
+
+describe('строгий владелец реестра', () => {
+  it.each([
+    ['TASK-6.22.10', true],
+    ['DELIBERATE', true],
+    ['6.22.10', false],
+    ['TASK-6.22.10 (закрыта)', false],
+    ['TASK-6.22', true],
+    ['', false],
+    [undefined, false],
+    [42, false],
+  ])('%s: допустим=%s', (owner, expected) => {
+    expect(validLagOwner(owner)).toBe(expected);
+  });
+
+  it('неправильный владелец попадает в incompleteEntries через сверку', () => {
+    const row = { reason: 'Названная причина', owner: 'команда', severity: 'LIVE_400' };
+    expect(
+      reconcileWithRegistry(
+        { missingTools: ['a'], contractLag: [] },
+        {
+          missingTools: { a: row },
+          contractLag: {},
+        },
+      ).incomplete,
+    ).toEqual(['a']);
+  });
+
+  it.each(LAG_SECTIONS)(
+    '%s: осознанный долг требует согласованную пару владельца и тяжести',
+    (section) => {
+      const row = { reason: 'Принятое ограничение; decision:6.19.51:test', owner: 'DELIBERATE', severity: 'DELIBERATE' };
+      expect(lagMetadataErrors({ [section]: { field: row } })).toEqual([]);
+      for (const broken of [
+        { ...row, owner: 'TASK-6.19.51' },
+        { ...row, severity: 'LIVE_400' },
+        { ...row, owner: 'домен' },
+        { ...row, reason: ' ' },
+        { ...row, reason: 'Принято без ссылки' },
+        { ...row, reason: 'decision:6.19.51:test' },
+        { ...row, severity: 'UNKNOWN' },
+      ])
+        expect(lagMetadataErrors({ [section]: { field: broken } })).toEqual([`${section}:field`]);
+      expect(
+        lagMetadataErrors({
+          [section]: { field: { ...row, owner: 'TASK-6.19.51', severity: 'LIVE_400' } },
+        }),
+      ).toEqual([]);
+    },
+  );
+
+  it('в реальном реестре нет строк без строгого владельца, включая дополнительные разделы', () => {
+    const registry = JSON.parse(
+      readFileSync(new URL('../src/schemas/shipped-lag.json', import.meta.url), 'utf8'),
+    );
+    expect(lagMetadataErrors(registry)).toEqual([]);
+  });
+});
+import {
+  loadShippedRegistry,
+  SHIPPED_REGISTRY_COMMIT_ENV,
+  SHIPPED_REGISTRY_PATH_ENV,
+} from './shipped-registry.mjs';
+
+const packageRoot = new URL('..', import.meta.url).pathname;
+const SHIPPED_REGISTRY_TEST_TIMEOUT_MS = 30_000;
+
+function tool(name, properties, required = []) {
+  return { name, inputSchema: { type: 'object', properties, required } };
+}
+
+describe('schemaConstraints', () => {
+  it('разворачивает вложенные объекты и элементы массивов', () => {
+    const paths = [
+      ...schemaConstraints({
+        type: 'object',
+        properties: {
+          a: { type: 'string' },
+          nested: { type: 'object', properties: { b: { type: 'number' } } },
+          list: { type: 'array', items: { type: 'object', properties: { c: { type: 'string' } } } },
+        },
+      }).keys(),
+    ].sort();
+
+    // `list[]` — сам элемент массива: его ограничения (тип, перечисление) сравниваются отдельно
+    // от свойств внутри него, иначе сужение `items.enum` прошло бы незамеченным.
+    expect(paths).toEqual(['a', 'list', 'list[]', 'list[].c', 'nested', 'nested.b']);
+  });
+
+  it('объединяет ветки oneOf: инструмент принимает любую из них', () => {
+    const paths = [
+      ...schemaConstraints({
+        oneOf: [
+          { type: 'object', properties: { left: { type: 'string' } } },
+          { type: 'object', properties: { right: { type: 'string' } } },
+        ],
+      }).keys(),
+    ].sort();
+
+    expect(paths).toEqual(['left', 'right']);
+  });
+});
+
+describe('разыменование локальных $ref', () => {
+  const refTool = (name, defs) => ({
+    name,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        media: {
+          type: 'object',
+          properties: {
+            image: { $ref: '#/$defs/rich' },
+            audio: { $ref: '#/$defs/plain' },
+          },
+        },
+      },
+      $defs: defs,
+    },
+  });
+  const rich = (values) => ({
+    type: 'object',
+    properties: { behavior: { type: 'string', enum: values } },
+  });
+
+  it('сужение перечисления ВНУТРИ $defs попадает в отставание', () => {
+    const shipped = [refTool('a', { rich: rich(['SILENT', 'LLM']), plain: rich(['SILENT']) })];
+    const local = [refTool('a', { rich: rich(['SILENT']), plain: rich(['SILENT']) })];
+
+    // До разыменования путей `media.image.behavior` не существовало НИ НА ОДНОЙ стороне, и
+    // расхождение внутри общего определения не мог заметить никто.
+    expect(diffRegistries(shipped, local).contractLag.map((entry) => entry.path)).toContain(
+      'media.image.behavior#enum',
+    );
+  });
+
+  it('две РАЗНЫЕ ссылки резолвятся каждая в своё определение', () => {
+    const constraints = schemaConstraints(
+      refTool('a', { rich: rich(['SILENT', 'LLM']), plain: rich(['SILENT']) }).inputSchema,
+    );
+
+    // ⛔ Различающая проверка: разыменование, подставляющее ПЕРВОЕ попавшееся определение обеим
+    // ссылкам, дало бы здесь одинаковые перечисления и прошло бы незамеченным.
+    expect(constraints.get('media.image.behavior').enum).toBe('LLM|SILENT');
+    expect(constraints.get('media.audio.behavior').enum).toBe('SILENT');
+  });
+
+  it.each([
+    ['указатель никуда не ведёт', { $ref: '#/$defs/typo' }, 'никуда не ведёт'],
+    ['внешний документ', { $ref: 'other.json#/x' }, 'внешняя ссылка'],
+  ])('fail-closed: %s роняет сверку', (_name, node, message) => {
+    // ⛔ Молчаливый пропуск здесь был бы той же слепотой под другим именем: узел с одним `$ref`
+    // неотличим для обхода от схемы БЕЗ ограничений.
+    expect(() => schemaConstraints({ type: 'object', properties: { x: node }, $defs: {} })).toThrow(
+      message,
+    );
+  });
+
+  it.each([
+    ['запрещающая схема false', false],
+    ['разрешающая схема true', true],
+    ['null', null],
+    ['массив', []],
+    ['скаляр', 42],
+  ])('fail-closed: цель ссылки «%s» роняет сверку', (_name, target) => {
+    // ⛔ Самый коварный из этих случаев — `false`: в JSON Schema он означает «не принимать
+    // НИЧЕГО», а спред объекта превращал его в пустой узел, то есть в «ограничений нет». Это
+    // был бы fail-open внутри правки, написанной ради устранения fail-open.
+    expect(() =>
+      schemaConstraints({
+        type: 'object',
+        properties: { x: { $ref: '#/$defs/target' } },
+        $defs: { target },
+      }),
+    ).toThrow('не на объект-схему');
+  });
+
+  it('указатель на КОРЕНЬ схемы законен и не считается внешней ссылкой', () => {
+    const constraints = schemaConstraints({
+      type: 'object',
+      properties: { self: { $ref: '#' }, x: { type: 'string' } },
+    });
+
+    // Прежняя редакция объявляла `#` внешним документом: отказ безопасен, но диагноз уводил
+    // искать причину не туда.
+    expect(constraints.get('self.x')).toMatchObject({ type: 'string' });
+  });
+
+  it('fail-closed: цикл ссылок роняет сверку, а не вешает её', () => {
+    expect(() =>
+      schemaConstraints({
+        type: 'object',
+        properties: { x: { $ref: '#/$defs/a' } },
+        $defs: { a: { $ref: '#/$defs/b' }, b: { $ref: '#/$defs/a' } },
+      }),
+    ).toThrow('вероятен цикл');
+  });
+
+  it('соседние ключи узла-ссылки побеждают тело определения', () => {
+    const constraints = schemaConstraints({
+      type: 'object',
+      properties: { x: { $ref: '#/$defs/a', format: 'uuid' } },
+      $defs: { a: { type: 'string', format: 'email' } },
+    });
+
+    expect(constraints.get('x')).toMatchObject({ type: 'string', format: 'uuid' });
+  });
+
+  it('живой реестр: обработчики вложения раскрываются полем в поле', () => {
+    const local = JSON.parse(
+      readFileSync(`${packageRoot}src/schemas/mcp-tools.json`, 'utf8'),
+    ).tools;
+    const behavior = local.find((entry) => entry.name === 'besales_behavior_update');
+    const constraints = schemaConstraints(behavior.inputSchema);
+    const media = [...constraints.keys()]
+      .filter((path) => path.startsWith('media_handling'))
+      .sort();
+
+    // ⛔ Проверяется ДЕЛЬТА по обработчикам вложения, а не итог по инструменту: итог меняется от
+    // любой соседней правки схемы, и хардкод протух бы на здоровой работе. До разыменования этих
+    // путей было пять (сама секция и четыре ссылки), теперь двадцать два (плюс версия формата секции).
+    expect(media).toEqual([
+      'media_handling',
+      'media_handling.audio',
+      'media_handling.audio.behavior',
+      'media_handling.audio.call_operator',
+      'media_handling.audio.fixed_response_text',
+      'media_handling.audio.operator_comment',
+      'media_handling.document',
+      'media_handling.document.behavior',
+      'media_handling.document.call_operator',
+      'media_handling.document.fixed_response_text',
+      'media_handling.document.operator_comment',
+      'media_handling.image',
+      'media_handling.image.behavior',
+      'media_handling.image.call_operator',
+      'media_handling.image.fixed_response_text',
+      'media_handling.image.operator_comment',
+      'media_handling.schema_version',
+      'media_handling.video',
+      'media_handling.video.behavior',
+      'media_handling.video.call_operator',
+      'media_handling.video.fixed_response_text',
+      'media_handling.video.operator_comment',
+    ]);
+    expect(constraints.get('media_handling.audio.behavior').enum).toBe('FIXED_RESPONSE|SILENT');
+    expect(constraints.get('media_handling.image.behavior').enum).toBe(
+      'FIXED_RESPONSE|PROCESS_WITH_LLM|SILENT',
+    );
+  });
+
+  it('ни один узел реестра не объявляет const без type', () => {
+    const local = JSON.parse(
+      readFileSync(`${packageRoot}src/schemas/mcp-tools.json`, 'utf8'),
+    ).tools;
+    const naked = [];
+    const walk = (node, tool, path) => {
+      if (node === null || typeof node !== 'object') return;
+      if (node.const !== undefined && node.type === undefined) naked.push(`${tool}::${path}`);
+      for (const key of ['properties', '$defs']) {
+        if (node[key]) {
+          for (const [name, child] of Object.entries(node[key])) {
+            walk(child, tool, path === '' ? name : `${path}.${name}`);
+          }
+        }
+      }
+      if (node.items) walk(node.items, tool, `${path}[]`);
+      for (const key of ['oneOf', 'anyOf', 'allOf']) {
+        if (Array.isArray(node[key])) for (const branch of node[key]) walk(branch, tool, path);
+      }
+    };
+    for (const entry of local) walk(entry.inputSchema, entry.name, '');
+
+    // Класс уже возвращался руками: без `type` клиент сериализует подтверждение СТРОКОЙ, zod ждёт
+    // булев литерал, и вызов падает ВСЕГДА. Обход намеренно не заходит в `if`-матчеры: там
+    // `const` — часть условия, а не объявление значения поля.
+    expect(naked).toEqual([]);
+  });
+});
+
+describe('diffRegistries', () => {
+  it('новое обязательное поле видно даже без отгруженного пути; необязательное не ломает вызов', () => {
+    const shipped = [tool('a', { id: { type: 'string' } }, ['id'])];
+    const local = [tool('a', {
+      id: { type: 'string' }, request_key: { type: 'string' }, optional: { type: 'string' },
+    }, ['id', 'request_key'])];
+    expect(diffRegistries(shipped, local).contractLag).toEqual([
+      { tool: 'a', path: 'request_key#required', kind: 'CONSTRAINT', shipped: false, v2: true },
+    ]);
+    local[0].inputSchema.required = ['id'];
+    expect(diffRegistries(shipped, local).contractLag).toEqual([]);
+  });
+  it('видит инструмент, которого нет в ветке v2', () => {
+    const diff = diffRegistries([tool('a', {}), tool('b', {})], [tool('a', {})]);
+
+    expect(diff.missingTools).toEqual(['b']);
+  });
+
+  it('видит поле, которого нет у v2-двойника, включая вложенное', () => {
+    const shipped = [
+      tool('a', {
+        top: { type: 'string' },
+        list: {
+          type: 'array',
+          items: { type: 'object', properties: { inner: { type: 'string' } } },
+        },
+      }),
+    ];
+    const local = [
+      tool('a', { list: { type: 'array', items: { type: 'object', properties: {} } } }),
+    ];
+
+    expect(diffRegistries(shipped, local).contractLag.map((entry) => entry.path)).toEqual([
+      'list[].inner',
+      'top',
+    ]);
+  });
+
+  it('видит расхождение ограничений: значения перечисления, обязательность, предел', () => {
+    const shipped = [
+      tool(
+        'a',
+        { mode: { type: 'string', enum: ['x', 'y'] }, name: { type: 'string', maxLength: 200 } },
+        ['name'],
+      ),
+    ];
+    const local = [
+      tool('a', {
+        mode: { type: 'string', enum: ['x'] },
+        name: { type: 'string', maxLength: 100 },
+      }),
+    ];
+
+    expect(
+      diffRegistries(shipped, local)
+        .contractLag.map((entry) => entry.path)
+        .sort(),
+    ).toEqual(['mode#enum', 'name#maxLength', 'name#required']);
+  });
+
+  /** Мутация, которая красит: читать у свойства-объединения только собственные ограничения узла. */
+  it('свойство-объединение: отгруженная форма, которую держит одна из веток, отставанием не считается', () => {
+    const shipped = [tool('a', { from: { type: 'string', format: 'date' } })];
+    const local = [
+      tool('a', { from: { type: 'string', anyOf: [{ format: 'date' }, { format: 'date-time' }] } }),
+    ];
+
+    expect(diffRegistries(shipped, local).contractLag).toEqual([]);
+  });
+
+  it('объединение без совпадающей ветки — расхождение с ограничениями самого узла', () => {
+    const shipped = [tool('a', { from: { type: 'string', format: 'date' } })];
+    const local = [tool('a', { from: { type: 'string', anyOf: [{ format: 'date-time' }] } })];
+
+    expect(diffRegistries(shipped, local).contractLag).toEqual([
+      { tool: 'a', path: 'from#format', kind: 'CONSTRAINT', shipped: 'date', v2: null },
+    ]);
+  });
+
+  it('инструмент, которого нет в отгруженной копии, отставанием не считается', () => {
+    expect(diffRegistries([tool('a', {})], [tool('a', {}), tool('b', {})]).v2Only).toEqual(['b']);
+  });
+
+  it('переименование показывает ОБА факта: имя исчезло и поля разошлись', () => {
+    // ⚠️ Прежде здесь стояло `missingTools = []`: переименование считалось «ничего не пропало».
+    // Это прятало клиентский разрыв — вызов старого имени сегодня отвечает «инструмент не найден».
+    // Преемник объясняет, ЧЕМ заменён инструмент, и даёт сверить схемы; он не отменяет того, что
+    // отгруженное имя ушло с поверхности. Оба факта обязаны быть объявлены отдельно.
+    const shipped = [tool('old', { legacy: { type: 'string' } })];
+    const local = [tool('new', { canonical: { type: 'string' } })];
+    const diff = diffRegistries(shipped, local, { old: 'new' });
+
+    expect(diff.missingTools).toEqual(['old']);
+    expect(diff.v2Only).toEqual([]);
+    expect(diff.contractLag).toEqual([
+      { tool: 'old', path: 'legacy', kind: 'MISSING_FIELD', shipped: 'string', v2: null },
+    ]);
+  });
+
+  it('отвергает протухшее сопоставление преемника', () => {
+    expect(() =>
+      diffRegistries([tool('old', {})], [tool('old', {}), tool('new', {})], { old: 'new' }),
+    ).toThrow(/старое имя уже существует/u);
+    expect(() => diffRegistries([tool('old', {})], [], { old: 'missing' })).toThrow(
+      /отсутствующий v2-инструмент/u,
+    );
+  });
+});
+
+describe('reconcileWithRegistry', () => {
+  const diff = {
+    missingTools: ['b'],
+    contractLag: [{ tool: 'a', path: 'top', kind: 'MISSING_FIELD', shipped: 'string', v2: null }],
+  };
+
+  it('незаявленное расхождение называется поимённо', () => {
+    const actual = reconcileWithRegistry(diff, { missingTools: {}, contractLag: {} });
+
+    expect(actual.undeclaredMissing).toEqual(['b']);
+    expect(actual.undeclaredLag).toEqual(['a::top::"string"→null']);
+  });
+
+  it('протухшая строка реестра называется тоже — иначе она станет способом замолчать будущее', () => {
+    const actual = reconcileWithRegistry(diff, {
+      missingTools: { b: {}, c: {} },
+      contractLag: { 'a::top::"string"→null': {}, 'a::gone::"x"→null': {} },
+    });
+
+    expect(actual.undeclaredMissing).toEqual([]);
+    expect(actual.staleMissing).toEqual(['c']);
+    expect(actual.staleLag).toEqual(['a::gone::"x"→null']);
+  });
+
+  it('второе расхождение у уже отстающего инструмента не проходит по старой строке', () => {
+    const actual = reconcileWithRegistry(
+      {
+        missingTools: [],
+        contractLag: [
+          { tool: 'a', path: 'top', kind: 'MISSING_FIELD', shipped: 'string', v2: null },
+          { tool: 'a', path: 'second', kind: 'MISSING_FIELD', shipped: 'string', v2: null },
+        ],
+      },
+      { missingTools: {}, contractLag: { 'a::top::"string"→null': {} } },
+    );
+
+    expect(actual.undeclaredLag).toEqual(['a::second::"string"→null']);
+  });
+});
+
+describe('loadShippedRegistry', () => {
+  it('офлайн-вход без коммита отвергается: непроверяемый эталон хуже отсутствующего', () => {
+    expect(() =>
+      loadShippedRegistry(packageRoot, {
+        env: { [SHIPPED_REGISTRY_PATH_ENV]: 'src/schemas/mcp-tools.json' },
+      }),
+    ).toThrow(SHIPPED_REGISTRY_COMMIT_ENV);
+  });
+
+  it('офлайн-вход с коммитом принимается и называет своё происхождение', () => {
+    const actual = loadShippedRegistry(packageRoot, {
+      env: {
+        [SHIPPED_REGISTRY_PATH_ENV]: `${packageRoot}src/schemas/mcp-tools.json`,
+        [SHIPPED_REGISTRY_COMMIT_ENV]: 'deadbeef',
+      },
+    });
+
+    expect(actual.provenance).toMatchObject({ source: 'file', commit: 'deadbeef' });
+    expect(actual.tools.length).toBeGreaterThan(0);
+  });
+});
+
+describe('реестр отставания', () => {
+  it(
+    'совпадает с фактическим расхождением ветки v2 и отгруженной копии',
+    () => {
+      const shipped = loadShippedRegistry(packageRoot);
+      const local = JSON.parse(
+        readFileSync(`${packageRoot}src/schemas/mcp-tools.json`, 'utf8'),
+      ).tools;
+      const fullRegistry = JSON.parse(
+        readFileSync(`${packageRoot}src/schemas/shipped-lag.json`, 'utf8'),
+      );
+      // Строки «путь#refused» — отказ, живущий в КОДЕ инструмента: сравнение схем его не видит, его наблюдает выгрузка
+      // исполнением законного отгруженного вызова и сверяет в обе стороны сама. Здесь сверяется только сравнение схем.
+      const registry = {
+        ...fullRegistry,
+        contractLag: Object.fromEntries(
+          Object.entries(fullRegistry.contractLag).filter(([key]) => !key.includes('#refused::')),
+        ),
+      };
+      const diff = diffRegistries(shipped.tools, local, registry.toolSuccessors);
+      const actual = reconcileWithRegistry(diff, registry);
+
+      expect({
+        необъявленные: [...actual.undeclaredMissing, ...actual.undeclaredLag],
+        протухшие: [...actual.staleMissing, ...actual.staleLag],
+      }).toEqual({ необъявленные: [], протухшие: [] });
+      expect(diff.contractLag.every((entry) => registry.contractLag[lagKey(entry)]?.severity)).toBe(
+        true,
+      );
+    },
+    SHIPPED_REGISTRY_TEST_TIMEOUT_MS,
+  );
+});
+
+describe('паритет JSON-реестра и zod по ВЛОЖЕННЫМ путям', () => {
+  it('отличает сохранение произвольного config от настоящего удаления полей', async () => {
+    const { z } = await import('zod');
+    const inputValue = { config: { stopOnPayment: true, steps: [{ statusName: 'Новый' }] } };
+    const inputPreserving = z.object({ config: z.object({}).passthrough() });
+    const inputStripping = z.object({ config: z.object({}) });
+    const inputPaths = [
+      'config.stopOnPayment',
+      'config.steps',
+      'config.steps[]',
+      'config.steps[].statusName',
+    ];
+
+    for (const inputPath of inputPaths) {
+      expect(schemaRetainsPath(z.toJSONSchema(inputPreserving, { io: 'output' }), inputPath)).toBe(
+        true,
+      );
+      expect(schemaRetainsPath(z.toJSONSchema(inputStripping, { io: 'output' }), inputPath)).toBe(
+        false,
+      );
+    }
+    expect(inputPreserving.parse(inputValue)).toEqual(inputValue);
+    expect(inputStripping.parse(inputValue)).toEqual({ config: {} });
+    expect(
+      z.toJSONSchema(inputStripping, { io: 'input' }).properties.config.additionalProperties,
+    ).toBeUndefined();
+  });
+
+  it('passthrough родителя не скрывает удаление поля известного вложенного объекта', async () => {
+    const { z } = await import('zod');
+    const inputSchema = z.object({
+      config: z.object({ steps: z.array(z.object({ message: z.string() })) }).passthrough(),
+    });
+    const inputValue = {
+      config: { stopOnPayment: true, steps: [{ message: 'Привет', statusName: 'Новый' }] },
+    };
+    const actualSchema = z.toJSONSchema(inputSchema, { io: 'output' });
+
+    expect(schemaRetainsPath(actualSchema, 'config.stopOnPayment')).toBe(true);
+    expect(schemaRetainsPath(actualSchema, 'config.steps[].message')).toBe(true);
+    expect(schemaRetainsPath(actualSchema, 'config.steps[].statusName')).toBe(false);
+    expect(inputSchema.parse(inputValue)).toEqual({
+      config: { stopOnPayment: true, steps: [{ message: 'Привет' }] },
+    });
+  });
+
+  it('проверяет схему значений record и разыменовывает локальные ссылки', async () => {
+    const { z } = await import('zod');
+    const inputSchema = z.object({
+      config: z.record(z.string(), z.object({ message: z.string() })),
+    });
+    const actualSchema = z.toJSONSchema(inputSchema, { io: 'output' });
+
+    expect(schemaRetainsPath(actualSchema, 'config.first.message')).toBe(true);
+    expect(schemaRetainsPath(actualSchema, 'config.first.statusName')).toBe(false);
+    expect(
+      schemaRetainsPath(
+        {
+          properties: { config: { $ref: '#/$defs/config' } },
+          $defs: { config: { additionalProperties: true } },
+        },
+        'config.stopOnPayment',
+      ),
+    ).toBe(true);
+    expect(
+      schemaRetainsPath(
+        { properties: { config: { additionalProperties: false } } },
+        'config.stopOnPayment',
+      ),
+    ).toBe(false);
+    expect(() =>
+      schemaRetainsPath(
+        { properties: { config: { $ref: '#/$defs/missing' } } },
+        'config.stopOnPayment',
+      ),
+    ).toThrow();
+  });
+
+  it('пересечение сохраняет поля из обеих частей результата разбора', async () => {
+    const { z } = await import('zod');
+    const inputSchema = z.intersection(
+      z.object({ config: z.object({ message: z.string() }) }),
+      z.object({ config: z.object({ stopOnPayment: z.boolean() }) }),
+    );
+    const inputValue = { config: { message: 'Привет', stopOnPayment: true } };
+    const actualSchema = z.toJSONSchema(inputSchema, { io: 'output' });
+
+    expect(schemaRetainsPath(actualSchema, 'config.message')).toBe(true);
+    expect(schemaRetainsPath(actualSchema, 'config.stopOnPayment')).toBe(true);
+    expect(schemaRetainsPath(actualSchema, 'config.statusName')).toBe(false);
+    expect(inputSchema.parse(inputValue)).toEqual(inputValue);
+  });
+
+  it('конечный элемент nullable-массива сохраняется на пределе, незавершённый спуск всё ещё ограничен', async () => {
+    const { z } = await import('zod');
+    const schema = z.object({
+      config: z.object({
+        steps: z.array(
+          z.object({
+            getcourse: z
+              .object({ delivery: z.object({ transports: z.array(z.string()) }).nullable() })
+              .nullable(),
+          }),
+        ),
+      }),
+    });
+    const derived = z.toJSONSchema(schema, { io: 'output' });
+    expect(schemaRetainsPath(derived, 'config.steps[].getcourse.delivery.transports[]')).toBe(true);
+    expect(() =>
+      schemaRetainsPath(derived, 'config.steps[].getcourse.delivery.transports[].extra'),
+    ).toThrow('глубже 8');
+  });
+
+  it('ни одно объявленное поле не теряется фактическим фильтром аргументов', async () => {
+    const { z } = await import('zod');
+    const { toolDefinitions } = await import('../src/tools/definitions.js');
+    const registry = JSON.parse(readFileSync(`${packageRoot}src/schemas/mcp-tools.json`, 'utf8'));
+    const declared = new Map(registry.tools.map((tool) => [tool.name, tool.inputSchema]));
+
+    const lost = [];
+    for (const definition of toolDefinitions) {
+      const schema = declared.get(definition.name);
+      if (schema === undefined) continue;
+      let derived;
+      try {
+        derived = z.toJSONSchema(definition.schema, { io: 'output' });
+      } catch {
+        // Transform может иметь преобразуемый вход и непредставимый выход. Для него сохраняем
+        // прежнюю проверку именованных путей: смена направления не должна уменьшать охват.
+        let inputDerived;
+        try {
+          inputDerived = z.toJSONSchema(definition.schema, { io: 'input' });
+        } catch {
+          // Непреобразуемые в обоих направлениях схемы по-прежнему сверяет registry.spec.
+          continue;
+        }
+        const inputPaths = new Set(schemaConstraints(inputDerived).keys());
+        for (const path of schemaConstraints(schema).keys()) {
+          if (!inputPaths.has(path)) lost.push(`${definition.name}::${path}`);
+        }
+        continue;
+      }
+      for (const path of schemaConstraints(schema).keys()) {
+        // Произвольный объект сохраняет поля без их поимённого перечисления. Известные вложенные
+        // объекты всё равно проверяются: у них может быть собственный срезающий фильтр.
+        if (!schemaRetainsPath(derived, path)) lost.push(`${definition.name}::${path}`);
+      }
+    }
+
+    expect(lost).toEqual([]);
+  });
+
+  it('перечни общих путей совпадают; односторонние перечни и отказы конвертера учтены поимённо', async () => {
+    const { z } = await import('zod');
+    const { toolDefinitions } = await import('../src/tools/definitions.js');
+    const declared = new Map(
+      JSON.parse(readFileSync(`${packageRoot}src/schemas/mcp-tools.json`, 'utf8')).tools.map(
+        (tool) => [tool.name, tool.inputSchema],
+      ),
+    );
+    const different = [],
+      oneSided = [],
+      conversionFailed = [];
+    let compared = 0;
+    for (const definition of toolDefinitions) {
+      if (!declared.has(definition.name)) continue;
+      let derived;
+      try {
+        derived = z.toJSONSchema(definition.schema, { io: 'input' });
+      } catch {
+        conversionFailed.push(definition.name);
+        continue;
+      }
+      const a = enumValuesByPath(declared.get(definition.name)),
+        b = enumValuesByPath(derived);
+      for (const path of new Set([...a.keys(), ...b.keys()])) {
+        const name = `${definition.name}::${path}`;
+        if (!a.has(path) || !b.has(path)) {
+          oneSided.push(name);
+          continue;
+        }
+        compared += 1;
+        if (JSON.stringify(a.get(path)) !== JSON.stringify(b.get(path)))
+          different.push({ name, registry: a.get(path), zod: b.get(path) });
+      }
+    }
+    // Замер импорта схем 01.10.2026: 274 общих пути, 4 односторонних, отказов конвертера нет.
+    // Обратное направление полей остаётся границей #1074; этот сторож держит именно значения перечней.
+    expect(compared).toBeGreaterThanOrEqual(274);
+    expect(conversionFailed.sort()).toEqual([]);
+    expect(oneSided.sort()).toEqual(Object.keys(ENUM_PARITY_ONE_SIDED).sort());
+    expect(different).toEqual([]);
+  });
+});
+
+const ENUM_PARITY_ONE_SIDED = {
+  'besales_followup_sequence_upsert::config.filterMode':
+    'config проходит через passthrough верхнего уровня; перечисление проверяет refineFollowUpConfig через reactivationConfigSchema.',
+  'besales_followup_sequence_upsert::config.sequenceConditions[].op':
+    'config проходит через passthrough верхнего уровня; перечисление проверяет refineFollowUpConfig через reactivationConfigSchema.',
+  'besales_followup_sequence_upsert::config.steps[].anchorMode':
+    'config проходит через passthrough верхнего уровня; перечисление проверяет refineFollowUpConfig через reactivationConfigSchema.',
+  'besales_followup_sequence_upsert::config.steps[].conditions[].op':
+    'config проходит через passthrough верхнего уровня; перечисление проверяет refineFollowUpConfig через reactivationConfigSchema.',
+  'besales_followup_sequence_upsert::config.steps[].scheduleMode':
+    'config проходит через passthrough верхнего уровня; перечисление проверяет refineFollowUpConfig через reactivationConfigSchema.',
+  'besales_followup_sequence_upsert::config.steps[].stepType':
+    'config проходит через passthrough верхнего уровня; перечисление проверяет refineFollowUpConfig через reactivationConfigSchema.',
+  'besales_behavior_update::message_filters.schema_version':
+    'В zod версия literal(1), в JSON — числовое поле версии.',
+  'besales_platform_settings_update::crm_behavior.deal_marker_type':
+    'JSON перечисляет маркировки, фактический фильтр принимает прежнюю строковую форму.',
+  'besales_knowledge_table_patch::source.kind':
+    'Прежний дискриминатор источника объявлен в JSON; неподдерживаемую запись отвергает код инструмента.',
+};
+
+describe('полный обход перечней', () => {
+  it('M1: реальный freshness_anchor чувствителен к потере и лишнему значению; null пропускается', () => {
+    const registry = JSON.parse(readFileSync(`${packageRoot}src/schemas/mcp-tools.json`, 'utf8'));
+    const original = registry.tools.find(
+      (entry) => entry.inputSchema.properties?.freshness_anchor !== undefined,
+    ).inputSchema;
+    const originalValues = enumValuesByPath(original).get('freshness_anchor');
+    expect(originalValues).toContain('FIRST_SESSION_END_PLUS_WAIT');
+    const lost = structuredClone(original),
+      extra = structuredClone(original),
+      nullable = structuredClone(original);
+    lost.properties.freshness_anchor.enum = lost.properties.freshness_anchor.enum.filter(
+      (value) => value !== 'FIRST_SESSION_END_PLUS_WAIT',
+    );
+    extra.properties.freshness_anchor.enum.push('UNDECLARED');
+    nullable.properties.freshness_anchor.enum.push(null);
+    expect(enumValuesByPath(lost).get('freshness_anchor')).not.toEqual(originalValues);
+    expect(enumValuesByPath(extra).get('freshness_anchor')).not.toEqual(originalValues);
+    expect(enumValuesByPath(nullable).get('freshness_anchor')).toEqual(originalValues);
+  });
+  it.each([false, true])(
+    'потеря только скалярного значения видна (вложенное объединение=%s)',
+    (nested) => {
+      const scalar = { enum: ['x', 'y'] },
+        array = { type: 'array', items: { enum: ['x', 'y'] } };
+      const wrap = (node) => ({
+        properties: {
+          modes: { anyOf: nested ? [{ oneOf: [node, { type: 'null' }] }, array] : [node, array] },
+        },
+      });
+      const original = enumValuesByPath(wrap(scalar));
+      const mutation = enumValuesByPath(wrap({ enum: ['x'] }));
+      expect(original.get('modes')).toEqual(['x', 'y']);
+      expect(original.get('modes[]')).toEqual(['x', 'y']);
+      expect(mutation.get('modes[]')).toEqual(original.get('modes[]'));
+      expect(mutation.get('modes')).not.toEqual(original.get('modes'));
+    },
+  );
+  it('разворачивает refs, const и allOf, не считает null и не скрывает битый ref', () => {
+    expect(
+      enumValuesByPath({
+        $defs: { a: { enum: ['x', null] } },
+        properties: { a: { allOf: [{ $ref: '#/$defs/a' }, { const: 'y' }] } },
+      }).get('a'),
+    ).toEqual(['x', 'y']);
+    expect(() => enumValuesByPath({ properties: { a: { $ref: '#/$defs/missing' } } })).toThrow(
+      'никуда не ведёт',
+    );
+  });
+});
+
+it('перечни реактивации проверяются по схеме refineFollowUpConfig, включая вложенные шаги', async () => {
+  const { z } = await import('zod');
+  const { reactivationConfigSchema } = await import('../src/tools/definitions/follow-up-config.js');
+  const registry = JSON.parse(readFileSync(`${packageRoot}src/schemas/mcp-tools.json`, 'utf8'));
+  const published = registry.tools.find((tool) => tool.name === 'besales_followup_sequence_upsert')
+    .inputSchema.properties.config;
+  const expected = enumValuesByPath(z.toJSONSchema(reactivationConfigSchema, { io: 'input' }));
+  const actual = enumValuesByPath(published);
+  for (const path of [
+    'filterMode',
+    'sequenceConditions[].op',
+    'steps[].anchorMode',
+    'steps[].conditions[].op',
+    'steps[].scheduleMode',
+    'steps[].stepType',
+  ]) {
+    expect(expected.has(path), path).toBe(true);
+    expect(actual.get(path), path).toEqual(expected.get(path));
+  }
+});