dsh-telegram-multiagent 1.2.2 → 1.3.0

package/README.md

@@ -49,8 +49,10 @@ see "Where to put the row" below:
 | `a2aDir` | no | Directory for a file-based agent-to-agent channel (`in/`, `out/`). Omit and no such channel exists. |
 | `a2aSession` | no | Session id used for that channel. Default `a2a`. |
 | `transcribeCommand` | no | External command for voice messages: `<cmd> <audio-file> auto` → transcript on stdout. Omit and voice is politely refused. |
+| `goalUsers` | no | Telegram user ids allowed to run `/goal`. **Empty (default) = the command is refused for everyone.** Not inherited from `allowedUsers` on purpose: talking to an agent and starting a paid autonomous loop are different rights. |
+| `goalA2ASenders` | no | Sender names allowed to run `/goal` from the agent-to-agent channel. The sender names itself in the first line of the file (`From: <name>`) — this is bookkeeping, not authentication; see 1.3.0 below. |
 
-## Four things that cost us a day
+## Five things that cost us a day
 
 Each of these fails **while looking like success**. They are commented inline in the source; this is
 the short version.
@@ -74,6 +76,17 @@ session id makes the persistence layer abort *every* turn with an id-collision e
 "accepted the message and went quiet" — the turn honestly starts and dies in milliseconds. It works
 until the first restart, which is what makes it nasty. Use `resume()` when the session exists.
 
+**5. `ctx.get()` returns nothing *quietly* while a service is still starting.** cordis hands back
+`undefined` without throwing until the provider's fiber is active, so "this service is not in the
+build" and "this service is thirty milliseconds away" arrive as the same value. Code written as
+`const x = ctx.get('x'); if (x) {...}` then takes the "feature absent" branch and says nothing — the
+agent is assembled, answers, and never mentions what it lost. This bit us three times in three days:
+the agent factory (3), session persistence (4, the whole resume block was skipped), and the agent
+preset — where a neighbouring agent's toolset dropped from 33 tools to 3 with no error and no log
+line. Wait for the service with a stated deadline, and when the deadline passes, say so *and name
+the consequence*. One helper for all of them: a fix applied to the instance instead of the class
+guarantees a relapse, and the relapse looks like a new illness.
+
 ## Where to put the row
 
 In the `web` profile the common-plane tools are **disabled on purpose**; the toolset comes from the
@@ -160,3 +173,96 @@ MIT.
 
 **Урок общий:** канал доставки без повтора — это тихая потеря. Отказ, о котором никто не узнал,
 дороже отказа громкого: его невозможно даже сосчитать.
+
+## 1.3.0 — постановка цели прямо из канала
+
+🔴 **Зачем это вообще нужно.** Если цикл агента ведёт внешний движок — например, агент работает
+через подписку, а не через родной цикл платформы, — родные инструменты платформы до модели **не
+доходят вовсе**. Доходит только то, что имеет форму сообщения. Значит поставить агенту цель изнутри
+разговора нельзя: руками в веб-интерфейсе можно, а из чата нет. Здесь мы даём постановку из любого
+канала: сервису целей не нужен инструмент модели, он доступен коду плагина напрямую.
+
+Команды одинаковы в обоих каналах:
+
+```
+/goal                     показать состояние цели
+/goal <замысел>           поставить цель
+/goal stop                снять цель
+```
+
+**Кто вправе — двумя отдельными списками, оба по умолчанию ПУСТЫЕ, то есть команда отказывает
+всем.** Право не наследуется от `allowedUsers` сознательно: «с кем я разговариваю» и «кто вправе
+завести дорогой автономный цикл» — разные вопросы, а в `allowedUsers` завтра добавят гостя.
+
+```yaml
+goalUsers: [123456789]          # из Telegram — по числовому id
+goalA2ASenders: ["coordinator"] # из служебного канала — по имени в заголовке
+```
+
+🔴 **Чем за это платят, сказать обязано само описание.** Проверки платформы
+(`currentInitiator`, `hasDirectHumanInput`, права на корневого агента) живут в её инструменте целей
+и на этом пути **не участвуют**. Плагин не обходит политику — он пишет её заново, и две строки выше
+есть вся политика целиком. Ставя `goalUsers`, вы соглашаетесь именно на это.
+
+**Счётчик постановок: не более трёх за скользящий час на канал.** Предел раундов у платформы стоит
+на ЦЕЛЬ, а не на агента: новая цель — новый счётчик, и поток целей ничем не ограничен. А каталог
+входящих принадлежит самому агенту, то есть в автономном раунде он способен положить себе файл
+`/goal …` и продлить цикл собственными руками.
+
+🔴 **Где счётчик НЕ применяется — назвать важнее, чем сам счётчик.** Он защищает от РАЗГОНА:
+от петли, в которую механизм вошёл сам, от ошибки в коде, от лавины повторов. Он **не** защищает от
+намеренного действия агента с правами администратора: такой агент снимет и счётчик, и предел
+раундов одной командой. Изоляция здесь **поведенческая**, технической границы против самого агента
+не существует. Настоящий сторож живёт снаружи машины. Снятию цели (`/goal stop`) счётчик не мешает
+никогда: механизм, включаемый снаружи и невыключаемый, хуже отсутствия механизма.
+
+**Заголовок отправителя — учёт, а не защита.** Служебный канал файловый, и вид источника получает
+любое сообщение в нём; правом «всем, кто пишет в канал» вы раздали бы дорогие циклы кому попало.
+Поэтому отправитель называет себя первой строкой файла:
+
+```
+From: coordinator
+/goal разобрать вчерашние отказы и доложить
+```
+
+Имя подделает любой, кто может положить файл в каталог входящих. Настоящая граница здесь — права
+ОС на этот каталог. Нужна проверка сильнее самоназвания — это общий секрет в файле с правами, и
+заводить его надо отдельным решением, а не походя.
+
+**Об исходе цели плагин сообщает сам.** Доводчик платформы при упоре в предел раундов переводит
+цель в `blocked` — и делает это молча: снаружи автономный цикл просто перестаёт просыпаться, что
+неотличимо от поломки. Плагин говорит об исходе ровно один раз и в тот канал, из которого цель
+ставили.
+
+**Служебный маркер цели вырезается из всего, что уходит наружу.** Его дело — остановить цикл, а не
+попасть человеку в чат. Вырезается маркер последней строки; маркер в середине текста оставлен
+видимым нарочно — он и так отвергнут, и пусть будет заметен читателю.
+
+### Ожидание сервисов: где оно есть и где его нет — решение по каждому месту
+
+`ctx.get()` возвращает `undefined` **молча**, пока волокно поставщика не активно. «Сервиса нет в
+сборке» и «сервис ещё поднимается» приходят одним и тем же значением — и код, написанный как
+`const x = ctx.get('x'); if (x)`, тихо уходит по ветке «этой возможности просто нет».
+
+| место | ожидание | почему |
+|---|---|---|
+| заведение агента (пресет, модель, персистенция) | **есть**, до 30 с | идёт вплотную к подъёму платформы, отказ молчалив и разрушителен |
+| `/goal` → сервисы целей, маркера, моста | **есть**, коротко | ответ «сервис не подключён» был бы диагнозом, которого код поставить не может; но на том конце живой собеседник, и полминуты молчания в чате читаются как «бот умер» |
+| вырезание маркера из исходящего | **нет** | место синхронное, а отказ не молчалив: маркер уедет в чат видимым текстом |
+| сообщение об исходе цели | **нет** | сюда попадают только сессии, где цель уже поставлена, — значит пустота означает не «ещё не поднялся», а «сервис пропал», и это надо сказать, а не переждать |
+
+Замечено на живом: порядок готовности волокон **меняется от подъёма к подъёму**. В одном подъёме
+ждала фабрика агентов, в другом — набор пресета, причём гонка была в обоих. Значит судить о гонке
+по соседнему сервису нельзя, и ожидание ставится по устройству места, а не по тому, где однажды
+видели примету.
+
+### Чего эта версия НЕ делает
+
+- **не даёт модели инструмент постановки цели** — команда приходит от человека или от координатора
+  через канал, модель её не вызывает и в заголовке запроса плагин невидим;
+- **не заменяет права платформы** — она их здесь не применяет вовсе (см. выше);
+- **не защищает от агента с правами администратора** — вся защита поведенческая;
+- **не проверяет подлинность отправителя** в служебном канале — только самоназвание;
+- **не переносит цель через перезапуск процесса**: счётчик постановок обнуляется, а связь
+  «сессия → куда сообщить об исходе» живёт в памяти процесса. Сама цель хранится платформой и
+  переживает перезапуск, а вот сообщение об её исходе после перезапуска не придёт.

