clawgram 2.21.1 → 2.23.0

package/dist/outbound.js

@@ -0,0 +1,260 @@
+"use strict";
+// Исходящий контур канала: куда уходит текст и что при этом проверяется.
+//
+// Вынесено из channel.ts — файла на 3009 строк при следующем по величине
+// 1165 (находка A6-11). Замыкание использовало отсюда ровно две вещи:
+// карту рантаймов и журнал, поэтому блок отделяется фабрикой, а не
+// переписыванием.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOutbound = createOutbound;
+const core_1 = require("openclaw/plugin-sdk/core");
+const media_1 = require("./media");
+const send_scope_1 = require("./send-scope");
+const system_notice_1 = require("./system-notice");
+const group_reply_address_1 = require("./group-reply-address");
+const group_visible_reply_guard_1 = require("./group-visible-reply-guard");
+const helpers_1 = require("./helpers");
+const helpers_2 = require("./helpers");
+const actionLog = (0, core_1.createSubsystemLogger)("channels/clawgram");
+/** Исходящий контур для карты рантаймов канала. */
+function createOutbound(runtimes) {
+    return {
+        // Core's agent-delivery path (`--deliver`, subagent announces) calls this
+        // hook under three constraints, all learned live on 2026-08-06:
+        //
+        // - `to` may be undefined (no explicit target, session route yielded
+        //   none), and a rejection is NOT caught: a throw here is an unhandled
+        //   rejection that takes down the entire gateway process.
+        // - `resolveAgentDeliveryPlanWithSessionRoute` calls it WITHOUT await.
+        //   An async hook hands core a Promise, `promise.ok` reads undefined and
+        //   the error branch dereferences `promise.error.message` — the crash
+        //   every subagent announce died on. The hook must return a plain value;
+        //   the call sites that do await are unaffected, await of a value works.
+        // - In a not-ok result core reads `error.message`, so the error must be
+        //   Error-like, not a bare string.
+        //
+        // Peer resolution deliberately does not happen here: `sendText` resolves
+        // the peer itself, and doing it here would force the hook async again.
+        resolveTarget(ctx) {
+            try {
+                const raw = typeof ctx.to === "string" ? ctx.to.trim() : "";
+                actionLog.info("clawgram outbound resolveTarget", {
+                    accountId: ctx.accountId,
+                    rawTo: raw || null,
+                });
+                if (!raw) {
+                    return { ok: false, error: new Error("clawgram: no delivery target — pass `to` or use a session with a bound chat") };
+                }
+                const target = (0, helpers_1.normalizeOutboundTarget)(raw);
+                // Тот же барьер, что у `handleAction`: доставка ядра (`--deliver`,
+                // анонсы субагентов) идёт этим путём и мимо той проверки. Отказ
+                // здесь возвращается результатом, а не броском: бросок в этом хуке
+                // роняет весь gateway (грабли 06.08.2026, выше).
+                if (!(0, send_scope_1.isChatSendable)(target, (0, send_scope_1.sendScopeFor)(ctx.accountId))) {
+                    const reason = (0, send_scope_1.isPhoneNumberTarget)(target)
+                        ? "phone-number target"
+                        : "chat outside send scope";
+                    actionLog.warn("clawgram outbound resolveTarget refused", {
+                        accountId: ctx.accountId,
+                        target,
+                        reason,
+                    });
+                    return { ok: false, error: new Error(`clawgram: not-allowed-chat ${target}`) };
+                }
+                return { ok: true, to: target };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err : new Error(String(err)) };
+            }
+        },
+        async sendText(ctx) {
+            // Never log `text`: outbound bodies are private correspondence and the
+            // channel log is a plain journald sink. Length is enough to tell an
+            // empty or truncated send apart from a real one.
+            actionLog.info("clawgram outbound sendText", {
+                accountId: ctx.accountId,
+                rawTo: ctx.to,
+                replyToId: ctx.replyToId ?? null,
+                threadId: ctx.threadId ?? null,
+                textLength: ctx.text.length,
+            });
+            // Core normalizes reply payloads and drops the silent token before a
+            // channel is called, so this should never see one. "Should never" is
+            // what the inbound path was assumed to be too, right until it posted a
+            // token — and the check costs a string comparison.
+            if (ctx.text.trim() && (0, helpers_1.isSilentReplyText)(ctx.text)) {
+                actionLog.info("clawgram suppressing silent outbound send", {
+                    accountId: ctx.accountId,
+                    rawTo: ctx.to,
+                });
+                return { skipped: "silent" };
+            }
+            // Core's operational chatter (tool-error warnings, fallback notices)
+            // stays out of group chats: it is telemetry for the operator, not a
+            // reply to the room, and it has already been seen carrying shell
+            // commands with secret-store paths. DMs keep it. The text itself is
+            // never logged — see system-notice.ts for why.
+            const suppressedNotice = (0, system_notice_1.shouldSuppressGroupSystemNotice)({
+                targetKind: (0, helpers_1.inferOutboundTargetKind)(ctx.to),
+                text: ctx.text,
+                to: ctx.to,
+                operatorIds: (0, system_notice_1.operatorIdsFor)(ctx.accountId),
+            });
+            if (suppressedNotice) {
+                actionLog.warn("clawgram suppressing system notice in group", {
+                    accountId: ctx.accountId,
+                    rawTo: ctx.to,
+                    noticeKind: suppressedNotice,
+                    textLength: ctx.text.length,
+                });
+                return { skipped: "system-notice" };
+            }
+            const gram = runtimes.get(ctx.accountId);
+            if (!gram) {
+                throw new Error(`clawgram: runtime not found for account ${ctx.accountId}`);
+            }
+            // The agent already answered this message with its own `send`, and this
+            // is core delivering the same turn's final text. Two messages for one
+            // answer is how 2026-08-10 read in a work chat: every request reported
+            // twice, in slightly different words, seconds apart.
+            //
+            // Core's own convention is that an agent which has sent a message
+            // returns NO_REPLY; this catches the turns that forget. The window is
+            // seconds wide, so a result the assistant comes back with later is
+            // still delivered.
+            if (ctx.replyToId !== null && ctx.replyToId !== undefined && (0, group_visible_reply_guard_1.hadTurnSendJustNow)({
+                accountId: ctx.accountId,
+                chatId: (0, helpers_1.normalizeOutboundTarget)(ctx.to),
+                currentMessageId: ctx.replyToId,
+            })) {
+                actionLog.warn("clawgram suppressing echo of a turn that already sent", {
+                    accountId: ctx.accountId,
+                    rawTo: ctx.to,
+                    replyToId: ctx.replyToId,
+                    textLength: ctx.text.length,
+                });
+                return { skipped: "duplicate" };
+            }
+            const groupReplyAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
+                accountId: ctx.accountId,
+                chatId: ctx.to,
+                replyToId: ctx.replyToId,
+            });
+            const targetKind = (0, helpers_1.inferOutboundTargetKind)(ctx.to);
+            const target = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
+            const messageThreadId = (0, helpers_2.parseOptionalThreadId)(ctx.threadId);
+            const sent = await gram.sendText({
+                target,
+                text: (0, helpers_1.prefixReplyTextToAddress)(ctx.text, groupReplyAddress),
+                targetKind,
+                replyToMessageId: (0, helpers_1.resolveReplyToMessageIdForTarget)(ctx.to, ctx.replyToId),
+                messageThreadId,
+                parseMode: gram.replyParseMode,
+            });
+            actionLog.info("clawgram outbound sendText completed", {
+                accountId: ctx.accountId,
+                to: target,
+                targetKind,
+                replyToId: ctx.replyToId ?? null,
+                sentMessageId: String(sent?.id ?? ""),
+            });
+            return {
+                ok: true,
+                messageId: String(sent?.id ?? ""),
+            };
+        },
+        async sendMedia(ctx) {
+            const gram = runtimes.get(ctx.accountId);
+            if (!gram) {
+                throw new Error(`clawgram: runtime not found for account ${ctx.accountId}`);
+            }
+            // Same rule as the action path: a local file outside the declared
+            // roots is refused before anything is uploaded.
+            const outboundRoots = ctx.mediaLocalRoots ?? ctx.mediaAccess?.localRoots;
+            (0, media_1.assertLocalMediaWithinRoots)(ctx.filePath, outboundRoots);
+            (0, media_1.assertLocalMediaWithinRoots)(ctx.mediaUrl, outboundRoots);
+            actionLog.info("clawgram outbound sendMedia", {
+                accountId: ctx.accountId,
+                rawTo: ctx.to,
+                replyToId: ctx.replyToId ?? null,
+                threadId: ctx.threadId ?? null,
+                filePath: ctx.filePath ?? null,
+                mediaUrl: ctx.mediaUrl ?? null,
+                hasText: Boolean(ctx.text),
+                hasCaption: Boolean(ctx.caption),
+                asVoice: ctx.audioAsVoice === true,
+            });
+            const file = ctx.filePath ?? ctx.mediaUrl;
+            if (!file) {
+                throw new Error("clawgram: sendMedia requires filePath or mediaUrl");
+            }
+            // Ниже — проверки, которые у `sendText` были, а здесь не было ни
+            // одной: путь доставки медиа писался отдельно и обзавёлся только
+            // своими границами (находка A6-18).
+            const mediaTarget = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
+            // Область отправки: файл наружу — такое же исходящее, как текст.
+            // `resolveTarget` ядро зовёт не на каждом пути, поэтому проверяем и тут.
+            if (!(0, send_scope_1.isChatSendable)(mediaTarget, (0, send_scope_1.sendScopeFor)(ctx.accountId))) {
+                actionLog.warn("clawgram outbound sendMedia refused", {
+                    accountId: ctx.accountId,
+                    target: mediaTarget,
+                    reason: (0, send_scope_1.isPhoneNumberTarget)(mediaTarget) ? "phone-number target" : "chat outside send scope",
+                });
+                return { skipped: "not-allowed" };
+            }
+            // Молчаливый ответ: подпись с токеном молчания означает «ничего не
+            // говорить», и отправлять файл с ним в подписи — тем более.
+            const mediaCaption = ctx.caption ?? ctx.text;
+            if (mediaCaption?.trim() && (0, helpers_1.isSilentReplyText)(mediaCaption)) {
+                actionLog.info("clawgram suppressing silent outbound media", {
+                    accountId: ctx.accountId,
+                    rawTo: ctx.to,
+                });
+                return { skipped: "silent" };
+            }
+            // Обращение в группе — то же, что у текста: адрес принадлежит
+            // конкретному входящему сообщению, а не последнему говорившему.
+            const mediaReplyAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
+                accountId: ctx.accountId,
+                chatId: ctx.to,
+                replyToId: ctx.replyToId,
+            });
+            // Чего здесь НЕТ намеренно:
+            // — подавление эха хода (`hadTurnSendJustNow`): у текста дубль стоит
+            //   лишнего сообщения, а у медиа отказ стоит потерянного файла —
+            //   картинку агент готовил, и второй раз она не появится;
+            // — подавление служебных сообщений ядра в группах: они текстовые,
+            //   медиа-доставка ими не бывает.
+            const messageThreadId = (0, helpers_2.parseOptionalThreadId)(ctx.threadId);
+            // Same normalization `sendText` does two functions up. Without it the
+            // channel prefix reaches peer resolution and the send throws — which is
+            // exactly how a synthesized group reply died on 2026-08-08, silently
+            // enough that the transcript fallback posted it as raw text instead.
+            const target = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
+            const sent = await gram.sendMedia({
+                target,
+                file,
+                // Подпись получает то же обращение, что и текстовый ответ.
+                caption: mediaCaption
+                    ? (0, helpers_1.prefixReplyTextToAddress)(mediaCaption, mediaReplyAddress)
+                    : mediaCaption,
+                // Captions follow the account reply format like every other reply:
+                // they are the same agent prose, just attached to a file (2.15.0).
+                parseMode: gram.replyParseMode,
+                replyToMessageId: (0, helpers_1.resolveReplyToMessageIdForTarget)(ctx.to, ctx.replyToId),
+                messageThreadId,
+                asVoice: ctx.audioAsVoice === true,
+            });
+            actionLog.info("clawgram outbound sendMedia completed", {
+                accountId: ctx.accountId,
+                to: ctx.to,
+                replyToId: ctx.replyToId ?? null,
+                sentMessageId: String(sent?.id ?? ""),
+            });
+            return {
+                ok: true,
+                messageId: String(sent?.id ?? ""),
+            };
+        },
+    };
+}

