polygram 0.17.3 → 0.17.4

package/lib/process/cli-process.js

@@ -2186,14 +2186,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 +2482,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.
@@ -3493,6 +3508,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.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": {