polygram 0.11.0-rc.2 → 0.11.0-rc.4

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.11.0-rc.2",
+  "version": "0.11.0-rc.4",
   "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/tmux/startup-gate.js

@@ -72,16 +72,42 @@ async function runStartupGate({
   const deadline = startedAt + deadlineMs;
   const seen = new Set();
   const matchedTriggers = [];
+  // rc.4: remember the most recent successful pane snapshot. If the gate
+  // fails (deadline OR session-gone), include the snapshot in the error
+  // so we can see what the TUI last printed before claude exited. Without
+  // this, "claude exits code 0 after dev-channels Enter" surfaces as a
+  // 30-second `can't find pane` spam with no diagnostic about WHY.
+  let lastPane = null;
 
   while (Date.now() < deadline) {
     let pane;
     try {
       pane = await runner.captureWide(tmuxName);
     } catch (err) {
-      logger.warn?.(`[${label}] captureWide failed: ${err.message}`);
+      // rc.4: detect "can't find pane" / "no server" — tmux session died
+      // (claude exited, killed the bash that hosted it, tmux tore down the
+      // pane). Fast-fail with a distinct code instead of spinning for the
+      // full deadline. Pattern matches the actual tmux capture-pane errors:
+      //   - "can't find pane: <name>"     (session/pane gone after spawn)
+      //   - "no server running"           (entire tmux server gone)
+      const msg = err?.message || '';
+      if (/can't find (pane|session)|no server running|session not found/i.test(msg)) {
+        const goneErr = new Error(
+          `[${label}] tmux session disappeared for ${tmuxName} after ${Date.now() - startedAt}ms ` +
+          `(matched: ${matchedTriggers.length ? matchedTriggers.join(', ') : 'none'}). ` +
+          `claude likely exited; last pane content:\n` +
+          _formatPaneTail(lastPane),
+        );
+        goneErr.code = 'TMUX_SESSION_GONE';
+        goneErr.lastPane = lastPane;
+        goneErr.matchedTriggers = matchedTriggers;
+        throw goneErr;
+      }
+      logger.warn?.(`[${label}] captureWide failed: ${msg}`);
       await new Promise(r => setTimeout(r, settleMs));
       continue;
     }
+    lastPane = pane;
 
     // Walk triggers in declaration order — first match (and not yet seen) wins
     let matched = false;
@@ -111,12 +137,33 @@ async function runStartupGate({
 
   const err = new Error(
     `[${label}] startup gate did not resolve within ${deadlineMs}ms for ${tmuxName} ` +
-    `(matched: ${matchedTriggers.length ? matchedTriggers.join(', ') : 'none'})`,
+    `(matched: ${matchedTriggers.length ? matchedTriggers.join(', ') : 'none'}). ` +
+    `Last pane content:\n` +
+    _formatPaneTail(lastPane),
   );
   err.code = timeoutCode;
+  err.lastPane = lastPane;
+  err.matchedTriggers = matchedTriggers;
   throw err;
 }
 
+/**
+ * Render the last ~800 chars of pane content for inclusion in error messages.
+ * Truncate at line boundaries when possible so the diagnostic isn't visually
+ * mangled. Returns "(no pane content ever captured)" for null/undefined.
+ */
+function _formatPaneTail(pane) {
+  if (!pane) return '  (no pane content ever captured — claude exited before first captureWide)';
+  const MAX = 800;
+  const text = String(pane);
+  if (text.length <= MAX) return text.split('\n').map(l => '  ' + l).join('\n');
+  // Take last MAX chars, then trim to a line boundary if one exists nearby
+  let tail = text.slice(-MAX);
+  const nl = tail.indexOf('\n');
+  if (nl > 0 && nl < 80) tail = tail.slice(nl + 1);
+  return '  …(truncated)…\n' + tail.split('\n').map(l => '  ' + l).join('\n');
+}
+
 module.exports = {
   runStartupGate,
   DEFAULT_DEADLINE_MS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.11.0-rc.2",
+  "version": "0.11.0-rc.4",
   "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

@@ -476,6 +476,31 @@ async function sendToProcess(sessionKey, prompt, context = {}, { onDispatched }
   const chatConfig = config.chats[chatId];
   const timeoutMs = (chatConfig.timeout || config.defaults.timeout) * 1000;
   const maxTurnMs = (chatConfig.maxTurn || config.defaults?.maxTurn || 1800) * 1000;
+
+  // ChannelsProcess-only liveness heartbeat. Lazy-attached HERE (after
+  // getOrSpawnForChat) so handleMessage stays fast for slash commands and
+  // any other non-pm.send paths — earlier wiring at handleMessage:~1003
+  // forced a cold-spawn (~30s on channels) before THINKING reactor /
+  // typing indicator / autosteer decision, hiding user feedback. Now the
+  // reactor only exists when we genuinely need a turn.
+  //
+  // Gated on entry.backend === 'channels' AND context.sourceMsgId (the
+  // TG user-msg to react on). Non-msg callers (boot-replay,
+  // autonomous-wakeup re-dispatch) pass no sourceMsgId and skip the
+  // reactor entirely.
+  let heartbeatReactor = null;
+  if (entry.backend === 'channels'
+      && typeof context.heartbeatSetReaction === 'function'
+      && context.sourceMsgId != null) {
+    heartbeatReactor = new HeartbeatReactor({
+      process: entry,
+      chatId,
+      messageId: context.sourceMsgId,
+      setReaction: context.heartbeatSetReaction,
+      logger: { debug: () => {}, warn: (m) => console.warn(`[${sessionKey}] ${m}`) },
+    });
+  }
+
   // Hold the per-session lock across the FULL turn (write + result wait),
   // not just the stdin write. Claude's stream-json input mode batches any
   // user messages that arrive while a turn is in flight into the next
@@ -504,6 +529,10 @@ async function sendToProcess(sessionKey, prompt, context = {}, { onDispatched }
     return await turnP;
   } finally {
     release();
+    // Belt-and-braces stop. The reactor auto-stops on idle/close/
+    // bridge-disconnected events from the Process, so this is idempotent
+    // — but it also covers the "send threw before any event fired" path.
+    heartbeatReactor?.stop();
   }
 }
 
@@ -1001,35 +1030,18 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       });
     },
   });
