@besales/mcp 0.48.0 → 1.0.0-beta.2

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);

package/scripts/platform-settings-shipped-parity.spec.mjs

@@ -0,0 +1,89 @@
+import { shippedRef } from './shipped-ref.mjs';
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+import { toolDefinitions } from '../src/tools/definitions.js';
+import { diffRegistries } from './registry-diff.mjs';
+import { sample } from './sample-args.mjs';
+import { loadShippedDefinitions } from './shipped-definitions.mjs';
+import { mergeShippedArgs } from './shipped-sample-candidates.mjs';
+import {
+  buildShippedSample,
+  filterOf,
+  prepareKnownArgs,
+  routeShape,
+  schemaLagExplains,
+  schemaPathsOf,
+} from './shipped-sample.mjs';
+
+const packageRoot = fileURLToPath(new URL('..', import.meta.url));
+const name = 'besales_platform_settings_update';
+
+describe('настройки канала — настоящий образец отгруженного моста', () => {
+  it('полный образец не отбрасывает выключатель как отказавшее поле', async () => {
+    const commit = execFileSync('git', ['-C', packageRoot, 'rev-parse', shippedRef()], {
+      encoding: 'utf8',
+    }).trim();
+    const shippedRegistry = JSON.parse(
+      execFileSync('git', ['-C', packageRoot, 'show', `${commit}:src/schemas/mcp-tools.json`], {
+        encoding: 'utf8',
+        maxBuffer: 16 * 1024 * 1024,
+      }),
+    );
+    const localRegistry = JSON.parse(
+      readFileSync(new URL('../src/schemas/mcp-tools.json', import.meta.url), 'utf8'),
+    );
+    const lagRegistry = JSON.parse(
+      readFileSync(new URL('../src/schemas/shipped-lag.json', import.meta.url), 'utf8'),
+    );
+    const fixtures = JSON.parse(
+      readFileSync(new URL('../src/schemas/mcp-v2-route-map.json', import.meta.url), 'utf8'),
+    );
+    const fixture = fixtures.find((entry) => entry.tool === name && entry.variant === undefined);
+    const shippedDefinitions = await loadShippedDefinitions(packageRoot, commit);
+    const shipped = shippedDefinitions.toolDefinitions.find((entry) => entry.name === name);
+    const local = toolDefinitions.find((entry) => entry.name === name);
+    const shippedJson = shippedRegistry.tools.find((entry) => entry.name === name).inputSchema;
+    const localJson = localRegistry.tools.find((entry) => entry.name === name).inputSchema;
+    const shippedPaths = schemaPathsOf(shippedJson, name);
+    const localPaths = schemaPathsOf(localJson, name);
+    const known = prepareKnownArgs(fixture.canonicalArgs, shippedPaths);
+    const full = mergeShippedArgs(sample(shippedJson), known);
+    const workspace = '00000000-0000-4000-8000-0000000000ff';
+    const diff = diffRegistries(
+      shippedRegistry.tools,
+      localRegistry.tools,
+      lagRegistry.toolSuccessors,
+    );
+    const result = buildShippedSample({
+      full,
+      known,
+      acceptShipped: filterOf(shipped, workspace),
+      acceptV2: filterOf(local, workspace),
+      explains: (path, args) =>
+        schemaLagExplains(
+          path,
+          args,
+          diff.contractLag.filter((entry) => entry.tool === name),
+          localPaths,
+        ),
+      shippedConstraints: shippedPaths,
+      goodValues: () => [],
+      mainRouteShape: routeShape(local.createRequest(local.schema.parse(fixture.canonicalArgs))),
+    });
+    expect(result.request).toBeDefined();
+    expect(result.refused.map((entry) => entry.path)).not.toContain('access_control.is_active');
+    expect(result.omitted.map((entry) => entry.path)).not.toContain('access_control.is_active');
+    expect(result.request.body.generalSettings.isActive).toBe(
+      fixture.canonicalArgs.general_settings.is_active,
+    );
+    expect(
+      Object.keys(lagRegistry.contractLag).some((key) =>
+        key.startsWith(`${name}::access_control.is_active#refused::`),
+      ),
+    ).toBe(false);
+  });
+});