polygram 0.8.0-rc.55 → 0.8.0-rc.57

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.55",
+  "version": "0.8.0-rc.57",
   "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/context-format.js

@@ -1,5 +1,5 @@
 /**
- * Pure formatters for /context command output and the 85%-full hint.
+ * Pure formatters for /context command output and the context-full hint.
  *
  * Lifted from polygram.js so the formatting can be unit-tested without
  * spinning up the full handleMessage stack. Both functions are pure —
@@ -12,11 +12,22 @@
  *   0-1 ratio and multiplied by 100, which displayed "7700% full" and
  *   skipped the 85% hint threshold. The formatters below assume the
  *   0-100 scale; do not multiply or divide.
+ *
+ * rc.56 threshold change: default lowered from 85 → 70.
+ *   Background: at 85% the SDK has typically already auto-compacted
+ *   mid-turn, so polygram's post-turn check sees a low percentage
+ *   and the hint never fires. Production data showed 0 user-visible
+ *   hint triggers across 15 auto-compactions in May 2026, all of
+ *   which fired at pre_tokens 167-262k (≈85% of Sonnet's 200k
+ *   window). Lowering to 70% means polygram warns ~30k tokens
+ *   before the SDK auto-compacts, giving the user 1-3 turns of
+ *   headroom to choose /new vs /compact vs continue. Configurable
+ *   per-bot or per-chat via `contextHintThreshold` (number, 0-100).
  */
 
 'use strict';
 
-const HINT_THRESHOLD_PCT = 85;
+const HINT_THRESHOLD_PCT = 70;
 
 /**
  * Format a getContextUsage() result into a multi-line chat reply.
@@ -55,14 +66,20 @@ function formatContextReply(usage) {
 }
 
 /**
- * Decide whether to send the 85% hint and return the hint text if so.
+ * Decide whether to send the context-full hint and return the hint
+ * text if so.
  *
  * @param {object} usage  — same shape as formatContextReply input.
- * @returns {string|null} the hint text to send, or null when below threshold.
+ * @param {object} [opts]
+ * @param {number} [opts.threshold] — override the default percent
+ *   threshold (rc.56). Caller resolves per-chat / per-bot config
+ *   and passes it in. Defaults to HINT_THRESHOLD_PCT (70).
+ * @returns {string|null} the hint text to send, or null when below
+ *   threshold.
  */
