@besales/mcp 0.48.0 → 1.0.0-beta.2

package/scripts/audit-revert-mutants.mjs

@@ -0,0 +1,107 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+const artifacts = '.codex-artifacts-prB3-f3/mutants';
+fs.mkdirSync(artifacts, { recursive: true });
+const cases = [
+  {
+    name: 'audit-confirmation-dropped',
+    file: 'src/tools/definitions/platform-setup.ts',
+    from: 'explicitConfirmation: input.explicit_confirmation',
+    to: 'explicitConfirmation: undefined',
+    suite: 'src/tools/definitions/audit-revert-confirmation.spec.ts',
+    test: 'передаёт явное подтверждение',
+  },
+  {
+    name: 'audit-false-dropped',
+    file: 'src/tools/definitions/platform-setup.ts',
+    from: 'explicitConfirmation: input.explicit_confirmation',
+    to: 'explicitConfirmation: input.explicit_confirmation || undefined',
+    suite: 'src/tools/definitions/audit-revert-confirmation.spec.ts',
+    test: 'передаёт явное подтверждение',
+  },
+];
+function run(suite, pattern, stem) {
+  const output = path.resolve(artifacts, stem + '.json');
+  fs.rmSync(output, { force: true });
+  const result = spawnSync(
+    process.execPath,
+    [
+      'node_modules/vitest/vitest.mjs',
+      'run',
+      suite,
+      '--reporter=json',
+      '--testNamePattern',
+      pattern,
+      '--outputFile=' + output,
+    ],
+    { encoding: 'utf8', timeout: 180000, maxBuffer: 16 * 1024 * 1024 },
+  );
+  fs.writeFileSync(
+    path.join(artifacts, stem + '.log'),
+    (result.stdout ?? '') + '\n' + (result.stderr ?? ''),
+  );
+  const json = fs.existsSync(output) ? JSON.parse(fs.readFileSync(output, 'utf8')) : null;
+  return { result, json };
+}
+
+const names = process.argv.slice(2);
+if (names.some((name) => !cases.some((entry) => entry.name === name)))
+  throw new Error('Unknown mutation name');
+const active = names.length === 0 ? cases : cases.filter((entry) => names.includes(entry.name));
+for (const [index, suite] of [...new Set(active.map((entry) => entry.suite))].entries()) {
+  const { result, json } = run(suite, '.*', 'baseline-' + index);
+  if (result.status !== 0 || !json?.success || json.numPassedTests === 0)
+    throw new Error('Baseline failed: ' + suite + '\n' + result.stdout + result.stderr);
+  console.log('BASELINE PASS: ' + suite + ' (' + json.numPassedTests + ')');
+}
+const summaryFile = path.join(artifacts, 'summary.json');
+const summary =
+  names.length !== 0 && fs.existsSync(summaryFile)
+    ? JSON.parse(fs.readFileSync(summaryFile, 'utf8')).filter(
+        (entry) => !names.includes(entry.name),
+      )
+    : [];
+for (const entry of active) {
+  const original = fs.readFileSync(entry.file, 'utf8');
+  if (original.split(entry.from).length !== 2)
+    throw new Error('Anchor is not unique: ' + entry.name);
+  try {
+    fs.writeFileSync(entry.file, original.replace(entry.from, entry.to));
+    const { result, json } = run(entry.suite, entry.test, entry.name);
+    const failures = (json?.testResults ?? [])
+      .flatMap((suite) => suite.assertionResults ?? [])
+      .filter((test) => test.status === 'failed' && test.fullName.includes(entry.test));
+    const assertion = failures.some((test) =>
+      test.failureMessages.some((message) => /^AssertionError:/.test(message)),
+    );
+    const killed =
+      result.status !== 0 &&
+      !result.signal &&
+      json !== null &&
+      json.testResults.every((suite) => suite.message === '') &&
+      assertion;
+    summary.push({
+      name: entry.name,
+      killed,
+      assertions: failures.map((test) => test.fullName),
+    });
+    fs.writeFileSync(summaryFile, JSON.stringify(summary, null, 2) + '\n');
+    if (!killed) console.error('SURVIVED or infrastructure failure: ' + entry.name);
+    else console.log('KILLED by assertion: ' + entry.name);
+  } finally {
+    fs.writeFileSync(entry.file, original);
+  }
+}
+console.log(
+  summary.filter((entry) => active.some((test) => test.name === entry.name) && entry.killed)
+    .length +
+    '/' +
+    active.length +
+    ' selected mutants KILLED; sources restored',
+);
+console.log(
+  summary.filter((entry) => entry.killed).length + '/' + cases.length + ' total mutants KILLED',
+);
+if (summary.some((entry) => active.some((test) => test.name === entry.name) && !entry.killed))
+  throw new Error('Selected mutations include a survivor or infrastructure failure');

