polygram 0.17.4 → 0.17.7

package/lib/feedback/session-feedback.js

@@ -69,6 +69,22 @@ function createSessionFeedback({
     });
   }
 
+  // Stop the cycle's TYPING the moment it delivers its answer, decoupled from
+  // endCycle. endCycle fires on the Process 'idle' edge (= session idle), which a
+  // later turn delays — so without this the "typing…" indicator spun minutes past the
+  // delivered answer (field: Ivan DM 2026-06-26). The entry is LEFT in place so
+  // endCycle still clears the anchor 🤔 and tears the entry down. docs/typing-tracks-activity-spec.md
+  function stopCycleTyping(sessionKey) {
+    const entry = active.get(sessionKey);
+    if (!entry || entry.typingStopped) return;
+    entry.typingStopped = true;
+    try { entry.stop(); } catch { /* best-effort */ }
+    logEvent('autonomous-cycle-visuals', {
+      chat_id: entry.anchor?.chatId ?? getChatIdFromKey(sessionKey),
+      session_key: sessionKey, state: 'typing-stopped',
+    });
+  }
+
   function endCycle(sessionKey) {
     const entry = active.get(sessionKey);
     if (!entry) return;
@@ -85,7 +101,7 @@ function createSessionFeedback({
     });
   }
 
-  return { startAutonomousCycle, endCycle };
+  return { startAutonomousCycle, stopCycleTyping, endCycle };
 }
 
 module.exports = { createSessionFeedback };

package/lib/handlers/dispatcher.js

