polygram 0.8.0-rc.32 → 0.8.0-rc.34

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.8.0-rc.32",
+  "version": "0.8.0-rc.34",
   "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 and a history skill.",
   "keywords": [
     "telegram",

package/lib/status-reactions.js

@@ -29,12 +29,21 @@
 // are progressively safer. All endings in this list are in Telegram's
 // default available reactions as of 2026-04.
 const STATES = {
-  QUEUED:      { label: 'queued',      chain: ['👀', '🤔']       },
-  THINKING:    { label: 'thinking',    chain: ['🤔']             },
-  CODING:      { label: 'coding',      chain: ['👨‍💻', '✍', '🤔'] },
-  WEB:         { label: 'web',         chain: ['⚡', '🔥', '🤔']  },
-  TOOL:        { label: 'tool',        chain: ['🔥', '🤔']       },
-  WRITING:     { label: 'writing',     chain: ['✍', '🤔']        },
+  QUEUED:           { label: 'queued',           chain: ['👀', '🤔']       },
+  // rc.32: progressive-deepening cascade. setState('THINKING') auto-
+  // promotes through THINKING_DEEPER → THINKING_DEEPEST as time passes
+  // without a state change. Thresholds calibrated to Ivan DM 14-day
+  // production: 8% turns finish <5s, 33% in 5-15s (so 8s catches the
+  // meaty band), 25% in 15-30s (20s threshold catches them mid-flow),
+  // 17% over 60s (existing 45s STALL still fires for the truly long).
+  // All three emoji on Telegram's curated standard reaction list.
+  THINKING:         { label: 'thinking',         chain: ['🤔']             },
+  THINKING_DEEPER:  { label: 'thinking-deeper',  chain: ['🤨', '🤔']       },
+  THINKING_DEEPEST: { label: 'thinking-deepest', chain: ['🧐', '🤓', '🤔'] },
+  CODING:           { label: 'coding',           chain: ['👨‍💻', '✍', '🤔'] },
+  WEB:              { label: 'web',              chain: ['⚡', '🔥', '🤔']  },
+  TOOL:             { label: 'tool',             chain: ['🔥', '🤔']       },
+  WRITING:          { label: 'writing',          chain: ['✍', '🤔']        },
   // 0.8.0-rc.11: terminal "your follow-up was incorporated into the
   // in-flight turn" state. Used by polygram's autosteer block when a
   // mid-turn user message is buffered for the next PostToolBatch
@@ -70,6 +79,14 @@ const DEFAULT_STALL_MS = 45_000;
 // which 180s captures while letting routine work breathe. Pm has its
 // own 5-minute hard idle timeout that actually rejects stuck turns.
 const DEFAULT_FREEZE_MS = 180_000;
+// rc.32: thinking-deepening cascade thresholds. Calibrated to Ivan DM
+// 14-day production data (445 turns) — 8% finish <5s, 33% in 5-15s,
+// 25% in 15-30s. 8s catches the meaty band, 20s catches the
+// mid-bracket. STALL still fires at 45s for the genuinely-long 17%.
+// CODING / TOOL / WEB / WRITING reset the cascade (any state-change
+// in setState clears the deepening timers).
+const DEFAULT_THINKING_DEEPER_MS = 8_000;
+const DEFAULT_THINKING_DEEPEST_MS = 20_000;
 
 // Tool name → state classifier. Case-insensitive substring match so we
 // don't have to enumerate every existing or future tool. Order matters:
@@ -139,6 +156,8 @@ function createReactionManager({
   throttleMs = DEFAULT_THROTTLE_MS,
   stallMs = DEFAULT_STALL_MS,
   freezeMs = DEFAULT_FREEZE_MS,
+  thinkingDeeperMs = DEFAULT_THINKING_DEEPER_MS,
+  thinkingDeepestMs = DEFAULT_THINKING_DEEPEST_MS,
   logError = () => {},
 } = {}) {
   if (typeof apply !== 'function') throw new Error('apply function required');
@@ -149,6 +168,8 @@ function createReactionManager({
   let pendingTimer = null;
   let stallTimer = null;
   let freezeTimer = null;
+  let deeperTimer = null;          // rc.32: THINKING → THINKING_DEEPER (8s)
+  let deepestTimer = null;         // rc.32: THINKING → THINKING_DEEPEST (20s)
   let stopped = false;
   // 0.8.0-rc.11: serialize Telegram setMessageReaction calls. Without
   // this, multiple flush()es race at the network layer because each
@@ -162,7 +183,13 @@ function createReactionManager({
   // 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.
-  const STALL_PROMOTABLE = new Set(['THINKING', 'CODING', 'WEB', 'TOOL', 'WRITING']);
+  // rc.32: THINKING_DEEPER and THINKING_DEEPEST are stall-promotable
+  // too — if the model is stuck in a deep-thinking phase past 45s,
+  // STALL still fires.
+  const STALL_PROMOTABLE = new Set([
+    'THINKING', 'THINKING_DEEPER', 'THINKING_DEEPEST',
+    'CODING', 'WEB', 'TOOL', 'WRITING',
+  ]);
 
   const flush = async (stateName) => {
     if (stopped && !TERMINAL_STATES.has(stateName)) return;
@@ -191,6 +218,42 @@ function createReactionManager({
     if (freezeTimer) { clearTimeout(freezeTimer); freezeTimer = null; }
   };
 
+  // rc.32: thinking-deepening cascade. When state is THINKING, schedule
+  // auto-promotion at 8s (→ THINKING_DEEPER, 🤨) and 20s (→ THINKING_DEEPEST,
+  // 🧐). Any other setState (CODING / TOOL / WEB / WRITING / terminal) clears
+  // these. heartbeat() does NOT re-arm them — heartbeat is for keeping
+  // STALL/TIMEOUT at bay during silent activity, not for resetting
+  // visible deepening progression.
+  const clearDeepeningTimers = () => {
+    if (deeperTimer) { clearTimeout(deeperTimer); deeperTimer = null; }
+    if (deepestTimer) { clearTimeout(deepestTimer); deepestTimer = null; }
+  };
+  const armDeepeningTimers = () => {
+    clearDeepeningTimers();
+    if (stopped) return;
+    if (currentState !== 'THINKING') return;
+    deeperTimer = setTimeout(() => {
+      deeperTimer = null;
+      if (stopped) return;
+      if (currentState !== 'THINKING') return;
+      // Promote without going through setState — we want the visual
+      // change but NOT to reset the deepest timer (which keeps
+      // counting from the original THINKING start).
+      currentState = 'THINKING_DEEPER';
+      flush('THINKING_DEEPER');
+    }, thinkingDeeperMs);
+    deeperTimer.unref?.();
+    deepestTimer = setTimeout(() => {
+      deepestTimer = null;
+      if (stopped) return;
+      // Promote from THINKING or THINKING_DEEPER (NOT from CODING etc).
+      if (currentState !== 'THINKING' && currentState !== 'THINKING_DEEPER') return;
+      currentState = 'THINKING_DEEPEST';
+      flush('THINKING_DEEPEST');
+    }, thinkingDeepestMs);
+    deepestTimer.unref?.();
+  };
+
   const armStallTimers = () => {
     clearStallTimers();
     if (stopped) return;
@@ -223,6 +286,7 @@ function createReactionManager({
     if (TERMINAL_STATES.has(stateName)) {
       if (pendingTimer) { clearTimeout(pendingTimer); pendingTimer = null; }
       clearStallTimers();
+      clearDeepeningTimers();
       return flush(stateName);
     }
 
@@ -230,6 +294,12 @@ function createReactionManager({
     // doing *something*. Re-arm only if the new state is promotable
     // (no point arming over QUEUED/STALL/TIMEOUT itself).
     armStallTimers();
+    // rc.32: arm/clear deepening cascade. Only THINKING starts the
+    // 8s/20s progression; any other state (CODING / TOOL / etc)
+    // clears it (the visible state has moved on, deepening would be
+    // a regression).
+    if (stateName === 'THINKING') armDeepeningTimers();
+    else clearDeepeningTimers();
 
     // 0.8.0-rc.24: drop the 800ms throttle. Pre-rc.24, when a tool-
     // using turn fired QUEUED → THINKING → TOOL within a few ms,
@@ -251,6 +321,7 @@ function createReactionManager({
   const clear = async () => {
     if (pendingTimer) { clearTimeout(pendingTimer); pendingTimer = null; }
     clearStallTimers();
+    clearDeepeningTimers();
     if (currentEmoji == null) return;
     currentEmoji = null;
     // Same applyChain serialization as flush — clear() is a state
@@ -269,6 +340,7 @@ function createReactionManager({
     stopped = true;
     if (pendingTimer) { clearTimeout(pendingTimer); pendingTimer = null; }
     clearStallTimers();
+    clearDeepeningTimers();
   };
 
   // 0.8.0-rc.16: heartbeat — re-arm stall/freeze timers without
@@ -306,5 +378,7 @@ module.exports = {
   DEFAULT_THROTTLE_MS,
   DEFAULT_STALL_MS,
   DEFAULT_FREEZE_MS,
+  DEFAULT_THINKING_DEEPER_MS,
+  DEFAULT_THINKING_DEEPEST_MS,
   GENERIC_FALLBACKS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.8.0-rc.32",
+  "version": "0.8.0-rc.34",
   "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

@@ -2429,7 +2429,20 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   // 0.7.4 (item G) voice-ack guard preserved: if 👂 is up from
   // voice transcription, don't overwrite it. Let onFirstStream
   // promote to 🤔 when Claude actually starts work.
-  if (!voiceAck.ackEmitted) {
+  //
+  // rc.32 second guard: skip THINKING if we're going to autosteer
+  // this message. Pre-fix, autosteer messages briefly showed
+  // 🤔 → ✍ (THINKING set here, then AUTOSTEERED set inside the
+  // autosteer block ~50 lines below). The flash was visible to
+  // users. Detect the autosteer pre-condition (SDK pm active AND
+  // session in-flight AND chat hasn't opted out) and skip.
+  const willAutosteer = pm.has(sessionKey)
+    && pm.get(sessionKey)?.inFlight
+    && pm.isSdkFor(sessionKey)
+    && (chatConfig.autosteer != null
+      ? chatConfig.autosteer !== false
+      : config.bot?.autosteer !== false);
+  if (!voiceAck.ackEmitted && !willAutosteer) {
     reactor.setState('THINKING');
   }
 
@@ -2524,7 +2537,19 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       // (queue-head transition) flipped to THINKING the moment we wrote
       // stdin, even though Claude could spend hundreds of ms loading.
       // Result: long flat 🤔 with nothing happening; users assumed stall.
-      onFirstStream: () => reactor.setState('THINKING'),
+      //
+      // rc.33: also stop typing here. Telegram's "typing…" indicator
+      // shows for ~5s after the LAST sendChatAction tick. If we stop
+      // typing at turn-end (~5-10s post final reply), the indicator
+      // persists 5s past when the user sees the reply — confusing
+      // ("bot replied AND is still typing?"). Stopping at the first
+      // chunk means typing fades naturally as the streamer emits the
+      // bubble. Reactions (THINKING/CODING/etc) take over as the
+      // "still working" signal for long agent turns.
+      onFirstStream: () => {
+        reactor.setState('THINKING');
+        stopTyping();
+      },
     });
     const elapsed = ((Date.now() - t0) / 1000).toFixed(1);