clawgram 2.19.4 → 2.20.2

package/dist/channel.js

@@ -70,6 +70,7 @@ const joins_1 = require("./joins");
 const reactions_1 = require("./reactions");
 const manage_1 = require("./manage");
 const silent_reaction_1 = require("./silent-reaction");
+const system_notice_1 = require("./system-notice");
 const chat_info_1 = require("./chat-info");
 const topics_1 = require("./topics");
 const dialogs_1 = require("./dialogs");
@@ -800,7 +801,11 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                                     text,
                                     message: rawMessage,
                                 });
-                            const wasReplyToSelf = await (0, helpers_1.isReplyToSelfMessage)(rawMessage, selfId);
+                            // One fetch serves two needs: the reply-to-self gate below and
+                            // the parent's text for the agent (ReplyToBody), which a plain
+                            // reply does not carry on its own.
+                            const replyParent = await (0, helpers_1.resolveReplyParent)(rawMessage, { selfId, selfLabel });
+                            const wasReplyToSelf = replyParent.isSelf;
                             const mentionDecision = (0, channel_inbound_1.resolveInboundMentionDecision)({
                                 facts: {
                                     canDetectMention: true,
@@ -874,6 +879,10 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                                 // bare text, and the fragment the person pointed at is lost.
                                 ReplyToQuoteText: normalized.replyQuoteText,
                                 ReplyToIsQuote: normalized.replyIsQuote,
+                                // A plain reply has no highlight; core then falls back to the
+                                // parent's body, which only exists if the channel fetched it.
+                                ReplyToBody: replyParent.body,
+                                ReplyToSender: replyParent.sender,
                                 MessageThreadId: normalized.messageThreadId,
                                 NativeChannelId: normalized.chatId,
                                 // Trusted per-group prompt block from `groups.<id>.systemPrompt`.
@@ -1178,6 +1187,10 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                             });
                             return;
                         }
