@besales/mcp 0.48.0 → 1.0.0-beta.4

package/scripts/icp-import-verification/mutate.cjs

@@ -0,0 +1,70 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+const root = process.cwd();
+const maxMs = Number(process.env.VERIFY_PORTION_MAX_MS ?? 540000);
+if (!Number.isSafeInteger(maxMs) || maxMs <= 0) throw new Error('Invalid VERIFY_PORTION_MAX_MS');
+const manifest = JSON.parse(fs.readFileSync('test/icp-import/mutations.json', 'utf8'));
+const wanted = process.argv.slice(2);
+if (wanted.length === 0 || wanted.some(id => !manifest.some(row => row.id === id)))
+  throw new Error('Supply existing mutant IDs; one invocation is one bounded portion');
+const deadline = Date.now() + maxMs;
+const directory = path.join(root, '.codex-artifacts-codex-icpb14417', 'mutations');
+fs.mkdirSync(directory, { recursive: true });
+const sha = data => crypto.createHash('sha256').update(data).digest('hex');
+function run(row, phase) {
+  const report = path.join(directory, row.id + '-' + phase + '.json');
+  if (fs.existsSync(report)) fs.unlinkSync(report);
+  const args = ['--max-old-space-size=6144', 'node_modules/vitest/vitest.mjs', 'run', '--maxWorkers=2', row.test, '--testNamePattern', row.name, '--reporter=json', '--outputFile', report];
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) throw new Error('Portion expired before ' + row.id);
+  const processResult = spawnSync(process.execPath, args, {
+    cwd: root, env: process.env, timeout: remaining, killSignal: 'SIGTERM', encoding: 'utf8', maxBuffer: 8 * 1024 * 1024,
+  });
+  fs.writeFileSync(path.join(directory, row.id + '-' + phase + '.log'),
+    processResult.stdout + '\n' + processResult.stderr);
+  const payload = fs.existsSync(report) ? JSON.parse(fs.readFileSync(report, 'utf8')) : null;
+  const failures = (payload?.testResults ?? []).flatMap(suite => suite.assertionResults ?? [])
+    .filter(result => result.status === 'failed' && new RegExp(row.name).test(result.fullName));
+  const targetPath = row.test.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const targetStack = new RegExp('\\bat\\s+[^\\n]*' + targetPath + ':\\d+:\\d+');
+  const targetAssertion = failures.some(result => result.failureMessages.some(message => {
+    const plain = message.replace(/\u001b\[[0-9;]*m/g, '');
+    return /expect\(|AssertionError|Expected:/.test(plain) && targetStack.test(plain);
+  }));
+  return { rc: processResult.status, signal: processResult.signal, timedOut: processResult.error?.code === 'ETIMEDOUT',
+    tested: payload?.numPassedTests ?? 0, failed: payload?.numFailedTests ?? 0, targetAssertion };
+}
+let failed = false;
+for (const row of manifest.filter(row => wanted.includes(row.id))) {
+  const originals = new Map();
+  let result;
+  try {
+    const baseline = run(row, 'control');
+    if (baseline.rc !== 0 || baseline.tested < 1) throw new Error('Control is not green: ' + JSON.stringify(baseline));
+    for (const patch of row.patches) {
+      const file = path.resolve(root, patch.file);
+      if (!file.startsWith(root + path.sep)) throw new Error('Patch escapes root');
+      if (!originals.has(file)) originals.set(file, fs.readFileSync(file));
+      const text = fs.readFileSync(file, 'utf8');
+      if (text.split(patch.from).length - 1 !== patch.count) throw new Error('Patch drift: ' + row.id);
+      fs.writeFileSync(file, text.split(patch.from).join(patch.to));
+    }
+    const mutated = run(row, 'mutant');
+    const state = mutated.rc !== null && mutated.rc !== 0 && !mutated.signal && !mutated.timedOut && mutated.targetAssertion ? 'KILLED'
+      : mutated.rc === 0 ? 'SURVIVED' : 'INFRASTRUCTURE';
+    result = { id: row.id, criterion: row.criterion, state, baseline, mutated };
+  } catch (error) {
+    result = { id: row.id, criterion: row.criterion, state: 'INFRASTRUCTURE', error: String(error) };
+  } finally {
+    for (const [file, content] of originals) {
+      fs.writeFileSync(file, content);
+      if (sha(fs.readFileSync(file)) !== sha(content)) throw new Error('RESTORATION FAILED: ' + file);
+    }
+  }
+  fs.writeFileSync(path.join(directory, row.id + '-result.json'), JSON.stringify(result, null, 2) + '\n');
+  console.log(JSON.stringify(result));
+  if (result.state !== 'KILLED') { failed = true; break; }
+}
+process.exitCode = failed ? 1 : 0;

package/scripts/import-secret-read-contract.mjs

@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const [apiRoot, verifierLog] = process.argv.slice(2);
+assert(apiRoot && verifierLog, 'Usage: node scripts/import-secret-read-contract.mjs API_ROOT VREQ_LOG');
+const matches = [...readFileSync(verifierLog, 'utf8').matchAll(/PRSM_BRIDGE_CONTRACT=([A-Za-z0-9+/=]+)/gu)];
+assert.equal(matches.length, 1, 'Exactly one successful API contract is required');
+const contract = JSON.parse(Buffer.from(matches[0][1], 'base64').toString('utf8'));
+assert.equal(contract.version, 1);
+assert.match(contract.apiRevision, /^[a-f0-9]{40}$/u);
+const git = (...args) => execFileSync('git', ['-C', apiRoot, ...args], { encoding: 'utf8' }).trimEnd();
+const localRevision = git('rev-parse', 'HEAD');
+// Канал синхронизирует рабочие файлы, но его Git-метка может отставать. Чужая ветка
+// запрещена; любой изменённый runtime-файл обязан иметь совпавший проверенный хэш.
+git('merge-base', '--is-ancestor', contract.apiRevision, localRevision);
+const roots = ['src', 'scripts/migration'];
+const committed = git('diff', '--name-only', contract.apiRevision, localRevision, '--', ...roots).split('\n').filter(Boolean);
+const uncommitted = git('status', '--porcelain', '--untracked-files=all', '--', ...roots).split('\n').filter(Boolean).map(line => line.slice(3));
+for (const file of new Set([...committed, ...uncommitted])) {
+  if (!file.endsWith('.spec.ts')) assert(Object.hasOwn(contract.sources, file), 'API runtime has unverified changes: ' + file);
+}
+assert.equal(contract.samples.length, 30);
+assert.equal(Object.keys(contract.sources).length, 17);
+const rejectedColumns = contract.columnNames.filter(vector => vector.decision !== 'SAFE').length;
+assert.equal(contract.metadataWrites.length, rejectedColumns + 18);
+assert.equal(contract.metadataWrites.filter(sample => sample.status === 400).length, rejectedColumns + 16);
+assert(contract.metadataWrites.some(sample => JSON.stringify(sample.requestBody).includes('ｇｈｐ_1234567890abcdefghij') && sample.status === 400));
+for (const sample of contract.metadataWrites) {
+  assert([201, 400].includes(sample.status));
+  for (const secret of contract.forbidden)
+    assert(!JSON.stringify(sample.response).includes(JSON.stringify(secret).slice(1, -1)), 'Unsafe metadata write response');
+}
+assert.equal(contract.inventory.version, 1);
+assert.equal(contract.inventory.groups.flatMap(group => group.tools).length, 292);
+for (const [file, expected] of Object.entries(contract.sources)) {
+  assert(/^(?:src|test|scripts)\//u.test(file) && !file.includes('..'));
+  const actual = createHash('sha256').update(readFileSync(resolve(apiRoot, file))).digest('hex');
+  assert.equal(actual, expected, 'API source changed since verification: ' + file);
+}
+for (const sample of contract.samples) {
+  const wire = JSON.stringify(sample.response);
+  for (const secret of contract.forbidden) assert(!wire.includes(JSON.stringify(secret).slice(1, -1)), sample.tool + ': unsafe fixture');
+  assert(sample.principal === 'owner' ? [200, 422].includes(sample.status) : [403, 404].includes(sample.status));
+}
+contract.verifiedApiRevision = localRevision;
+const destination = new URL('../src/tools/__fixtures__/secret-read-contract.json', import.meta.url);
+// Compact wire capture: response bodies are never rewritten.
+mkdirSync(new URL('.', destination), { recursive: true });
+writeFileSync(destination, JSON.stringify(contract) + '\n');
+console.log('Imported ' + contract.samples.length + ' verified HTTP responses; all source hashes and runtime changes match');

package/scripts/install-claude-desktop.js

@@ -11,7 +11,7 @@ const CLAUDE_CONFIG_PATH = join(
   'Library/Application Support/Claude/claude_desktop_config.json',
 );
 const LOCAL_API_BASE_URL = 'http://localhost:3000/api/v2';
-const LOCAL_OAUTH_AUTHORIZE_URL = 'http://localhost:5173/settings/mcp/consent';
+const LOCAL_OAUTH_AUTHORIZE_URL = 'http://localhost:3000/api/v2/auth/mcp-connect/start';
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const packageRoot = dirname(fileURLToPath(new URL('../package.json', import.meta.url)));
 const binPath = join(packageRoot, 'bin/besales-mcp.js');

package/scripts/lag-decisions.mjs

@@ -0,0 +1,37 @@
+/** ACTIVE без причины и точной пары ID + ключ не разрешает расхождение отгруженного контракта. */
+export function lagDecisionErrors(registry, decisionsText) {
+  const decisions = new Map();
+  const ids = new Set();
+  const errors = [];
+  for (const match of decisionsText.matchAll(/<!-- contract-ledger-decision (.+?) -->/gu)) {
+    const entry = JSON.parse(match[1]);
+    if (entry.status !== 'ACTIVE') continue;
+    if (
+      typeof entry.id !== 'string' ||
+      !/^\d+(?:\.\d+)+:[^\s;,]+$/u.test(entry.id) ||
+      typeof entry.key !== 'string' ||
+      typeof entry.reason !== 'string' ||
+      !entry.reason.replace(/decision:[^\s;,]+/gu, '').replace(/[;\s]/gu, '') ||
+      ids.has(entry.id) ||
+      decisions.has(entry.key)
+    ) {
+      errors.push(`решение ${entry.id}: нужны уникальные ID, ключ и непустая причина`);
+      continue;
+    }
+    ids.add(entry.id);
+    decisions.set(entry.key, entry);
+  }
+  for (const [section, rows] of Object.entries(registry)) {
+    if (rows === null || typeof rows !== 'object' || Array.isArray(rows)) continue;
+    for (const [key, row] of Object.entries(rows)) {
+      if (row?.owner !== 'DELIBERATE') continue;
+      const fullKey = `${section}:${key}`;
+      const entry = decisions.get(fullKey);
+      const reason = typeof row.reason === 'string' ? row.reason : '';
+      const refs = [...reason.matchAll(/decision:([^\s;,]+)/gu)].map((match) => match[1]);
+      if (entry === undefined || !refs.includes(entry.id))
+        errors.push(`${fullKey}: нет ACTIVE решения для точного ключа и ссылки`);
+    }
+  }
+  return errors.sort();
+}

package/scripts/lag-decisions.spec.mjs

@@ -0,0 +1,87 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { describe, expect, it } from 'vitest';
+import { lagDecisionErrors } from './lag-decisions.mjs';
+import { lagMetadataErrors } from './registry-diff.mjs';
+
+const root = fileURLToPath(new URL('../..', import.meta.url));
+const text = readFileSync(`${root}/besales-api/docs/contract-ledger/cledg-decisions.md`, 'utf8');
+const registry = JSON.parse(
+  readFileSync(new URL('../src/schemas/shipped-lag.json', import.meta.url), 'utf8'),
+);
+const entries = [...text.matchAll(/<!-- contract-ledger-decision (.+?) -->/gu)]
+  .map((match) => JSON.parse(match[1]))
+  .filter((entry) => entry.status === 'ACTIVE');
+const restorations = [...text.matchAll(/<!-- contract-ledger-restoration (.+?) -->/gu)].map(
+  (match) => JSON.parse(match[1]),
+);
+const require = createRequire(import.meta.url);
+const api = require(`${root}/besales-api/scripts/contract-ledger/lag-owners.js`);
+
+describe('адресное решение обязательно у производителя и независимого API-потребителя', () => {
+  it('все 90 строк аудита и 26 прежних ссылок разобраны; каждая ACTIVE имеет точный ключ', () => {
+    expect(
+      [...entries, ...restorations]
+        .filter((entry) => entry.auditNumber)
+        .map((entry) => entry.auditNumber)
+        .sort((a, b) => a - b),
+    ).toEqual(Array.from({ length: 90 }, (_, index) => index + 1));
+    expect(
+      [...entries, ...restorations]
+        .filter((entry) => entry.referenceNumber)
+        .map((entry) => entry.referenceNumber)
+        .sort((a, b) => a - b),
+    ).toEqual(Array.from({ length: 26 }, (_, index) => index + 1));
+    expect(lagDecisionErrors(registry, text)).toEqual([]);
+    expect(lagMetadataErrors(registry)).toEqual([]);
+    const rows = api.collectRows(registry, 'bridge');
+    expect(api.ownershipErrors(rows, text, '', { requireOpenOwners: false })).toEqual([]);
+    for (const entry of entries) {
+      expect(rows.filter((row) => row.key === entry.key)).toHaveLength(1);
+      expect(entry.reason.trim()).not.toBe('');
+      for (const file of [...entry.code, ...entry.tests])
+        expect(readFileSync(`${root}/${file}`, 'utf8').length, file).toBeGreaterThan(0);
+    }
+    for (const entry of restorations) {
+      expect(
+        rows.filter((row) => row.key === entry.key),
+        entry.key,
+      ).toHaveLength(0);
+      for (const file of [...entry.code, ...entry.tests])
+        expect(readFileSync(`${root}/${file}`, 'utf8').length, file).toBeGreaterThan(0);
+    }
+  });
+
+  it.each(entries)('$id: удаление причины или ACTIVE не проходит ни один сторож', (entry) => {
+    for (const broken of [
+      { ...entry, reason: '' },
+      { ...entry, reason: 'decision:' + entry.id },
+      { ...entry, status: 'PROPOSED' },
+      { ...entry, key: entry.key + '-other' },
+    ]) {
+      const changed = text.replace(JSON.stringify(entry), JSON.stringify(broken));
+      expect(lagDecisionErrors(registry, changed), entry.id).not.toEqual([]);
+      expect(
+        api.ownershipErrors(api.collectRows(registry, 'bridge'), changed, '', {
+          requireOpenOwners: false,
+        }),
+        entry.id,
+      ).not.toEqual([]);
+    }
+  });
+
+  it.each(['contractLag', 'optionalInputExtensions', 'contractExtensions'])(
+    '%s: одна ссылка вместо причины недостаточна',
+    (section) => {
+      const row = {
+        owner: 'DELIBERATE',
+        severity: 'DELIBERATE',
+        reason: 'decision:6.19.51:empty',
+      };
+      expect(lagMetadataErrors({ [section]: { field: row } })).toEqual([`${section}:field`]);
+      expect(api.metadataErrors(section, row)).toContain('пустая причина');
+      expect(lagDecisionErrors({ [section]: { field: row } }, '')).not.toEqual([]);
+    },
+  );
+});

package/scripts/lag-open-task-owners.mjs

@@ -0,0 +1,46 @@
+import { readFileSync } from 'node:fs';
+
+import { LAG_SECTIONS, lagMetadataErrors } from './registry-diff.mjs';
+import { lagDecisionErrors } from './lag-decisions.mjs';
+
+/** Планы — обязательные входы CI, а не снимок списка открытых задач в пакете. */
+export function readLagPlans(env = process.env) {
+  const texts = ['BESALES_WORKING_PLAN', 'BESALES_CLOSED_PLAN'].map((name) => {
+    const path = env[name]?.trim();
+    if (!path) throw new Error(`${name}: укажите файл плана; открытость владельцев не проверена`);
+    return readFileSync(path, 'utf8');
+  });
+  const decisionsText = readFileSync(
+    env.BESALES_LAG_DECISIONS_FILE ??
+      new URL('../../besales-api/docs/contract-ledger/cledg-decisions.md', import.meta.url),
+    'utf8',
+  );
+  return { workingText: texts[0], closedText: texts[1], decisionsText };
+}
+
+/** Только заголовок задачи: упоминания номера и старые списки владельцев не подходят. */
+export function planTaskIds(text) {
+  const ids = new Set();
+  for (const match of text.matchAll(/^#### Task (\d+(?:\.\d+)+)(?=[: (])/gmu)) {
+    ids.add(match[1]);
+  }
+  if (ids.size === 0) throw new Error('План не содержит заголовков Task');
+  return ids;
+}
+
+/** Ни бюджета, ни исключений для старых строк: проверяются все разделы реестра. */
+export function lagOpenTaskErrors(registry, { workingText, closedText, decisionsText = '' }) {
+  const working = planTaskIds(workingText);
+  const closed = planTaskIds(closedText);
+  const errors = [...lagMetadataErrors(registry), ...lagDecisionErrors(registry, decisionsText)];
+  for (const section of LAG_SECTIONS) {
+    for (const [key, row] of Object.entries(registry[section] ?? {})) {
+      if (row.owner === 'DELIBERATE') continue;
+      const id = typeof row.owner === 'string' ? row.owner.replace(/^TASK-/u, '') : '';
+      if (!working.has(id) || closed.has(id)) {
+        errors.push(`${section}:${key}: ${row.owner} — задача не открыта однозначно`);
+      }
+    }
+  }
+  return [...new Set(errors)].sort();
+}

package/scripts/lag-open-task-owners.spec.mjs

@@ -0,0 +1,78 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+import { LAG_SECTIONS } from './registry-diff.mjs';
+import { lagOpenTaskErrors, planTaskIds, readLagPlans } from './lag-open-task-owners.mjs';
+
+const plans = {
+  workingText: '#### Task 6.19.51: Открытая\nСсылка на Task 6.22.10\n',
+  closedText: '#### Task 6.22.10: Закрытая\n',
+};
+const row = {
+  owner: 'TASK-6.19.51',
+  reason: 'Отказ проверяет владелец; decision:6.19.51:test',
+  severity: 'LIVE_400',
+};
+
+describe('владелец — открытая задача рабочего плана или DELIBERATE', () => {
+  it.each(LAG_SECTIONS)('%s: нет исключений для раздела или прежней строки', (section) => {
+    expect(lagOpenTaskErrors({ [section]: { field: row } }, plans)).toEqual([]);
+    for (const owner of ['домен', 'TASK-6.999.1', 'TASK-6.22.10', 'TASK-6.19.51 (закрыта)']) {
+      expect(
+        lagOpenTaskErrors({ [section]: { field: { ...row, owner } } }, plans).join('\n'),
+      ).toContain(`${section}:field`);
+    }
+    expect(
+      lagOpenTaskErrors(
+        { [section]: { field: row } },
+        {
+          ...plans,
+          closedText: plans.closedText + '\n#### Task 6.19.51: тоже закрытая',
+        },
+      ),
+    ).toEqual([`${section}:field: TASK-6.19.51 — задача не открыта однозначно`]);
+    expect(
+      lagOpenTaskErrors(
+        {
+          [section]: {
+            field: {
+              ...row,
+              owner: 'DELIBERATE',
+              severity: 'DELIBERATE',
+            },
+          },
+        },
+        {
+          ...plans,
+          decisionsText:
+            'Решение <!-- contract-ledger-decision ' +
+            JSON.stringify({
+              id: '6.19.51:test',
+              key: section + ':field',
+              status: 'ACTIVE',
+              reason: 'Защита данных',
+            }) +
+            ' -->',
+        },
+      ),
+    ).toEqual([]);
+  });
+
+  it('пустой и недоступный план не дают зелёный ответ', () => {
+    expect(() => readLagPlans({})).toThrow('BESALES_WORKING_PLAN');
+    expect(() => readLagPlans({ BESALES_WORKING_PLAN: '/nonexistent/br6191/plan' })).toThrow();
+    expect(() => readLagPlans({ BESALES_WORKING_PLAN: new URL(import.meta.url).pathname })).toThrow(
+      'BESALES_CLOSED_PLAN',
+    );
+    expect(() => planTaskIds('Task 6.19.51 упомянута')).toThrow('не содержит');
+    expect([...planTaskIds(plans.workingText.repeat(2))]).toEqual(['6.19.51']);
+  });
+
+  // Мутант: вернуть проверку только формата TASK-N либо пропустить закрытый план.
+  it('каждая строка реального реестра принадлежит открытой задаче или DELIBERATE', () => {
+    const registry = JSON.parse(
+      readFileSync(new URL('../src/schemas/shipped-lag.json', import.meta.url), 'utf8'),
+    );
+    expect(lagOpenTaskErrors(registry, readLagPlans())).toEqual([]);
+  });
+});

package/scripts/lag-payload.mjs

@@ -0,0 +1,10 @@
+import { LAG_SECTIONS } from './registry-diff.mjs';
+
+/** Missing tools and observed schema differences have their own emitted representation. */
+export function remainingLagSections(registry) {
+  return Object.fromEntries(
+    LAG_SECTIONS.filter((section) => !['missingTools', 'contractLag'].includes(section)).map(
+      (section) => [section, registry[section] ?? {}],
+    ),
+  );
+}

package/scripts/legacy-action-lag.spec.mjs

@@ -0,0 +1,22 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const registry = JSON.parse(
+  readFileSync(new URL('../src/schemas/shipped-lag.json', import.meta.url), 'utf8'),
+);
+
+describe('отставание прежних конфигов действий', () => {
+  /** Мутация, которая красит: вернуть хотя бы одну строку отставания для уже поддержанного поля. */
+  it('остаётся только осознанный отказ от общей константы для пересказа', () => {
+    expect(Object.keys(registry.legacyActionLag)).toEqual([
+      'besales_trigger_upsert::actions[].summarizeConfig.targetType#PLATFORM_CONSTANT',
+    ]);
+    expect(Object.values(registry.legacyActionLag)).toEqual([
+      {
+        owner: 'DELIBERATE',
+        severity: 'DELIBERATE',
+        reason: expect.stringContaining('пересказ человека'),
+      },
+    ]);
+  });
+});

package/scripts/legacy-field-refusal.shipped.spec.mjs

@@ -0,0 +1,99 @@
+import { shippedRef } from './shipped-ref.mjs';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+import { loadShippedModule } from './shipped-definitions.mjs';
+
+/**
+ * ⭐ Отказ сервера v2 на прежнее имя поля — глазами УСТАНОВЛЕННОГО у клиентов моста, а не ветки.
+ *
+ * После переключения домена прежняя установка моста зовёт сервер v2 и шлёт прежние имена (`platformId`). Сервер
+ * отвечает именованным отказом `LEGACY_FIELD_NAME`. Проверяется итоговый ответ, который прежний мост отдаёт модели:
+ * исполняется КОД отгруженной линии по общей настройке ссылки, извлечённый из git тем же загрузчиком, что и отгруженные
+ * определения. Прежний мост на отказ 400 добавляет своё «исправь причину и повтори вызов» — модель могла бы убрать
+ * необязательный фильтр канала и получить успешный НЕВЕРНЫЙ ответ. С полем `remediation` в корне тела он показывает
+ * действие сервера («перезапустите приложение, без поля не отправляйте»), а своё приглашение повторить не добавляет.
+ *
+ * Форму тела закрепляет сервер (`besales-api/src/shared/pipes/http-validation.pipe.spec.ts`); здесь — что эта форма
+ * значит для установленного клиента.
+ */
+
+const packageRoot = fileURLToPath(new URL('..', import.meta.url));
+const shippedCommit = execFileSync('git', ['-C', packageRoot, 'rev-parse', shippedRef()], {
+  encoding: 'utf8',
+}).trim();
+
+const REMEDIATION =
+  'Если запрос отправил мост besales-mcp, он устарел. Попросите человека перезапустить приложение ' +
+  '(Claude Desktop, Claude Code или Codex). При запуске через npx без версии с npm 9.6.5 или новее ' +
+  'мост может обновиться до latest; старый npm, закреплённая версия, локальный пакет или кэш могут ' +
+  'помешать обновлению. Если ошибка сохранилась после перезапуска, обновите npm и настройте запуск ' +
+  'актуального @besales/mcp@latest либо обновите локальный пакет; если это не помогло, обратитесь ' +
+  'в поддержку. До обновления этот инструмент недоступен прежнему мосту. Другому клиенту нужно ' +
+  'заменить имя поля на указанное. Не отправляйте запрос без этого поля: пропал бы фильтр, ' +
+  'и ответ был бы неверным.';
+
+/** Тело отказа в той форме, которую отдаёт сервер v2 (после общего фильтра — с correlationId). */
+function legacyRefusal(overrides = {}) {
+  return {
+    statusCode: 400,
+    message: ['Поле platformId переименовано в channelId.'],
+    error: 'Bad Request',
+    code: 'LEGACY_FIELD_NAME',
+    field: 'platformId',
+    replacement: 'channelId',
+    remediation: REMEDIATION,
+    correlationId: 'corr-legacy-1',
+    ...overrides,
+  };
+}
+
+/** Итоговый ответ отгруженного моста на отказ сервера с этим телом. */
+async function shippedToolResult(body) {
+  const { ApiClient } = await loadShippedModule(packageRoot, shippedCommit, 'src/http/api-client.ts');
+  const { mapToolError } = await loadShippedModule(packageRoot, shippedCommit, 'src/tools/result.ts');
+  const transport = {
+    async request() {
+      // Форма отказа axios: по ней отгруженный клиент отличает ответ сервера от обрыва связи.
+      throw {
+        isAxiosError: true,
+        message: 'Request failed with status code 400',
+        response: { status: 400, data: body, headers: {} },
+      };
+    },
+  };
+  const client = new ApiClient({ transport, apiBaseUrl: 'https://core.besales.ai/api/v2' });
+  let failure;
+  try {
+    await client.request('GET', '/workspaces/ws/broadcast-analytics?platformId=channel', 'mcp_key');
+  } catch (error) {
+    failure = error;
+  }
+  return mapToolError(failure, { sideEffect: 'none' });
+}
+
+describe('именованный отказ на прежнее имя поля — у установленного моста', () => {
+  it('модель видит действие сервера: перезапуск приложения и запрет повтора без поля', async () => {
+    const actual = await shippedToolResult(legacyRefusal());
+
+    expect(actual.isError).toBe(true);
+    expect(actual.structuredContent.error).toMatchObject({
+      code: 'LEGACY_FIELD_NAME',
+      status: 400,
+      continuation: REMEDIATION,
+    });
+    expect(actual.content[0].text).toContain('переименовано в channelId');
+    expect(actual.content[0].text).toContain('перезапустить приложение');
+    expect(JSON.stringify(actual)).not.toContain('повтори вызов');
+  });
+
+  it('без действия в теле прежний мост добавляет своё «повтори вызов» — поэтому поле обязательно', async () => {
+    const { remediation: _omitted, ...inputBody } = legacyRefusal();
+
+    const actual = await shippedToolResult(inputBody);
+
+    expect(actual.structuredContent.error.continuation).toBe('Исправь причину из сообщения и повтори вызов.');
+  });
+});

package/scripts/mcpcompat-handler.mjs

@@ -0,0 +1,34 @@
+// Исполняется только дочерним процессом HTTP-приёмки; не читает keychain оператора.
+import { createTools } from '../src/tools/registry.ts';
+import { ConnectionStore } from '../src/auth/connection-store.ts';
+import { ApiClient } from '../src/http/api-client.ts';
+process.on('message', async ({ id, baseUrl, workspaceId, key, name, args }) => {
+  try {
+    const values = new Map();
+    const store = new ConnectionStore({
+      async get(account) {
+        return values.get(account) ?? null;
+      },
+      async set(account, value) {
+        values.set(account, value);
+      },
+      async delete(account) {
+        values.delete(account);
+      },
+      async accounts() {
+        return [...values.keys()];
+      },
+    });
+    await store.addOrReplace(workspaceId, key);
+    const apiClient = new ApiClient({ apiBaseUrl: baseUrl, locale: 'ru' });
+    const tool = createTools({ store, apiClient, toolsets: null }).find(
+      (entry) => entry.name === name,
+    );
+    if (!tool) throw new Error(`Unknown tool: ${name}`);
+    const result = await tool.handler(args);
+    process.send?.({ id, result });
+  } catch (error) {
+    process.send?.({ id, error: String(error) });
+  }
+});
+process.on('disconnect', () => process.exit(0));

package/scripts/mcpcompat-loader.mjs

@@ -0,0 +1,36 @@
+// Узкий загрузчик исходников моста для HTTP-приёмки соседнего API, без артефактов сборки.
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+const source = new URL('../src/', import.meta.url).href;
+export function resolve(specifier, context, nextResolve) {
+  // Приёмка задаёт ConnectionStore в памяти: native keychain оператора недоступен.
+  if (specifier === 'keytar') return { url: 'mcpcompat:keychain-disabled', shortCircuit: true };
+  if (context.parentURL?.startsWith(source) && specifier.endsWith('.js')) {
+    const target = new URL(specifier.slice(0, -3) + '.ts', context.parentURL);
+    if (target.href.startsWith(source) && existsSync(target))
+      return { url: target.href, shortCircuit: true };
+  }
+  return nextResolve(specifier, context);
+}
+export function load(url, context, nextLoad) {
+  if (url === 'mcpcompat:keychain-disabled')
+    return {
+      format: 'module',
+      shortCircuit: true,
+      source:
+        'export default new Proxy({}, { get() { throw new Error("Keychain disabled in HTTP acceptance"); } });',
+    };
+  if (url.startsWith(source) && url.endsWith('.ts'))
+    return {
+      format: 'module',
+      shortCircuit: true,
+      source: ts.transpileModule(readFileSync(fileURLToPath(url), 'utf8'), {
+        compilerOptions: {
+          target: ts.ScriptTarget.ES2022,
+          module: ts.ModuleKind.ESNext,
+        },
+      }).outputText,
+    };
+  return nextLoad(url, context);
+}

package/scripts/mcpcompat-typescript.mjs

@@ -0,0 +1,3 @@
+// Асинхронный ESM-загрузчик: совместим с CommonJS-зависимостями на серверном Node 22.
+import { register } from 'node:module';
+register('./mcpcompat-loader.mjs', import.meta.url);