dsh-telegram-multiagent 1.2.3 → 1.4.0

package/test/extract.mjs

@@ -0,0 +1,44 @@
+// Вырезает тело именованной функции ИЗ ФАЙЛА пакета — стенд обязан проверять
+// установленный код, а не его пересказ. Поиск по ИМЕНИ, не по номеру строки:
+// номер строки протухает от первой же правки выше по файлу.
+import fs from 'node:fs';
+
+export function readSource(file) {
+  return fs.readFileSync(file, 'utf-8');
+}
+
+export function extractFunction(src, name) {
+  const re = new RegExp(`(?:^|\\n)\\s*(?:async\\s+)?function\\s+${name}\\s*\\(`);
+  const m = re.exec(src);
+  if (!m) throw new Error(`функция ${name} не найдена в исходнике`);
+  // 🔴 Начало берём от `async`, если оно есть: обрезав его, стенд получил бы
+  // обычную функцию с await внутри и упал бы с «await is only valid in async
+  // functions» — то есть покраснел бы на исправном коде.
+  const fnAt = src.indexOf('function', m.index);
+  const asyncAt = src.lastIndexOf('async', fnAt);
+  const start = (asyncAt !== -1 && /^async\s+function$/.test(src.slice(asyncAt, fnAt + 8).replace(/\s+/g, ' ').trim().replace(/ $/, '')))
+    ? asyncAt : fnAt;
+  const open = src.indexOf('{', src.indexOf('(', start));
+  let depth = 0, i = open, inStr = null, esc = false;
+  for (; i < src.length; i++) {
+    const c = src[i];
+    if (inStr) {
+      if (esc) { esc = false; continue; }
+      if (c === '\\') { esc = true; continue; }
+      if (c === inStr) inStr = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') { inStr = c; continue; }
+    if (c === '{') depth++;
+    else if (c === '}') { depth--; if (depth === 0) break; }
+  }
+  if (depth !== 0) throw new Error(`не удалось сбалансировать скобки у ${name}`);
+  return src.slice(start, i + 1);
+}
+
+export function extractConst(src, name) {
+  const re = new RegExp(`\\n\\s*const\\s+${name}\\s*=\\s*([^;\\n]+);`);
+  const m = re.exec(src);
+  if (!m) throw new Error(`константа ${name} не найдена`);
+  return m[1].trim();
+}

package/test/stend-imena.mjs

@@ -0,0 +1,133 @@
+// Стенд правки «имена из настройки». Строки берутся ИЗ файла, не пишутся заново.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+// 🔴 Путь по умолчанию — УСТАНОВЛЕННЫЙ файл рядом со стендом. Без него стенд,
+// запущенный без довода (а в приёмке списком его запускают именно так), падал
+// сырым TypeError и читался кодом 1 — то есть слепота проверки выглядела отказом
+// предмета. Аргументом по-прежнему можно указать другую копию.
+const SRC = process.argv[2]
+  || new URL('../src/index.js', import.meta.url).pathname;
+let s;
+try {
+  s = fs.readFileSync(SRC, 'utf-8');
+} catch (e) {
+  console.log(`СЛЕПОТА: не читается ${SRC} — ${e.code || e.message}`);
+  process.exit(2);          // 2 = не смогла проверить. Это НЕ «сошлось» и НЕ отказ.
+}
+let ok = 0, fail = 0, slep = 0;
+const t = (name, cond, syrio) => { if (cond) { ok++; console.log(`ok   ${name}`); }
+  else { fail++; console.log(`FAIL ${name}\n     сырьё: ${syrio}`); } };
+
+// 1. Объявление who_ есть и берёт значение из настройки.
+const decl = s.match(/const who_ = ([^;]+);/);
+t('who_ объявлена из config.agentName', !!decl && /config\.agentName/.test(decl[1]),
+  decl ? decl[1] : '(объявления нет)');
+
+// 🔴 СПИСОК ЧАСТНЫХ ИМЁН ЖИВЁТ ФАЙЛОМ РЯДОМ, А НЕ В ГОЛОВЕ ПРОВЕРЯЮЩЕГО.
+// Прецедент 01.09.2026: три обхода одного файла дали 0, 2 и 4 находки. Причём
+// второй обход был ХУЖЕ первого не по списку, а по его СУЖЕНИЮ: первый шёл по
+// полному списку латиницей и дал ноль; после провала проверяющий перезапросил ОДНО
+// имя — то, что уже видел, — нашёл ожидаемое и счёл поиск законченным.
+// 🔴 Список схлопнулся при первой находке. Это опаснее забытого имени: там дыра
+// видна при перечитывании, здесь список БЫЛ полным и стал неполным незаметно.
+// Поэтому: список в файле, прогоняется ВЕСЬ ВСЕГДА, и покрытие по нему печатается —
+// без числа «имён N из N» сужение снова стало бы невидимым.
+const FAJL_IMEN = path.join(path.dirname(fileURLToPath(import.meta.url)), 'chastnye-imena.json')
+let SPISOK_IMEN = null
+try {
+  SPISOK_IMEN = JSON.parse(fs.readFileSync(FAJL_IMEN, 'utf-8')).imena
+} catch (e) {
+  // У постороннего установившего файла нет и быть не должно: список наших имён —
+  // частные данные, он не входит в состав пакета. Это СЛЕПОТА, а не беда.
+  console.log(`---  список частных имён не прочитан (${FAJL_IMEN}): ${e.code ?? e.message}`)
+  console.log('---  проверка обезличенности НЕ СОСТОЯЛАСЬ; у стороннего установившего это норма')
+  slep += 1
+}
+if (Array.isArray(SPISOK_IMEN) && SPISOK_IMEN.length) {
+  const svoj = fs.readFileSync(fileURLToPath(import.meta.url), 'utf-8')
+  // Из обхода исключаются строки, где имя И ЕСТЬ предмет проверки: отрицания вида
+  // !/Имя/.test(...) — там оно обязано присутствовать, иначе проверять нечего.
+  const bezZashity = svoj.split('\n').filter((l) => !/!\/[^/]+\/\.test\(/.test(l)).join('\n')
+  const najdeno = SPISOK_IMEN.filter((im) => bezZashity.includes(im))
+  t(`в стенде нет частных имён как данных (проверено имён ${SPISOK_IMEN.length} из ${SPISOK_IMEN.length}, файл ${path.basename(FAJL_IMEN)})`,
+    najdeno.length === 0, najdeno.length ? `найдено: ${najdeno.join(', ')}` : 'ни одного')
+}
+
+// 🔴 НИЖЕ ДВАЖДЫ ВСТРЕЧАЕТСЯ ЧАСТНОЕ ИМЯ — И ЭТО НЕ ГРЯЗЬ, А ЗАЩИТА.
+// Стенд проверяет, что кличка конкретного агента НЕ попала в код: имя стоит
+// внутри отрицания (!/.../.test(...)), то есть проверка краснеет, если имя
+// появится в предмете. Уберёшь эти два вхождения «чтобы обезличить файл» —
+// снимешь единственную проверку от возврата клички. Защита, выглядящая как
+// грязь, вычищается из лучших побуждений; поэтому объяснение стоит здесь, а не
+// в отчёте, который читатель файла не увидит.
+// 2. Ветка отказа чужому: используется who_, а НЕ who (та затенена msg.from).
+const alertLine = s.split('\n').find((l) => l.includes('Чужой написал'));
+t('тревога о чужом использует who_', !!alertLine && /\$\{who_\}/.test(alertLine), String(alertLine));
+t('тревога о чужом без клички соседа', !!alertLine && !/Петрович/.test(alertLine), String(alertLine));
+
+// 3. Затенение существует — значит who_ не блажь: проверяем фактом по файлу.
+t('внутри ветки чужого who действительно затенена',
+  /const who = msg\.from \?\? \{\};/.test(s),
+  `затенений найдено: ${(s.match(/const who = msg\.from \?\? \{\};/g) ?? []).length}`);
+
+// 4. Приветствие /start.
+const hi = s.split('\n').find((l) => l.includes('на связи. Пишите задачу'));
+t('приветствие использует who_', !!hi && /\$\{who_\}/.test(hi), String(hi));
+t('приветствие без клички соседа', !!hi && !/Петрович/.test(hi), String(hi));
+
+// 5. Поведение подстановки — проверяем ИСПОЛНЕНИЕМ, а не глазом.
+// 🔴 Проверки 5-6 требуют объявления who_ и строки тревоги. Нет их — стенд обязан
+// СКАЗАТЬ, что не смог измерить, а не упасть сырым TypeError: падение читается
+// как «стенд сломан», хотя сломан предмет. Отделяем слепоту от отказа.
+if (!decl || !alertLine) {
+  console.log('---  подстановка и умолчание НЕ ПРОВЕРЕНЫ: нет объявления who_ или строки тревоги');
+} else {
+  // Фикстура НЕЙТРАЛЬНАЯ: годится любое имя, и частное было выбрано по привычке.
+  // Файл едет в пакет — частное имя увидел бы каждый установивший.
+  const config = { agentName: 'агент-проба' };
+  const who_ = eval(decl[1]);
+  const who = { first_name: 'Чужой' };            // то самое затенение
+  const alert = eval('`' + alertLine.split('`')[1] + '`');
+  t('подстановка даёт имя, а не [object Object]',
+    alert.includes('агент-проба') && !alert.includes('[object Object]'), alert.trim());
+
+  // 6. Умолчание, когда agentName не задан.
+  const config2 = {}; const who2 = eval(decl[1].replace('config.', 'config2.'));
+  t('без настройки — нейтральное слово, не пусто', who2 === 'агент', String(who2));
+}
+
+// 7. Команда расшифровки — настройкой, с громким отказом.
+t('расшифровка берётся из config.transcribeCommand',
+  /execFileSync\(config\.transcribeCommand,/.test(s), 'execFileSync(config.transcribeCommand,');
+t('зашитого пути расшифровки не осталось',
+  !/execFileSync\('\/usr\/local\/bin\//.test(s),
+  `зашитых вызовов: ${(s.match(/execFileSync\('\/usr\/local\/bin\/[^']*'/g) ?? []).join(', ') || 'нет'}`);
+t('не задана — говорит в журнал и возвращает null',
+  /не задан config\.transcribeCommand/.test(s),
+  `вхождений строки отказа: ${(s.match(/не задан config\.transcribeCommand/g) ?? []).length}`);
+
+// 8. sayTo: каталог обмена не задан — сказать, а не падать в mkdirSync(undefined).
+const sayTo = s.slice(s.indexOf('async function sayTo'), s.indexOf('async function sayTo') + 600);
+t('sayTo проверяет A2A_OUT ДО mkdirSync',
+  sayTo.indexOf('if (!A2A_OUT)') > -1 && sayTo.indexOf('if (!A2A_OUT)') < sayTo.indexOf('mkdirSync'),
+  sayTo.split('\n').slice(1, 4).join(' | '));
+
+// 9. НАШ вид источника не потерян (его отсутствие сняло бы право в мосте).
+t('source kind a2a сохранён', /source: \{ kind: 'a2a' \}/.test(s),
+  `видов источника в файле: ${(s.match(/source: \{ kind: '[^']+' \}/g) ?? []).join(', ') || 'ни одного'}`);
+
+// 10. Подсказка о правах не адресует чужой дом.
+t('подсказка о правах не называет чужого владельца',
+  !/chown dsh:dsh/.test(s), `вхождений «chown dsh:dsh»: ${(s.match(/chown dsh:dsh/g) ?? []).length}`);
+
+// 11. Устаревшее про «общий модуль» вычищено.
+t('нет утверждения «модуль общий для машины»',
+  !/модуль общий для машины/.test(s),
+  `вхождений: ${(s.match(/модуль общий для машины/g) ?? []).length}`);
+
+console.log(`\nИТОГ: ok=${ok} fail=${fail} слепота=${slep}`);
+// 🔴 Код 0 ТОЛЬКО когда всё состоялось и сошлось. Слепота — код 2: «проверить
+// нечем» и «проверил, всё хорошо» это разные новости, и машина, читающая код,
+// не должна принимать первое за второе.
+process.exit(fail ? 1 : slep ? 2 : 0);

package/test/stend-yashchika-shiny.mjs

@@ -0,0 +1,184 @@
+// Стенд замыкания выхода шины A2A: чтение ящика модулем связи.
+// Текст функций берётся ИЗ файла предмета и ИСПОЛНЯЕТСЯ на подставном ящике.
+// Боевой ящик не трогается ни на одном шаге.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const SRC = process.argv[2] || new URL('../src/index.js', import.meta.url).pathname;
+let s;
+try { s = fs.readFileSync(SRC, 'utf-8'); }
+catch (e) { console.log(`СЛЕПОТА: не читается ${SRC} — ${e.code || e.message}`); process.exit(2); }
+
+let ok = 0, fail = 0, slep = 0;
+const t = (n, c, syr) => { if (c) { ok++; console.log(`ok   ${n}`); }
+  else { fail++; console.log(`FAIL ${n}\n     сырьё: ${syr}`); } };
+const sl = (n, p) => { slep++; console.log(`СЛЕПОТА ${n}: ${p}`); };
+
+// ── извлечение функций ИЗ предмета ───────────────────────────────────────────
+function vynut(imya) {
+  const i = s.indexOf(`  function ${imya}(`) >= 0
+    ? s.indexOf(`  function ${imya}(`) : s.indexOf(`  async function ${imya}(`);
+  if (i < 0) return null;
+  const j = s.indexOf('\n  }\n', i);
+  return j < 0 ? null : s.slice(i, j + 5);
+}
+const tSender = vynut('spoolSender');
+const tAge = vynut('spoolAgeHours');
+const tPoll = vynut('pollSpool');
+if (!tSender || !tAge || !tPoll) {
+  sl('извлечение', `spoolSender=${!!tSender} spoolAgeHours=${!!tAge} pollSpool=${!!tPoll}`);
+  console.log(`ИТОГО: сошлось ${ok}, расхождений ${fail}, слепот ${slep}`);
+  process.exit(2);
+}
+
+// ── 1. настройка, а не константа ─────────────────────────────────────────────
+const declIn = s.match(/const SPOOL_IN = ([^;]+);/);
+t('путь ящика — настройка config.spoolDir, не константа',
+  !!declIn && /config\.spoolDir/.test(declIn[1]) && !/\/var\/spool/.test(declIn[1]),
+  declIn ? declIn[1] : '(объявления нет)');
+const declB = s.match(/const SPOOL_BATCH = ([^;]+);/);
+t('порог пачки — настройка', !!declB && /config\.spoolBatchCount/.test(declB[1]),
+  declB ? declB[1] : '(нет)');
+const declS = s.match(/const SPOOL_STALE_HOURS = ([^;]+);/);
+t('порог возраста — настройка', !!declS && /config\.spoolStaleHours/.test(declS[1]),
+  declS ? declS[1] : '(нет)');
+
+// ── 2. вызов в цикле опроса ──────────────────────────────────────────────────
+t('pollSpool зовётся из цикла опроса', /await pollSpool\(\);/.test(s),
+  `вхождений: ${(s.match(/await pollSpool\(\)/g) ?? []).length}`);
+
+// ── 3. удаление ПОСЛЕ передачи, а не до ──────────────────────────────────────
+const posle = tPoll.indexOf('handle.agent.send');
+const unl = tPoll.indexOf('unlinkSync(p.full)');
+t('удаление письма стоит ПОСЛЕ передачи агенту', posle > 0 && unl > posle,
+  `send@${posle} unlink@${unl}`);
+t('команды /goal из ящика НЕ принимаются', !/\/goal/.test(tPoll),
+  `вхождений /goal в pollSpool: ${(tPoll.match(/\/goal/g) ?? []).length}`);
+
+// ── исполнение: разбор имени и возраст ───────────────────────────────────────
+const mkFn = (txt, args) => new Function(...args, `${txt}\n return arguments.callee;`);
+const sender = new Function('fs', `${tSender}\n return spoolSender;`)(fs);
+t('отправитель из имени: dsh', sender('20260829T205711Z-dsh-af8b9699.txt') === 'dsh',
+  sender('20260829T205711Z-dsh-af8b9699.txt'));
+t('имя не по форме — сказано прямо, а не пусто',
+  sender('pismo.txt') === '(имя не разобрано)', sender('pismo.txt'));
+
+const ageFn = new Function('fs', `${tAge}\n return spoolAgeHours;`)(fs);
+const svezh = new Date(Date.now() - 3600000).toISOString().replace(/[-:]/g, '').slice(0, 15) + 'Z';
+const a1 = ageFn(`${svezh}-dsh-x.txt`, '/nonexistent');
+t('возраст свежего письма около 1 часа', a1 > 0.5 && a1 < 1.5, String(a1));
+const a2 = ageFn('20260829T205711Z-dsh-x.txt', '/nonexistent');
+t('возраст письма от 29.08 больше 12 часов', a2 > 12, String(a2));
+
+// ── исполнение pollSpool на подставном ящике ─────────────────────────────────
+function progon(pisma, opts = {}) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'stend-spool-'));
+  for (const [name, body] of pisma) fs.writeFileSync(path.join(dir, name), body);
+  const zhurnal = [];
+  const podano = [];
+  const env = {
+    fs, path,
+    SPOOL_IN: opts.brokenDir ? path.join(dir, 'net-takogo') : dir,
+    SPOOL_BATCH: opts.batch ?? 5,
+    SPOOL_STALE_HOURS: opts.stale ?? 12,
+    A2A_EXT: ['.txt', '.md'],
+    A2A_CHAT: 'a2a',
+    a2aReported: opts.reported ?? new Set(),
+    log: (m) => zhurnal.push(String(m)),
+    stripMark: (x) => x,
+    lastOrigin: new Map(),
+    pushAsk: () => {},
+    copyAsk: () => {},
+    nudgeUntilClaimed: () => {},
+    platform: { createUserMessage: (m) => m },
+    agentFor: async () => {
+      if (opts.otkazPeredachi) throw new Error('фабрика агентов не поднялась');
+      return { handle: { agent: { send: (m) => podano.push(m.content[0].text) } }, sessionId: 's1' };
+    },
+    spoolSender: sender,
+    spoolAgeHours: ageFn,
+  };
+  const argsN = Object.keys(env);
+  const fn = new Function(...argsN, `${tPoll}\n return pollSpool;`)(...argsN.map((k) => env[k]));
+  // 🔴 УБИРАЕМ ЗА СОБОЙ. Первая редакция оставила 89 каталогов в /tmp за один
+  // заход: стенд создавал mkdtemp и не удалял. Механизм, копящий в ОБЩЕМ
+  // каталоге, — наш известный класс (долг 40), и завести его в приёмке,
+  // которая гоняется ежедневно, значит копить молча.
+  return fn().then(() => {
+    const itog = {
+      dir, zhurnal, podano,
+      ostalos: fs.existsSync(dir) ? fs.readdirSync(dir) : [],
+    };
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* уже нет */ }
+    return itog;
+  });
+}
+
+const R = {};
+// 🔴 Метка времени СВЕЖЕГО письма вычисляется, а не зашивается: с зашитой датой
+// стенд протухает через 12 часов и краснеет на исправном предмете —
+// «свежее письмо несёт пометку возраста». Проверено 01.09.2026: зашитая
+// вчерашняя дата дала возраст 28 ч.
+const svezhaya = new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z');
+R.odno = await progon([[`${svezhaya}-dsh-aaa.txt`, 'привет из ящика']]);
+t('письмо из ящика подано агенту', R.odno.podano.length === 1, JSON.stringify(R.odno.podano));
+t('в тексте метка отправителя', /от агента dsh/.test(R.odno.podano[0] ?? ''), R.odno.podano[0]);
+t('прочитанное удалено из ящика', R.odno.ostalos.length === 0, JSON.stringify(R.odno.ostalos));
+t('в журнале сказано о принятии', R.odno.zhurnal.some((l) => /\[ящик\] принято/.test(l)),
+  JSON.stringify(R.odno.zhurnal));
+
+R.povtor = await progon([]);
+t('пустой ящик — ни одной строки в журнале', R.povtor.zhurnal.length === 0,
+  JSON.stringify(R.povtor.zhurnal));
+
+R.staroe = await progon([['20260829T205711Z-dsh-bbb.txt', 'старое письмо']]);
+t('старое письмо несёт пометку возраста',
+  /пролежало в ящике \d+ ч/.test(R.staroe.podano[0] ?? ''), R.staroe.podano[0]);
+t('свежее письмо пометки возраста НЕ несёт (зрячесть)',
+  !/пролежало в ящике/.test(R.odno.podano[0] ?? ''), R.odno.podano[0]);
+
+R.pachka = await progon(Array.from({ length: 6 }, (_, i) =>
+  [`2026083109000${i}Z-dsh-c${i}.txt`, `письмо ${i}`]));
+t('шесть писем поданы ОДНИМ ходом', R.pachka.podano.length === 1,
+  `подач: ${R.pachka.podano.length}`);
+t('в пачке названо число писем', /6 писем из ящика одной пачкой/.test(R.pachka.podano[0] ?? ''),
+  (R.pachka.podano[0] ?? '').slice(0, 80));
+t('пачка убрана из ящика целиком', R.pachka.ostalos.length === 0, JSON.stringify(R.pachka.ostalos));
+
+R.pyat = await progon(Array.from({ length: 5 }, (_, i) =>
+  [`2026083109000${i}Z-dsh-d${i}.txt`, `письмо ${i}`]));
+t('пять писем поданы ПО ОДНОМУ (зрячесть порога пачки)', R.pyat.podano.length === 5,
+  `подач: ${R.pyat.podano.length}`);
+
+R.otkaz = await progon([[`${svezhaya}-dsh-eee.txt`, 'письмо']], { otkazPeredachi: true });
+t('при отказе передачи письмо ОСТАВЛЕНО', R.otkaz.ostalos.length === 1,
+  JSON.stringify(R.otkaz.ostalos));
+t('при отказе передачи сказано вслух',
+  R.otkaz.zhurnal.some((l) => /ОСТАВЛЕНЫ/.test(l)), JSON.stringify(R.otkaz.zhurnal));
+
+R.pusto = await progon([[`${svezhaya}-dsh-fff.txt`, '   ']]);
+t('пустое письмо убрано без подачи',
+  R.pusto.podano.length === 0 && R.pusto.ostalos.length === 0,
+  `подано ${R.pusto.podano.length}, осталось ${JSON.stringify(R.pusto.ostalos)}`);
+
+R.chuzhoe = await progon([[`${svezhaya}-dsh-ggg.pdf`, 'бинарь']]);
+t('чужое расширение не подано, имя названо',
+  R.chuzhoe.podano.length === 0 && R.chuzhoe.zhurnal.some((l) => /НЕ ВЗЯТ/.test(l)),
+  JSON.stringify(R.chuzhoe.zhurnal));
+t('чужое расширение оставлено в ящике, а не стёрто', R.chuzhoe.ostalos.length === 1,
+  JSON.stringify(R.chuzhoe.ostalos));
+
+R.nedostup = await progon([], { brokenDir: true });
+t('недоступный ящик — громкая строка один раз',
+  R.nedostup.zhurnal.filter((l) => /недоступен/.test(l)).length === 1,
+  JSON.stringify(R.nedostup.zhurnal));
+
+// ── канарейка точного числа ──────────────────────────────────────────────────
+const ZHDYOM = 27;
+console.log(`ИТОГО: сошлось ${ok}, расхождений ${fail}, слепот ${slep}`);
+if (ok + fail !== ZHDYOM) {
+  console.log(`СЛЕПОТА: проведено ${ok + fail} проверок, ждали ${ZHDYOM} — часть не состоялась`);
+  process.exit(2);
+}
+process.exit(fail ? 1 : 0);