package/scripts/bridge-api-input.spec.mjs

@@ -0,0 +1,98 @@
+import { shippedRef } from './shipped-ref.mjs';
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { toolDefinitions } from '../src/tools/definitions.js';
+import { loadShippedDefinitions } from './shipped-definitions.mjs';
+
+const require = createRequire(import.meta.url);
+const apiRoot = process.env.BESALES_API_ROOT ?? fileURLToPath(new URL('../../besales-api', import.meta.url));
+const load = require('../test/bridge-contract/api-source-loader.cjs')(apiRoot);
+const { mapTriggerActions } = load('control/agent-config/trigger-action.mapper.ts');
+const { instagramCommentBehaviorJsonSchema } = load('shared/types/jsonb/channel-behavior.schema.ts');
+const { mergeInstagramCommentBehavior, assertInstagramCommentWritable } = load('control/channel/instagram-comment-behavior.merge.ts');
+const id = '00000000-0000-4000-8000-000000000001';
+let shippedSettings;
+beforeAll(async () => {
+  const root = fileURLToPath(new URL('..', import.meta.url));
+  const commit = execFileSync('git', ['-C', root, 'rev-parse', shippedRef()], { encoding: 'utf8' }).trim();
+  const shipped = await loadShippedDefinitions(root, commit);
+  shippedSettings = shipped.toolDefinitions.find(entry => entry.name === 'besales_platform_settings_update');
+}, 60000);
+function request(name, input) {
+  const definition = toolDefinitions.find(entry => entry.name === name);
+  // JSON serialization is the actual HTTP boundary; it must retain false, {}, and null.
+  return JSON.parse(JSON.stringify(definition.createRequest(definition.schema.parse(input))));
+}
+
+describe('прежние действия моста → настоящий mapper API образа', () => {
+  it.each([
+    ['SILENT_AI', 'silentAiConfig', { lastMessageType: 'NONE', silenceMinutes: 30 }, 'SILENT_MODE', { duration_minutes: 30 }],
+    ['READ_NAMESPACES', 'readNamespacesConfig', { limit: 4 }, 'KNOWLEDGE_SEARCH', { top_k: 4 }],
+    ['SUMMARIZE_DIALOG', 'summarizeAction', { targetType: 'USER_VARIABLE', targetName: 'summary' }, 'TRIGGER_SUMMARIZE', { key: 'summary' }],
+    ['SEND_TELEGRAM_CHANNEL_MESSAGE', 'telegramChannelConfig', { channelId: id, messageTemplate: 'Сообщение' }, 'SEND_CHANNEL_MESSAGE', { channel_id: id, text: 'Сообщение' }],
+  ])('%s: прежний конверт и продолжение при ошибке сохраняют серверный смысл', (actionType, envelope, config, stepType, expected) => {
+    const actions = [{ actionType, [envelope]: config, priority: 7, continueOnError: false, isEnabled: true }];
+    const actual = request('besales_trigger_upsert', { platform_id: id, agent_id: id, actions });
+    expect(actual.body.actions).toEqual(actions);
+    expect(mapTriggerActions(actual.body.actions, [stepType])).toEqual([
+      expect.objectContaining({ stepType, config: expect.objectContaining(expected), onError: 'STOP' }),
+    ]);
+    const disabled = request('besales_trigger_upsert', { platform_id: id, agent_id: id, actions: [{ ...actions[0], isEnabled: false }] });
+    try {
+      mapTriggerActions(disabled.body.actions, [stepType]);
+      throw new Error('Выключенный шаг не должен записываться');
+    } catch (error) {
+      expect(error.getResponse()).toMatchObject({ code: 'TRIGGER_STEP_DISABLED_UNSUPPORTED', path: 'isEnabled' });
+    }
+  });
+});
+
+describe('Instagram: HTTP-документ моста → схемы и атомарное слияние API', () => {
+  const templates = {
+    dm: { ru: 'd-r', uz: 'd-u', uz_cyrl: 'd-c' },
+    dm_complaint: { ru: 'dc-r', uz: 'dc-u', uz_cyrl: 'dc-c' },
+    public_complaint: { ru: 'pc-r', uz: 'pc-u', uz_cyrl: 'pc-c' },
+  };
+  const expected = {
+    dm: { ru: 'd-r', uz: 'd-u', uzCyrl: 'd-c' },
+    dmComplaint: { ru: 'dc-r', uz: 'dc-u', uzCyrl: 'dc-c' },
+    publicComplaint: { ru: 'pc-r', uz: 'pc-u', uzCyrl: 'pc-c' },
+  };
+  function patch(value, method = 'PUBLIC_AND_DM') {
+    const input = { instagram_comment_reply_method: method };
+    if (value !== undefined) input.instagram_comment_templates = value;
+    const { body } = request('besales_platform_settings_update', { platform_id: id, instagram_comment_behavior: input });
+    const section = body.instagramCommentBehavior;
+    const result = { reply_method: section.instagramCommentReplyMethod };
+    if (Object.hasOwn(section, 'instagramCommentTemplates')) result.templates = section.instagramCommentTemplates;
+    return result;
+  }
+  const current = { schema_version: 2, reply_to_comments: true, handling_mode: 'ALL', reply_method: 'PUBLIC_AND_DM', keywords: [], reply_to_story_mentions: false, templates: expected };
+  it('девять значений читаются схемой сервера; PUBLIC_AND_DM не превращается в BOTH', () => {
+    const shippedInput = { platform_id: id, instagram_comment_behavior: {
+      instagram_comment_templates: templates, instagram_comment_reply_method: 'PUBLIC_AND_DM',
+    } };
+    const parsed = shippedSettings.schema.parse(shippedInput);
+    const oldRequest = JSON.parse(JSON.stringify(shippedSettings.createRequest(parsed)));
+    expect(oldRequest.body.instagramCommentBehavior.instagramCommentTemplates).toEqual(expected);
+    expect(oldRequest.body.instagramCommentBehavior).toEqual(request('besales_platform_settings_update', shippedInput).body.instagramCommentBehavior);
+    const actual = instagramCommentBehaviorJsonSchema.parse(mergeInstagramCommentBehavior(current, patch(templates)));
+    expect(actual.templates).toEqual(expected);
+    expect(actual.reply_method).toBe('PUBLIC_AND_DM');
+    expect(patch(templates, 'BOTH').reply_method).toBe('BOTH');
+  });
+  it.each([{}, null, { dm: { ru: 'replacement' } }])('явное %j заменяет документ целиком', (value) => {
+    const actual = instagramCommentBehaviorJsonSchema.parse(mergeInstagramCommentBehavior(current, patch(value)));
+    expect(actual.templates).toEqual(value);
+  });
+  it('пропуск сохраняет документ; ворота READER отказывают новому писателю', () => {
+    expect(mergeInstagramCommentBehavior(current, patch(undefined)).templates).toEqual(expected);
+    expect(() => assertInstagramCommentWritable(patch(templates), { get: () => 'READER' })).toThrow();
+    expect(() => assertInstagramCommentWritable(patch(templates), { get: () => 'WRITER' })).not.toThrow();
+  });
+  it('явная метка жалобы не теряется в HTTP-документе триггера', () => {
+    expect(request('besales_trigger_upsert', { platform_id: id, agent_id: id, instagram_comment_kind: 'COMPLAINT' }).body.instagramCommentKind).toBe('COMPLAINT');
+  });
+});

