polygram 0.10.0-rc.47 → 0.10.0-rc.50

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.10.0-rc.47",
+  "version": "0.10.0-rc.50",
   "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/error/classify.js

@@ -74,6 +74,19 @@ const PATTERNS = {
   // image-failure verb co-located with "image" or "photo".
   imageProcess:     /(could not process|cannot process|failed to (process|load|decode)|unsupported|invalid|corrupt(?:ed)?)[^\n]{0,80}\b(image|photo)\b|\b(image|photo)\b[^\n]{0,80}(could not process|failed to (process|load|decode)|is (invalid|corrupted|unsupported))/i,
 
+  // rc.50: lib/process-manager.js `_awaitLruSlot` rejects when no
+  // backend slot is available within `lruWaitMs` (default 5 min).
+  // Symptom of an upstream wedge (an inFlight tmux process can't be
+  // LRU-evicted; if its turn is wedged the slot stays held for the
+  // whole idle-ceiling). Production 2026-05-24 (shumorobot Music):
+  // hit twice during the wedged-"yes" turn that took 30 min to
+  // surface. Pre-rc.50 the user got `Hit a snag: lru wait timed
+  // out after 300000ms` which is opaque; now they get a hint that
+  // it's a busy/queued condition and a retry will probably work.
+  // Placed BEFORE the generic `timeout` pattern so the LRU phrasing
+  // wins over the broader timeout match.
+  lruWaitTimeout:   /lru wait timed out/i,
+
   // rc.47: tmux backend's TMUX_TURN_TIMEOUT after H3 idle-ceiling fired.
   // Production wedge 2026-05-24 msg 1020: a Bash tool's `PreToolUse`
   // fired but `PostToolUse` never came — claude waited forever for the
@@ -115,6 +128,7 @@ const USER_MESSAGES = {
   missingToolInput: '⚠️ Session history looks corrupted. Try /new.',
   imageProcess:     '🖼 One of the images in this conversation can\'t be re-processed by Claude — likely an older one in the history. Starting a fresh session for this chat.',
   tmuxToolWedge:    '🔧 A tool didn\'t return in time — I cut it off. Most often this is a Bash command waiting on something external (a server, a file lock, an interactive prompt). Try resending; if it happens again, break the task into smaller steps.',
+  lruWaitTimeout:   '⏳ Other chats are busy — couldn\'t free up a backend slot in time. Try resending in a moment; if it keeps happening, an operator may need to raise the warm-process cap.',
   timeout:          '⏳ I went quiet too long without finishing. Try resending or simplifying.',
   format:           '⚠️ Invalid request format. Try rephrasing or /new.',
   // Used both for in-flight retry attempts AND for the post-retry-failed

package/lib/process/tmux-process.js

@@ -251,6 +251,26 @@ const DEFAULT_READY_DEBUG_QUIET_MS = 1000;
 // combined with the "Resuming the full session" rationale.
 const SESSION_AGE_PROMPT_RE = /Resuming the full session.*Resume from summary/s;
 
+// rc.48 (production 2026-05-24 post-rc.47 deploy, shumorobot HOME):
+// rc.43's session-age menu auto-dismiss + rc.44's deadline reset
+// gave `/compact` a fresh `readyTimeoutMs` (120 s) budget — but on
+// an 8h+ aged session compact STILL took >120 s (observed pane:
+// `✶ Compacting conversation… (1m 58s)  ▰▰…▱ 73%` at the timeout
+// moment). The single one-shot reset is too coarse.
+//
+// Fix: while `/compact` is in progress AND making observable progress
+// (the captured signature changes between polls — elapsed time,
+// progress bar, percentage), keep extending the deadline. Compact
+// that genuinely stalls (same signature across multiple polls) is
+// still allowed to time out so a real wedge isn't masked.
+//
+// Match captures the distinctive header `Compacting conversation…`
+// (with ellipsis or three dots) plus everything up to the
+// percentage, giving a signature that changes as compact advances:
+// elapsed wall-time (1m 58s → 1m 59s), progress bar density
+// (▰…▱ → ▰▰…▱), AND percentage (73% → 74%).
+const COMPACT_PROGRESS_RE = /Compacting (?:conversation|context)(?:…|\.\.\.)[\s\S]{0,300}?\d+%/i;
+
 // R7: sentinel returned by _awaitTurnComplete when its poll loop is
 // stopped by the caller's absolute-deadline abort (rather than by a
 // real READY quiescence or its own internal timeout). _runTurn maps
@@ -2674,6 +2694,12 @@ class TmuxProcess extends Process {
     // prompt this wait, so we don't fire Enter every poll if claude
     // is slow to re-render after dismissing it.
     let sessionAgePromptDismissed = false;
+    // rc.48: track the most recently observed `/compact` progress
+    // signature so we can extend the deadline ONLY when compact is
+    // making real progress. A genuinely-stalled compact (same
+    // signature N polls in a row) will not extend, so the wedge
+    // safety net is preserved.
+    let lastCompactSignature = null;
     if (this.pollScheduler) this.pollScheduler.acquire();
     try {
       while (this._now() < deadline) {
@@ -2716,6 +2742,13 @@ class TmuxProcess extends Process {
           // the menu but the post-dismiss wait still timed out.
           // Reset the deadline so compact has a full
           // `readyTimeoutMs` budget from dismissal time.
+          //
+          // rc.48: the rc.44 one-shot reset isn't enough either —
+          // observed on shumorobot post-rc.47 deploy with an even
+          // older session, compact ran >120 s and still timed out.
+          // The new compact-progress block below extends the deadline
+          // each poll that observes progress, with the rc.44 reset
+          // here as the initial budget for the FIRST compact tick.
           deadline = this._now() + this.readyTimeoutMs;
           // Reset readiness clock + prev-pane so the menu's content
           // doesn't satisfy the byte-stability check while claude is
@@ -2725,6 +2758,45 @@ class TmuxProcess extends Process {
           await this._waitForNextTick();
           continue;
         }
+        // rc.48: `/compact` (triggered by the session-age dismissal,
+        // OR by any future code path that runs compact during startup)
+        // shows a progress UI in the pane. If we can SEE compact making
+        // progress (signature changes between polls), extend the
+        // deadline so compact has unbounded time to finish AS LONG AS
+        // it's progressing. A stalled compact (same signature across
+        // multiple polls) is still bounded by the existing deadline —
+        // the wedge safety net is preserved.
+        const compactMatch = lastBuf.match(COMPACT_PROGRESS_RE);
+        if (compactMatch) {
+          const currentSignature = compactMatch[0];
+          if (currentSignature !== lastCompactSignature) {
+            // Compact made observable progress (elapsed time advanced,
+            // progress bar grew, or percentage incremented). Extend
+            // the deadline and emit a forensics event so a soak can
+            // count how often this kicks in.
+            lastCompactSignature = currentSignature;
+            deadline = this._now() + this.readyTimeoutMs;
+            readySinceAt = null;
+            prevBuf = null;
+            this.emit('compact-progress', {
+              sessionId: this.claudeSessionId,
+              backend: 'tmux',
+            });
+          }
+          // Whether progressing or stalled, skip the ready-hint check
+          // this poll — compact's progress UI is on the pane, not the
+          // ready hint. The next poll re-evaluates.
+          await this._waitForNextTick();
+          continue;
+        } else if (lastCompactSignature != null) {
+          // Compact finished (no longer visible in pane). Clear the
+          // tracker; the normal ready-check below resumes. Do NOT
+          // reset the deadline here — the existing deadline still has
+          // its last-extended budget, which is the right window for
+          // claude to repaint the ready hint after compact returns
+          // control.
+          lastCompactSignature = null;
+        }
         // Ready ⇔ the hint is on the pane AND the pane is identical to
         // the previous poll (the MCP-loading repaint storm has
         // stopped). The first poll has no previous buffer to compare,
@@ -3354,4 +3426,6 @@ module.exports = {
   CLAUDE_CLI_PINNED_VERSION,
   // rc.43 — exported for unit-test coverage of the menu pattern.
   SESSION_AGE_PROMPT_RE,
+  // rc.48 — exported for unit-test coverage of the /compact progress pattern.
+  COMPACT_PROGRESS_RE,
 };

package/lib/process/turn-phase.js

@@ -117,7 +117,12 @@ const ALLOWED_TRANSITIONS = Object.freeze({
   // PASTED_UNCONFIRMED intermediate. rc.35 production caught this as
   // log noise once Commit 3 (`_awaitSettle`) started consuming
   // predicate fields more strictly.
-  [TurnPhase.QUEUED]:             new Set([TurnPhase.PASTED_UNCONFIRMED, TurnPhase.PASTE_PARKED, TurnPhase.FAILED]),
+  // rc.49 (shumorobot HOME 2026-05-24): SUBMITTED is reachable
+  // directly from QUEUED when the TUI's `jsonl:user-message` event
+  // races ahead of the `paste:returned` event-loop callback that
+  // normally lands first and advances QUEUED → PASTED_UNCONFIRMED.
+  // Symmetric to the rc.35→rc.36 PASTE_PARKED edge; same fix shape.
+  [TurnPhase.QUEUED]:             new Set([TurnPhase.PASTED_UNCONFIRMED, TurnPhase.PASTE_PARKED, TurnPhase.SUBMITTED, TurnPhase.FAILED]),
   [TurnPhase.PASTED_UNCONFIRMED]: new Set([TurnPhase.PASTE_PARKED, TurnPhase.SUBMITTED, TurnPhase.STREAMING, TurnPhase.TOOL_RUNNING, TurnPhase.SUBAGENT_RUNNING, TurnPhase.APPROVAL_PENDING, TurnPhase.QUIET, TurnPhase.DONE, TurnPhase.FAILED]),
   [TurnPhase.PASTE_PARKED]:       new Set([TurnPhase.SUBMITTED, TurnPhase.STREAMING, TurnPhase.TOOL_RUNNING, TurnPhase.SUBAGENT_RUNNING, TurnPhase.APPROVAL_PENDING, TurnPhase.QUIET, TurnPhase.DONE, TurnPhase.FAILED]),
   [TurnPhase.SUBMITTED]:          new Set([TurnPhase.STREAMING, TurnPhase.TOOL_RUNNING, TurnPhase.SUBAGENT_RUNNING, TurnPhase.APPROVAL_PENDING, TurnPhase.QUIET, TurnPhase.DONE, TurnPhase.FAILED]),

package/lib/sdk/callbacks.js

@@ -39,6 +39,21 @@ function createSdkCallbacks({
   getChatIdFromKey,
   getThreadIdFromKey,
   logger = console,
+  // rc.50 (production 2026-05-24, shumorobot HOME): the
+  // autonomous-wakeup path (`onAutonomousAssistantMessage` below)
+  // was bypassing parseResponse + sanitizeReply + deliverReplies
+  // entirely, so `[sticker:pumped]` showed up as literal text and
+  // `No response requested.` leaked through (the rc.45 sanitizer
+  // only protected the regular reply path). Inject the full
+  // pipeline so autonomous messages get the same treatment as
+  // streamed bot replies. All optional — fallback below preserves
+  // the pre-rc.50 raw-sendMessage behavior when any dep is unwired
+  // (e.g. an old caller of createSdkCallbacks).
+  parseResponse = null,
+  sanitizeAssistantReply = null,
+  chunkMarkdownText = null,
+  deliverReplies = null,
+  chunkBudget = 3500,
 } = {}) {
   // rc.9: typing-indicator state for autosteer NEW-TURN extraction.
   // Keyed by sessionKey. extra-turn-started installs a 4-second
@@ -202,6 +217,25 @@ function createSdkCallbacks({
     // ScheduleWakeup case where the agent self-fires without an
     // inbound user message. Best-effort send: failures are logged
     // but don't propagate.
+    //
+    // rc.50 (production 2026-05-24): pre-fix this called
+    // `tg(bot, 'sendMessage', { text: <raw> })` directly, bypassing
+    // parseResponse + sanitizeReply + deliverReplies. Two
+    // user-visible bugs as a result:
+    //   - `[sticker:NAME]` and `[react:EMOJI]` tags appeared as
+    //     literal text in the chat (no sticker bubble fired, no
+    //     reaction set).
+    //   - The CLI canned-string leak `No response requested.`
+    //     reached Telegram (the rc.45 sanitizer was wired into the
+    //     regular reply path only — this path was unprotected).
+    // Fix: route the autonomous text through the same pipeline as
+    // bot-reply-stream — parseResponse → sanitize → chunk →
+    // deliverReplies → send inline stickers/sticker. No user-msg to
+    // reply to or react against; inline reactions are logged-and-
+    // dropped instead of applied. Optional deps: if the caller of
+    // createSdkCallbacks didn't inject the pipeline pieces, fall
+    // back to the pre-rc.50 raw-sendMessage path (preserves
+    // back-compat for older test harnesses).
     onAutonomousAssistantMessage: (sessionKey, msg /* , entry */) => {
       try {
         // Backend-shape normalization: SDK emits the raw SDKMessage
@@ -218,21 +252,129 @@ function createSdkCallbacks({
           logger.error?.(`[${botName}] autonomous wakeup: bot not ready, dropping ${text.length} chars`);
           return;
         }
-        const params = {
-          chat_id: chatId,
-          text,
-          ...(Number.isInteger(threadId) && { message_thread_id: threadId }),
-        };
-        // Don't await — keep the pm-sdk event loop unblocked.
-        tg(bot, 'sendMessage', params,
-          { source: 'autonomous-wakeup', botName }).catch((err) => {
-            logger.error?.(`[${botName}] autonomous wakeup send failed: ${err.message}`);
+
+        // Pre-rc.50 fallback: any pipeline dep missing → raw send.
+        // Used in tests or partial-wire scenarios. Production wires
+        // all five (parseResponse, sanitizeAssistantReply,
+        // chunkMarkdownText, deliverReplies, chunkBudget).
+        const haveFullPipeline = (typeof parseResponse === 'function')
+          && (typeof sanitizeAssistantReply === 'function')
+          && (typeof chunkMarkdownText === 'function')
+          && (typeof deliverReplies === 'function');
+
+        if (!haveFullPipeline) {
+          const params = {
+            chat_id: chatId,
+            text,
+            ...(Number.isInteger(threadId) && { message_thread_id: threadId }),
+          };
+          tg(bot, 'sendMessage', params,
+            { source: 'autonomous-wakeup', botName }).catch((err) => {
+              logger.error?.(`[${botName}] autonomous wakeup send failed: ${err.message}`);
+            });
+          logEvent('autonomous-wakeup-message', {
+            chat_id: chatId,
+            session_key: sessionKey,
+            thread_id: threadIdRaw,
+            text_len: text.length,
+            pipeline: 'raw-fallback',
           });
+          return;
+        }
+
+        // Full pipeline (mirrors polygram.js handleMessage's
+        // bot-reply-stream branch). Don't await — keep the pm-sdk
+        // event loop unblocked; surface failures via .catch.
+        (async () => {
+          const parsed = parseResponse(text);
+          if (parsed.text) {
+            const sanitized = sanitizeAssistantReply(parsed.text);
+            if (sanitized.replaced) {
+              logEvent('canned-reply-suppressed', {
+                chat_id: chatId,
+                msg_id: null,                       // no inbound msg
+                original: sanitized.original,
+                source: 'autonomous-wakeup',
+              });
+              parsed.text = sanitized.text;
+            }
+          }
+
+          // Text first (so any follow-up stickers read as
+          // punctuation, matching the bot-reply-stream order).
+          if (parsed.text) {
+            const chunks = chunkMarkdownText(parsed.text, chunkBudget);
+            await deliverReplies({
+              bot,
+              send: (b, method, params, m) => tg(b, method, params, m),
+              chatId,
+              threadId,
+              chunks,
+              replyToMessageId: null,                 // no inbound msg
+              meta: { source: 'autonomous-wakeup', botName },
+              logger,
+            });
+          }
+
+          // Solo-sticker path (parseResponse returns a single
+          // sticker when the WHOLE text was just `[sticker:NAME]`).
+          if (parsed.sticker) {
+            await tg(bot, 'sendSticker', {
+              chat_id: chatId,
+              sticker: parsed.sticker,
+              ...(Number.isInteger(threadId) && { message_thread_id: threadId }),
+            }, {
+              source: 'autonomous-wakeup-sticker', botName,
+              stickerName: parsed.stickerLabel || null,
+            }).catch((err) => {
+              logger.error?.(`[${botName}] autonomous-wakeup sendSticker failed: ${err.message}`);
+            });
+          }
+
+          // Inline stickers (parsed.stickers[] when the text
+          // embedded one or more `[sticker:NAME]` tags). Send
+          // sequentially so order matches the order in the text.
+          for (const s of (parsed.stickers || [])) {
+            try {
+              await tg(bot, 'sendSticker', {
+                chat_id: chatId,
+                sticker: s.fileId,
+                ...(Number.isInteger(threadId) && { message_thread_id: threadId }),
+              }, {
+                source: 'autonomous-wakeup-inline-sticker', botName,
+                stickerName: s.name,
+              });
+            } catch (err) {
+              logger.error?.(`[${botName}] autonomous-wakeup inline sendSticker(${s.name}) failed: ${err.message}`);
+            }
+          }
+
+          // Reactions: parsed.reaction (solo) and parsed.reactions[]
+          // (inline). Autonomous-wakeup has no target msg to react
+          // against (the message isn't replying to anything). Log
+          // and drop so this surfaces in forensics if a future agent
+          // starts using react-tags in autonomous output.
+          const allReactions = [
+            ...(parsed.reaction ? [parsed.reaction] : []),
+            ...(parsed.reactions || []),
+          ];
+          if (allReactions.length > 0) {
+            logEvent('autonomous-wakeup-reactions-dropped', {
+              chat_id: chatId,
+              session_key: sessionKey,
+              dropped: allReactions,
+            });
+          }
+        })().catch((err) => {
+          logger.error?.(`[${botName}] autonomous wakeup pipeline failed: ${err.message}`);
+        });
+
         logEvent('autonomous-wakeup-message', {
           chat_id: chatId,
           session_key: sessionKey,
           thread_id: threadIdRaw,
           text_len: text.length,
+          pipeline: 'full',
         });
       } catch (err) {
         logger.error?.(`[${botName}] autonomous wakeup handler: ${err.message}`);

package/lib/telegram/api.js

@@ -93,6 +93,17 @@ const METHODS_WITHOUT_MSG = new Set([
   'deleteMessage',
   'editMessageReplyMarkup',
   'editMessageText',
+  // rc.49 (production wedge 2026-05-24): sendChatAction is the
+  // typing indicator. lib/sdk/callbacks.js fires it every 4s during
+  // a turn. Telegram returns `true` (boolean, not a message object)
+  // — `res?.message_id ?? 0` evaluates to 0, so markOutboundSent
+  // would UPDATE the row to (chat_id, msg_id=0). The 2nd+ tick in
+  // the same chat then UNIQUE-collides on (chat_id, 0), leaving
+  // pending rows stranded. shumorobot post-rc.48 deploy: shutdown
+  // drain reported "marked 236 stale pending rows as failed" — all
+  // 236 had source='extra-turn-typing' and text=''. Excluding
+  // sendChatAction from the row-tracking set is the surgical fix.
+  'sendChatAction',
 ]);
 
 // Derive the row's `text` column. sendSticker has no text/caption, so we

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.10.0-rc.47",
+  "version": "0.10.0-rc.50",
   "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

@@ -2130,6 +2130,14 @@ async function main() {
     classifyToolName, announce, shouldAnnounce, contextHintShown,
     extractAssistantText, getChatIdFromKey, getThreadIdFromKey,
     logger: console,
+    // rc.50: full reply-pipeline deps for the autonomous-wakeup path
+    // (see `onAutonomousAssistantMessage` in lib/sdk/callbacks.js).
+    // Mirrors what bot-reply-stream uses in handleMessage so
+    // [sticker:NAME] / [react:EMOJI] tags get processed and the
+    // rc.45 canned-string sanitizer fires.
+    parseResponse, sanitizeAssistantReply,
+    chunkMarkdownText, deliverReplies,
+    chunkBudget: TG_CHUNK_BUDGET,
   });
   // 0.10.0: sdkCallbacks (the polygram-side lifecycle handlers — status
   // reactor, stream chunk → bubble edit, etc.) move from the underlying