-function maybeContextFullHint(usage) {
+function maybeContextFullHint(usage, { threshold = HINT_THRESHOLD_PCT } = {}) {
   const pct = usage?.percentage ?? 0;
-  if (pct < HINT_THRESHOLD_PCT) return null;
+  if (pct < threshold) return null;
   return [
     `📚 Context window ${pct.toFixed(0)}% full. Three options:`,
     '',

package/lib/replay-window.js

@@ -0,0 +1,53 @@
+/**
+ * rc.57: pure resolver for the boot-replay window in milliseconds.
+ *
+ * Lifted out of polygram.js's main() so the derivation rule can be
+ * unit-tested without spinning up the daemon.
+ *
+ * Precedence:
+ *   1. config.bot.replayWindowMs — explicit operator override (any
+ *      positive integer in ms).
+ *   2. Auto-derive from max(maxTurn) × 1.2 across all configured chats
+ *      (and defaults.maxTurn). Reasoning: if a chat allows turns up to
+ *      maxTurn seconds, an interrupted turn could be that old when
+ *      polygram restarts; replay window should outlast it. ×1.2 adds
+ *      buffer.
+ *   3. If no maxTurn is configured anywhere, return undefined (db.js
+ *      uses its 3-min default).
+ *
+ * Floor at 3 min (legacy default — never tighter than what we shipped
+ * before). Cap at 2h (sanity bound — replaying anything older is
+ * almost certainly stale work the user already moved on from).
+ *
+ * Discovery: msg 151 in Shumabit@UMI thread :24 (chat -1003369922517)
+ * was sent 2026-05-05 01:55:14, polygram restarted for rc.56 at
+ * 02:17 (22 min later). Pre-rc.57 the 3-min default discarded msg 151
+ * as too old; the agent's 7-hour Xero-template-build task was
+ * abandoned silently. Shumabit@UMI has maxTurn=3600 (60 min); 1.2×
+ * = 72 min replay window now keeps long turns alive across deploys.
+ */
+
+'use strict';
+
+const FLOOR_MS = 3 * 60 * 1000;        // 3 min
+const CAP_MS = 2 * 60 * 60 * 1000;     // 2 h
+const BUFFER = 1.2;                    // ×
+
+function resolveReplayWindowMs(config) {
+  const explicit = Number(config?.bot?.replayWindowMs);
+  if (Number.isInteger(explicit) && explicit > 0) return explicit;
+  const chatMaxes = Object.values(config?.chats || {})
+    .map((c) => Number(c?.maxTurn) || 0);
+  const defaultMax = Number(config?.defaults?.maxTurn) || 0;
+  const maxTurnSec = Math.max(0, ...chatMaxes, defaultMax);
+  if (maxTurnSec === 0) return undefined;
+  const derivedMs = Math.round(maxTurnSec * BUFFER * 1000);
+  return Math.max(FLOOR_MS, Math.min(CAP_MS, derivedMs));
+}
+
+module.exports = {
+  resolveReplayWindowMs,
+  FLOOR_MS,
+  CAP_MS,
+  BUFFER,
+};

package/package.json

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

@@ -66,6 +66,7 @@ const { createReactionManager, classifyToolName } = require('./lib/status-reacti
 const { createMediaGroupBuffer } = require('./lib/media-group-buffer');
 const { classify: classifyError, isTransientHttpError } = require('./lib/error-classify');
 const { createAutoResumeTracker, isAutoResumable } = require('./lib/auto-resume');
+const { resolveReplayWindowMs } = require('./lib/replay-window');
 const {
   createStore: createApprovalsStore,
   matchesAnyPattern: matchesApprovalPattern,
@@ -2859,14 +2860,22 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       // result, the followup messages (if any) get their own SDK
       // pause to absorb at, no special handling needed.
 
-      // 0.8.0 Phase 2 step 4: 85%-context-full live hint. After a
+      // 0.8.0 Phase 2 step 4: context-full live hint. After a
       // successful turn, peek at SDK's getContextUsage(); if past
-      // 85%, post a quiet hint so the user knows /new will help.
-      // SDK pm only — CLI pm has no equivalent (no Query object,
-      // no getContextUsage). OPT-IN per-chat or per-bot
-      // (rc.12+) — most chats don't want the noise. Per-chat takes
+      // the threshold, post a quiet hint so the user knows /new
+      // will help. SDK pm only — CLI pm has no equivalent (no
+      // Query object, no getContextUsage). OPT-IN per-chat or
+      // per-bot — most chats don't want the noise. Per-chat takes
       // precedence over per-bot so admins (Ivan DM) can opt in
       // without forcing it on every other chat.
+      //
+      // rc.56: threshold default lowered to 70% (was 85%) because
+      // the SDK auto-compacts mid-turn at ~85% — by the time
+      // polygram queries getContextUsage post-turn, the percentage
+      // has already dropped and the hint never fires. 70% gives
+      // the user 1-3 turns of headroom before SDK compaction.
+      // Configurable via `contextHintThreshold` (number, 0-100)
+      // per-chat or per-bot. Same precedence rule as contextHint.
       const chatCtxHint = chatConfig.contextHint != null
         ? chatConfig.contextHint
         : config.bot?.contextHint;
@@ -2874,8 +2883,13 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
         const entry = pm.get(sessionKey);
         const q = entry?.query;
         if (q && typeof q.getContextUsage === 'function') {
+          const threshold = chatConfig.contextHintThreshold != null
+            ? chatConfig.contextHintThreshold
+            : (config.bot?.contextHintThreshold != null
+              ? config.bot.contextHintThreshold
+              : undefined);
           q.getContextUsage().then((usage) => {
-            const text = maybeContextFullHint(usage);
+            const text = maybeContextFullHint(usage, threshold != null ? { threshold } : undefined);
             if (!text) return;
             return tg(bot, 'sendMessage', {
               chat_id: chatId,
@@ -3641,7 +3655,13 @@ async function pollBot(bot) {
           const chatId = m.chat.id.toString();
           const chatConfig = config.chats[chatId];
           const threadId = m.message_thread_id?.toString();
-          const topicName = threadId && chatConfig?.topics?.[threadId] ? chatConfig.topics[threadId] : threadId;
+          // rc.57: use getTopicName() helper which handles BOTH legacy string
+          // form and rc.48 object form. Pre-rc.57 the direct lookup
+          // `chatConfig.topics[threadId]` template-literal'd into "[object Object]"
+          // because rc.48 topics are objects like {name:"Music",agent:"...",...}.
+          const topicName = threadId
+            ? (chatConfig ? getTopicName(chatConfig, threadId) : threadId)
+            : null;
           const chatLabel = chatConfig?.name || chatId;
           const label = topicName ? `${chatLabel}/${topicName}` : chatLabel;
           console.log(`[${BOT_NAME}] ← ${label}: ${(m.text || m.caption || '(media)').slice(0, 60)}`);
@@ -4153,18 +4173,25 @@ async function main() {
   // Boot replay: re-dispatch any inbound turns that were interrupted by
   // the previous polygram's shutdown or crash. These are rows marked
   // 'dispatched', 'processing', or 'replay-pending' (set by the SIGTERM
-  // handler) — all within the last `replayWindowMs` (default 3 min) so
-  // we don't resurrect ancient work. Override via
-  // `config.bot.replayWindowMs` for ops tuning. Dedupe against
-  // already-sent outbound replies in case the previous instance DID
-  // answer before dying.
+  // handler) — all within the last `replayWindowMs` so we don't
+  // resurrect ancient work. Dedupe against already-sent outbound
+  // replies in case the previous instance DID answer before dying.
+  //
+  // rc.57: auto-derive replayWindowMs from max(maxTurn) * 1.2 when not
+  // explicitly set. Pre-rc.57 the default was 3 min — but chats with
+  // long agent tasks (Shumabit@UMI maxTurn=3600 = 60 min) would have
+  // their interrupted turns silently dropped because the turn was
+  // typically older than 3 min when polygram restarted. Discovery
+  // context: msg 151 in Shumabit@UMI thread :24 on 2026-05-05 was
+  // sent at 01:55:14, polygram restarted for rc.56 at 02:17 (22 min
+  // later). msg 151 was 'replay-pending' but boot-replay's 3-min
+  // window discarded it; the agent's 7-hour Xero task was abandoned.
+  // Auto-derive: 1.2 × max(chatConfig.maxTurn) across all chats,
+  // floored at 3 min (legacy default), capped at 2 hours (sanity).
   try {
     const chatIds = Object.keys(config.chats);
     if (chatIds.length > 0) {
-      const replayWindowMs = (() => {
-        const v = Number(config.bot?.replayWindowMs);
-        return (Number.isInteger(v) && v > 0) ? v : undefined; // undefined → use db.js default
-      })();
+      const replayWindowMs = resolveReplayWindowMs(config);
       const candidates = db.getReplayCandidates({ chatIds, ...(replayWindowMs && { olderThanMs: replayWindowMs }) });
       let replayed = 0;
       let skipped = 0;