package/scripts/bridge-controls-mutants.mjs

@@ -0,0 +1,130 @@
+// Каждая мутация исполняет один различающий тест; исходник восстанавливается в finally.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = fileURLToPath(new URL('..', import.meta.url));
+const definitions = 'src/tools/definitions/';
+const cases = [
+  {
+    name: 'stop invokes resume',
+    file: 'prompt-batch-controls.ts',
+    before: '/${input.run_id}/stop`',
+    after: '/${input.run_id}/resume`',
+    test: 'bridge-controls.spec.ts',
+    pattern: 'stop завершает текущего агента',
+  },
+  {
+    name: 'key is silently normalized',
+    file: 'prompt-batch-controls.ts',
+    before: 'idempotencyKey: input.idempotency_key',
+    after: 'idempotencyKey: input.idempotency_key.trim()',
+    test: 'bridge-controls.spec.ts',
+    pattern: 'by-key сохраняет исходный ключ',
+  },
+  {
+    name: 'reader mutates state',
+    file: 'dialogue-followup-state.ts',
+    before: "method: 'GET'",
+    after: "method: 'PATCH'",
+    test: 'bridge-controls.spec.ts',
+    pattern: 'читает только выбранный диалог',
+  },
+  {
+    name: 'false history is lost',
+    file: 'shared-input.helpers.ts',
+    before: 'useCrossPlatformHistory: input.use_cross_platform_history,',
+    after: 'useCrossPlatformHistory: input.use_cross_platform_history || undefined,',
+    test: 'bridge-settings-acceptance.spec.ts',
+    pattern: 'история сохраняет true и false',
+  },
+  {
+    name: 'SMS section refused again',
+    file: 'platform-settings-update.ts',
+    before: 'const openInvoiceFields = [',
+    after:
+      "if (value.smsgorod_settings !== undefined) context.addIssue({ code: 'custom', path: ['smsgorod_settings'], message: 'SECTION_DEFERRED' });\n    const openInvoiceFields = [",
+    test: 'bridge-settings-acceptance.spec.ts',
+    pattern: 'прежняя форма проходит одним атомарным PATCH',
+  },
+  {
+    name: 'Bitrix mode confirmation dropped',
+    file: 'platform-setup.ts',
+    before: 'body: { ...platformSettingsSections(input), ...setupConfirmation(input) },',
+    after: 'body: { ...platformSettingsSections(input) },',
+    test: 'bridge-settings-acceptance.spec.ts',
+    pattern: 'подтверждение смены режима передаётся',
+  },
+  {
+    name: 'old create requires ICP',
+    file: 'agent-settings.ts',
+    before: 'default_icp_profile_id: uuidSchema.optional(),',
+    after: 'default_icp_profile_id: uuidSchema,',
+    test: 'agent-icp-shipped-compatibility.spec.ts',
+    pattern: 'create не требует портрет',
+  },
+  {
+    name: 'null cannot clear default ICP',
+    file: 'agent-settings.ts',
+    before: 'default_icp_profile_id: uuidSchema.nullable().optional(),',
+    after: 'default_icp_profile_id: uuidSchema.optional(),',
+    test: 'agent-icp-shipped-compatibility.spec.ts',
+    pattern: 'update сохраняет omission',
+  },
+];
+
+const temp = mkdtempSync(join(tmpdir(), 'bridge-controls-mutants-'));
+try {
+  // Зелёная база обязательна: сбой импорта/старта не считается убитой мутацией.
+  const baseline = spawnSync(
+    process.execPath,
+    [
+      'node_modules/vitest/vitest.mjs',
+      'run',
+      ...[...new Set(cases.map((entry) => definitions + entry.test))],
+    ],
+    { cwd: root, encoding: 'utf8' },
+  );
+  if (baseline.status !== 0)
+    throw new Error(`Baseline failed:\n${baseline.stdout}\n${baseline.stderr}`);
+  for (const [index, entry] of cases.entries()) {
+    const file = join(root, definitions, entry.file);
+    const original = readFileSync(file, 'utf8');
+    if (original.split(entry.before).length !== 2)
+      throw new Error(`Mutation is not unique: ${entry.name}`);
+    const report = join(temp, `${index}.json`);
+    try {
+      writeFileSync(file, original.replace(entry.before, entry.after));
+      const run = spawnSync(
+        process.execPath,
+        [
+          'node_modules/vitest/vitest.mjs',
+          'run',
+          definitions + entry.test,
+          '--testNamePattern',
+          entry.pattern,
+          '--reporter=json',
+          '--outputFile',
+          report,
+        ],
+        { cwd: root, encoding: 'utf8' },
+      );
+      const result = JSON.parse(readFileSync(report, 'utf8'));
+      const failed = result.testResults
+        .flatMap((suite) => suite.assertionResults)
+        .filter((test) => test.status === 'failed' && test.fullName.includes(entry.pattern));
+      if (run.status === 0 || failed.length === 0)
+        throw new Error(
+          `SURVIVED or infrastructure failure: ${entry.name}\n${run.stdout}\n${run.stderr}`,
+        );
+      console.log(`KILLED: ${entry.name} (${failed.length} distinguishing assertion test)`);
+    } finally {
+      writeFileSync(file, original);
+    }
+  }
+  console.log(`${cases.length}/${cases.length} KILLED; baseline passed; all sources restored`);
+} finally {
+  rmSync(temp, { recursive: true, force: true });
+}

