polygram 0.12.0-rc.15 → 0.12.0-rc.16

package/lib/process/cli-process.js

@@ -1249,6 +1249,7 @@ class CliProcess extends Process {
     if (pending.hardTimer) clearTimeout(pending.hardTimer);
     if (pending.absoluteTimer) clearTimeout(pending.absoluteTimer);
     if (pending._stopGraceTimer) clearTimeout(pending._stopGraceTimer);
+    const hadReplyToolCalls = pending.replies.length > 0;
     let text = pending.replies.join('\n\n');
     // 0.12 Phase 1.7 fallback: if no reply tool calls landed (claude ended
     // the turn without calling mcp__polygram-bridge__reply), use the Stop
@@ -1266,12 +1267,14 @@ class CliProcess extends Process {
     // to appear free in dashboards.
     const result = {
       text,
-      // Review F#2: dispatcher has ALREADY delivered text to Telegram on each
-      // reply tool call (incremental real-time UX is the channels delivery
-      // model). polygram.js's post-pm.send pipeline must short-circuit its
-      // streamer.finalize / deliverReplies branch — otherwise every turn
-      // delivers twice. Logging + DB transcript still use result.text.
-      alreadyDelivered: true,
+      // Review F#2: when claude used reply tool calls, the dispatcher ALREADY
+      // delivered that text to Telegram incrementally — polygram.js must
+      // short-circuit its deliverReplies branch or every turn delivers twice.
+      // BUT a turn finalized via the Stop fallback (no reply tool calls — the
+      // stuck-turn case) has delivered NOTHING; marking it alreadyDelivered
+      // would resolve the turn silently and the user still sees nothing. So
+      // only claim already-delivered when reply tool calls actually fired.
+      alreadyDelivered: hadReplyToolCalls,
       sessionId: this.claudeSessionId,
       cost: null,             // Channels protocol doesn't expose per-turn cost
       duration,
@@ -1632,6 +1635,22 @@ class CliProcess extends Process {
   _handleHookEvent(ev) {
     if (!ev || typeof ev !== 'object') return;
 
+    // rc.16 observability: emit once when the FIRST hook event arrives for
+    // this session, confirming the claude→ndjson→tail pipeline is actually
+    // flowing. The 2026-06-02 stuck turn had a session whose hook ndjson was
+    // 0 bytes — claude emitted no hooks polygram could see, so no Stop ever
+    // arrived to finalize the turn. Without this signal that's invisible: a
+    // turn that hangs with NO `cli-hook-stream-live` for its session means the
+    // hook pipeline is dead for it (distinct from "Stop fired but wasn't
+    // acted on", which `cli-turn-resolved-by-stop` now covers).
+    if (!this._sawHookStream) {
+      this._sawHookStream = true;
+      this._logEvent('cli-hook-stream-live', {
+        session_id: this.claudeSessionId,
+        first_event: ev.type,
+      });
+    }
+
     // 0.12 Phase 1.8 (Finding 0.4.A): per-event lag measurement.
     // polygram_received_at_ms is stamped by the helper subprocess at write
     // time; subtracting from Date.now() gives the helper-write → tail-emit
@@ -1740,15 +1759,47 @@ class CliProcess extends Process {
         return;
       }
 
-      case 'Stop':
-        // Phase 1.7 (TODO) will use this as the authoritative turn-end
-        // signal with stopGraceMs. For now: pass through as 'stop-hook'
-        // event so the resolver in Phase 1.7 can subscribe.
-        this.emit('stop-hook', {
+      case 'Stop': {
+        // 0.12.0 Phase 1.7 (rc.16): Stop is the AUTHORITATIVE turn-end signal.
+        const info = {
           stopHookActive: ev.stopHookActive,
           lastAssistantMessage: ev.lastAssistantMessage,
           backend: this.backend,
-        });
+        };
+        // Turns already resolving via a reply quiet-window consume this via
+        // their per-turn onStop listener (the text-fallback rescue inside
+        // _resolveTurn). Emit first so that path runs synchronously and any
+        // grace-pending turn is finalized + removed before the check below.
+        this.emit('stop-hook', info);
+
+        // THE FIX (2026-06-02 stuck-turn): a turn that ended WITHOUT a reply
+        // tool call has no quiet-window to fire _resolveTurn — pre-fix it hung
+        // until the 30-min wall-clock backstop while the unknown-prompt
+        // watchdog spun. Stop IS the turn-end; resolve the single in-flight
+        // turn now (reply text if any, else last_assistant_message). After the
+        // emit above, a grace-pending turn is already gone, so this only fires
+        // for the no-reply case. Gated on exactly one in-flight turn — Stop
+        // carries no turn_id, so we cannot attribute it when turns are
+        // concurrent (the M1 cross-attribution hazard).
+        if (this.pendingTurns.size === 1) {
+          const [turnId, p] = [...this.pendingTurns.entries()][0];
+          if (!p._stopGracePending) {
+            p._stopHookData = info;
+            this._logEvent('cli-turn-resolved-by-stop', {
+              turn_id: turnId,
+              reply_count: p.replies?.length || 0,
+              via_text_fallback: (p.replies?.length || 0) === 0,
+              session_id: this.claudeSessionId,
+            });
+            this._finalizeTurn(turnId);
+          }
+        } else if (this.pendingTurns.size > 1) {
+          // Can't attribute Stop to one of several concurrent turns — surface
+          // it so a turn that waited for its grace timer (instead of resolving
+          // on Stop) is explained in the events DB.
+          this._logEvent('cli-stop-unattributed', { pending_count: this.pendingTurns.size });
+        }
+
         // 0.12.0-rc.13 proactive compaction warning: on turn-end, if enabled
         // for this chat and not already warned this climb, sample context
         // occupancy from the transcript and warn (propose /compact) BEFORE
@@ -1758,6 +1809,7 @@ class CliProcess extends Process {
           this._maybeProactiveCompactionWarn(ev.transcriptPath);
         }
         return;
+      }
 
       case 'PreCompact':
         // 0.12.0-rc.13: auto-compaction is the event that detaches the

package/lib/telegram/album-reactions.js

@@ -0,0 +1,50 @@
+/**
+ * album-reactions — apply one status reaction to every message of a Telegram
+ * album (the anchor + its siblings), so a multi-file send shows the same emoji
+ * on each item instead of only the first.
+ *
+ * Background: Telegram delivers an album as N separate messages sharing a
+ * media_group_id; polygram coalesces them into ONE turn anchored on the first.
+ * The status reactor therefore only ever reacted to that anchor, leaving the
+ * sibling files with no visible reaction (the rc.16 observation). This mirrors
+ * the reactor's emoji onto the siblings.
+ *
+ * Semantics:
+ *   - The ANCHOR (first id) is awaited so a failure surfaces to the reactor's
+ *     own error handling (same as the single-message path).
+ *   - SIBLINGS are best-effort: a failure on one must not drop the anchor's
+ *     reaction or the other siblings (and must not throw — reactions are
+ *     cosmetic). They also can't share the anchor's fate of being retried.
+ *   - Calls are sequential to respect Telegram's setMessageReaction rate limit
+ *     (~5/s/chat) — an album is ≤10 items so this stays well within budget.
+ */
+
+'use strict';
+
+/**
+ * @param {object}   opts
+ * @param {Function} opts.tg        async (bot, method, params, meta) => any
+ * @param {*}        opts.bot
+ * @param {string}   opts.chatId
+ * @param {number[]} opts.msgIds    [anchor, ...siblings] — anchor first
+ * @param {string|null} opts.emoji  emoji to set, or null/'' to clear
+ * @param {string}   [opts.botName]
+ */
+async function applyReactionToMessages({ tg, bot, chatId, msgIds, emoji, botName } = {}) {
+  const reaction = emoji ? [{ type: 'emoji', emoji }] : [];
+  const ids = Array.isArray(msgIds) ? msgIds : [];
+  for (let i = 0; i < ids.length; i++) {
+    const params = { chat_id: chatId, message_id: ids[i], reaction };
+    const meta = {
+      source: i === 0 ? 'status-reaction' : 'status-reaction-album-sibling',
+      botName,
+    };
+    if (i === 0) {
+      await tg(bot, 'setMessageReaction', params, meta);          // anchor: surface failure
+    } else {
+      await tg(bot, 'setMessageReaction', params, meta).catch(() => {});  // siblings: best-effort
+    }
+  }
+}
+
+module.exports = { applyReactionToMessages };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.12.0-rc.15",
+  "version": "0.12.0-rc.16",
   "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

@@ -97,6 +97,7 @@ const { startTyping } = require('./lib/telegram/typing');
 // consumer is lib/handlers/download.js.
 const { createReactionManager, classifyToolName } = require('./lib/telegram/reactions');
 const { createMediaGroupBuffer } = require('./lib/media-group-buffer');
+const { applyReactionToMessages } = require('./lib/telegram/album-reactions');
 const { classify: classifyError, detectWedgedSessionError, isTransientHttpError } = require('./lib/error/classify');
 const { createAutoResumeTracker, isAutoResumable } = require('./lib/db/auto-resume');
 const { resolveReplayWindowMs } = require('./lib/db/replay-window');
@@ -998,13 +999,17 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   const availableEmojis = await getReactionAllowlist(bot, chatId);
   const reactor = createReactionManager({
     apply: async (emoji) => {
-      const params = {
-        chat_id: chatId,
-        message_id: msg.message_id,
-        reaction: emoji ? [{ type: 'emoji', emoji }] : [],
-      };
-      await tg(bot, 'setMessageReaction', params,
-        { source: 'status-reaction', botName: BOT_NAME });
+      // rc.16: mirror the reaction onto album siblings too, so a multi-file
+      // send shows the same status emoji on EVERY item, not just the anchor.
+      // For a normal single message, _albumSiblingMsgIds is undefined and this
+      // is exactly the prior single setMessageReaction. Anchor is awaited
+      // (failure surfaces to the reactor); siblings are best-effort.
+      await applyReactionToMessages({
+        tg, bot, chatId,
+        msgIds: [msg.message_id, ...(msg._albumSiblingMsgIds || [])],
+        emoji,
+        botName: BOT_NAME,
+      });
     },
     availableEmojis,
     logError: (m) => console.error(`[${label}] ${m}`),
@@ -1892,6 +1897,10 @@ function createBot(token) {
       }
 
       const synthetic = { ...primary, _mergedAttachments: merged };
+      // rc.16: carry the album sibling msg_ids so the status reactor can mirror
+      // its emoji onto every item (not just the anchor) — see the reactor
+      // `apply` closure + lib/telegram/album-reactions.js.
+      if (siblingMsgIds.length) synthetic._albumSiblingMsgIds = siblingMsgIds;
       // Carry the primary's text verbatim (dispatchRegularMessage re-cleans
       // the mention). Caption → text so downstream sees it uniformly.
       if (!synthetic.text && synthetic.caption) synthetic.text = synthetic.caption;