@@ -133,8 +133,24 @@ function createDispatcher({
       throw new Error('auto-resume turn produced no text');
     }
 
-    // 4. Send the continuation reply as regular Telegram messages,
-    //    threaded under the original user message.
+    // 4. Deliver the continuation reply — UNLESS the resumed turn already
+    //    delivered it itself. On the channels/cli backend Claude responds via the
+    //    reply tool DURING the turn, so result.alreadyDelivered is set and the main
+    //    dispatch path short-circuits its own deliver (cli-process.js ~2116). The
+    //    resume path must honor it too, or the reply-tool send + this re-send
+    //    double-post the SAME answer (field: shumabit@umi WhatsApp topic 2026-06-27,
+    //    a bridge-disconnect resume sent "Fixed. ✅…" twice). SDK / genuine no-reply
+    //    turns leave it falsy → deliver as before.
+    if (result.alreadyDelivered) {
+      logEvent('auto-resume-already-delivered', {
+        chat_id: chatId, session_key: sessionKey, msg_id: originalMsg.message_id,
+        text_len: result.text.length,
+      });
+      return result.text;
+    }
+
+    // Send the continuation reply as regular Telegram messages, threaded under
+    // the original user message.
     const chunks = chunkMarkdownText(result.text, chunkBudget);
     await deliverReplies({
       bot,

package/lib/process/channels-bridge.mjs

@@ -119,11 +119,19 @@ function resolveToolAck(toolCallId, ok, error, messageId) {
 }
 
 // ─── 0.12 interactive questions: `ask` blocks for the user's answer ──
-// Separate from tool_ack: a question can take MINUTES (the daemon-side 30-min
-// question timeout — aligned to the turn absolute cap — resolves it with {timedout}
-// before this hard ceiling, which sits just above as the last-resort backstop).
+// Separate from tool_ack: a question waits for the user, possibly for hours. The
+// DAEMON owns the lifecycle — it resolves the ask with the user's answer, or sweeps
+// it {timedout} at its configured question timeout (POLYGRAM_QUESTION_TIMEOUT_MS,
+// default 24h). This local timer is ONLY a last-resort backstop for the narrow case
+// where the daemon stays connected but never calls back; it sits a margin ABOVE the
+// daemon timeout so the daemon always resolves first (with the proper user-facing
+// message). It must track the daemon value — a hardcoded 32min here once fired long
+// before the 24h wait, resolving {timedout} on a question the user answered an hour
+// later (0.17.5).
 const pendingQuestions = new Map() // tool_call_id → { resolve, timer }
-const QUESTION_ANSWER_TIMEOUT_MS = 32 * 60 * 1000
+const QUESTION_BACKSTOP_MARGIN_MS = 5 * 60 * 1000
+const DAEMON_QUESTION_TIMEOUT_MS = Number(process.env.POLYGRAM_QUESTION_TIMEOUT_MS) || (24 * 60 * 60 * 1000)
+const QUESTION_ANSWER_TIMEOUT_MS = DAEMON_QUESTION_TIMEOUT_MS + QUESTION_BACKSTOP_MARGIN_MS
 
 function awaitQuestionAnswer(toolCallId) {
   return new Promise((resolve) => {

package/lib/process/cli-process.js

@@ -48,6 +48,10 @@ const { Process, UnsupportedOperationError } = require('./process');
 const { ChannelsBridgeServer } = require('./channels-bridge-server');
 const { writeHookFiles, removeHookFiles } = require('./hook-settings');
 const { createHookTail } = require('./hook-event-tail');
+// Single source of truth for the question wait: the daemon owns the question
+// lifecycle (answer or {timedout} sweep), and we pass this to the bridge so its
+// last-resort `ask` backstop sits ABOVE it instead of undercutting it.
+const { DEFAULT_TIMEOUT_MS: QUESTION_TIMEOUT_MS } = require('../questions/store');
 // File-send staging: reuse the dispatcher's allowlist root so the dir we
 // create exactly matches the realpath the validator accepts (no /tmp vs
 // /private/tmp drift — one of the original Music-topic failures).
@@ -343,6 +347,9 @@ class CliProcess extends Process {
     // is the broader surface (hooks + pane heartbeat + bridge tool calls).
     this._lastHookEventAt = 0;
     this._lastActivityAt = 0;
+    // Monotonic count of work hooks (all but the terminal Stop) — the rung-2
+    // no-reply backstop snapshots it at Stop capture to detect a later resume.
+    this._workHookSeq = 0;
     // 0.13 D2: the InputLedger — every user-shaped input written to the bridge
     // gets an observable lifecycle: written → seen → resolved | dropped |
     // superseded | fold-suspected. Pre-P3, injectUserMessage minted a turn_id
@@ -553,13 +560,25 @@ class CliProcess extends Process {
     await this.bridgeServer.listen();
   }
 
-  async _spawnTmuxClaude({ tmuxName, opts }) {
-    const bridgeEnv = {
-      POLYGRAM_SESSION_KEY:       this.sessionKey,
-      POLYGRAM_SOCK:              this.sockPath,
-      POLYGRAM_SOCK_SECRET:       this.sockSecret,
-      POLYGRAM_CLAUDE_SESSION_ID: this.claudeSessionId,
+  /**
+   * Env for the spawned channels-bridge MCP subprocess. POLYGRAM_QUESTION_TIMEOUT_MS
+   * tells the bridge our question wait so its last-resort `ask` backstop sits ABOVE
+   * it — without it the bridge fell back to a hardcoded 32min that fired long before
+   * the daemon's 24h wait, so a question the user answered an hour later was already
+   * resolved {timedout}. Extracted (pure) so the alignment is unit-testable.
+   */
+  _bridgeEnv() {
+    return {
+      POLYGRAM_SESSION_KEY:        this.sessionKey,
+      POLYGRAM_SOCK:               this.sockPath,
+      POLYGRAM_SOCK_SECRET:        this.sockSecret,
+      POLYGRAM_CLAUDE_SESSION_ID:  this.claudeSessionId,
+      POLYGRAM_QUESTION_TIMEOUT_MS: String(QUESTION_TIMEOUT_MS),
     };
+  }
+
+  async _spawnTmuxClaude({ tmuxName, opts }) {
+    const bridgeEnv = this._bridgeEnv();
     const mcpConfig = {
       mcpServers: {
         'polygram-bridge': {
@@ -1764,20 +1783,41 @@ class CliProcess extends Process {
     }
   }
 
+  /**
+   * Is this turn eligible for the rung-2 activity-quiet finalize? Eligible when the
+   * answer is already captured where a finalize can deliver it:
+   *   - a delivered FINAL reply (it went out incrementally), OR
+   *   - seen + consumed-acked (the answer rode a sibling turn_id — fold-id echo;
+   *     see _ledgerAckConsumed), OR
+   *   - an attributed Stop captured the answer AND no work hook has fired since
+   *     (_workHookSeq unchanged from the capture) — i.e. claude is genuinely done,
+   *     not resumed into more work. A reply-less turn's only finalizer is its Stop grace;
+   *     when a pane-thinking heartbeat cancels that grace (the turn's own residual
+   *     "esc to interrupt"), this is the backstop that still delivers the captured
+   *     last_assistant_message instead of orphaning to the idle ceiling. The
+   *     hook-recency check withdraws eligibility the moment claude resumes (a resume
+   *     emits PreToolUse/etc. that increments _workHookSeq past the capture), so a
+   *     stale early Stop can't finalize over a still-working turn — that also covers
+   *     an in-flight sub-agent, which emits work hooks after any boundary Stop.
+   * An interim-only turn with no captured answer stays ineligible (it must keep working).
+   */
+  _activityQuietEligible(pending) {
+    if (this._turnHasFinalReply(pending)) return true;
+    if (pending.seen === true && pending._consumedAcked === true) return true;
+    if (pending._stopHookData
+        && (this._workHookSeq || 0) === (pending._stopHookDataSeq || 0)) return true;
+    return false;
+  }
+
   /**
    * D1 rung 2: arm/refresh the activity-quiet finalize for one pending.
-   * Preconditions: hooks live, ≥1 delivered reply (a reply-less turn ends via
-   * rung 1 or the ceilings), no open question (waiting-on-user suspends the
-   * clock — claude is legitimately silent), and no rung-1 grace in flight.
+   * Preconditions: hooks live, the answer is captured (see _activityQuietEligible),
+   * no open question (waiting-on-user suspends the clock — claude is legitimately
+   * silent), and no rung-1 grace in flight.
    */
   _armActivityQuiet(turnId, pending) {
     if (!this._sawHookStream) return;
-    // ≥1 FINAL reply, OR seen + consumed-acked (the answer rode a sibling turn_id —
-    // fold-id echo; see _ledgerAckConsumed). Same eligibility as the fire site. An
-    // interim-only turn (status promise, no final reply) is NOT eligible — it must
-    // keep working, not quiet-finalize as done. docs/progress-is-not-turn-end-spec.md
-    if (!this._turnHasFinalReply(pending)
-        && !(pending.seen === true && pending._consumedAcked === true)) return;
+    if (!this._activityQuietEligible(pending)) return;
     if (this._openQuestions.size > 0) return;
     if (pending._stopGracePending) return;
     if (pending._activityQuietTimer) clearTimeout(pending._activityQuietTimer);
@@ -1797,20 +1837,19 @@ class CliProcess extends Process {
 
   /**
    * D1 rung 2 fire: the whole activity surface (hooks + pane heartbeat + bridge
-   * tool calls) has been quiet for activityQuietMs on a replied turn — the tail
-   * is over (Stop was lost, foreign, or the hook stream died mid-session; the
-   * pre-D1 `_sawHookStream` one-way boolean left that last class with NO
-   * finalizer until a 10-min TURN_TIMEOUT *rejection* after a delivered answer).
+   * tool calls) has been quiet for activityQuietMs and the answer is captured (a
+   * delivered reply, a consumed-ack, or an attributed Stop — see
+   * _activityQuietEligible). The tail is over (Stop was lost, foreign, the hook
+   * stream died mid-session, or — the no-reply case — the Stop grace was cancelled
+   * by a pane-thinking heartbeat racing the Stop's own residual streaming hint).
    */
   _activityQuietFinalize(turnId) {
     const pending = this.pendingTurns.get(turnId);
     if (!pending) return;
     if (pending._stopGracePending) return;
     if (this._openQuestions.size > 0) return;          // re-check at fire time
-    // Eligibility: ≥1 bound reply, OR seen + consumed-acked (the answer went
-    // out under a sibling turn_id — fold-id echo; see _ledgerAckConsumed).
+    if (!this._activityQuietEligible(pending)) return;
     const consumedAcked = pending.seen === true && pending._consumedAcked === true;
-    if (!this._turnHasFinalReply(pending) && !consumedAcked) return;
     const lastHookAgeMs = this._lastHookEventAt ? Date.now() - this._lastHookEventAt : null;
     this._logEvent('cli-activity-quiet-finalize', {
       turn_id: turnId,
@@ -1819,6 +1858,16 @@ class CliProcess extends Process {
       last_hook_age_ms: lastHookAgeMs,
       had_stop: !!pending._stopHookData,
     });
+    // The no-reply rescue: a reply-less, not-consumed-acked turn finalizing here
+    // qualified ONLY via its captured Stop — i.e. it would have orphaned to the idle
+    // ceiling before this backstop existed. Distinct event so the soak can count it.
+    if (!this._turnHasFinalReply(pending) && !consumedAcked) {
+      this._logEvent('cli-noreply-stop-rescued', {
+        turn_id: turnId,
+        last_hook_age_ms: lastHookAgeMs,
+        text_len: (pending._stopHookData?.lastAssistantMessage || '').length,
+      });
+    }
     if (lastHookAgeMs != null && lastHookAgeMs >= this.activityQuietMs) {
       // A previously-live hook stream went quiet enough that rung 2 (not an
       // attributed Stop) ended the turn — the soak's mid-session-death signal.
@@ -1827,13 +1876,25 @@ class CliProcess extends Process {
     this._finalizeTurn(turnId);
   }
 
+  /**
+   * Capture a Stop hook's data on a pending, recording the work-hook count AT capture.
+   * The rung-2 no-reply backstop (_activityQuietEligible) compares the live _workHookSeq
+   * against this snapshot to tell "claude is done" (no work hook since the Stop) from
+   * "claude resumed" (a later work hook bumped the count). A monotonic counter — not a
+   * timestamp — so a Stop and a resume hook landing in the same millisecond still differ.
+   */
+  _captureStopHookData(pending, info) {
+    pending._stopHookData = info;
+    pending._stopHookDataSeq = this._workHookSeq || 0;
+  }
+
   /**
    * D1 rung 1: an attributed Stop (the pending was `seen` at pickup, or has
    * ≥1 turn_id-bound reply) finalizes through a short grace that any
    * subsequent same-session activity cancels (see _noteActivity #2).
    */
   _beginAttributedStopGrace(turnId, pending, info) {
-    pending._stopHookData = info;
+    this._captureStopHookData(pending, info);
     pending._stopGracePending = true;
     if (pending._activityQuietTimer) {
       clearTimeout(pending._activityQuietTimer);
@@ -1932,7 +1993,7 @@ class CliProcess extends Process {
       let graceCount = 0;
       for (const p of this.pendingTurns.values()) if (p._stopGracePending) graceCount++;
       if (graceCount !== 1) return;
-      pending._stopHookData = info;
+      this._captureStopHookData(pending, info);
       clearTimeout(pending._stopGraceTimer);
       pending._stopGraceTimer = null;
       finalize();
@@ -2876,6 +2937,10 @@ class CliProcess extends Process {
       this._lastHookEventAt = Date.now();
     } else if (ev.type && ev.type !== 'parse-error' && ev.type !== 'unknown') {
       this._lastHookEventAt = Date.now();
+      // Monotonic count of WORK hooks (everything but the terminal Stop). The rung-2
+      // no-reply backstop snapshots this at Stop capture; a later increment means
+      // claude resumed work, withdrawing the stale Stop's finalize eligibility.
+      this._workHookSeq = (this._workHookSeq || 0) + 1;
       this._noteActivity(`hook:${ev.type}`);
     }
 
@@ -3058,7 +3123,7 @@ class CliProcess extends Process {
             // sub-agent: refresh the captured last_assistant_message so the
             // eventual finalize delivers the LATEST produced answer (claude's real
             // end-of-work text), not the boundary Stop's stale/partial text.
-            p._stopHookData = info;
+            this._captureStopHookData(p, info);
           }
         } else if (this.pendingTurns.size > 1) {
           // Can't attribute Stop to one of several concurrent turns — surface

package/lib/sdk/callbacks.js

@@ -216,6 +216,10 @@ function createSdkCallbacks({
         const text = (msg && typeof msg.text === 'string' && msg.text)
           || extractAssistantText(msg);
         if (!text) return;
+        // 0.13 D3 fix: the cycle delivered its answer → stop its "typing…" NOW. endCycle
+        // (Process idle = SESSION idle) is delayed by any later turn, so typing otherwise
+        // spins minutes past the delivered answer. docs/typing-tracks-activity-spec.md
+        sessionFeedback?.stopCycleTyping?.(sessionKey);
         const chatId = getChatIdFromKey(sessionKey);
         const threadIdRaw = getThreadIdFromKey(sessionKey);
         const threadId = threadIdRaw ? parseInt(threadIdRaw, 10) : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.17.4",
+  "version": "0.17.7",
   "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": {