polygram 0.8.0-rc.37 → 0.8.0-rc.39

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.8.0-rc.37",
+  "version": "0.8.0-rc.39",
   "description": "Telegram integration for Claude Code that preserves the OpenClaw per-chat session model. Migration target for OpenClaw users. Multi-bot, multi-chat, per-topic isolation; SQLite transcripts; inline-keyboard approvals. Bundles /polygram:status|logs|pair-code|approvals admin commands and a history skill.",
   "keywords": [
     "telegram",

package/lib/autosteer-buffer.js

@@ -120,7 +120,19 @@ function makePostToolBatchHook({ buffer, sessionKey, logEvent = null, chatId = n
         } catch { /* logger errors must not break the hook */ }
       }
       if (typeof onDrained === 'function') {
-        try { onDrained(sessionKey, drained.length); }
+        // rc.38: async-safe. onDrained may return a Promise (it does
+        // today — clearAutosteeredReactions is async). A bare
+        // synchronous try/catch only catches throws, not rejections;
+        // an unhandled rejection escaping the hook would land on the
+        // process-level handler as misleading noise. Detect a
+        // thenable and attach .catch so async failures are logged at
+        // the same site, not as out-of-band unhandledRejection.
+        try {
+          const r = onDrained(sessionKey, drained.length);
+          if (r && typeof r.then === 'function') {
+            r.catch((err) => logger?.error?.(`[${sessionKey}] onDrained async: ${err?.message || err}`));
+          }
+        }
         catch (err) { logger?.error?.(`[${sessionKey}] onDrained: ${err?.message || err}`); }
       }
       return {

package/lib/parse-response.js

@@ -3,7 +3,8 @@
  *   - sticker (single emoji that maps to a sticker, OR literal
  *     `[sticker:NAME]` mimic — see below)
  *   - reaction (single emoji not mapped to a sticker)
- *   - text (everything else)
+ *   - text (everything else, with inline `[sticker:NAME]` markers
+ *     extracted into a parallel `stickers[]` array)
  *
  * Why this lives in lib/: polygram.js is a top-level script (calls main()
  * at bottom) and can't be require()'d from a test without starting a bot.
@@ -19,38 +20,102 @@
  * the placeholder ended up rendered in the user's chat instead of an
  * actual sticker.
  *
- * Match shape: optional whitespace, `[sticker:`, NAME (alnum/_/-), `]`,
- * optional whitespace. NAME must resolve in the supplied stickerMap;
- * unknown NAMEs fall through to the text path so a genuine
- * "[sticker:foo]" message (e.g. someone joking, or a stale name from an
- * older deploy) still reaches the user verbatim.
+ * 0.8.0-rc.39 (item: inline sticker regression):
+ * Claude evolved to use `[sticker:NAME]` INLINE within longer replies
+ * (e.g. "Done! [sticker:pumped]\n\nStripe Mar 2026 created ✅\n…") —
+ * not as a solo response. The 0.7.5 fix only handled the solo case
+ * (full text = tag), so inline tags leaked through the text path
+ * verbatim. Now we extract every recognised inline tag, strip it
+ * from the text, and surface them in a `stickers[]` array on the
+ * result. polygram.js sends the cleaned text first, then each
+ * sticker in order. Unknown sticker names still pass through as
+ * literal text (someone may genuinely write that string).
+ *
+ * Match shape: `[sticker:` NAME `]` where NAME is `[A-Za-z0-9_-]+`.
+ * The solo-form regex anchors with `^\s*…\s*$`; the inline-form
+ * regex is unanchored and global. Both share the same NAME charset.
  */
 
+'use strict';
+
 const STICKER_TAG_RE = /^\s*\[sticker:([A-Za-z0-9_-]+)\]\s*$/;
+const STICKER_TAG_INLINE_RE = /\[sticker:([A-Za-z0-9_-]+)\]/g;
 
 function parseResponse(text, { stickerMap = {}, emojiToSticker = {} } = {}) {
   const trimmed = (text || '').trim();
 
+  // Solo-sticker path: entire response is just the tag.
   const tagMatch = trimmed.match(STICKER_TAG_RE);
   if (tagMatch) {
     const name = tagMatch[1];
     const fileId = stickerMap[name];
     if (fileId) {
-      return { text: '', sticker: fileId, stickerLabel: name, reaction: null };
+      return {
+        text: '',
+        sticker: fileId,
+        stickerLabel: name,
+        reaction: null,
+        stickers: [],
+      };
     }
   }
 
+  // Solo-emoji shortcuts (single emoji → sticker if mapped, else reaction).
   const emojiOnly = /^\p{Emoji_Presentation}$/u.test(trimmed)
     || /^\p{Emoji}️?$/u.test(trimmed);
 
   if (emojiOnly && trimmed) {
     if (emojiToSticker[trimmed]) {
-      return { text: '', sticker: emojiToSticker[trimmed], stickerLabel: trimmed, reaction: null };
+      return {
+        text: '',
+        sticker: emojiToSticker[trimmed],
+        stickerLabel: trimmed,
+        reaction: null,
+        stickers: [],
+      };
     }
-    return { text: '', sticker: null, stickerLabel: null, reaction: trimmed };
+    return {
+      text: '',
+      sticker: null,
+      stickerLabel: null,
+      reaction: trimmed,
+      stickers: [],
+    };
   }
 
-  return { text: trimmed, sticker: null, stickerLabel: null, reaction: null };
+  // Inline sticker extraction. Walk every `[sticker:NAME]` in the text;
+  // for each NAME present in stickerMap, push to `stickers[]` and remove
+  // it from the cleaned text. Unknown NAMEs stay verbatim (someone may
+  // genuinely write that string in a message).
+  //
+  // Whitespace handling: replacing a tag with the empty string can leave
+  // a trailing space on its line ("Done! [sticker:x]" → "Done! ") or
+  // stack newlines if the tag stood alone on a line. We strip trailing
+  // whitespace per-line and collapse runs of 3+ blank lines to 2. We do
+  // NOT touch intra-line spacing or code-block indentation.
+  const stickers = [];
+  const cleaned = trimmed.replace(STICKER_TAG_INLINE_RE, (match, name) => {
+    const fileId = stickerMap[name];
+    if (fileId) {
+      stickers.push({ fileId, name });
+      return '';
+    }
+    return match;
+  });
+  const tidied = cleaned
+    .split('\n')
+    .map((line) => line.replace(/[ \t]+$/g, ''))
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+
+  return {
+    text: tidied,
+    sticker: null,
+    stickerLabel: null,
+    reaction: null,
+    stickers,
+  };
 }
 
-module.exports = { parseResponse, STICKER_TAG_RE };
+module.exports = { parseResponse, STICKER_TAG_RE, STICKER_TAG_INLINE_RE };

package/lib/process-manager.js

@@ -298,6 +298,14 @@ class ProcessManager {
   }
 
   async shutdown() {
+    // rc.38: mark "we're shutting down" so the proc.on('close') handler
+    // suppresses the misleading `resume-fail` event for signal-driven
+    // exits (SIGHUP from tmux pty close, SIGTERM from our own kill,
+    // SIGKILL from the kill-timeout escalator). Pre-rc.38 every deploy
+    // logged a `resume-fail` for every CLI-pm chat AND cleared the
+    // saved session_id, forcing a fresh resume on the next user turn
+    // — slower first turn, fresh context — for no real reason.
+    this._shuttingDown = true;
     const keys = Array.from(this.procs.keys());
     for (const key of keys) await this.kill(key);
   }
@@ -542,7 +550,22 @@ class ProcessManager {
       this.procs.delete(sessionKey);
       // A slot freed up → maybe an LRU waiter can run now.
       this._maybeSignalLruWaiter();
-      if (code !== 0 && ctx.existingSessionId && this.db?.clearSessionId) {
+      // rc.38: only fire `resume-fail` for UNEXPECTED non-zero exits.
+      // Signal-driven exits during planned shutdown (SIGHUP from tmux
+      // pty close on `tmux kill-session`, SIGTERM from our own kill(),
+      // SIGKILL from the kill-timeout escalator) are NOT resume
+      // failures — the saved session_id is still valid, we'd just be
+      // clearing it for nothing and logging misleading noise on every
+      // deploy. The real signal we care about is "the CLI rejected a
+      // stale or corrupt resume id at startup with a non-zero exit
+      // while polygram is healthy."
+      const isPlannedShutdown = this._shuttingDown
+        || code === null   // killed without an exit code
+        || code === 129    // SIGHUP (tmux pty close on deploy kickstart)
+        || code === 143    // SIGTERM (our own kill())
+        || code === 137;   // SIGKILL (kill-timeout escalation)
+      if (code !== 0 && ctx.existingSessionId && this.db?.clearSessionId
+          && !isPlannedShutdown) {
         this._logEvent('resume-fail', { session_key: sessionKey, session_id: ctx.existingSessionId, code });
         try { this.db.clearSessionId(sessionKey); } catch (err) {
           this.logger.error(`[${entry.label}] clearSessionId failed: ${err.message}`);
@@ -551,6 +574,16 @@ class ProcessManager {
       if (this.onClose) this.onClose(sessionKey, code, entry);
     });
 
+    // rc.38: stdin error listener. Async EIO writes (the kernel reports
+    // them after the subprocess pipe closed during shutdown) had no
+    // listener pre-rc.38 → bubbled to the global uncaughtException
+    // handler → emitted misleading `uncaught-exception: write EIO`
+    // events on every deploy. Listening swallows that path; runtime
+    // stdin errors (rare; usually a real problem) still log here.
+    proc.stdin?.on?.('error', (err) => {
+      this.logger.error(`[${entry.label}] stdin error: ${err.message}`);
+    });
+
     proc.on('error', (err) => {
       this.logger.error(`[${entry.label}] proc error: ${err.message}`);
       entry.closed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.8.0-rc.37",
+  "version": "0.8.0-rc.39",
   "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

@@ -2532,6 +2532,14 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
         // applyChain — so it serializes after any in-flight
         // QUEUED apply and lands as the final visible reaction.
         await reactor.setState('AUTOSTEERED');
+        // rc.38: stop the reactor's STALL/TIMEOUT timers. Pre-rc.38
+        // the timers stayed armed, holding setTimeout handles for
+        // up to 30s and pinning the closure (and the bot/chatId
+        // captures) until they fired. AUTOSTEERED is terminal — no
+        // further state changes — so the timers serve no purpose
+        // and just delay GC. One-line patch; small steady-state
+        // heap relief in busy chats.
+        reactor.stop();
         markReplied();
         return;
       }
@@ -2729,6 +2737,28 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     const parsed = parseResponse(result.text);
     const outMeta = { ...outMetaBase, sessionId: result.sessionId, costUsd: result.cost };
 
+    // 0.8.0-rc.39: send any inline stickers Claude embedded with
+    // `[sticker:NAME]` markers (parseResponse stripped them from
+    // parsed.text and surfaced them in parsed.stickers[]). Send AFTER
+    // the text reply lands so the sticker reads as punctuation on the
+    // message, not as a leading icon. Failures are logged but never
+    // block the rest of the reply — a missing sticker is a soft UX
+    // miss, not a turn failure.
+    const sendInlineStickers = async () => {
+      if (!parsed.stickers || parsed.stickers.length === 0) return;
+      for (const s of parsed.stickers) {
+        try {
+          await tg(bot, 'sendSticker', {
+            chat_id: chatId,
+            sticker: s.fileId,
+            ...(threadId && { message_thread_id: threadId }),
+          }, { ...outMeta, stickerName: s.name, source: 'inline-sticker' });
+        } catch (err) {
+          console.error(`[${label}] inline sendSticker(${s.name}) failed: ${err.message}`);
+        }
+      }
+    };
+
     // OpenClaw's preview-becomes-final flow:
     //
     //   1. flushDraft() — drain any pending throttled edit so the
@@ -2749,6 +2779,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
         if (fin.finalEditOk) {
           // Preview was successfully edited to the final text.
           // No follow-up messages needed.
+          await sendInlineStickers();
           await cleanupArchivedBubbles();
           console.log(`[${label}] ${elapsed}s | ${result.text.length} chars | streamed | ${chatConfig.model}/${chatConfig.effort} | $${result.cost?.toFixed(4) || '?'}`);
           markReplied();
@@ -2794,6 +2825,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
             console.error(`[${label}] partial-delivery warning failed: ${warnErr.message}`);
           }
         }
+        await sendInlineStickers();
         await cleanupArchivedBubbles();
         console.log(`[${label}] ${elapsed}s | ${result.text.length} chars | streamed-redeliver(${reason}, ${chunks.length} chunks${r.failed.length ? `, ${r.failed.length} failed` : ''}) | ${chatConfig.model}/${chatConfig.effort} | $${result.cost?.toFixed(4) || '?'}`);
         markReplied();
@@ -2836,6 +2868,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       });
     }
 
+    await sendInlineStickers();
     console.log(`[${label}] ${elapsed}s | ${result.text.length} chars | ${chatConfig.model}/${chatConfig.effort} | $${result.cost?.toFixed(4) || '?'}`);
     markReplied();
   } catch (err) {
@@ -2868,6 +2901,17 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   } finally {
     stopTyping();
     reactor.stop();
+    // rc.38: defensive clear-on-exit for ✍ reactions. Pre-rc.38 only
+    // the success path (line ~2622), the abort path (line ~2858), and
+    // the tool-only-completion path (line ~2681) cleared
+    // autosteeredRefs. The plain error path (`if (result.error)` →
+    // throw at ~2612), the empty-response fallback failure (~2714),
+    // and the streamer-overflow path could all leave ✍ reactions
+    // stuck on follow-ups whose buffer entries had never been
+    // drained by PostToolBatch. The clear is idempotent (the second
+    // call returns 0 against an already-emptied map) so adding it
+    // here covers ALL exit paths without double-clearing harm.
+    clearAutosteeredReactions(sessionKey).catch(() => {});
   }
 }