dsh-telegram-multiagent 1.4.0 → 1.4.1

package/README.md

@@ -132,6 +132,12 @@ MIT.
 файл пишет сам отправитель, там заголовок и есть его подпись. В обоих случаях это
 учёт, а не удостоверение личности.
 
+И третье следствие того же различия: **команды (`/goal`) из ящика не принимаются вовсе** —
+они живут только в канале a2a, где отправитель подписывает файл сам. Положив `/goal` в
+ящик, вы получите обычное письмо с этим текстом: ни выполнения, ни отказа. Право ставить
+цель поимённое, и проверять его по имени файла, которое задаёт посторонний процесс,
+означало бы раздать это право владельцу каталога.
+
 **Чтение писем из системного почтового ящика** (`spoolDir`). Письмо старше 12 часов
 подаётся с явной пометкой возраста — иначе двухсуточное письмо толкает отвечать на
 устаревшее. Больше пяти писем подаются одной пачкой, а не по одному. Ящик не задан —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-telegram-multiagent",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Канал Telegram для DeepSeek Harness: один модуль на машину обслуживает несколько агентов, у каждого свой бот, свой файл токена и свой список разрешённых. Метка отправителя неподделываема, память владельца и координатора слита в одну, режим доставки переключается файлом вне кода, цели управляются из канала.",
   "type": "module",
   "main": "src/index.js",
@@ -11,6 +11,7 @@
     "test/stend-imena.mjs",
     "test/stend-yashchika-shiny.mjs",
     "test/test-goal-control.mjs",
+    "test/stend-pobudki.mjs",
     "cordis.patch.yml",
     "README.md"
   ],

package/src/index.js