package/cordis.patch.yml

@@ -17,3 +17,13 @@
         # Empty means everyone can talk to an agent that usually has shell
         # access. Set it.
         allowedUsers: []
+        # Goal control from the channel (1.3.0). BOTH lists are empty by
+        # default, which means the /goal command is refused for everyone —
+        # deliberately: starting an autonomous goal loop costs money, so the
+        # right is granted by name, never inherited from allowedUsers.
+        # Telegram user ids allowed to run /goal:
+        goalUsers: []
+        # Names allowed to run /goal from the agent-to-agent channel. The
+        # sender names itself in the first line of the file: "From: <name>".
+        # This is bookkeeping, not authentication — see README.
+        goalA2ASenders: []

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "dsh-telegram-multiagent",
-  "version": "1.2.2",
-  "description": "Telegram channel for DeepSeek Harness — one shared module serving several agents, with unforgeable sender marks, merged owner+coordinator memory, and a delivery mode you switch in a file outside the code.",
+  "version": "1.3.0",
+  "description": "Telegram channel for DeepSeek Harness — one shared module serving several agents, with unforgeable sender marks, merged owner+coordinator memory, a delivery mode you switch in a file outside the code, and goal control from the channel for agents whose loop runs outside the platform.",
   "type": "module",
   "main": "src/index.js",
   "files": [
     "src",
+    "test",
     "cordis.patch.yml",
     "README.md"
   ],

package/src/index.js

