polygram 0.8.0-rc.65 → 0.8.0-rc.67

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.65",
+  "version": "0.8.0-rc.67",
   "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 plus history (transcript queries) and polygram-send (out-of-turn IPC sends with file-upload validation) skills.",
   "keywords": [
     "telegram",

package/lib/db.js

@@ -381,7 +381,22 @@ function wrap(db) {
              AND json_extract(detail_json, '$.session_key') = ?
            LIMIT 1
         `).get(c.id, c.session_key);
-        if (!boundary) orphans.push(c);
+        if (boundary) continue;
+        // rc.66: also skip if a previous boot has already handled
+        // this orphan (silent replay via compact-replay event, OR
+        // surface-fallback via compact-failed-restart event). Both
+        // of those record `original_ts` in their detail_json
+        // matching the original compact-command's ts. Without this
+        // dedupe, every subsequent deploy re-surfaces / re-replays
+        // the same orphan (annoying noise).
+        const handled = db.prepare(`
+          SELECT id FROM events
+           WHERE kind IN ('compact-replay', 'compact-failed-restart')
+             AND json_extract(detail_json, '$.original_ts') = ?
+           LIMIT 1
+        `).get(c.ts);
+        if (handled) continue;
+        orphans.push(c);
       }
       return orphans;
     },

package/lib/parse-response.js

@@ -165,4 +165,59 @@ function parseResponse(text, { stickerMap = {}, emojiToSticker = {} } = {}) {
   };
 }
 
-module.exports = { parseResponse, STICKER_TAG_RE, STICKER_TAG_INLINE_RE, REACT_TAG_RE, REACT_TAG_INLINE_RE };
+/**
+ * rc.67: streamer-side pre-processor.
+ *
+ * The streamer (lib/stream-reply.js) writes the FIRST chunk of a turn to
+ * Telegram as soon as text crosses minChars. The DB row for that bubble
+ * snapshots whatever was sent, and editMessageText calls don't update
+ * the row — so if the agent emitted `[sticker:working]` in the first
+ * chunk, the messages.text column captures it verbatim and the bubble
+ * shows the literal tag until parseResponse + streamer.finalize clean it
+ * up at turn end. That cleanup is fragile in three ways:
+ *   - parseResponse returns the tag verbatim if stickerMap[name] is
+ *     falsy (unknown sticker name OR map not loaded). Then
+ *     finalize sees parsed.text === currentText and takes the no-op
+ *     branch (stream-reply.js:286-289), bubble untouched.
+ *   - The turn never reaches `result` (interrupt, transient error,
+ *     hung query) → onResult never fires, no parseResponse, no edit.
+ *   - The final edit fails inside the HTML→plain fallback in
+ *     lib/telegram.js without surfacing telegram-edit-failed.
+ *
+ * stripInlineTags fixes the leak architecturally: applied at chunk-time
+ * (via createStreamer's `transformText` hook), the bubble + DB row never
+ * carry a recognised tag in the first place. parseResponse remains the
+ * canonical extractor — it surfaces stickers/reactions for outbound
+ * dispatch — but its `text` output is now a no-op compared to what the
+ * streamer already showed the user.
+ *
+ * Output is intentionally identical to `parseResponse(text, deps).text`
+ * for the same input, modulo `parseResponse`'s leading-trim of the
+ * fully-resolved final text. (Streaming text could legitimately end on
+ * a partial-token whitespace; we match the per-line right-trim and
+ * triple-blank-line collapse but don't touch the outer edges so a
+ * mid-stream "Done. " stays "Done." after right-trim — fine — but a
+ * legitimate intentional-leading-newline stays.)
+ */
+function stripInlineTags(text, { stickerMap = {} } = {}) {
+  if (text == null) return '';
+  let cleaned = String(text).replace(STICKER_TAG_INLINE_RE, (match, name) => {
+    return stickerMap[name] ? '' : match;
+  });
+  cleaned = cleaned.replace(REACT_TAG_INLINE_RE, () => '');
+  return cleaned
+    .split('\n')
+    .map((line) => line.replace(/[ \t]+$/g, ''))
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+module.exports = {
+  parseResponse,
+  stripInlineTags,
+  STICKER_TAG_RE,
+  STICKER_TAG_INLINE_RE,
+  REACT_TAG_RE,
+  REACT_TAG_INLINE_RE,
+};

package/lib/stream-reply.js

@@ -55,6 +55,20 @@ function createStreamer({
   schedule = setTimeout,
   cancel = clearTimeout,
   logger = console,
+  // rc.67: pre-processor applied to every chunk before send/edit. polygram
+  // passes stripInlineTags(...) so [sticker:NAME] / [react:EMOJI] never
+  // reach the bubble or the messages.text DB row. Default identity keeps
+  // existing tests + non-polygram callers untouched.
+  //
+  // Why here (streamer) and not in polygram's send callback: the streamer
+  // owns currentText/latestText state used by finalize's no-op-edit
+  // optimisation. If pre-processing only happened in send/edit closures,
+  // the streamer's internal state would carry raw text and finalize's
+  // body-vs-currentText comparison would still fire spurious edits.
+  // Applying transformText here means the WHOLE state machine sees clean
+  // text — finalize correctly takes the no-op branch when the bubble is
+  // already final.
+  transformText = null,
   // rc.44: by default, KEEP intermediate text bubbles when
   // forceNewMessage transitions to a fresh bubble for a new
   // top-level assistant message. These are NOT "thinking" tokens
@@ -110,8 +124,23 @@ function createStreamer({
     return s.slice(0, maxLen - 3) + '...';
   }
 
+  // rc.67: scrub recognised inline tags BEFORE the streamer commits text
+  // to its state machine. Identity when no transformer was configured.
+  // Defensive: if transformText throws, fall back to the raw text rather
+  // than swallow the chunk — log via injected logger.
+  function applyTransform(text) {
+    if (!transformText) return text;
+    try {
+      return transformText(text);
+    } catch (err) {
+      logger.error?.(`[stream] transformText threw, falling back to raw: ${err.message}`);
+      return text;
+    }
+  }
+
   async function onChunk(text) {
     if (state === 'finalized') return;
+    text = applyTransform(text);
     latestText = text;
 
     // idle: not yet sent the initial message. Only fire the initial send
@@ -269,7 +298,12 @@ function createStreamer({
 
     // live → finalize.
     state = 'finalized';
-    let body = finalText ?? latestText;
+    // rc.67: defense-in-depth — even if a caller passes raw text to
+    // finalize, transformText scrubs it before the bubble's last edit.
+    // Apply to BOTH branches (explicit finalText AND fallback to
+    // latestText) so the comparison `body === currentText` is always
+    // apples-to-apples (currentText was already transformed in onChunk).
+    let body = applyTransform(finalText ?? latestText);
     if (errorSuffix) body = `${body}\n\n⚠️ ${errorSuffix}`;
 
     // If body overflows the single-message cap, the caller needs to

package/package.json

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

@@ -1377,10 +1377,24 @@ const stdinLock = createAsyncLock();
 // mimicking the format as plain text. Without the new branch the
 // placeholder was rendered verbatim in the chat instead of swapped for
 // the actual sticker.
-const { parseResponse: parseResponseImpl } = require('./lib/parse-response');
+const {
+  parseResponse: parseResponseImpl,
+  stripInlineTags: stripInlineTagsImpl,
+} = require('./lib/parse-response');
 function parseResponse(text) {
   return parseResponseImpl(text, { stickerMap, emojiToSticker });
 }
+// rc.67: pre-processor for the streamer. Strips recognised inline
+// `[sticker:NAME]` and any `[react:EMOJI]` tags BEFORE the chunk is
+// committed to the bubble + DB row, so the user never sees a literal
+// tag even when the turn-end finalize path doesn't manage to clean it
+// (interrupt, error, hung query, edit failure, or the stickerMap-miss
+// no-op branch). parseResponse continues to surface the same tags in
+// `parsed.stickers[]` / `parsed.reactions[]` for outbound dispatch via
+// sendInlineStickers / sendInlineReactions.
+function stripInlineTagsForStreamer(text) {
+  return stripInlineTagsImpl(text, { stickerMap });
+}
 
 // ─── Cron/IPC send ─────────────────────────────────────────────────
 
@@ -2572,6 +2586,10 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   // code path. For short responses the streamer stays idle and we fall
   // through to the normal send path via finalize() returning streamed=false.
   const streamer = createStreamer({
+    // rc.67: pre-process every chunk to strip recognised
+    // [sticker:NAME] / [react:EMOJI] tags BEFORE the bubble or DB row
+    // captures them. See stripInlineTagsForStreamer above.
+    transformText: stripInlineTagsForStreamer,
     send: async (text) => {
       const params = {
         chat_id: chatId, text,