@@ -221,21 +221,57 @@ export function apply(ctx, config = {}) {
   // 🔴 НИКАКИХ ТИХИХ ВЫХОДОВ: каждая ветка что-то пишет в журнал. Ровно на этом
   // обжглись сегодня — `agent.inbox?.hasPending` при недоступном inbox даёт
   // undefined, условие «всё хорошо» проходит, и отказ маскируется под успех.
+  // ── ЧЕТЫРЕ ИСХОДА ВМЕСТО ДВУХ (обосновано замером 01.09.2026).
+  // Прежняя редакция знала только «забрано» и «не забрали», и второе печаталось
+  // бедой. Замер за сутки: 48 писем принято, 45 строк «не забрали», побудок за всё
+  // время НОЛЬ, а настоящая задержка доставки — медиана 10 с. То есть беда
+  // объявлялась при штатной работе, 94 раза из 100.
+  //
+  // Две причины, обе исправлены здесь:
+  //  1) проверка «забрано ли» стояла ПОСЛЕ проверки занятости, и при занятом агенте
+  //     очередь не смотрелась вовсе — выйти из цикла было структурно нельзя, пока
+  //     агент работает. Теперь состояние очереди проверяется ПЕРВЫМ и от занятости
+  //     не зависит: забрано — значит забрано, кто бы чем ни был занят;
+  //  2) «агент был занят весь срок» и «агент свободен, а письмо висит» — разные
+  //     новости. Первое — сведение о штатном состоянии, второе — отказ механизма.
+  //     Раньше обе давали одну красную строку, и настоящий отказ утонул бы в шуме.
+  //
+  // 🔴 ГДЕ НЕ ПРИМЕНЯЕТСЯ И ЧЕГО НЕ ЛОВИТ:
+  //  • это наблюдение, а не доставка: письмо доходит и без побудки, платформа
+  //    заберёт его на следующем ходе. Молчание механизма не означает потери;
+  //  • «занят все проверки» не доказывает, что письмо доставлено — только что
+  //    будить было некого. Момент забора виден лишь при выходе по пустой очереди;
+  //  • очередь, опустевшая уже на первой проверке, неотличима от «письмо вклеено
+  //    в идущий ход» — поэтому такой случай помечается отдельно, а не молчит.
+  //
+  // 🔴 НИКАКИХ ТИХИХ ВЫХОДОВ: каждая ветка что-то пишет в журнал.
   function nudgeUntilClaimed(agent, tag, budgetMs = 120000) {
     void (async () => {
-      const deadline = Date.now() + budgetMs;
-      let woke = 0;
+      const nachato = Date.now();
+      const deadline = nachato + budgetMs;
+      let woke = 0;       // сколько раз будили
+      let proverok = 0;   // сколько проходов сделали
+      let zanyat = 0;     // из них пришлось на занятого агента
+      let videliOchered = false;  // видели ли очередь непустой хоть раз
       while (Date.now() < deadline) {
         await new Promise((r) => setTimeout(r, 500));
+        proverok += 1;
         if (typeof agent?.inbox?.hasPending !== 'boolean') {
           log(`${tag} 🔴 очередь агента недоступна — добивать побудку нечем`);
           return;
         }
-        if (agent.status === 'running') continue;
+        // Забрано ли — вопрос о ПИСЬМЕ, а не об агенте. Спрашиваем всегда.
         if (!agent.inbox.hasPending) {
-          if (woke) log(`${tag} сообщение забрано после ${woke} повторных побудок`);
+          const sek = ((Date.now() - nachato) / 1000).toFixed(1);
+          const primech = videliOchered
+            ? ''
+            : ' (очередь была пуста уже на первой проверке — вероятно, письмо вклеено в идущий ход)';
+          log(`${tag} сообщение забрано за ${sek} с: побудок ${woke}, проверок ${proverok}${primech}`);
           return;
         }
+        videliOchered = true;
+        // А вот будить — вопрос об АГЕНТЕ: занятого будить незачем и нечем.
+        if (agent.status === 'running') { zanyat += 1; continue; }
         if (typeof agent.wakeDriver !== 'function') {
           log(`${tag} 🔴 сообщение висит в очереди, а wakeDriver недоступен`);
           return;
@@ -243,7 +279,11 @@ export function apply(ctx, config = {}) {
         agent.wakeDriver();
         woke += 1;
       }
-      log(`${tag} 🔴 за ${budgetMs} мс сообщение так и не забрали (побудок: ${woke})`);
+      if (proverok > 0 && zanyat === proverok) {
+        log(`${tag} письмо ещё в очереди спустя ${budgetMs} мс: агент был занят все ${zanyat} проверок из ${proverok} — будить было некого, состояние штатное`);
+      } else {
+        log(`${tag} 🔴 за ${budgetMs} мс сообщение так и не забрали: агент был свободен ${proverok - zanyat} проверок из ${proverok}, побудок ${woke} — побудка не помогла`);
+      }
     })();
   }
 

package/test/stend-imena.mjs

@@ -64,7 +64,17 @@ if (Array.isArray(SPISOK_IMEN) && SPISOK_IMEN.length) {
 // 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));
+// 🔴 ИСКОМОЕ ИМЯ — ДАННЫМИ, А НЕ ЛИТЕРАЛОМ. Прежняя редакция несла кличку
+// соседа прямо здесь: проверка была верной, но сама публиковала то, что искала —
+// файл уезжает в пакет. Теперь кличка берётся из списка вне пакета; нет списка —
+// СЛЕПОТА, а не молчаливое «чисто» (у постороннего проверять нечем по построению).
+const netKlichki = (line) => !SPISOK_IMEN.some((im) => line.includes(im));
+if (Array.isArray(SPISOK_IMEN) && SPISOK_IMEN.length) {
+  t('тревога о чужом без клички соседа', !!alertLine && netKlichki(alertLine), String(alertLine));
+} else {
+  console.log('---  кличка не проверена в строке тревоги: списка имён нет');
+  slep += 1;
+}
 
 // 3. Затенение существует — значит who_ не блажь: проверяем фактом по файлу.
 t('внутри ветки чужого who действительно затенена',
@@ -74,7 +84,12 @@ t('внутри ветки чужого who действительно зате
 // 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));
+if (Array.isArray(SPISOK_IMEN) && SPISOK_IMEN.length) {
+  t('приветствие без клички соседа', !!hi && netKlichki(hi), String(hi));
+} else {
+  console.log('---  кличка не проверена в приветствии: списка имён нет');
+  slep += 1;
+}
 
 // 5. Поведение подстановки — проверяем ИСПОЛНЕНИЕМ, а не глазом.
 // 🔴 Проверки 5-6 требуют объявления who_ и строки тревоги. Нет их — стенд обязан

package/test/stend-pobudki.mjs

@@ -0,0 +1,142 @@
+// Стенд различения исходов побудки в модуле связи.
+// Текст функции берётся ИЗ файла предмета и ИСПОЛНЯЕТСЯ на подставных агентах.
+// Ни платформа, ни живая очередь не задействованы ни на одном шаге.
+//
+// Зачем стенд: механизм печатал беду при штатной работе — «не забрали» в 45 случаях
+// из 48 за сутки, при нулевом числе побудок. Здесь проверяется, что четыре исхода
+// различаются и что беда осталась только там, где механизм действительно не сработал.
+import fs from 'node:fs';
+
+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}(`);
+  if (i < 0) return null;
+  const j = s.indexOf('\n  }\n', i);
+  return j < 0 ? null : s.slice(i, j + 5);
+}
+const txt = vynut('nudgeUntilClaimed');
+if (!txt) {
+  sl('извлечение', 'функция nudgeUntilClaimed в предмете не найдена');
+  console.log(`ИТОГО: сошлось ${ok}, расхождений ${fail}, слепот ${slep}`);
+  process.exit(2);
+}
+
+// ── 1. порядок проверок: очередь спрашивается ДО занятости ───────────────────
+const iPending = txt.indexOf('!agent.inbox.hasPending');
+const iRunning = txt.indexOf("agent.status === 'running'");
+t('проверка «забрано ли» стоит ДО проверки занятости',
+  iPending > 0 && iRunning > 0 && iPending < iRunning,
+  `hasPending@${iPending} running@${iRunning}`);
+
+// ── 2. счётчики объявлены ────────────────────────────────────────────────────
+for (const im of ['proverok', 'zanyat']) {
+  t(`счётчик ${im} объявлен`, new RegExp(`let ${im} = 0`).test(txt), `в тексте: ${txt.includes(im)}`);
+}
+
+// ── исполнение на подставных агентах ─────────────────────────────────────────
+const mk = () => new Function('log', `${txt}\n return nudgeUntilClaimed;`);
+const BUDGET = 1600;               // 3 прохода по 500 мс
+const ZHDAT = BUDGET + 900;
+
+async function progon(agent) {
+  const stroki = [];
+  let fn;
+  try { fn = mk()((m) => stroki.push(String(m))); }
+  catch (e) { return { stroki: [], oshibka: e.message }; }
+  fn(agent, '[проба]', BUDGET);
+  await new Promise((r) => setTimeout(r, ZHDAT));
+  return { stroki, oshibka: null };
+}
+
+// счётчик обращений к очереди — им проверяем, что проверки реально шли
+const agentZanyat = (pending) => {
+  let n = 0;
+  return { status: 'running', get inbox() { return { get hasPending() { n++; return pending; } }; },
+           wakeDriver() {}, get _n() { return n; } };
+};
+const agentSvoboden = (pendingFn, wake) => ({
+  status: 'idle', inbox: { get hasPending() { return pendingFn(); } }, wakeDriver: wake,
+});
+
+const R = {};
+R.zanyat   = await progon(agentZanyat(true));
+R.zabrano  = await progon(agentSvoboden(((c) => () => ++c <= 2)(0), () => {}));
+R.srazu    = await progon(agentSvoboden(() => false, () => {}));
+let vzyato = 0, zn = 0;
+R.svoboden = await progon(agentSvoboden(() => true, () => { vzyato++; }));
+R.netOch   = await progon({ status: 'idle', inbox: { hasPending: undefined }, wakeDriver: () => {} });
+R.netWake  = await progon({ status: 'idle', inbox: { hasPending: true }, wakeDriver: null });
+
+const odna = (r) => (r.stroki.length === 1 ? r.stroki[0] : `(строк ${r.stroki.length})`);
+
+// ── 3. занят весь срок — СВЕДЕНИЕ, не беда ───────────────────────────────────
+t('занят весь срок: строка есть и она НЕ беда',
+  R.zanyat.stroki.length === 1 && !/🔴/.test(odna(R.zanyat)), odna(R.zanyat));
+t('занят весь срок: названо ЧИСЛО проверок',
+  /занят все \d+ проверок из \d+/.test(odna(R.zanyat)), odna(R.zanyat));
+t('занят весь срок: сказано, что состояние штатное',
+  /штатн/.test(odna(R.zanyat)), odna(R.zanyat));
+
+// ── 4. письмо забрано ────────────────────────────────────────────────────────
+t('забрано: строка есть и она НЕ беда',
+  R.zabrano.stroki.length === 1 && !/🔴/.test(odna(R.zabrano)), odna(R.zabrano));
+t('забрано: названо время и число проверок',
+  /забрано за [\d.]+ с: побудок \d+, проверок \d+/.test(odna(R.zabrano)), odna(R.zabrano));
+t('забрано после побудок: побудок больше нуля',
+  /побудок [1-9]/.test(odna(R.zabrano)), odna(R.zabrano));
+t('забрано после побудок: пометки про первую проверку НЕТ',
+  !/пуста уже на первой/.test(odna(R.zabrano)), odna(R.zabrano));
+
+// ── 5. очередь пуста сразу — помечается отдельно ─────────────────────────────
+t('пусто с первой проверки: случай помечен вслух',
+  /пуста уже на первой проверке/.test(odna(R.srazu)), odna(R.srazu));
+t('пусто с первой проверки: это НЕ беда',
+  !/🔴/.test(odna(R.srazu)), odna(R.srazu));
+
+// ── 6. свободен, а письмо висит — БЕДА (контроль зрячести) ───────────────────
+t('свободен и висит: строка помечена бедой',
+  /🔴/.test(odna(R.svoboden)), odna(R.svoboden));
+t('свободен и висит: названо, сколько проверок агент был свободен',
+  /свободен \d+ проверок из \d+/.test(odna(R.svoboden)), odna(R.svoboden));
+t('свободен и висит: побудки реально делались', vzyato > 0, `вызовов wakeDriver: ${vzyato}`);
+
+// ── 7. отказы устройства — беда ──────────────────────────────────────────────
+t('очередь недоступна: беда с причиной',
+  /🔴/.test(odna(R.netOch)) && /очередь агента недоступна/.test(odna(R.netOch)), odna(R.netOch));
+t('wakeDriver недоступен: беда с причиной',
+  /🔴/.test(odna(R.netWake)) && /wakeDriver недоступен/.test(odna(R.netWake)), odna(R.netWake));
+
+// ── 8. ни один исход не молчит ───────────────────────────────────────────────
+// ── 8а. ЗАНЯТ, но очередь опустела: письмо забрано, и это видно ──────────────
+// Ровно тот случай, ради которого проверка очереди вынесена вперёд: при прежнем
+// порядке занятость закрывала выход, и забранное письмо объявлялось незабранным.
+R.zanyatNoZabrano = await progon({
+  status: 'running',
+  inbox: { get hasPending() { return ++zn <= 2; } },
+  wakeDriver() {},
+});
+t('занят, но очередь опустела: сказано ЗАБРАНО, а не «занят весь срок»',
+  /забрано за/.test(odna(R.zanyatNoZabrano)) && !/занят все/.test(odna(R.zanyatNoZabrano)),
+  odna(R.zanyatNoZabrano));
+
+const molchat = Object.entries(R).filter(([, r]) => r.stroki.length === 0).map(([k]) => k);
+t('ни один из семи исходов не молчит', molchat.length === 0, `молчали: ${molchat.join(', ') || '—'}`);
+
+// ── итог ПЕРЕД канарейкой ────────────────────────────────────────────────────
+console.log(`ИТОГО: сошлось ${ok}, расхождений ${fail}, слепот ${slep}`);
+const ZHDYOM = 19;
+if (ok + fail + slep !== ZHDYOM) {
+  console.log(`🔴 КАНАРЕЙКА: проверок ${ok + fail + slep}, а стенд состоит из ${ZHDYOM}`);
+  process.exit(2);
+}
+process.exit(fail ? 1 : (slep ? 2 : 0));