polygram 0.17.3 → 0.17.5

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();
@@ -2186,14 +2247,20 @@ class CliProcess extends Process {
       const fireTimeout = (reason, probeResult = null) => {
         if (!this.pendingTurns.has(turnId)) return;
         const pending = this.pendingTurns.get(turnId);
-        // 0.13 D1 (S9): unblock any open ask FIRST — claude must never stay
-        // hung on a question whose turn we are about to end. The card cleanup
-        // stays with the question sweep; this only resolves the blocking tool.
+        // A question waits for the user: while an `ask` is open the turn must NOT
+        // time out and die mid-question. Defer — re-arm the absolute checkpoint and
+        // keep waiting; the question store's long safety backstop is the only bound
+        // (a truly-abandoned question eventually expires {timedout}). Pre-0.17.4 this
+        // force-answered {timedout} at the ~30-min ceiling and killed the turn.
+        // docs/progress-is-not-turn-end-spec.md
         if (this._openQuestions.size > 0) {
-          for (const tc of [...this._openQuestions]) {
-            this._logEvent('cli-question-timedout-at-ceiling', { tool_call_id: tc, reason });
-            try { this.writeQuestionAnswer(tc, { timedout: true }); } catch { /* best-effort */ }
-          }
+          this._logEvent('cli-question-wait-extended', { reason, open_count: this._openQuestions.size });
+          // Reached via the idle hardTimer too — clear any still-armed absoluteTimer
+          // before re-arming so we don't orphan a ref-holding handle teardown can't see.
+          if (pending.absoluteTimer) clearTimeout(pending.absoluteTimer);
+          pending.absoluteTimer = setTimeout(() => this._checkpointAbsolute(turnId), this.turnAbsoluteMs);
+          pending.absoluteTimer.unref?.();
+          return;
         }
         this.pendingTurns.delete(turnId);
         const idx = this.pendingQueue.findIndex(e => e.turnId === turnId);
@@ -2476,6 +2543,15 @@ class CliProcess extends Process {
   async _checkpointAbsolute(turnId) {
     if (!this.pendingTurns.has(turnId)) return;
     let pending = this.pendingTurns.get(turnId);
+    // A question is open → the turn is waiting on the USER, not stalled. Don't probe
+    // or time out: re-arm and keep waiting (the question store's long backstop is the
+    // bound). docs/progress-is-not-turn-end-spec.md
+    if (this._openQuestions.size > 0) {
+      this._logEvent('cli-question-wait-extended', { reason: 'absolute-checkpoint', open_count: this._openQuestions.size });
+      pending.absoluteTimer = setTimeout(() => this._checkpointAbsolute(turnId), this.turnAbsoluteMs);
+      pending.absoluteTimer.unref?.();
+      return;
+    }
     // Turn with a FINAL reply (or consumed-acked): the ceiling RESOLVES it, never
     // extends. An interim-only turn (status promise, no final reply) is still
     // working — fall through to the busy-aware probe so it extends, not resolves.
@@ -2861,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}`);
     }
 
@@ -3043,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
@@ -3493,6 +3573,11 @@ class CliProcess extends Process {
       try { pending.reject(err); } catch {}
     }
     this.pendingTurns.clear();
+    // Drop interactive-question state too (parity with _doKill /
+    // _handleBridgeDisconnected) — else the 60s keep-alive interval leaks and
+    // _openQuestions is left stale on the reset session.
+    this._stopQuestionKeepAlive();
+    this._openQuestions.clear();
     // Now drain pendingQueue. Skip matching turnIds (already counted), reject
     // the rest (entries pushed by callers other than this.send — contract
     // test, tmux/sdk pm callback path).

package/lib/questions/store.js

@@ -11,12 +11,13 @@
 
 const { newToken, tokensEqual } = require('../approvals/store');
 
-// Option A (2026-06-09): don't expire a question before the turn that's blocking on
-// it can. A blocking `ask` can live at most the 30-min turn ABSOLUTE cap
-// (DEFAULT_TURN_ABSOLUTE_MS) — the keep-alive resets the idle cap but not the absolute
-// — so align here. The user answers any time within the turn's life, not an arbitrary
-// 8-min window. (Truly-unbounded "answer hours later" needs the non-blocking redesign.)
-const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+// A question waits for the user — the turn no longer times out while an `ask` is open
+// (cli-process defers its ceilings during a question wait, docs/progress-is-not-turn-end-spec.md),
+// so this is only the long SAFETY BACKSTOP: a forgotten/abandoned question eventually
+// expires {timedout} instead of pinning the session forever. Generous (a full day) so a
+// real user answering hours later is never cut off; tune via the `questionTimeoutMs` config
+// if a chat needs shorter/longer.
+const DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 
 function createQuestionStore(rawDb, now = () => Date.now()) {
   const insertStmt = rawDb.prepare(`

package/lib/sdk/callbacks.js

@@ -351,6 +351,9 @@ function createSdkCallbacks({
         ctx?.typing?.resume?.();
         const r = ctx?.reactor;
         if (r && typeof r.setState === 'function') {
+          // 0.17.4: release the question-wait hold (a concurrent sub-agent hold, if
+          // any, keeps its own — owner-scoped so they don't stomp each other).
+          if (typeof r.setWorkInFlight === 'function') r.setWorkInFlight(false, 'question');
           r.setState('THINKING');
           logEvent('question-resumed', { chat_id: getChatIdFromKey(sessionKey), session_key: sessionKey });
         }
@@ -367,6 +370,13 @@ function createSdkCallbacks({
         // loop) alive through the whole wait, so without this pause every
         // ask-wait would show continuous typing. Guarded no-op on dead turns.
         try { entry?.pendingQueue?.[0]?.context?.typing?.pause?.(); } catch { /* guarded */ }
+        // 0.17.4: hold the reaction through the question wait — it's waiting on the
+        // USER, not stalled, so don't let it decay to the 🥱/😨 stall faces (reuses
+        // the B3 work-in-flight hold). Released on the answer in onQuestionResumed.
+        try {
+          const r = entry?.pendingQueue?.[0]?.context?.reactor;
+          if (r && typeof r.setWorkInFlight === 'function') r.setWorkInFlight(true, 'question');
+        } catch { /* guarded */ }
         if (typeof renderQuestion !== 'function') return;
         await renderQuestion({ sessionKey, ...payload });
       } catch (err) {
@@ -792,7 +802,7 @@ function createSdkCallbacks({
           // B3: hold a "working" face for the whole sub-agent run — the quiet
           // stretch between its tool hooks is expected, not a stall, so suppress
           // the 🥱/😨 decay until it finishes. docs/progress-is-not-turn-end-spec.md
-          if (typeof r.setWorkInFlight === 'function') r.setWorkInFlight(true);
+          if (typeof r.setWorkInFlight === 'function') r.setWorkInFlight(true, 'subagent');
         }
       } catch (err) {
         logger.error?.(`[${botName}] subagent-start handler: ${err.message}`);
@@ -807,7 +817,7 @@ function createSdkCallbacks({
         if (r) {
           // B3: release the working-hold only when the LAST sub-agent finishes
           // (inFlight === 0) — nested/parallel sub-agents keep it held.
-          if (typeof r.setWorkInFlight === 'function') r.setWorkInFlight((payload?.inFlight ?? 0) > 0);
+          if (typeof r.setWorkInFlight === 'function') r.setWorkInFlight((payload?.inFlight ?? 0) > 0, 'subagent');
           if (typeof r.heartbeat === 'function') r.heartbeat();
         }
         logEvent('subagent-done', {

package/lib/telegram/reactions.js

@@ -226,9 +226,11 @@ function createReactionManager({
   // Chaining all applies through `applyChain` guarantees they're sent
   // to Telegram in setState() invocation order.
   let applyChain = Promise.resolve();
-  // B3: set true while a sub-agent / background work is in flight — suppresses the
-  // stall/freeze decay so a working-but-quiet turn never shows 🥱/😨.
-  let workInFlight = false;
+  // B3 / 0.17.4: independent "hold the reaction, suppress the 🥱/😨 decay" owners —
+  // a sub-agent run AND an open question can each hold concurrently. A boolean would
+  // let one release while the other still needs the hold (review MUST-FIX), so track
+  // the set of active owners; the decay is suppressed while ANY owner holds.
+  const workOwners = new Set();
   // States the auto-stall path may transition to. Once we've already
   // shown STALL or TIMEOUT we don't downgrade or rearm — only an
   // explicit setState() call (Claude resumed) can move us forward.
@@ -333,10 +335,10 @@ function createReactionManager({
   const armStallTimers = () => {
     clearStallTimers();
     if (stopped) return;
-    // B3: while a sub-agent (or background work) is genuinely in flight, a quiet
-    // stretch is EXPECTED — the turn is working, not stalled. Don't arm the
-    // 🥱/😨 decay; hold the current working face until work drains.
-    if (workInFlight) return;
+    // B3 / 0.17.4: while any owner holds (a sub-agent in flight, or an open question
+    // waiting on the user), a quiet stretch is EXPECTED — not stalled. Don't arm the
+    // 🥱/😨 decay; hold the current face until every owner releases.
+    if (workOwners.size > 0) return;
     if (!STALL_PROMOTABLE.has(currentState)) return;
     stallTimer = setTimeout(() => {
       stallTimer = null;
@@ -439,7 +441,7 @@ function createReactionManager({
 
   const stop = () => {
     stopped = true;
-    workInFlight = false;   // B3: defense-in-depth if a reactor is ever reused
+    workOwners.clear();   // B3: defense-in-depth if a reactor is ever reused
     if (pendingTimer) { clearTimeout(pendingTimer); pendingTimer = null; }
     clearStallTimers();
     clearDeepeningTimers();
@@ -460,16 +462,18 @@ function createReactionManager({
     armStallTimers();
   };
 
-  // B3: mark whether work (a sub-agent / background shell) is in flight. While
-  // active, the silence between tool hooks is expected, so the stall/freeze decay
-  // is suppressed and the reactor holds its working face. When work drains, the
-  // normal cascade resumes from now. docs/progress-is-not-turn-end-spec.md
-  const setWorkInFlight = (active) => {
-    const next = !!active;
-    if (next === workInFlight) return;
-    workInFlight = next;
-    if (workInFlight) clearStallTimers();   // cancel any pending 🥱/😨 decay
-    else armStallTimers();                   // work drained — resume the cascade
+  // B3 / 0.17.4: a named owner ('subagent', 'question', …) holds/releases the
+  // reaction. While ANY owner holds, the silence is expected (work in flight, or
+  // waiting on the user), so the stall/freeze decay is suppressed and the reactor
+  // holds its face. The cascade resumes only when the LAST owner releases. A boolean
+  // couldn't represent two concurrent owners. docs/progress-is-not-turn-end-spec.md
+  const setWorkInFlight = (active, owner = 'default') => {
+    const wasHeld = workOwners.size > 0;
+    if (active) workOwners.add(owner); else workOwners.delete(owner);
+    const isHeld = workOwners.size > 0;
+    if (isHeld === wasHeld) return;
+    if (isHeld) clearStallTimers();   // first owner → cancel any pending 🥱/😨 decay
+    else armStallTimers();             // last owner released → resume the cascade
   };
 
   return {

package/lib/telegram/typing.js

@@ -133,8 +133,15 @@ function startTyping({
   // tearing the loop down; resume() restarts immediately (the answer landed,
   // claude is working again). Attached to the stop function so every existing
   // `stopTyping()` call site keeps working unchanged.
-  stop.pause = () => { paused = true; };
+  stop.pause = () => {
+    if (paused) return;
+    paused = true;
+    // 0.17.4: instrument the question pause/resume so "typing disappeared after I
+    // answered" is diagnosable (typing pings themselves aren't logged).
+    onEvent?.({ kind: 'typing-state', chat_id: key, detail: { state: 'paused' } });
+  };
   stop.resume = () => {
+    onEvent?.({ kind: 'typing-state', chat_id: key, detail: { state: 'resume-called', stopped } });
     if (stopped) return;
     paused = false;
     tick();

package/package.json

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