polygram 0.5.8 → 0.5.10

package/lib/process-manager.js

@@ -168,6 +168,12 @@ class ProcessManager {
    * If the queue is empty, kill now; otherwise mark the entry so it kills
    * itself when the last pending resolves. Next send() respawns fresh
    * with whatever config spawnFn reads at that moment.
+   *
+   * onRespawn fires with `wasDrained=true` ONLY when we waited for an
+   * in-flight turn to finish before swapping. The immediate-kill case
+   * (queue empty at request time) calls onRespawn with `wasDrained=false`
+   * so callers can decide whether to post a user-visible confirmation
+   * (which is redundant noise when the user wasn't waiting on a turn).
    */
   requestRespawn(sessionKey, reason = 'config-change') {
     const entry = this.procs.get(sessionKey);
@@ -181,17 +187,17 @@ class ProcessManager {
     });
     if (entry.pendingQueue.length === 0) {
       // Queue empty — kill immediately, fire onRespawn after close.
-      this._killAndNotifyRespawn(sessionKey, reason).catch(() => {});
+      this._killAndNotifyRespawn(sessionKey, reason, false).catch(() => {});
       return { killed: true, queued: 0 };
     }
     return { killed: false, queued: entry.pendingQueue.length };
   }
 
-  async _killAndNotifyRespawn(sessionKey, reason) {
+  async _killAndNotifyRespawn(sessionKey, reason, wasDrained) {
     const entry = this.procs.get(sessionKey);
     await this.kill(sessionKey);
     if (this.onRespawn && entry) {
-      try { this.onRespawn(sessionKey, reason, entry); }
+      try { this.onRespawn(sessionKey, reason, entry, wasDrained); }
       catch (err) { this.logger.error(`[pm] onRespawn: ${err.message}`); }
     }
   }
@@ -321,7 +327,10 @@ class ProcessManager {
               chat_id: entry.chatId,
               reason,
             });
-            this._killAndNotifyRespawn(sessionKey, reason).catch(() => {});
+            // wasDrained=true: this path runs after the queue emptied
+            // naturally (an in-flight turn finished), so the user was
+            // waiting and the confirmation message is meaningful.
+            this._killAndNotifyRespawn(sessionKey, reason, true).catch(() => {});
           }
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "Telegram daemon for Claude Code that preserves the OpenClaw per-chat session model. Migration path for OpenClaw users moving to Claude Code.",
   "main": "lib/ipc-client.js",
   "bin": {

package/polygram.js

@@ -1626,9 +1626,17 @@ function shouldHandle(msg, chatConfig, botUsername) {
     const text = msg.text || msg.caption || '';
     const isReplyToBot = msg.reply_to_message?.from?.username === botUsername;
     const hasMention = text.includes(`@${botUsername}`);
-    // Paired users bypass requireMention — they've been explicitly trusted
-    // in this chat by an operator, no need for a mention every time.
-    const paired = pairings && msg.from?.id
+    // A reply targeting some other user (not the bot) is a strong signal
+    // "this message is for that person, not me". Paired users normally
+    // bypass requireMention, but not in this case — without the guard a
+    // paired user saying "Gotcha!" to a teammate gets processed by the
+    // bot just because the user is paired, which is what bit us in
+    // UMI Group on 0.5.9 (bot leaked reasoning as a reply to "Gotcha!").
+    const repliesToOtherUser = !!msg.reply_to_message
+      && msg.reply_to_message.from?.username !== botUsername;
+    // Paired users bypass requireMention — operator-trusted, no @ needed
+    // every time. Skipped when they're replying to a non-bot user (above).
+    const paired = !repliesToOtherUser && pairings && msg.from?.id
       ? pairings.hasLivePairing({ bot_name: BOT_NAME, user_id: msg.from.id, chat_id: chatId })
       : false;
     if (!isReplyToBot && !hasMention && !paired) return false;
@@ -2174,8 +2182,13 @@ async function main() {
     },
     // Fires after a graceful /model or /effort drain has actually
     // swapped to the new settings. Post a confirmation back to the
-    // chat so the user knows the switch happened.
-    onRespawn: (sessionKey, reason, entry) => {
+    // chat ONLY when wasDrained=true — the user actively waited for an
+    // in-flight turn to finish before the switch took effect, so the
+    // explicit "switched" message is meaningful. When the kill was
+    // immediate (queue empty), the inline-card update + button toast
+    // already convey "done", and a separate message is just noise.
+    onRespawn: (sessionKey, reason, entry, wasDrained) => {
+      if (!wasDrained) return;
       const chatId = entry.chatId;
       if (!chatId) return;
       const chatConfig = config.chats[chatId];