+                        // Same fetch as the group path. In a DM the parent is as often
+                        // the agent's own message as the person's — the owner answers a
+                        // notice she sent — and neither text is available any other way.
+                        const replyParent = await (0, helpers_1.resolveReplyParent)(rawMessage, { selfId, selfLabel });
                         await gram.withTyping(conversationTarget, async () => {
                             await (0, direct_dm_1.dispatchInboundDirectDmWithRuntime)({
                                 cfg,
@@ -1209,6 +1222,8 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                                     // direct messages too, and the fragment is not part of the text.
                                     ReplyToQuoteText: normalized.replyQuoteText,
                                     ReplyToIsQuote: normalized.replyIsQuote,
+                                    ReplyToBody: replyParent.body,
+                                    ReplyToSender: replyParent.sender,
                                     NativeChannelId: normalized.chatId,
                                 },
                                 deliver: async (payload) => {
@@ -2405,6 +2420,24 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                     });
                     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,
+                });
+                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}`);

package/dist/helpers.js

@@ -36,6 +36,7 @@ exports.prefixReplyTextToAddress = prefixReplyTextToAddress;
 exports.resolveReplyTarget = resolveReplyTarget;
 exports.resolveChatTarget = resolveChatTarget;
 exports.isReplyToSelfMessage = isReplyToSelfMessage;
+exports.resolveReplyParent = resolveReplyParent;
 exports.resolveSenderProfile = resolveSenderProfile;
 exports.resolveSenderProfileWithTimeout = resolveSenderProfileWithTimeout;
 exports.normalizeParseMode = normalizeParseMode;
@@ -549,27 +550,58 @@ async function resolveChatTarget(message) {
     }
     return message?.inputChat ?? message?._inputChat ?? message?.chat ?? message?._chat ?? message?.peerId;
 }
-async function isReplyToSelfMessage(message, selfId) {
-    if (!selfId) {
-        return false;
-    }
+/**
+ * The message a reply points at, fetched once.
+ *
+ * Telegram does not put the parent's text into the reply; a highlight
+ * (`quoteText`) is the only fragment that travels with it, and most replies
+ * have none. Core renders `[Replying to: …]` from the highlight or, failing
+ * that, from `ReplyToBody` — so without this fetch a plain reply reaches the
+ * agent as a bare parent id. The case that exposed it: the owner answered, in
+ * a DM, the agent's own notice about an unknown sender; the notice had been
+ * sent from another session, DMs are outside `readChats`, and the agent had
+ * no way to learn what "reply to #1011" referred to.
+ *
+ * Failure degrades to "no context" on purpose: a parent that cannot be
+ * fetched (deleted, flood-waited, transport hiccup) must not cost the
+ * message itself.
+ */
+async function resolveReplyParent(message, input) {
     const replyToMessageId = message?.replyTo?.replyToMsgId ?? message?.replyToMsgId;
     if (!replyToMessageId) {
-        return false;
+        return { isSelf: false };
     }
     const replied = typeof message?.getReplyMessage === "function"
         ? await message.getReplyMessage().catch(() => undefined)
         : undefined;
     if (!replied) {
-        return false;
-    }
-    if (replied.out === true) {
-        return true;
+        return { isSelf: false };
     }
     const replySenderId = replied.senderId ??
         replied.fromId?.userId ??
         replied.fromId?.channelId;
-    return replySenderId !== undefined && String(replySenderId) === selfId;
+    const isSelf = replied.out === true ||
+        (input.selfId !== undefined && replySenderId !== undefined && String(replySenderId) === input.selfId);
+    const rawText = typeof replied.message === "string" ? replied.message :
+        typeof replied.text === "string" ? replied.text :
+            "";
+    const body = rawText.trim() ? rawText : undefined;
+    const source = replied.sender ?? replied._sender;
+    const sender = isSelf
+        ? (input.selfLabel ?? (input.selfId !== undefined ? input.selfId : undefined))
+        : toDisplayName({
+            firstName: typeof source?.firstName === "string" ? source.firstName : undefined,
+            lastName: typeof source?.lastName === "string" ? source.lastName : undefined,
+            username: undefined,
+            fallback: resolveActiveUsername(source) ? `@${resolveActiveUsername(source)}` : (replySenderId !== undefined ? String(replySenderId) : undefined),
+        });
+    return { isSelf, body, sender: sender || undefined };
+}
+async function isReplyToSelfMessage(message, selfId) {
+    if (!selfId) {
+        return false;
+    }
+    return (await resolveReplyParent(message, { selfId })).isSelf;
 }
 async function resolveSenderProfile(message, input) {
     const pickProfile = (source) => {

package/dist/system-notice.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Core's operational chatter — and why a group chat never sees it.
+ *
+ * When a tool call fails or the model silently degrades, core appends a
+ * status line to the turn's outbound payloads: `⚠️ 🛠️ Exec failed: …`,
+ * `⚠️ ✉️ Message failed`, `↪️ Model Fallback: …`. In a DM with the owner that
+ * is legitimate telemetry. In a group it is the assistant narrating its own
+ * kitchen to an audience the message was never for — measured three days in a
+ * row in the owner's work chat (2026-08-30 … 09-01): a jq stack trace with
+ * server paths, a bare "Message failed", an exec step list. The people in the
+ * chat cannot act on any of it, and the owner reads it as the assistant
+ * being broken.
+ *
+ * Detection is by core's own exact prefixes, not by keyword: the assistant is
+ * allowed to *say* "⚠️" or discuss a failure in its own words — only core's
+ * machine-built notices match. The list mirrors what core actually emits
+ * (`isCronToolWarning` matches `⚠️ 🛠️ ` verbatim; the message-failed check is
+ * the same normalized comparison core uses; fallback notices are built by
+ * `buildFallbackNotice`/`buildFallbackClearedNotice`).
+ *
+ * Nothing is lost by dropping them here: the same failures live in the run's
+ * diagnostics, the cron job's `lastError` and the gateway log. The drop is
+ * logged with the notice's class and length — never its text, which has
+ * already been seen carrying secret-store paths and full shell commands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifySystemNotice = classifySystemNotice;
+exports.shouldSuppressGroupSystemNotice = shouldSuppressGroupSystemNotice;
+const TOOL_WARNING_PREFIX = "⚠️ 🛠️ ";
+const MESSAGE_FAILED_PREFIX = "⚠️ ✉️ message failed";
+const FALLBACK_NOTICE_PREFIX = "↪️ model fallback";
+/**
+ * Classifies core's operational status lines. `undefined` means the text is a
+ * real reply and must be delivered untouched.
+ */
+function classifySystemNotice(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (trimmed.startsWith(TOOL_WARNING_PREFIX)) {
+        return "tool-warning";
+    }
+    const lower = trimmed.toLowerCase();
+    if (lower === MESSAGE_FAILED_PREFIX || lower.startsWith(`${MESSAGE_FAILED_PREFIX}:`)) {
+        return "message-failed";
+    }
+    // Covers both "↪️ Model Fallback: …" and "↪️ Model Fallback cleared: …".
+    if (lower.startsWith(FALLBACK_NOTICE_PREFIX)) {
+        return "model-fallback";
+    }
+    return undefined;
+}
+/**
+ * A notice glued to a real reply is not a notice: `classifySystemNotice` looks
+ * at the start of the text on purpose, so an answer that quotes or discusses a
+ * warning still goes out. Only a payload that IS the notice — the whole text,
+ * possibly with the group-address prefix core adds — is suppressible.
+ *
+ * The address prefix ("@name, ") is applied by the channel after this check,
+ * 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;
+    }
+    return classifySystemNotice(params.text);
+}

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "clawgram",
   "name": "Clawgram",
   "description": "Clawgram — personal Telegram (MTProto userbot) channel for OpenClaw. Your AI assistant reads and responds as you.",
-  "version": "2.19.4",
+  "version": "2.20.2",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawgram",
-  "version": "2.19.4",
+  "version": "2.20.2",
   "description": "Clawgram — personal Telegram (MTProto userbot) channel for OpenClaw. Your AI assistant reads and responds as you.",
   "main": "./dist/index.js",
   "scripts": {