package/scripts/brx3-shipped-refusals.spec.mjs

@@ -0,0 +1,149 @@
+import { shippedRef } from './shipped-ref.mjs';
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { toolDefinitions } from '../src/tools/definitions.ts';
+import { diffRegistries, lagKey } from './registry-diff.mjs';
+import { loadShippedDefinitions } from './shipped-definitions.mjs';
+import {
+  buildShippedSample,
+  filterOf,
+  schemaLagExplains,
+  schemaPathsOf,
+} from './shipped-sample.mjs';
+
+const ID = '00000000-0000-4000-8000-000000000001';
+const FOLLOWUP = 'besales_followup_sequence_upsert';
+const SETTINGS = 'besales_platform_settings_update';
+const TRANSPORTS = 'config.steps[].getcourse.delivery.transports';
+const KEYWORDS = 'instagram_comment_behavior.instagram_comment_keywords';
+const registry = JSON.parse(
+  readFileSync(new URL('../src/schemas/shipped-lag.json', import.meta.url), 'utf8'),
+);
+const current = JSON.parse(
+  readFileSync(new URL('../src/schemas/mcp-tools.json', import.meta.url), 'utf8'),
+).tools;
+let shipped;
+let shippedTools;
+let differences;
+
+beforeAll(async () => {
+  const root = fileURLToPath(new URL('..', import.meta.url));
+  const commit = execFileSync('git', ['-C', root, 'rev-parse', shippedRef()], {
+    encoding: 'utf8',
+  }).trim();
+  shipped = (await loadShippedDefinitions(root, commit)).toolDefinitions;
+  shippedTools = JSON.parse(
+    execFileSync('git', ['-C', root, 'show', `${commit}:src/schemas/mcp-tools.json`], {
+      encoding: 'utf8',
+      maxBuffer: 16 * 1024 * 1024,
+    }),
+  ).tools;
+  differences = diffRegistries(shippedTools, current).contractLag;
+});
+
+function accept(definitions, name, args) {
+  return filterOf(definitions.find((tool) => tool.name === name), ID)(args);
+}
+
+function observed(name, args) {
+  const shippedSchema = shippedTools.find((tool) => tool.name === name).inputSchema;
+  const currentSchema = current.find((tool) => tool.name === name).inputSchema;
+  return buildShippedSample({
+    full: args,
+    known: args,
+    acceptShipped: (input) => accept(shipped, name, input),
+    acceptV2: (input) => accept(toolDefinitions, name, input),
+    explains: (path, input) =>
+      schemaLagExplains(
+        path,
+        input,
+        differences.filter((row) => row.tool === name),
+        schemaPathsOf(currentSchema, name),
+      ),
+    shippedConstraints: schemaPathsOf(shippedSchema, name),
+    goodValues: () => [],
+  });
+}
+
+function sequence(delivery, sequence_id, type = 'LOST_CLIENTS') {
+  return {
+    platform_id: ID,
+    ...(sequence_id === undefined ? {} : { sequence_id }),
+    name: 'Проверка доставки',
+    type,
+    trigger: 'USER_INACTIVITY',
+    config: {
+      filterMode: 'eventType',
+      steps: [{ stepType: 'message', messageConfig: { message: 'Текст' }, getcourse: { delivery } }],
+    },
+  };
+}
+
+describe('BRX3: отказы исполнимого моста, пропущенные сравнением JSON-схем', () => {
+  it.each([undefined, ID])('создание/правка %s: LOST_CLIENTS пропускал неисполняемый список', (id) => {
+    for (const mode of ['contact', 'all']) {
+      const args = sequence({ mode, transports: ['Email'] }, id);
+      expect(accept(shipped, FOLLOWUP, args).ok).toBe(true);
+      const result = observed(FOLLOWUP, args);
+      expect(result.refused.map((row) => row.path)).toEqual([TRANSPORTS]);
+      expect(result.request).toBeDefined();
+      expect(registry.contractLag[lagKey({
+        tool: FOLLOWUP, path: `${TRANSPORTS}#refused`, shipped: 'array', v2: 'refused',
+      })]).toMatchObject({ owner: 'DELIBERATE', severity: 'DELIBERATE' });
+    }
+  });
+
+  it.each([undefined, ID])('создание/правка %s: explicit сохраняет выбранный набор', (id) => {
+    const delivery = { mode: 'explicit', transports: ['Telegram', 'Email'] };
+    const args = sequence(delivery, id);
+    expect(accept(shipped, FOLLOWUP, args).ok).toBe(true);
+    const result = observed(FOLLOWUP, args);
+    expect(result.refused).toEqual([]);
+    expect(result.request.body.config.steps[0].getcourse.delivery).toEqual(delivery);
+  });
+
+  it('реактивация уже отвергала contact/all со списком; чистые режимы сохранены', () => {
+    for (const mode of ['contact', 'all']) {
+      const args = sequence({ mode, transports: ['Email'] }, ID, 'INACTIVE_USER_REACTIVATION');
+      expect(accept(shipped, FOLLOWUP, args).ok).toBe(false);
+      expect(accept(toolDefinitions, FOLLOWUP, args).ok).toBe(false);
+      for (const type of ['LOST_CLIENTS', 'INACTIVE_USER_REACTIVATION']) {
+        const clean = sequence({ mode }, ID, type);
+        expect(accept(shipped, FOLLOWUP, clean).ok).toBe(true);
+        expect(accept(toolDefinitions, FOLLOWUP, clean).ok).toBe(true);
+      }
+    }
+  });
+
+  it.each([{}, { keywords: ['цена'] }])('Instagram: объект %j — отдельный наблюдённый отказ', (value) => {
+    const args = { platform_id: ID, instagram_comment_behavior: { instagram_comment_keywords: value } };
+    expect(accept(shipped, SETTINGS, args).ok).toBe(true);
+    const result = observed(SETTINGS, args);
+    expect(result.refused.map((row) => row.path)).toEqual([KEYWORDS]);
+    expect(registry.contractLag[lagKey({
+      tool: SETTINGS, path: `${KEYWORDS}#refused`, shipped: ['object', 'null'], v2: 'refused',
+    })]).toMatchObject({ owner: 'DELIBERATE', severity: 'DELIBERATE' });
+    expect(result.request.body).not.toHaveProperty('instagramCommentBehavior.instagramCommentKeywords');
+  });
+
+  it.each([null, [], ['цена']])('Instagram: %j сохраняется без подмены', (value) => {
+    const args = { platform_id: ID, instagram_comment_behavior: { instagram_comment_keywords: value } };
+    const result = accept(toolDefinitions, SETTINGS, args);
+    expect(result.ok).toBe(true);
+    expect(result.request.body.instagramCommentBehavior.instagramCommentKeywords).toEqual(value);
+    if (value === null) expect(accept(shipped, SETTINGS, args).ok).toBe(true);
+  });
+
+  it('в соседних инструментах обоих реестров нет копий этих полей, включая refs и union', () => {
+    for (const tools of [shippedTools, current]) {
+      const carriers = tools.flatMap((tool) =>
+        [...schemaPathsOf(tool.inputSchema, tool.name).keys()]
+          .filter((path) => path.endsWith('instagram_comment_keywords') || path.endsWith('getcourse.delivery.transports'))
+          .map((path) => `${tool.name}::${path}`),
+      ).sort();
+      expect(carriers).toEqual([`${FOLLOWUP}::${TRANSPORTS}`, `${SETTINGS}::${KEYWORDS}`].sort());
+    }
+  });
+});