-  // ChannelsProcess-only liveness heartbeat. SDK + tmux backends have
-  // per-tool reaction visibility via the JSONL stream / SDK callbacks —
-  // the symbolic `reactor` above handles them. Channels intentionally
-  // hides mid-turn tool calls behind the bridge MCP protocol, so we
-  // substitute a time-driven cycling heartbeat on the same user message.
-  //
-  // We instantiate before pm.send fires so the reactor is bound to the
-  // Process *before* the first 'thinking' emission. getOrSpawnForChat
-  // is idempotent — the inner sendToProcess call will see the same
-  // entry. Stop is in the finally below, mirroring the symbolic reactor.
-  let heartbeatReactor = null;
-  if (pickBackend({ config, chatId, threadId: threadId || null }) === 'channels') {
-    const entry = await getOrSpawnForChat(sessionKey);
-    if (entry && typeof entry.on === 'function') {
-      heartbeatReactor = new HeartbeatReactor({
-        process: entry,
-        chatId,
-        messageId: msg.message_id,
-        setReaction: async (cid, mid, emoji) => {
-          await tg(bot, 'setMessageReaction', {
-            chat_id: cid,
-            message_id: mid,
-            reaction: emoji.length ? [{ type: 'emoji', emoji: emoji[0] }] : [],
-          }, { source: 'channels-heartbeat', botName: BOT_NAME }).catch(() => {});
-        },
-        logger: { debug: () => {}, warn: (m) => console.warn(`[${label}] ${m}`) },
-      });
-    }
-  }
+  // Channels-only heartbeat setReaction adapter. Plumbed into sendToProcess
+  // via context; sendToProcess instantiates the actual HeartbeatReactor
+  // lazily after getOrSpawnForChat returns (rc.3: see sendToProcess body
+  // for why we no longer construct here). Closure over `bot` keeps the
+  // tg() dependency local.
+  const heartbeatSetReaction = async (cid, mid, emoji) => {
+    await tg(bot, 'setMessageReaction', {
+      chat_id: cid,
+      message_id: mid,
+      reaction: emoji.length ? [{ type: 'emoji', emoji: emoji[0] }] : [],
+    }, { source: 'channels-heartbeat', botName: BOT_NAME }).catch(() => {});
+  };
 
   // rc.32: skip QUEUED (👀) entirely for first-message-in-chain. Go
   // straight to THINKING (🤔). The 👀 → 🤔 two-hop didn't add
@@ -1096,6 +1108,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       await new Promise((dispatched) => {
         sendPromise = sendToProcess(sessionKey, prompt, {
           streamer, reactor, sourceMsgId: msg.message_id,
+          heartbeatSetReaction,
           // 0.7.4 (item B): fire THINKING when Claude actually starts
           // emitting — not the moment we wrote stdin.
           onFirstStream: () => reactor.setState('THINKING'),
@@ -1115,11 +1128,8 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     // AUTOSTEERED is terminal; stop the reactor's STALL / TIMEOUT
     // timers so they don't pin the closure for up to 30s.
     reactor.stop();
-    // Channels-only: stop the cycling-emoji heartbeat too. (When autosteer
-    // gets implemented for channels, the in-flight turn's own heartbeat
-    // will continue ticking on its primary msg-id; this msg's heartbeat
-    // stops here because its turn was folded into the primary's.)
-    heartbeatReactor?.stop();
+    // No channels-heartbeat stop here — autosteer skips sendToProcess
+    // entirely, so no HeartbeatReactor was constructed.
     markReplied();
     return;
   }
@@ -1620,10 +1630,8 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   } finally {
     stopTyping();
     reactor.stop();
-    // Channels-only: stop the cycling-emoji heartbeat. Idempotent — second
-    // stop is a no-op (the reactor's `stopped` flag short-circuits). Covers
-    // every exit path (success, throw, abort, timeout).
-    heartbeatReactor?.stop();
+    // HeartbeatReactor (channels-only) is stopped inside sendToProcess's
+    // own finally block — no handleMessage-level stop needed.
     // 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