package/dist/proxy-config.js

@@ -3,10 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveProxyConfig = resolveProxyConfig;
 exports.buildTelegramClientOptions = buildTelegramClientOptions;
 exports.describeProxy = describeProxy;
+const util_1 = require("./util");
 const CONNECTION_RETRIES = 5;
-function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function toFiniteNumber(value) {
     if (typeof value === "number") {
         return value;
@@ -83,7 +81,7 @@ function resolveProxyConfig(value) {
     if (value === undefined || value === null) {
         return undefined;
     }
-    if (!isPlainObject(value)) {
+    if (!(0, util_1.isPlainObject)(value)) {
         throw new Error("clawgram: proxy must be an object.");
     }
     const ip = resolveProxyHost(value.ip);

package/dist/reactions.js

@@ -14,6 +14,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAgentReactionGuidance = resolveAgentReactionGuidance;
 exports.parseReactionParams = parseReactionParams;
 const helpers_1 = require("./helpers");
+const history_1 = require("./history");
 /**
  * How freely the agent may react, from the account's `reactionLevel`.
  *
@@ -59,24 +60,14 @@ function readBooleanFlag(value) {
  * some unrelated message, so anything else is refused rather than coerced —
  * the same reasoning as the history parser's id/date guard.
  */
-function parseMessageId(value) {
-    if (value === undefined || value === null || value === "") {
-        return undefined;
-    }
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed <= 0) {
-        throw new Error(`clawgram: react messageId must be a positive integer, got ${JSON.stringify(value)}`);
-    }
-    return parsed;
-}
 function parseReactionParams(params, toolContext) {
     const rawTarget = (0, helpers_1.readChatTargetParam)(params, toolContext);
     const target = typeof rawTarget === "string" ? rawTarget.trim() : "";
     if (!target) {
         throw new Error("clawgram: react requires a chatId");
     }
-    const messageId = parseMessageId(params.messageId ?? params.msgId ?? params.message_id)
-        ?? parseMessageId(toolContext?.currentMessageId);
+    const messageId = (0, history_1.parseMessageId)(params.messageId ?? params.msgId ?? params.message_id, "react messageId")
+        ?? (0, history_1.parseMessageId)(toolContext?.currentMessageId, "react messageId");
     if (messageId === undefined) {
         throw new Error("clawgram: react requires a messageId");
     }

package/dist/secret-refs.js

@@ -19,6 +19,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.secretRefKey = secretRefKey;
+exports.asSecretRef = asSecretRef;
 exports.collectAccountSecretRefs = collectAccountSecretRefs;
 exports.applyAccountSecrets = applyAccountSecrets;
 exports.hasUnresolvedSecretRef = hasUnresolvedSecretRef;

package/dist/send-scope.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPhoneNumberTarget = isPhoneNumberTarget;
+exports.isSendScopeConfigured = isSendScopeConfigured;
+exports.isChatSendable = isChatSendable;
+exports.rememberSendScope = rememberSendScope;
+exports.sendScopeFor = sendScopeFor;
+exports.forgetSendScope = forgetSendScope;
+const history_1 = require("./history");
+/**
+ * Outbound scope for the account: who this account may write to.
+ *
+ * Reading has had a declared scope since 2.x (`readChats`), management has
+ * one (`manageChats`), and sending had none: `send`, `upload-file` and
+ * `react` resolved whatever target the caller named and delivered it. The
+ * account is a person's own Telegram account, so an injected turn could
+ * message strangers under the owner's name, or carry a work chat's content
+ * into an attacker's DM one `send` at a time (finding A5-12).
+ *
+ * Two decisions worth stating, because both could reasonably have gone the
+ * other way:
+ *
+ * 1. **An absent `sendChats` still allows sending.** `manageChats` denies by
+ *    default because management arrived as a new capability; sending is what
+ *    this plugin has always done, and flipping it to "current conversation
+ *    only" would silence every existing deployment on upgrade — including
+ *    scheduled digests that legitimately write to an id nobody is talking to
+ *    right now. A deployment that wants the boundary writes `sendChats`, and
+ *    then it is a boundary in code rather than a sentence in a prompt.
+ *
+ * 2. **A phone number is refused in every configuration**, wildcard included.
+ *    Messaging a raw number starts a conversation with someone who never
+ *    interacted with the account and hands them the account's identity;
+ *    no deployment has a reason to do that from an assistant, and the
+ *    address book is not the model's to walk.
+ */
+/** Anything that looks like a dialable number rather than a chat we know. */
+function isPhoneNumberTarget(target) {
+    const raw = String(target ?? "").trim();
+    if (!raw)
+        return false;
+    // A Telegram chat id is digits (a user) or `-100…` (a group); a phone
+    // number is what a person writes with a plus, spaces, dashes or brackets.
+    // The `+` is the giveaway that survives normalisation, and a long digit
+    // string with separators is the other spelling of the same thing.
+    const compact = raw.replace(/[\s()\-.]/g, "");
+    if (/^\+\d{6,15}$/.test(compact))
+        return true;
+    return /[\s()\-.]/.test(raw) && /^\+?\d[\d\s()\-.]{5,}$/.test(raw);
+}
+function normalizeScope(sendChats) {
+    if (sendChats === undefined || sendChats === null)
+        return [];
+    return (Array.isArray(sendChats) ? sendChats : [sendChats])
+        .map(history_1.normalizeChatKey)
+        .filter(Boolean);
+}
+/** True while the account has a declared outbound scope at all. */
+function isSendScopeConfigured(sendChats) {
+    return sendChats !== undefined && sendChats !== null;
+}
+function isChatSendable(target, sendChats) {
+    if (isPhoneNumberTarget(target))
+        return false;
+    if (!isSendScopeConfigured(sendChats))
+        return true;
+    const entries = normalizeScope(sendChats);
+    // A configured empty list is a decision, not an oversight: deny, the same
+    // way `readChats: []` denies rather than reading everything.
+    if (entries.length === 0)
+        return false;
+    if (entries.includes("*"))
+        return true;
+    return (0, history_1.chatKeyCandidates)(target).some((candidate) => entries.includes(candidate));
+}
+/**
+ * Область отправки каждого аккаунта, запомненная при его старте.
+ *
+ * В `outbound.resolveTarget` и `sendText` конфига нет — ядро зовёт их с
+ * `{ accountId, to }`, — а тащить её туда параметром значило бы менять
+ * контракт ядра ради одной проверки. Тот же приём уже применён к списку
+ * операторов (`system-notice.ts`), и по той же причине.
+ *
+ * Перезапуск канала при правке конфига обновляет запись; аккаунт, о котором
+ * ничего не помним, ведёт себя как аккаунт без области — то есть отправка
+ * разрешена, но телефонный адресат всё равно отвергнут.
+ */
+const sendScopeByAccount = new Map();
+function rememberSendScope(accountId, sendChats) {
+    sendScopeByAccount.set(accountId, sendChats);
+}
+function sendScopeFor(accountId) {
+    return sendScopeByAccount.get(accountId);
+}
+function forgetSendScope(accountId) {
+    sendScopeByAccount.delete(accountId);
+}

package/dist/silent-reaction.js

@@ -20,14 +20,13 @@
  * tested without Telegram or a model.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TELEGRAM_REACTIONS = void 0;
 exports.buildEmojiSystemPrompt = buildEmojiSystemPrompt;
 exports.canonicalizeReactionEmoji = canonicalizeReactionEmoji;
 exports.parseEmojiChoice = parseEmojiChoice;
 exports.shouldReactToSilentTurn = shouldReactToSilentTurn;
 exports.reactToSilentMention = reactToSilentMention;
 function buildEmojiSystemPrompt(appetite, allowed) {
-    const choices = allowed === undefined || allowed.length === 0 ? exports.TELEGRAM_REACTIONS : allowed;
+    const choices = allowed === undefined || allowed.length === 0 ? TELEGRAM_REACTIONS : allowed;
     const shared = [
         "You pick a single emoji reaction for a chat message.",
         "The assistant was mentioned in this message but decided it needs no written reply.",
@@ -84,7 +83,9 @@ function buildEmojiSystemPrompt(appetite, allowed) {
  * difference is invisible in an editor and a stray U+FE0F would break them
  * again silently.
  */
-exports.TELEGRAM_REACTIONS = [
+// Модульная константа: снаружи её никто не читает, а `export` обещает
+// публичную поверхность, которой нет (A6-21).
+const TELEGRAM_REACTIONS = [
     "👍", "👎", "❤", "🔥", "🥰", "👏", "😁", "🤔", "🤯", "😱",
     "🤬", "😢", "🎉", "🤩", "🤮", "💩", "🙏", "👌", "\u{1F54A}", "🤡",
     "🥱", "🥴", "😍", "🐳", "🌚", "🌭", "💯", "🤣", "⚡", "🍌",
@@ -101,7 +102,10 @@ exports.TELEGRAM_REACTIONS = [
  * `👍🏽` is not a member of the set, `👍` is.
  */
 function canonicalizeReactionEmoji(value) {
-    return value.replace(/️/g, "").replace(/[\u{1F3FB}-\u{1F3FF}]/gu, "");
+    // U+FE0F записан кодом, а не символом: в исходнике он невидим, и
+    // регекс выглядел как `/ /g` — пустая на вид группа, которую при
+    // следующей правке легко «почистить» вместе со смыслом (S1-09).
+    return value.replace(/\u{FE0F}/gu, "").replace(/[\u{1F3FB}-\u{1F3FF}]/gu, "");
 }
 /**
  * Turns a model answer into an emoji Telegram will actually take, or nothing.
@@ -132,7 +136,7 @@ function parseEmojiChoice(raw, allowed) {
     // `ChatReactionsNone` — reactions switched off — and must permit nothing.
     // Collapsing the two would react in a chat that forbids reacting.
     const permitted = allowed === undefined
-        ? exports.TELEGRAM_REACTIONS
+        ? TELEGRAM_REACTIONS
         : allowed.map(canonicalizeReactionEmoji);
     return permitted.includes(candidate) ? candidate : undefined;
 }

package/dist/state-dir.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStateDir = resolveStateDir;
+/**
+ * Где живёт состояние OpenClaw — одним ответом для всего плагина.
+ *
+ * `OPENCLAW_STATE_DIR` первичен, дом — запасной вариант. Правило не
+ * косметическое: изолированный Gateway, который AGENTS.md предписывает для
+ * любой локальной проверки («никогда не трогай `~/.openclaw` — всегда задавай
+ * `OPENCLAW_STATE_DIR`»), иначе продолжает писать в боевое состояние.
+ *
+ * Помощник по медиа переменную уже уважал, журнал присоединений — нет, и
+ * тестовый экземпляр дописывал записи в живой журнал, а на двух тысячах
+ * записей переписывал его (находка A6-07). Резолвер один, чтобы такие
+ * расхождения не заводились по одному на файл.
+ */
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+function resolveStateDir(env = process.env) {
+    const configured = env.OPENCLAW_STATE_DIR;
+    if (typeof configured === "string" && configured.trim())
+        return configured.trim();
+    return (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw");
+}

package/dist/system-notice.js

@@ -27,6 +27,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifySystemNotice = classifySystemNotice;
 exports.shouldSuppressGroupSystemNotice = shouldSuppressGroupSystemNotice;
+exports.isOperatorRecipient = isOperatorRecipient;
+exports.rememberOperatorIds = rememberOperatorIds;
+exports.operatorIdsFor = operatorIdsFor;
+exports.forgetOperatorIds = forgetOperatorIds;
 const TOOL_WARNING_PREFIX = "⚠️ 🛠️ ";
 const MESSAGE_FAILED_PREFIX = "⚠️ ✉️ message failed";
 const FALLBACK_NOTICE_PREFIX = "↪️ model fallback";
@@ -62,9 +66,50 @@ function classifySystemNotice(text) {
  * so the text seen here is core's payload verbatim.
  */
 function shouldSuppressGroupSystemNotice(params) {
-    // DMs keep the telemetry: there the reader is the person running the agent.
-    if (params.targetKind !== "group" && params.targetKind !== "channel") {
-        return undefined;
+    if (params.targetKind === "group" || params.targetKind === "channel") {
+        return classifySystemNotice(params.text);
+    }
+    // Личка держала телеметрию на допущении «здесь читает тот, кто запустил
+    // агента». Допущение неверно: в личку пишет всякий, кто попал в `allowFrom`,
+    // и посторонний, чей ход уронил инструмент, получал `⚠️ 🛠️ Bash failed:`
+    // с полной командой и путями вроде /opt/openclaw-secrets/… (A5-11).
+    //
+    // Поэтому телеметрия уходит только названному оператору. Список пуст или
+    // содержит `*` — значит «оператор» не определён, и уведомление подавляется:
+    // потерять диагностику дешевле, чем отдать раскладку инфраструктуры
+    // незнакомцу, тем более что те же сбои лежат в диагностике прогона,
+    // в `lastError` джоба и в логе gateway.
+    if (!isOperatorRecipient(params.to, params.operatorIds)) {
+        return classifySystemNotice(params.text);
     }
-    return classifySystemNotice(params.text);
+    return undefined;
+}
+function isOperatorRecipient(to, operatorIds) {
+    if (to === undefined || to === null || String(to).trim() === "")
+        return false;
+    if (!operatorIds || operatorIds.length === 0)
+        return false;
+    // `*` здесь не «все операторы», а «оператор не назван»: в списке отправителей
+    // звёздочка означает «кто угодно», и телеметрию кому угодно слать нельзя.
+    if (operatorIds.some((id) => String(id).trim() === "*"))
+        return false;
+    const target = String(to).trim().replace(/^@/, "").toLowerCase();
+    return operatorIds.some((id) => String(id).trim().replace(/^@/, "").toLowerCase() === target);
+}
+/**
+ * Кто оператор у каждого аккаунта.
+ *
+ * Список запоминается при старте аккаунта: в `outbound.sendText` конфига нет,
+ * а тащить её туда параметром значило бы менять контракт ради одной проверки.
+ * Перезапуск канала при правке конфига обновляет запись.
+ */
+const operatorIdsByAccount = new Map();
+function rememberOperatorIds(accountId, ids) {
+    operatorIdsByAccount.set(accountId, [...ids]);
+}
+function operatorIdsFor(accountId) {
+    return operatorIdsByAccount.get(accountId) ?? [];
+}
+function forgetOperatorIds(accountId) {
+    operatorIdsByAccount.delete(accountId);
 }