@@ -123,7 +123,7 @@ export function apply(ctx, config = {}) {
   // улетит в чат владельца. Ключ — сессия, значение — 'a2a' или 'tg'.
   const lastOrigin = new Map();
 
-  // 🔴 СЛИЯНИЕ КАНАЛОВ В ОДНУ ПАМЯТЬ (20.08.2026, решение Александра).
+  // 🔴 СЛИЯНИЕ КАНАЛОВ В ОДНУ ПАМЯТЬ (20.08.2026, решение владельца).
   // mergeChatIntoA2A: <идентификатор чата> — сообщения этого чата попадают НЕ в
   // свою сессию `telegram-<чат>`, а в служебную. Тогда владелец и координатор
   // говорят с ОДНИМ агентом и одной памятью разговора, а различает он их по
@@ -134,14 +134,14 @@ export function apply(ctx, config = {}) {
   // Куда отвечать в мессенджер, если сессия общая: sessionId → числовой чат.
   const tgChatFor = new Map();
 
-  // 🔴 КОМУ АДРЕСОВАН ОТВЕТ (21.08.2026, задача Александра).
+  // 🔴 КОМУ АДРЕСОВАН ОТВЕТ (21.08.2026, задача владельца).
   // Пометка на ВХОДЕ решает «кто спросил», но не решает «кому отвечено»: когда в
   // одной памяти сидят двое, ответ без адреса читается обоими как свой. И хуже:
   // маршрут «отвечаем последнему спросившему» ломается, если второй вопрос
   // пришёл, пока первый ещё считается, — ответ уедет не тому.
   // Поэтому происхождение привязано к ХОДУ, а не к последнему сообщению: на
   // входе кладём в очередь, на turn/start снимаем, ответ метим тем, что сняли.
-  // ── НАСТРОЙКА ДОСТАВКИ, ОТДЕЛЬНЫМ ФАЙЛОМ (21.08.2026, задача Александра)
+  // ── НАСТРОЙКА ДОСТАВКИ, ОТДЕЛЬНЫМ ФАЙЛОМ (21.08.2026, задача владельца)
   //
   // Файл живёт ВНЕ модуля и переживает его обновление: код можно переписать,
   // перевыпустить, поставить заново — настройка останется. Читается на лету,
@@ -264,6 +264,78 @@ export function apply(ctx, config = {}) {
     throw new Error(`фабрика агентов не появилась за ${tries} с`);
   }
 
+  /**
+   * Дождаться сервиса платформы, не заперев канал навсегда.
+   *
+   * 🔴 ctx.get() МОЛЧИТ, КОГДА СЕРВИСА ЕЩЁ НЕТ, и это опаснее исключения.
+   * cordis возвращает undefined БЕЗ ошибки, пока волокно поставщика не активно
+   * (ReflectService._getImpl: `if (strict && impl.fiber.state !== 2) return;`).
+   * Значит «сервиса нет в сборке» и «сервис ещё поднимается» приходят одним и
+   * тем же значением, и код, написанный как `const x = ctx.get('x'); if (x)`,
+   * тихо уходит по ветке «этой возможности просто нет». Снаружи это выглядит
+   * штатной работой: агент собирается, отвечает и молчит о том, чего лишился.
+   *
+   * Поймано трижды за три дня, каждый раз дороже предыдущего:
+   *   19.08.2026 — фабрика агентов (см. withFactoryRetry выше);
+   *   22.08.2026 — sessionPersistence: блок продолжения истории пропускался
+   *                целиком, агент создавался поверх существующего журнала, и
+   *                КАЖДЫЙ ход умирал с «id collision» за считаные миллисекунды;
+   *   22.08.2026 — agentPresets: набор инструментов у модели упал с 33 до 3,
+   *                без ошибки и без строки в журнале.
+   * Общий вывод, ради которого функция ОДНА, а не три: лечение, применённое к
+   * экземпляру, а не ко всем местам класса, гарантирует рецидив.
+   *
+   * ГРАНИЦА ОЖИДАНИЯ — назвать обязательно, иначе защита сама станет отказом:
+   * ждём не дольше `tries` секунд и только при заведении агента. Не дождались —
+   * говорим ГРОМКО, называем последствие и идём дальше. Канал не запирается там,
+   * где сервиса в сборке нет вовсе (это законная сборка, а не поломка).
+   */
+  async function waitService(name, tag, consequence, tries = 30) {
+    for (let i = 0; i < tries; i++) {
+      const found = ctx.get(name);
+      if (found) {
+        if (i > 0) log(`${tag} сервис ${name} появился через ${i} с ожидания`);
+        return found;
+      }
+      if (i === 0) log(`${tag} сервис ${name} ещё не активен — жду платформу`);
+      await new Promise((r) => setTimeout(r, 1000));
+    }
+    log(`${tag} 🔴 сервис ${name} не появился за ${tries} с — ${consequence}`);
+    return undefined;
+  }
+
+  /**
+   * 🔴 РЕШЕНИЕ ПО КАЖДОМУ ctx.get() В ЭТОМ ФАЙЛЕ. Проверять надо КАЖДЫЙ, а не
+   * тот, на котором обожглись, — иначе рецидив, и рецидив будет выглядеть новой
+   * болезнью, потому что рядом лежит доказательство «мы это уже лечили».
+   *
+   * ПРИЗНАК, по которому решается, а не «кажется безопасным»: ожидание нужно
+   * там, где место может сработать ДО подъёма сервиса И отказ при этом
+   * МОЛЧАЛИВ ИЛИ ЛОЖЕН. Одного условия мало.
+   *
+   * Отдельно замечено на живом: порядок готовности волокон МЕНЯЕТСЯ от подъёма
+   * к подъёму. В одном подъёме ждала фабрика агентов, в другом — набор пресета,
+   * причём гонка была в обоих. Значит судить о гонке по соседнему сервису
+   * нельзя: соседний в этот раз мог успеть. Ожидание ставится по устройству
+   * места, а не по тому, где однажды видели примету.
+   *
+   *   1) agentFor → agentPresets, agentDefaultModel, sessionPersistence.
+   *      ОЖИДАНИЕ ЕСТЬ, предел 30 с: заведение агента идёт вплотную к подъёму
+   *      платформы, а отказ здесь молчалив и разрушителен.
+   *   2) goalCommand → goals, goalMarker, mcpBridge. ОЖИДАНИЕ ЕСТЬ, предел
+   *      короткий (GOAL_WAIT_TRIES): по undefined невозможно отличить «сервиса
+   *      нет в сборке» от «ещё поднимается», а ответ «не подключён» — это
+   *      диагноз, которого код поставить не может. Ждём мало, потому что на том
+   *      конце живой собеседник.
+   *   3) stripGoalMarker → goalMarker. ОЖИДАНИЯ НЕТ намеренно: место
+   *      СИНХРОННОЕ (обработчик события сессии не async), а отказ не молчалив —
+   *      маркер уезжает в чат видимым текстом.
+   *   4) обработчик goal/change → goals. ОЖИДАНИЯ НЕТ намеренно: сюда попадают
+   *      только те сессии, где цель уже поставлена через goalCommand, а тот без
+   *      сервиса целей не проходит вовсе. Значит пустота здесь означает не «ещё
+   *      не поднялся», а «сервис ПРОПАЛ», и это надо не переждать, а сказать.
+   */
+
   async function agentFor(chatId) {
     const key = String(chatId);
     const found = chats.get(key);
@@ -275,9 +347,11 @@ export function apply(ctx, config = {}) {
     // в запрос к модели не попадает поле tools вообще, и агент физически не
     // может вызвать ни один инструмент, хотя они смонтированы (проверено
     // 2026-08-18 по событию request/header в журнале сессии).
-    const presets = ctx.get('agentPresets');
+    const presets = await waitService('agentPresets', `[${key}]`,
+      'агент будет собран БЕЗ ИНСТРУМЕНТОВ');
     const presetId = presets ? (await presets.resolve(config.preset)).id : undefined;
-    const defaultModel = ctx.get('agentDefaultModel');
+    const defaultModel = await waitService('agentDefaultModel', `[${key}]`,
+      'модель берётся из настроек плагина, а не из выбора платформы');
     const selection = defaultModel?.currentSelection?.() ?? {
       provider: config.provider,
       model: config.model,
@@ -285,6 +359,9 @@ export function apply(ctx, config = {}) {
     const setupFn = async (agentCtx) => {
       platform.installModelSelection(agentCtx, { current: selection, assembled: undefined });
       if (presets && presetId) await presets.mount(agentCtx, presetId);
+      // Молча остаться без инструментов нельзя: снаружи это выглядит как
+      // «агент отупел», а причина — несмонтированный пресет.
+      else log(`[${key}] 🔴 пресет НЕ смонтирован (presets=${!!presets}, presetId=${presetId})`);
     };
 
     // 🔴 СЕССИЮ, КОТОРАЯ УЖЕ ЛЕЖИТ НА ДИСКЕ, НАДО ПРОДОЛЖАТЬ, А НЕ СОЗДАВАТЬ ЗАНОВО.
@@ -299,16 +376,36 @@ export function apply(ctx, config = {}) {
     // события turn/end (раньше плагин печатал только тип события).
     // Правильный путь — ctx.agents.resume(): «загрузить сохранённую сессию и
     // продолжить агента на ней» (dsh-agent/lib/index.js, resume()).
-    const persistence = ctx.get('sessionPersistence');
+    const persistence = await waitService('sessionPersistence', `[${key}]`,
+      'сохранённую сессию продолжить нечем, история будет потеряна');
     let handle;
     if (persistence) {
-      let onDisk = false;
+      let known;
       try {
-        onDisk = (await persistence.list()).some((h) => h.id === sessionId);
+        known = (await persistence.list()).map((h) => h.id);
       } catch (e) {
-        log(`не смогла перечислить сохранённые сессии: ${e?.message ?? e}`);
+        log(`🔴 [${key}] не смог перечислить сохранённые сессии: ${e?.message ?? e}`);
+      }
+      // 🔴 УХОДИТЬ В create() МОЛЧА НЕЛЬЗЯ — ЭТО ВТОРОЙ ТИХИЙ ПУТЬ В ЭТОЙ ЖЕ
+      // ФУНКЦИИ. Снаружи он неотличим от честного первого запуска, а на деле
+      // означает create() поверх существующего журнала и «id collision» на
+      // каждом ходе. Поэтому список сообщаем ЧИСЛОМ и именами.
+      if (known !== undefined && !known.includes(sessionId)) {
+        // Пустой список — честный первый запуск, тревожить нечем. Тревога там,
+        // где сохранённые сессии ЕСТЬ, а нашей среди них нет.
+        if (known.length === 0) log(`[${key}] сохранённых сессий на диске нет — ${sessionId} заводится впервые`);
+        else {
+          // ⚠️, а не 🔴, СОЗНАТЕЛЬНО: по одному списку два исхода неразличимы —
+          // либо это первый разговор в новом чате (законно и обычно), либо
+          // журнал сессии потерян (беда). Отличить их отсюда нечем, поэтому
+          // строка называет ФАКТЫ и оба прочтения, а не ставит диагноз.
+          // Кричать 🔴 на законном событии — это защита, которая приучает
+          // не читать журнал.
+          const spisok = known.slice(0, 12).join(', ') + (known.length > 12 ? `, …и ещё ${known.length - 12}` : '');
+          log(`⚠️ [${key}] на диске ${known.length} сохранённых сессий, ${sessionId} среди них НЕТ: либо это первый разговор в чате, либо история потеряна — по одному списку не отличить. Продолжать нечего, создаю заново. Найдено: ${spisok}`);
+        }
       }
-      if (onDisk) {
+      if (known !== undefined && known.includes(sessionId)) {
         try {
           handle = await ctx.agents.resume({
             resumeSessionId: sessionId,
@@ -379,11 +476,240 @@ export function apply(ctx, config = {}) {
     }
   }
 
+  // ── ПОСТАНОВКА ЦЕЛИ ИЗ КАНАЛА (21.08.2026, задача владельца).
+  //
+  // ЗАЧЕМ. Когда цикл ведёт внешний движок (агент работает через подписку, а не
+  // через родной цикл платформы), инструменты платформы до модели НЕ ДОХОДЯТ
+  // вовсе — доходит только то, что имеет форму СООБЩЕНИЯ. Значит поставить цель
+  // изнутри разговора нельзя, а руками в веб-интерфейсе — можно. Здесь мы даём
+  // постановку из любого канала: сервис целей доступен КОДУ модуля как
+  // ctx.get('goals'), инструмент модели для этого не нужен.
+  //
+  // КТО ВПРАВЕ. Отдельные настройки, обе по умолчанию ВЫКЛЮЧЕНЫ:
+  //   goalUsers: [<числовые id>]     — кто ставит цель из Telegram
+  //   goalA2ASenders: ["<имя>", …]   — кто вправе из служебного канала
+  // Право НЕ наследуется от allowedUsers сознательно: allowedUsers — это
+  // «с кем я вообще разговариваю», и завтра туда добавят гостя. Право завести
+  // дорогой автономный цикл шире права поговорить.
+  //
+  // 🔴 ЧЕМ ЗА ЭТО ПЛАТИМ, назвать обязательно: проверки платформы
+  // (currentInitiator, hasDirectHumanInput, roots) живут в её инструменте целей
+  // и на ЭТОМ пути не участвуют. Мы не обходим политику — мы пишем её заново,
+  // и две строки ниже есть вся политика целиком. Пустые списки = постановка
+  // отключена; это умолчание выбрано нарочно.
+  const goalUsers = new Set((config.goalUsers ?? []).map(Number));
+  // 🔴 ПРАВО ИЗ СЛУЖЕБНОГО КАНАЛА — ПОИМЁННО, А НЕ «КАНАЛУ ЦЕЛИКОМ». Признак
+  // источника получает ЛЮБОЕ сообщение служебного канала, а каталог обмена
+  // бывает общим на несколько машин: правом «всем, кто пишет в канал» мы
+  // раздали бы возможность заводить дорогие циклы кому попало.
+  // Отправитель называет себя первой строкой файла:  From: <имя>
+  // Нет заголовка или имени нет в списке — отказ, и он произносится вслух.
+  const goalA2ASenders = new Set(config.goalA2ASenders ?? []);
+  // sessionId → { channel, agent } — куда сообщить об исходе цели.
+  const goalOrigin = new Map();
+  // канал → метки времени постановок, для счётчика ниже.
+  const goalStarts = new Map();
+
+  // 🔴 СЧЁТЧИК ПОСТАНОВОК: не более трёх за скользящий час на канал.
+  //
+  // ОТ ЧЕГО ЗАЩИЩАЕТ: от СЛУЧАЙНОСТИ и РАЗГОНА — от петли, в которую механизм
+  // вошёл сам, от ошибки в коде, от лавины повторов. Предел раундов у платформы
+  // стоит на ЦЕЛЬ, а не на агента: новая цель — новый счётчик, и поток целей
+  // ничем не ограничен. Каталог входящих принадлежит самому агенту, то есть в
+  // автономном раунде он способен положить себе файл «/goal …» и продлить цикл.
+  //
+  // 🔴 ГДЕ НЕ ПРИМЕНЯЕТСЯ: счётчик НЕ защищает от намеренного действия агента,
+  // у которого есть права администратора на этой машине, — такой агент снимет
+  // и его, и предел раундов одной командой. Технической границы против самого
+  // агента здесь не существует, изоляция ПОВЕДЕНЧЕСКАЯ. Настоящий сторож —
+  // снаружи, на другой машине, вне досягаемости этого процесса.
+  //
+  // ГРАНИЦЫ САМОГО СЧЁТЧИКА: снятию цели (/goal stop) он не мешает никогда —
+  // механизм, включаемый снаружи и невыключаемый, хуже отсутствия механизма;
+  // обнуляется перезапуском процесса; ничего не чинит сам, только отказывает.
+  const GOAL_MAX_PER_HOUR = 3;
+
+  // Сколько секунд ждать сервис на пути КОМАНДЫ (не на заведении агента).
+  // Пять, а не тридцать: см. пояснение в goalCommand ниже.
+  const GOAL_WAIT_TRIES = 5;
+
+  function goalRateOk(channel) {
+    const now = Date.now();
+    const marks = (goalStarts.get(channel) ?? []).filter((t) => now - t < 3600000);
+    goalStarts.set(channel, marks);
+    return marks.length < GOAL_MAX_PER_HOUR;
+  }
+
+  // 🔴 ПРИЗНАК СОБСТВЕННОЙ ИСПРАВНОСТИ. Права на постановку цели заголовком
+  // запроса к модели НЕ проверяются в принципе: плагин не даёт модели ни одного
+  // инструмента и в заголовке невидим. Печатаем ЧИСЛА, а не «загрузился»: длина
+  // списка прав отличает верную настройку от пустого умолчания, при котором
+  // постановка отказывает молча и выглядит поломкой. Сами идентификаторы не
+  // печатаем — в журнал уходит устройство, а не список людей.
+  log(`[goal] смонтирован: goalUsers=${goalUsers.size} goalA2ASenders=${goalA2ASenders.size} `
+    + `предел постановок=${GOAL_MAX_PER_HOUR}/час`);
+
+  async function sayTo(channel, chatId, text) {
+    if (channel === 'a2a') {
+      if (!A2A_OUT) { log('[goal] 🔴 ответ в служебный канал не ушёл: каталог обмена не задан'); return; }
+      try {
+        fs.mkdirSync(A2A_OUT, { recursive: true });
+        fs.writeFileSync(path.join(A2A_OUT, `${Date.now()}-goal.txt`), text);
+      } catch (e) { log(`[goal] 🔴 ответ в служебный канал не ушёл: ${e?.message ?? e}`); }
+    } else {
+      try { await tg.send(chatId, text); } catch (e) { log(`[goal] 🔴 ответ в чат не ушёл: ${e?.message ?? e}`); }
+    }
+  }
+
+  /**
+   * Отделить заголовок отправителя от текста служебного сообщения.
+   *
+   * 🔴 ЧЕСТНАЯ ГРАНИЦА, назвать её обязательно: это УЧЁТ, А НЕ ЗАЩИТА.
+   * Отправитель называет себя сам, и подделать имя может любой, кто способен
+   * положить файл в каталог входящих. Настоящая граница здесь — права ОС на
+   * этот каталог: писать в него должны только сам агент и доставка. Нужна
+   * проверка сильнее самоназвания — это общий секрет в файле с правами, и
+   * заводить его нужно отдельным решением, а не походя.
+   */
+  function splitSender(raw) {
+    const nl = raw.indexOf('\n');
+    const head = (nl === -1 ? raw : raw.slice(0, nl)).trim();
+    const m = /^From:\s*(\S+)$/.exec(head);
+    if (!m) return { sender: undefined, text: raw };
+    return { sender: m[1], text: nl === -1 ? '' : raw.slice(nl + 1).trimStart() };
+  }
+
+  /**
+   * Убрать маркер цели из текста, уходящего наружу.
+   *
+   * 🔴 ЗДЕСЬ ОЖИДАНИЯ СЕРВИСА НЕТ, И ЭТО РЕШЕНИЕ, А НЕ ПРОПУСК. Место
+   * СИНХРОННОЕ (зовётся из обработчика session/event, который не async), и
+   * отказ здесь НЕ молчалив: маркер уезжает в чат видимым текстом, читатель
+   * увидит его сам. Ждать по 30 с на каждом исходящем сообщении было бы
+   * лечением хуже болезни — см. общее решение по ctx.get() выше.
+   */
+  function stripGoalMarker(raw) {
+    const marker = ctx.get('goalMarker');
+    return marker ? marker.strip(raw) : raw;
+  }
+
+  // Разбор команды. Возвращает текст ответа; отправку делает вызывающий.
+  // Отказы называем вслух: молчаливый отказ здесь неотличим от «агент не понял».
+  async function goalCommand(text, channel, agent) {
+    const rest = text.slice('/goal'.length).trim();
+    // 🔴 ЖДЁМ СЕРВИС, А НЕ ОТКАЗЫВАЕМ СРАЗУ — и ждём КОРОТКО. Без ожидания
+    // ответ «сервис не подключён» был бы диагнозом, которого код поставить не
+    // может: undefined одинаково означает и «нет в сборке», и «ещё поднимается».
+    // Предел короткий (а не 30 с, как при заведении агента) потому, что на том
+    // конце ждёт живой собеседник: полминуты молчания в чате читаются как
+    // «бот умер», и лечение снова оказалось бы хуже болезни.
+    const goals = await waitService('goals', '[goal]', 'команда постановки цели невыполнима', GOAL_WAIT_TRIES);
+    if (!goals) return 'Сервис целей на этом агенте не подключён.';
+    let current;
+    try { current = goals.get(agent); }
+    catch (e) { log(`[goal] 🔴 состояние цели не прочитано: ${e?.message ?? e}`); return `Не смог прочитать состояние цели: ${e?.message ?? e}`; }
+
+    if (rest === '') {
+      if (!current) return 'Цели нет.';
+      return `Цель ${current.id}: ${current.phase}, раунд ${current.roundsStarted} из ${current.maxGoalRounds}.`
+        + (current.blockedReason ? `\nПричина остановки: ${current.blockedReason}` : '')
+        + `\nЗамысел: ${String(current.objective).slice(0, 200)}`;
+    }
+
+    if (rest === 'stop') {
+      // Снятие счётчиком НЕ ограничено — см. границы выше.
+      if (!current) return 'Цели нет, снимать нечего.';
+      try {
+        goals.clear(agent, { id: current.id, revision: current.revision });
+        goalOrigin.delete(String(agent.session?.id ?? ''));
+        log(`[goal] снята ${current.id} из ${channel}`);
+        return `Цель ${current.id} снята.`;
+      } catch (e) {
+        log(`[goal] 🔴 снятие не удалось: ${e?.message ?? e}`);
+        return `Не смог снять цель: ${e?.message ?? e}`;
+      }
+    }
+
+    // Постановка. Предел раундов командой НЕ задаётся: он живёт в настройке
+    // платформы и не должен подниматься тем же путём, каким запускается
+    // дорогой цикл.
+    if (!goalRateOk(channel)) {
+      log(`[goal] ОТКАЗ ${channel}: исчерпан предел ${GOAL_MAX_PER_HOUR} постановок за час`);
+      return `Предел ${GOAL_MAX_PER_HOUR} постановок цели за час исчерпан. Зовите человека.`;
+    }
+    try {
+      let view = goals.create(agent, { objective: rest });
+      // 🔴 НАСТАВЛЕНИЕ ПРО МАРКЕР КЛАДЁМ В САМ ЗАМЫСЕЛ. Промпт автоматического
+      // раунда несёт только замысел и номер раунда — ни идентификатора цели, ни
+      // ревизии в нём нет, а без них модель не сложит маркер. Идентификатор
+      // известен только после create, поэтому edit вторым шагом; edit поднимает
+      // ревизию на единицу, её и называем в наставлении.
+      const marker = await waitService('goalMarker', '[goal]',
+        'цель будет поставлена без наставления о маркере', GOAL_WAIT_TRIES);
+      if (marker) {
+        // 🔴 ИМЕНА ИНСТРУМЕНТОВ БЕРЁМ У МОСТА, А НЕ ПИШЕМ ПО ПАМЯТИ. Протокол
+        // MCP добавляет к базовому имени приставку mcp__<сервер>__; наставление,
+        // называющее инструмент БЕЗ неё, отсылает модель к несуществующему
+        // имени, и выглядит это как «мост не работает». Нет моста — нет и имён:
+        // тогда наставление честно говорит, что инструментов нет, и остаётся
+        // только пометка.
+        const bridge = await waitService('mcpBridge', '[goal]',
+          'в наставлении останется только пометка, без имён инструментов', GOAL_WAIT_TRIES);
+        const goalTools = bridge?.modelToolName
+          ? { update: bridge.modelToolName('update_goal'), get: bridge.modelToolName('get_goal') }
+          : undefined;
+        log(`[goal] наставление: ${goalTools ? `инструмент ${goalTools.update}, пометка запасной линией` : 'моста нет, только пометка'}`);
+        view = goals.edit(agent, { id: view.id, revision: view.revision },
+          { objective: `${rest}\n\n${marker.guidance(view.id, view.revision + 1, goalTools)}` });
+      } else {
+        log('[goal] ⚠️ сервис goalMarker не смонтирован: цель поставлена, но закрыть её сама модель не сможет — цикл дойдёт до предела раундов');
+      }
+      goalStarts.get(channel).push(Date.now());
+      goalOrigin.set(String(agent.session?.id ?? ''), { channel, agent });
+      log(`[goal] поставлена ${view.id} из ${channel}, предел ${view.maxGoalRounds} раундов: ${rest.slice(0, 60)}`);
+      return `Цель ${view.id} поставлена, предел ${view.maxGoalRounds} раундов.`;
+    } catch (e) {
+      const code = e?.code ?? '';
+      log(`[goal] 🔴 постановка не удалась (${code}): ${e?.message ?? e}`);
+      if (code === 'GOAL_ALREADY_EXISTS') return 'Цель уже поставлена. Сначала /goal stop.';
+      return `Не смог поставить цель: ${e?.message ?? e}`;
+    }
+  }
+
   // ── ВЫХОД: события сессии → сообщения в Telegram
   ctx.on('session/event', (session, event) => {
     // 🔴 DEBUG 2026-08-18: все типы событий
     log(`[event] type=${event.type} session.id=${session?.id} knownSessions=${[...sessionToChat.keys()].join('|')}`);
     const sid = String(session?.id ?? '');
+    // 🔴 ИСХОД ЦЕЛИ СООБЩАЕМ САМИ. Доводчик при упоре в предел раундов переводит
+    // цель в blocked — и делает это молча: снаружи автономный цикл просто
+    // перестаёт просыпаться. Молчаливый останов неотличим от поломки, поэтому
+    // говорим в тот канал, из которого цель ставили, и ровно один раз.
+    // Блок стоит ДО проверки chatId нарочно: у служебного канала числового чата
+    // нет вовсе, и ранний выход съел бы событие.
+    if (event.type === 'goal/change') {
+      const origin = goalOrigin.get(sid);
+      if (origin) {
+        try {
+          // Ожидания сервиса здесь нет намеренно — см. решение по ctx.get выше:
+          // сюда попадают только сессии, где цель уже поставлена, значит пустота
+          // означает не «ещё не поднялся», а «пропал», и это стоит строки.
+          const goalsSvc = ctx.get('goals');
+          if (!goalsSvc) {
+            log(`[goal] 🔴 сервис целей исчез — исход цели по сессии ${sid} не сообщён`);
+            return;
+          }
+          const view = goalsSvc.get(origin.agent);
+          if (view && view.phase !== 'active') {
+            goalOrigin.delete(sid);
+            void sayTo(origin.channel, tgChatFor.get(sid) ?? sessionToChat.get(sid),
+              `Цель ${view.id}: ${view.phase}`
+              + (view.blockedReason ? `, причина: ${view.blockedReason}` : '')
+              + `. Раундов пройдено ${view.roundsStarted} из ${view.maxGoalRounds}.`);
+          }
+        } catch (e) { log(`[goal] исход цели не прочитан: ${e?.message ?? e}`); }
+      }
+    }
     // 🔴 При слиянии sessionToChat указывает на КЛЮЧ служебной сессии, а не на
     // числовой чат — отправка по нему молча не дойдёт. Настоящий чат берём из
     // карты, заполняемой на входе из мессенджера.
@@ -418,7 +744,12 @@ export function apply(ctx, config = {}) {
                  && (turnAsk.get(sid)?.origin ?? lastOrigin.get(sid) ?? (chatId === A2A_CHAT ? 'a2a' : 'tg')) === 'a2a') {
         // ответ координатору — в файл, Telegram тут ни при чём
         const blocks = event.data?.message?.content ?? [];
-        const text = blocks.filter((b) => b?.type === 'text').map((b) => b.text).join('\n').trim();
+        // 🔴 МАРКЕР ВЫРЕЗАЕМ ИЗ ВСЕГО, ЧТО УХОДИТ НАРУЖУ — из доставляемого
+        // текста и из копий. Он служебный: его дело остановить цикл, а не
+        // попасть человеку в чат. Вырезается только маркер последней строки;
+        // маркер в середине оставляем видимым нарочно — он и так отвергнут,
+        // и пусть будет заметен читателю.
+        const text = stripGoalMarker(blocks.filter((b) => b?.type === 'text').map((b) => b.text).join('\n')).trim();
         if (text) {
           try {
             fs.mkdirSync(A2A_OUT, { recursive: true });
@@ -430,11 +761,11 @@ export function apply(ctx, config = {}) {
       } else if (event.type === 'assistant/message') {
         // Берём только видимый текст: рассуждения модели наружу не отдаём.
         const blocks = event.data?.message?.content ?? [];
-        const text = blocks
+        // Маркер цели наружу не отдаём — см. пояснение веткой выше.
+        const text = stripGoalMarker(blocks
           .filter((b) => b?.type === 'text')
           .map((b) => b.text)
-          .join('\n')
-          .trim();
+          .join('\n')).trim();
         if (text) {
           log(`[event] отправляю в Telegram chatId=${chatId} (${text.length} знаков)`);
           { const c = copyTo('tg'); if (c) sendCopy(c, sid, text); }
@@ -462,13 +793,12 @@ export function apply(ctx, config = {}) {
     return tmp;
   }
 
-  // Транскрибирует голосовое сообщение через нашу локальную цепочку.
+  // Расшифровывает голосовое сообщение внешней командой из настройки.
   // Возвращает строку с текстом или null при ошибке.
   async function transcribeVoice(fileId) {
     let tmpAudio = null;
     try {
       tmpAudio = await downloadTelegramFile(fileId);
-      // transcribe-local-shared — наша цепочка: sage-corrector → transcribe-whispercpp-core → whisper-warm.service
       // 🔴 Внешняя команда расшифровки — НАСТРОЙКА, а не зашитый путь: у каждого
       // своя цепочка. Не задана — голосовые просто не расшифровываются, и об этом
       // говорится в журнал, а не молча игнорируется.
@@ -546,6 +876,25 @@ export function apply(ctx, config = {}) {
       return;
     }
 
+    // Постановка цели — тоже команда канала, разбираем до передачи агенту.
+    if (text === '/goal' || text.startsWith('/goal ')) {
+      // Право проверяем ДО создания агента: отказ не должен заводить сессию.
+      if (!goalUsers.has(Number(userId))) {
+        log(`[goal] ОТКАЗ ${userId}: не в списке goalUsers`);
+        await tg.send(chatId, 'Постановка цели из этого канала вам не разрешена.');
+        return;
+      }
+      const key = (MERGE_CHAT && String(chatId) === MERGE_CHAT) ? A2A_CHAT : chatId;
+      try {
+        const { handle: gh } = await agentFor(key);
+        await sayTo('tg', chatId, await goalCommand(text, 'tg', gh.agent));
+      } catch (e) {
+        log(`[goal] 🔴 команда не выполнена: ${e?.message ?? e}`);
+        await tg.send(chatId, `Не смог выполнить команду: ${e?.message ?? e}`);
+      }
+      return;
+    }
+
     // При включённом слиянии владелец попадает в ту же сессию, что и служебный
     // канал: одна память на двоих. Ответ при этом обязан вернуться в мессенджер,
     // поэтому запоминаем настоящий чат отдельно.
@@ -649,10 +998,32 @@ export function apply(ctx, config = {}) {
         // который нам не по правам (например 600 root:root), молча оставался
         // лежать во входящих. Снаружи это «агент не отвечает», а на деле
         // мы даже не смогли прочитать вопрос. Поймано 18.08.2026.
-        log(`[a2a] 🔴 не смогла прочитать ${f}: ${e?.message ?? e} (права: попробуй chown dsh:dsh + chmod 644)`);
+        log(`[a2a] 🔴 не смог прочитать ${f}: ${e?.message ?? e} (права: файл должен принадлежать владельцу агента и быть читаемым, chmod 644)`);
         continue;
       }
       if (!text) continue;
+      // Заголовок отправителя отделяем ВСЕГДА: он служебный и в разговоре лишний.
+      const { sender, text: body } = splitSender(text);
+      if (sender !== undefined) text = body;
+      if (!text) continue;
+      if (text === '/goal' || text.startsWith('/goal ')) {
+        if (!goalA2ASenders.has(sender)) {
+          log(`[goal] ОТКАЗ служебному каналу: отправитель ${sender ?? '(не назвался)'} не в списке goalA2ASenders`);
+          await sayTo('a2a', null, sender === undefined
+            ? 'Постановка цели из служебного канала требует заголовка первой строкой: "From: <имя>".'
+            : `Отправитель ${sender} не вправе ставить цель.`);
+        } else {
+          try {
+            const { handle: gh } = await agentFor(A2A_CHAT);
+            await sayTo('a2a', null, await goalCommand(text, 'a2a', gh.agent));
+          } catch (e) {
+            log(`[goal] 🔴 команда не выполнена: ${e?.message ?? e}`);
+            await sayTo('a2a', null, `Не смог выполнить команду: ${e?.message ?? e}`);
+          }
+        }
+        try { fs.unlinkSync(full); } catch { /* уже убрали */ }
+        continue;
+      }
       try {
         const { handle, sessionId: a2aSessionId } = await agentFor(A2A_CHAT);
         lastOrigin.set(a2aSessionId, 'a2a');
@@ -664,7 +1035,7 @@ export function apply(ctx, config = {}) {
         // Наш агент на этом верно упёрся — отказался выполнять просьбу,
         // подписанную чужим именем, пришедшую не из своего канала. Значит
         // происхождение обязан сообщать код доставки, которому подделать нечем.
-        text = `[служебный канал, от координатора]\n${stripMark(text)}`;
+        text = `[служебный канал, от координатора${sender ? ` ${sender}` : ''}]\n${stripMark(text)}`;
         handle.agent.send(platform.createUserMessage({
           content: [{ type: 'text', text }],
           source: { kind: 'user' },

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/test-goal-control.mjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+/**
+ * Приёмка постановки цели из канала (1.3.0).
+ *
+ * Правила, по которым он написан:
+ *  — текст проверяемых функций берётся ИЗ ФАЙЛА пакета, а не пишется заново;
+ *  — рядом с вердиктом печатается сырьё, на котором он основан;
+ *  — код возврата: 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}, а его на диске НЕТ`);
+  }
+  eq('версия пакета', pj.version, '1.3.0');
+} 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.includes('не более трёх за скользящий час') && maxInCode === '3'
+    ? pass('предел в README и в коде сходится', `код=${maxInCode}`)
+    : fail('предел в README разошёлся с кодом', `код=${maxInCode}`);
+} 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));