polygram 0.8.0-rc.37 → 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.37",
+  "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

@@ -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/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.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

@@ -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;
       }
@@ -2868,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(() => {});
   }
 }