polygram 0.8.0-rc.36 → 0.8.0-rc.38

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.36",
+  "version": "0.8.0-rc.38",
   "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

@@ -91,10 +91,18 @@ function createAutosteerBuffer() {
  *     non-empty output, with kind='autosteer-hook-drained'.
  * @param {string|null} [opts.chatId] — for the logEvent payload only.
  * @param {object} [opts.logger]      — for error logging (must have .error).
+ * @param {(sessionKey: string, drainedCount: number) => void} [opts.onDrained]
+ *   — fired AFTER the hook successfully injects additionalContext.
+ *     rc.37 wires this to clearAutosteeredReactions so the ✍ reaction
+ *     fades the moment the agent absorbs the follow-up — not at SDK
+ *     turn-end, which under autosteer can stretch tens of minutes
+ *     (one SDK turn keeps absorbing follow-ups via additionalContext
+ *     and never emits result, so the old turn-end-only cleanup left
+ *     ✍ stuck across many user messages).
  *
  * @returns {async () => Promise<HookJSONOutput>}
  */
-function makePostToolBatchHook({ buffer, sessionKey, logEvent = null, chatId = null, logger = console } = {}) {
+function makePostToolBatchHook({ buffer, sessionKey, logEvent = null, chatId = null, logger = console, onDrained = null } = {}) {
   if (!buffer) throw new TypeError('buffer required');
   if (!sessionKey) throw new TypeError('sessionKey required');
   return async () => {
@@ -111,6 +119,22 @@ function makePostToolBatchHook({ buffer, sessionKey, logEvent = null, chatId = n
           });
         } catch { /* logger errors must not break the hook */ }
       }
+      if (typeof onDrained === 'function') {
+        // 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 {
         continue: true,
         hookSpecificOutput: {

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/lib/status-reactions.js

@@ -39,7 +39,13 @@ const STATES = {
   // All three emoji on Telegram's curated standard reaction list.
   THINKING:         { label: 'thinking',         chain: ['🤔']             },
   THINKING_DEEPER:  { label: 'thinking-deeper',  chain: ['🤨', '🤔']       },
-  THINKING_DEEPEST: { label: 'thinking-deepest', chain: ['🧐', '🤓', '🤔'] },
+  // rc.37: 🧐 (face with monocle) is REACTION_INVALID for bots — only
+  // Telegram Premium users can pick arbitrary emoji; bots are limited
+  // to ~70 standard reactions and 🧐 isn't on the list. Production
+  // log: `reaction apply failed (THINKING_DEEPEST → 🧐): 400: Bad
+  // Request: REACTION_INVALID`. 🤓 (nerd face, intellectual focus) is
+  // on the list and reads as "deeper than skeptical-eyebrow".
+  THINKING_DEEPEST: { label: 'thinking-deepest', chain: ['🤓', '🤔'] },
   CODING:           { label: 'coding',           chain: ['👨‍💻', '✍', '🤔'] },
   WEB:              { label: 'web',              chain: ['⚡', '🔥', '🤔']  },
   TOOL:             { label: 'tool',             chain: ['🔥', '🤔']       },
@@ -224,8 +230,8 @@ function createReactionManager({
   };
 
   // rc.32: thinking-deepening cascade. When state is THINKING, schedule
-  // auto-promotion at 8s (→ THINKING_DEEPER, 🤨) and 20s (→ THINKING_DEEPEST,
-  // 🧐). Any other setState (CODING / TOOL / WEB / WRITING / terminal) clears
+  // auto-promotion at 12s (→ THINKING_DEEPER, 🤨) and 30s (→ THINKING_DEEPEST,
+  // 🤓). Any other setState (CODING / TOOL / WEB / WRITING / terminal) clears
   // these. heartbeat() does NOT re-arm them — heartbeat is for keeping
   // STALL/TIMEOUT at bay during silent activity, not for resetting
   // visible deepening progression.

package/package.json

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

@@ -931,6 +931,18 @@ function buildSdkOptions(sessionKey, ctx) {
     chatId: ctx?.chatId ?? null,
     logEvent,
     logger: console,
+    // rc.37: clear ✍ reactions when the hook ABSORBS follow-ups, not
+    // at SDK turn-end. Under autosteer one SDK "turn" can stretch
+    // tens of minutes — every drain feeds more user text via
+    // additionalContext, the agent keeps reasoning, no `result` event
+    // fires, inFlight stays true, ✍ stays stuck on every drained
+    // follow-up. Clearing at drain time matches user perception
+    // ("the bot got my message → ✍ goes away").
+    onDrained: (key) => {
+      clearAutosteeredReactions(key).catch((err) => {
+        console.error(`[${BOT_NAME}] autosteer-hook clearReactions: ${err.message}`);
+      });
+    },
   });
 
   // 0.8.0-rc.21: SessionStart hook preloads recent polygram-DB
@@ -2520,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;
       }
@@ -2856,6 +2876,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(() => {});
   }
 }