package/scripts/brx4-ledger-payload.spec.mjs

@@ -0,0 +1,127 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { toolDefinitions } from '../src/tools/definitions.ts';
+import { diffRegistries, lagKey, reconcileWithRegistry } from './registry-diff.mjs';
+import { remainingLagSections } from './lag-payload.mjs';
+import { loadShippedDefinitions } from './shipped-definitions.mjs';
+import { filterOf } from './shipped-sample.mjs';
+
+const read = (path) => JSON.parse(readFileSync(new URL(path, import.meta.url), 'utf8'));
+const lag = read('../src/schemas/shipped-lag.json');
+const current = read('../src/schemas/mcp-tools.json').tools;
+const signed = read('../../besales-api/contracts/mcp-tool-routes.json');
+const text = readFileSync(
+  new URL('../../besales-api/docs/contract-ledger/cledg-decisions.md', import.meta.url),
+  'utf8',
+);
+const { collectRows, ownershipErrors } = createRequire(import.meta.url)(
+  '../../besales-api/scripts/contract-ledger/lag-owners.js',
+);
+let shipped;
+let differences;
+let baselineSchemas;
+
+beforeAll(async () => {
+  const root = fileURLToPath(new URL('..', import.meta.url));
+  // This checks the debt of the signed historical export, whose remote ref may have moved.
+  // Live freshness is checked separately by API mcp-routes-freshness, not by rebasing this fixture.
+  const commit = signed.shippedRegistry.commit;
+  expect(commit).toMatch(/^[a-f0-9]{40}$/u);
+  const tools = JSON.parse(
+    execFileSync('git', ['-C', root, 'show', `${commit}:src/schemas/mcp-tools.json`], {
+      encoding: 'utf8',
+      maxBuffer: 16 * 1024 * 1024,
+    }),
+  ).tools;
+  baselineSchemas = Object.fromEntries(tools.map((tool) => [tool.name, tool.inputSchema]));
+  shipped = (await loadShippedDefinitions(root, commit)).toolDefinitions;
+  differences = diffRegistries(tools, current);
+}, 60000);
+
+describe('BRX4: полный долг доезжает до API без запуска подписанной выгрузки', () => {
+  it('signed baseline retains every input schema of the exact exported commit', () => {
+    expect(baselineSchemas).toEqual(signed.shippedInputSchemas);
+  });
+
+  it('обе стороны видят равные множества точных ключей и те же ACTIVE основания', () => {
+    const observed = [
+      ...differences.contractLag,
+      ...signed.contractLag.filter((row) => row.kind === 'REFUSED'),
+    ];
+    const payload = {
+      contractLag: observed.map((row) => ({ ...row, ...lag.contractLag[lagKey(row)] })),
+      shippedOnly: differences.missingTools.map((name) => ({ name, ...lag.missingTools[name] })),
+      ...remainingLagSections(lag),
+    };
+    const actual = collectRows(payload, 'api');
+    const expected = collectRows(lag, 'bridge');
+    expect(actual.map((row) => row.key).sort()).toEqual(expected.map((row) => row.key).sort());
+    expect(ownershipErrors(actual, text, '', { requireOpenOwners: false })).toEqual([]);
+    expect(payload.optionalInputExtensions).toEqual(lag.optionalInputExtensions);
+    expect(payload.contractExtensions).toEqual(lag.contractExtensions);
+    const active = [...text.matchAll(/<!-- contract-ledger-decision (.+?) -->/gu)]
+      .map((match) => JSON.parse(match[1]))
+      .filter((entry) => entry.status === 'ACTIVE');
+    for (const decision of active)
+      expect(actual.filter((row) => row.key === decision.key)).toHaveLength(1);
+    expect(active.length).toBeGreaterThan(90);
+    const reconciliation = reconcileWithRegistry({ ...differences, contractLag: observed }, lag);
+    expect(reconciliation).toEqual({
+      undeclaredMissing: [],
+      staleMissing: [],
+      undeclaredLag: [],
+      staleLag: [],
+      incomplete: [],
+    });
+  });
+
+  it('ровно шесть новых обязательных аргументов требуют собственных ключей долга', () => {
+    const additions = differences.contractLag.filter(
+      (row) =>
+        row.shipped === false &&
+        row.v2 === true &&
+        row.path.endsWith('#required') &&
+        !Object.hasOwn(signed.shippedInputSchemas[row.tool].properties, row.path.split('#')[0]),
+    );
+    expect(additions.map(lagKey).sort()).toEqual(
+      [
+        'besales_icp_import_dialogues::request_key#required::false→true',
+        'besales_trigger_claim_reset::action_id#required::false→true',
+        'besales_trigger_claim_reset::conversation_id#required::false→true',
+        'besales_workspace_operator_assignment_get::conversation_id#required::false→true',
+        'besales_workspace_operator_assignment_set::conversation_id#required::false→true',
+        'besales_workspace_operator_assignment_set::expected_assigned_at#required::false→true',
+      ].sort(),
+    );
+    for (const row of additions) {
+      const broken = structuredClone(lag);
+      delete broken.contractLag[lagKey(row)];
+      expect(reconcileWithRegistry(differences, broken).undeclaredLag).toContain(lagKey(row));
+    }
+  });
+
+  it('старый text-вызов ICP принят старым фильтром; v2 требует ключ, согласованный источник сохранён', () => {
+    const name = 'besales_icp_import_dialogues';
+    const id = '00000000-0000-4000-8000-000000000001';
+    const args = { icp_id: id, mode: 'text', crm_connection_id: id, gdpr_confirmed: true };
+    const old = filterOf(
+      shipped.find((tool) => tool.name === name),
+      id,
+    );
+    const now = filterOf(
+      toolDefinitions.find((tool) => tool.name === name),
+      id,
+    );
+    expect(old(args).ok).toBe(true);
+    expect(now(args).ok).toBe(false);
+    expect(now({ ...args, request_key: id })).toMatchObject({
+      ok: true,
+      request: {
+        body: { requestKey: id, gdprConfirmed: true, source: { kind: 'stored_crm_dialogues' } },
+      },
+    });
+  });
+});