package/test/test-goal-control.mjs

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+/**
+ * Приёмка постановки цели из канала.
+ *
+ * Правила, по которым он написан:
+ *  — текст проверяемых функций берётся ИЗ ФАЙЛА пакета, а не пишется заново;
+ *  — рядом с вердиктом печатается сырьё, на котором он основан;
+ *  — код возврата: 0 всё сошлось, 1 расхождение, 2 стенд не смог проверить.
+ *
+ * Гоняется и на распакованном тарболе: `node test/test-goal-control.mjs`.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readSource, extractFunction, extractConst } from './extract.mjs';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const PKG = path.resolve(HERE, '..');
+const SRC_FILE = path.join(PKG, 'src', 'index.js');
+
+let ok = 0, bad = 0, blind = 0;
+const pass = (t, raw) => { ok++; console.log(`  ok   ${t}${raw !== undefined ? `   [${raw}]` : ''}`); };
+const fail = (t, raw) => { bad++; console.log(`  FAIL ${t}${raw !== undefined ? `   [${raw}]` : ''}`); };
+const blin = (t, raw) => { blind++; console.log(`  ??   ${t} — СТЕНД НЕ СМОГ ПРОВЕРИТЬ${raw !== undefined ? `   [${raw}]` : ''}`); };
+const eq = (t, got, want) => (String(got) === String(want) ? pass(t, `got=${got}`) : fail(t, `got=${got} want=${want}`));
+
+let src;
+try { src = readSource(SRC_FILE); }
+catch (e) { console.error(`СТЕНД СЛЕП: не читается ${SRC_FILE}: ${e.message}`); process.exit(2); }
+
+// ── 0. Манифест не обещает того, чего нет на диске ────────────────────────────
+console.log('0. целость манифеста');
+try {
+  const pj = JSON.parse(fs.readFileSync(path.join(PKG, 'package.json'), 'utf-8'));
+  const promised = new Set([...(pj.files ?? []), pj.main, pj.dsh?.bundle?.patch].filter(Boolean)
+    .map((f) => f.replace(/^\.\//, '')));
+  for (const f of promised) {
+    fs.existsSync(path.join(PKG, f))
+      ? pass(`манифест обещает ${f} — файл на месте`)
+      : fail(`манифест обещает ${f}, а его на диске НЕТ`);
+  }
+  // 🔴 НЕ сверяем с зашитым номером: такой стенд краснеет на КАЖДОМ выпуске и
+  // его перестают читать. Проверяем форму — версия есть и она трёхчастная.
+  /^\d+\.\d+\.\d+$/.test(String(pj.version || ''))
+    ? pass('версия объявлена и имеет форму X.Y.Z', `got=${pj.version}`)
+    : fail('версия объявлена и имеет форму X.Y.Z', `got=${pj.version}`);
+} catch (e) { blin('манифест', e.message); }
+
+// ── 1. Счётчик постановок ─────────────────────────────────────────────────────
+console.log('1. счётчик постановок');
+try {
+  const MAX = Number(extractConst(src, 'GOAL_MAX_PER_HOUR'));
+  eq('предел из файла', MAX, 3);
+  const goalStarts = new Map();
+  const goalRateOk = new Function('goalStarts', 'GOAL_MAX_PER_HOUR',
+    `${extractFunction(src, 'goalRateOk')}; return goalRateOk;`)(goalStarts, MAX);
+  let allowed = 0;
+  for (let i = 0; i < 5; i++) if (goalRateOk('tg')) { allowed++; goalStarts.get('tg').push(Date.now()); }
+  eq(`из пяти подряд пропущено ${MAX}`, allowed, MAX);
+  // старые метки выпадают из скользящего часа
+  goalStarts.set('tg', [Date.now() - 3600001, Date.now() - 3600001, Date.now() - 3600001]);
+  eq('метки старше часа не считаются', goalRateOk('tg'), true);
+  // счётчик отдельный на канал
+  goalStarts.set('tg', [Date.now(), Date.now(), Date.now()]);
+  eq('канал tg исчерпан', goalRateOk('tg'), false);
+  eq('канал a2a при этом свободен', goalRateOk('a2a'), true);
+} catch (e) { blin('счётчик', e.message); }
+
+// ── 2. Заголовок отправителя ──────────────────────────────────────────────────
+console.log('2. заголовок отправителя');
+try {
+  const splitSender = new Function(`${extractFunction(src, 'splitSender')}; return splitSender;`)();
+  let r = splitSender('From: coordinator\n/goal сделать дело');
+  eq('имя разобрано', r.sender, 'coordinator');
+  eq('заголовок отрезан', r.text, '/goal сделать дело');
+  r = splitSender('просто текст без заголовка');
+  eq('без заголовка — имени нет', r.sender, undefined);
+  eq('без заголовка текст цел', r.text, 'просто текст без заголовка');
+  r = splitSender('From: coordinator');
+  eq('заголовок без тела — пустой текст', r.text, '');
+  r = splitSender('From: two words\nтело');
+  eq('имя с пробелом заголовком не считается', r.sender, undefined);
+} catch (e) { blin('splitSender', e.message); }
+
+// ── 3. Ожидание сервиса ───────────────────────────────────────────────────────
+console.log('3. ожидание сервиса');
+try {
+  const lines = [];
+  const log = (m) => lines.push(m);
+  const mk = (ctx) => new Function('ctx', 'log', `${extractFunction(src, 'waitService')}; return waitService;`)(ctx, log);
+
+  let calls = 0;
+  const late = mk({ get: () => (++calls >= 3 ? { real: true } : undefined) });
+  const t0 = Date.now();
+  const got = await late('goals', '[t]', 'последствие названо', 5);
+  const spent = Date.now() - t0;
+  got ? pass(`сервис дождались за ${spent} мс`, `попыток=${calls}`) : fail('сервис не дождались, хотя он появился');
+  lines.some((l) => l.includes('ещё не активен')) ? pass('о начале ожидания сказано') : fail('ожидание молчаливое');
+
+  lines.length = 0;
+  const never = mk({ get: () => undefined });
+  const none = await never('goals', '[t]', 'ПОСЛЕДСТВИЕ-МЕТКА', 2);
+  eq('не дождались — undefined', none, undefined);
+  lines.some((l) => l.includes('ПОСЛЕДСТВИЕ-МЕТКА'))
+    ? pass('последствие названо в журнале', lines[lines.length - 1])
+    : fail('последствие НЕ названо', lines.join(' | '));
+
+  lines.length = 0;
+  const now = mk({ get: () => ({ real: true }) });
+  await now('goals', '[t]', 'последствие', 5);
+  lines.length === 0 ? pass('сервис готов сразу — лишних строк нет') : fail('печатает, когда ждать не пришлось', lines.join(' | '));
+} catch (e) { blin('waitService', e.message); }
+
+// ── 4. Команда целиком, на подставных сервисах ───────────────────────────────
+console.log('4. команда /goal на подставных сервисах');
+try {
+  const lines = [];
+  const log = (m) => lines.push(m);
+  const goalStarts = new Map();
+  const goalOrigin = new Map();
+  const agent = { session: { id: 'sess-1' } };
+  let created = null;
+  const goals = {
+    get: () => created,
+    create: (_a, { objective }) => (created = { id: 'g1', revision: 1, phase: 'active', roundsStarted: 0, maxGoalRounds: 12, objective }),
+    edit: (_a, _k, { objective }) => (created = { ...created, revision: created.revision + 1, objective }),
+    clear: () => { created = null; },
+  };
+  const marker = { guidance: (id, rev, tools) => `НАСТАВЛЕНИЕ ${id}/${rev} ${tools ? tools.update : 'без-инструментов'}` };
+  const bridge = { modelToolName: (n) => `mcp__srv__${n}` };
+  const services = { goals, goalMarker: marker, mcpBridge: bridge };
+  const ctx = { get: (n) => services[n] };
+
+  const src4 = `${extractFunction(src, 'waitService')}\n${extractFunction(src, 'goalRateOk')}\n${extractFunction(src, 'goalCommand')}\n; return goalCommand;`;
+  const goalCommand = new Function('ctx', 'log', 'goalStarts', 'goalOrigin', 'GOAL_MAX_PER_HOUR', 'GOAL_WAIT_TRIES', src4)(
+    ctx, log, goalStarts, goalOrigin, Number(extractConst(src, 'GOAL_MAX_PER_HOUR')), 1);
+
+  let r = await goalCommand('/goal', 'tg', agent);
+  eq('цели нет — так и сказано', r, 'Цели нет.');
+
+  r = await goalCommand('/goal разобрать отказы', 'tg', agent);
+  r.includes('поставлена') ? pass('цель поставлена', r) : fail('цель не поставлена', r);
+  created.objective.includes('НАСТАВЛЕНИЕ g1/2 mcp__srv__update_goal')
+    ? pass('наставление сложено с именем инструмента ОТ МОСТА', created.objective.split('\n').pop())
+    : fail('наставление без имени инструмента моста', created.objective);
+  eq('происхождение цели запомнено', goalOrigin.get('sess-1')?.channel, 'tg');
+
+  r = await goalCommand('/goal', 'tg', agent);
+  r.startsWith('Цель g1: active') ? pass('состояние показано', r.split('\n')[0]) : fail('состояние не показано', r);
+
+  r = await goalCommand('/goal stop', 'tg', agent);
+  eq('цель снята', r, 'Цель g1 снята.');
+  eq('происхождение забыто', goalOrigin.has('sess-1'), false);
+
+  // предел постановок
+  goalStarts.set('a2a', [Date.now(), Date.now(), Date.now()]);
+  r = await goalCommand('/goal ещё одна', 'a2a', agent);
+  r.includes('Предел') ? pass('четвёртая за час отвергнута', r) : fail('предел не сработал', r);
+
+  // 🔴 снятие пределом НЕ ограничено — механизм, который нельзя выключить, хуже отсутствия
+  created = { id: 'g2', revision: 1, phase: 'active', roundsStarted: 1, maxGoalRounds: 12, objective: 'x' };
+  r = await goalCommand('/goal stop', 'a2a', agent);
+  eq('снятие при исчерпанном пределе разрешено', r, 'Цель g2 снята.');
+
+  // сервиса целей нет вовсе
+  const lines2 = [];
+  const goalCommand2 = new Function('ctx', 'log', 'goalStarts', 'goalOrigin', 'GOAL_MAX_PER_HOUR', 'GOAL_WAIT_TRIES', src4)(
+    { get: () => undefined }, (m) => lines2.push(m), new Map(), new Map(), 3, 1);
+  r = await goalCommand2('/goal что-нибудь', 'tg', agent);
+  r.includes('не подключён') ? pass('без сервиса целей отказ внятный', r) : fail('без сервиса целей ответ невнятный', r);
+  lines2.some((l) => l.includes('невыполнима')) ? pass('и последствие названо в журнале', lines2[lines2.length - 1]) : fail('журнал молчит об отказе', lines2.join(' | '));
+
+  // маркера нет — цель ставится, но об этом сказано
+  const lines3 = [];
+  let created3 = null;
+  const goals3 = { get: () => created3,
+    create: (_a, { objective }) => (created3 = { id: 'g3', revision: 1, phase: 'active', roundsStarted: 0, maxGoalRounds: 12, objective }),
+    edit: () => { throw new Error('edit не должен зваться без маркера'); }, clear: () => {} };
+  const goalCommand3 = new Function('ctx', 'log', 'goalStarts', 'goalOrigin', 'GOAL_MAX_PER_HOUR', 'GOAL_WAIT_TRIES', src4)(
+    { get: (n) => (n === 'goals' ? goals3 : undefined) }, (m) => lines3.push(m), new Map(), new Map(), 3, 1);
+  r = await goalCommand3('/goal без маркера', 'tg', agent);
+  r.includes('поставлена') ? pass('без маркера цель всё равно поставлена', r) : fail('без маркера постановка сорвалась', r);
+  lines3.some((l) => l.includes('goalMarker') && l.includes('предела раундов'))
+    ? pass('последствие отсутствия маркера названо')
+    : fail('об отсутствии маркера промолчали', lines3.join(' | '));
+} catch (e) { blin('goalCommand', e.message); }
+
+// ── 5. Описание не расходится с кодом ────────────────────────────────────────
+console.log('5. README, патч и код говорят одно');
+try {
+  const readme = fs.readFileSync(path.join(PKG, 'README.md'), 'utf-8');
+  const patch = fs.readFileSync(path.join(PKG, 'cordis.patch.yml'), 'utf-8');
+  for (const field of ['goalUsers', 'goalA2ASenders']) {
+    const inCode = src.includes(`config.${field}`);
+    const inReadme = readme.includes(`\`${field}\``);
+    const inPatch = patch.includes(`${field}:`);
+    (inCode && inReadme && inPatch)
+      ? pass(`${field}: код+README+патч`, `код=${inCode} readme=${inReadme} патч=${inPatch}`)
+      : fail(`${field} описан не везде`, `код=${inCode} readme=${inReadme} патч=${inPatch}`);
+  }
+  const maxInCode = extractConst(src, 'GOAL_MAX_PER_HOUR');
+  // 🔴 Сверяем ЧИСЛО из кода с числом в README, а не дословную фразу: проверка
+  // по формулировке ломается от любой переписки текста, и тогда стенд краснеет
+  // на исправном предмете. Ищем число рядом со словом про час.
+  // \b и \n в шаблонной строке JS — это backspace и перевод строки, а НЕ границы
+  // регулярного выражения: их надо удваивать. Первая редакция этого не делала и
+  // краснела на исправном README.
+  const predelVReadme = new RegExp(`\\b${maxInCode}\\b[^.\\n]{0,60}час`, 'i').test(readme)
+                     || new RegExp(`час[^.\\n]{0,60}\\b${maxInCode}\\b`, 'i').test(readme);
+  predelVReadme
+    ? pass('предел в README и в коде сходится', `код=${maxInCode}`)
+    : fail('предел в README разошёлся с кодом', `код=${maxInCode}, в README не найден рядом со словом «час»`);
+} catch (e) { blin('README', e.message); }
+
+// ── 6. Проверка «ничего нашего не уехало» ВЫНЕСЕНА ИЗ ПАКЕТА ───────────────
+// Она лежит рядом со сборкой (proverka-sborki.mjs) и в тарбол не едет.
+// Причина: её образцы — это и есть наши имена и пути, то есть проверка
+// обезличенности сама несла их в опубликованный файл. Обнаружено на
+// сборке 1.3.0: единственное вхождение имени агента в тарболе было
+// внутри самой этой проверки. Чужому человеку она бесполезна — это
+// проверка НАШЕГО процесса сборки, а не работы плагина.
+
+console.log(`\nитог: ok=${ok} FAIL=${bad} слепота=${blind}`);
+process.exit(bad > 0 ? 1 : (blind > 0 ? 2 : 0));