polygram 0.9.0-rc.4 → 0.9.0-rc.6

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.9.0-rc.4",
+  "version": "0.9.0-rc.6",
   "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 plus history (transcript queries) and polygram-send (out-of-turn IPC sends with file-upload validation) skills.",
   "keywords": [
     "telegram",

package/lib/db.js

@@ -521,6 +521,20 @@ function wrap(db) {
       `).run(status, chat_id, msg_id);
     },
 
+    // 0.9.0: True when a specific inbound msg is still being processed
+    // by the SDK turn loop (handler_status in dispatched/processing).
+    // Used by the edit-correction injector — only inject a typo-fix
+    // note when the SDK actually still has the turn in flight.
+    isInboundLive({ chat_id, msg_id }) {
+      const row = db.prepare(`
+        SELECT 1 FROM messages
+        WHERE chat_id = ? AND msg_id = ? AND direction = 'in'
+          AND handler_status IN ('dispatched', 'processing')
+        LIMIT 1
+      `).get(chat_id, msg_id);
+      return !!row;
+    },
+
     // Find inbound messages that were being processed when polygram stopped.
     // Scoped by bot_name via the chat_id → config mapping, so each bot only
     // replays its own turns on boot. Scoped by olderThanMs (default 3 min)

package/lib/handlers/dispatcher.js

@@ -41,7 +41,13 @@ function createDispatcher({
   autoResumeTracker,              // lib/db/auto-resume.js instance
   chunkMarkdownText,              // lib/telegram/chunk.js
   deliverReplies,                 // lib/telegram/deliver.js
-  TG_MAX_LEN = 4096,
+  // Raw-markdown size budget for chunkMarkdownText. Set BELOW Telegram's
+  // 4096 hard limit to leave headroom for HTML inflation (toTelegramHtml
+  // adds <b>/<i>/<code> tags + entity escapes; ~10-15% in practice).
+  // Polygram passes TG_CHUNK_BUDGET (default 3500). Test default keeps
+  // the historic 4096 for back-compat in synthetic test runs that pass
+  // pre-formatted text.
+  chunkBudget = 4096,
   // State accessors (need late binding because polygram.js mutates):
   getIsShuttingDown,              // () → boolean
   logger = console,
@@ -119,7 +125,7 @@ function createDispatcher({
 
     // 4. Send the continuation reply as regular Telegram messages,
     //    threaded under the original user message.
-    const chunks = chunkMarkdownText(result.text, TG_MAX_LEN);
+    const chunks = chunkMarkdownText(result.text, chunkBudget);
     await deliverReplies({
       bot,
       send: (b, method, params, m) => tg(b, method, params, m),

package/lib/handlers/edit-correction.js

@@ -0,0 +1,77 @@
+'use strict';
+
+/**
+ * Edit-correction injector.
+ *
+ * When the user edits a Telegram message that's still being processed
+ * by the SDK turn loop, inject a correction note into the active turn
+ * via the same hook channel autosteer uses (pm.injectUserMessage,
+ * priority: 'next'). Lets users fix typos mid-turn without /stop +
+ * resend.
+ *
+ * Skipped when the turn already finished — at that point the
+ * conversation has moved on and re-opening it would confuse Claude
+ * more than help. Also skipped when the SDK session has been
+ * LRU-evicted (no live target to inject into).
+ *
+ * Architectural note: there's no polygram-side "buffer" to replace.
+ * pm.send and pm.injectUserMessage push the message text directly into
+ * the SDK's inputController AsyncIterable; once pushed, polygram has
+ * no way to retract it. So edit handling is always "inject correction
+ * note as additional context" — Claude reconciles.
+ */
+
+function createEditCorrectionInjector({
+  pm,
+  db,
+  getSessionKey,
+  config,
+  logEvent,
+  logger = console,
+} = {}) {
+
+  return function maybeInjectEditCorrection(editedMsg) {
+    if (!editedMsg?.chat) return false;
+    const chatId = editedMsg.chat.id.toString();
+    const chatConfig = config.chats[chatId];
+    if (!chatConfig) return false;
+
+    // Per-chat / bot-level opt-out. Default on.
+    const optOut = chatConfig.editCorrection != null
+      ? chatConfig.editCorrection === false
+      : config.bot?.editCorrection === false;
+    if (optOut) return false;
+
+    const threadIdStr = editedMsg.message_thread_id?.toString() || null;
+    const sessionKey = getSessionKey(chatId, threadIdStr, chatConfig);
+
+    // Three skip gates — all must be true for an injection:
+    //   1. SDK session exists (not LRU-evicted)
+    //   2. session has a turn in flight
+    //   3. the edited msg is still in the dispatched/processing pipeline
+    if (!pm.has(sessionKey)) return false;
+    if (!pm.get(sessionKey)?.inFlight) return false;
+    if (!db.isInboundLive({ chat_id: chatId, msg_id: editedMsg.message_id })) return false;
+
+    const newText = editedMsg.text || editedMsg.caption || '';
+    if (!newText) return false;
+
+    const ok = pm.injectUserMessage(sessionKey, {
+      content: `[edit] I corrected my previous message — it now reads: ${newText}`,
+      priority: 'next',
+    });
+    if (!ok) {
+      logger.error?.(`[${chatConfig.name || chatId}] edit-correction inject failed`);
+      return false;
+    }
+    logEvent('message-edit-injected', {
+      chat_id: chatId,
+      msg_id: editedMsg.message_id,
+      session_key: sessionKey,
+      text_len: newText.length,
+    });
+    return true;
+  };
+}
+
+module.exports = { createEditCorrectionInjector };

package/package.json

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

@@ -44,6 +44,7 @@ const { createDownloadAttachments } = require('./lib/handlers/download');
 const { createHandleConfigCallback } = require('./lib/handlers/config-callback');
 const { createHandleAbort } = require('./lib/handlers/abort');
 const { createAutosteerHandlers } = require('./lib/handlers/autosteer');
+const { createEditCorrectionInjector } = require('./lib/handlers/edit-correction');
 const { createSlashCommands } = require('./lib/handlers/slash-commands');
 const { createApprovals } = require('./lib/handlers/approvals');
 const { canonicalizeToolInput } = require('./lib/canonical-json');
@@ -108,6 +109,15 @@ const CLAUDE_BIN = process.env.POLYGRAM_CLAUDE_BIN
   || path.join(process.env.HOME || '', '.npm-global/bin/claude');
 const CHILD_HOME = process.env.POLYGRAM_CHILD_HOME || process.env.HOME || '';
 const TG_MAX_LEN = 4096;
+// 0.9.0-rc.6: chunker budget is intentionally lower than TG_MAX_LEN to
+// leave HTML headroom. toTelegramHtml converts markdown to HTML for
+// parse_mode=HTML — that conversion adds <b>/<i>/<code>/<a> tags and
+// entity-escapes &/</> chars, inflating length by ~10-15% for realistic
+// markdown. 2026-05-11 incident proved a 4044-char chunk inflated to
+// 4506 HTML chars and Telegram rejected. 3500 raw → max ~4030 HTML on
+// observed inputs, with headroom for adversarial code-heavy text.
+// Override via POLYGRAM_CHUNK_BUDGET if your traffic profile differs.
+const TG_CHUNK_BUDGET = Number.parseInt(process.env.POLYGRAM_CHUNK_BUDGET, 10) || 3500;
 const DEFAULT_MAX_WARM_PROCS = 10;
 
 let stickerMap = {}; // name → file_id
@@ -525,6 +535,7 @@ let handleConfigCallback = null;
 let handleAbortIfRequested = null;
 let autosteer = null;
 let dispatchSlashCommand = null;
+let maybeInjectEditCorrection = null;
 
 // rc.20: approvalCardText + safeParse moved to lib/approvals/ui.js.
 // 0.9.0 commit 29: makeCanUseTool / handleApprovalCallback /
@@ -1251,7 +1262,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
         // send the body as proper chunks.
         try { await streamer.discard(); }
         catch (err) { console.error(`[${label}] discard failed: ${err.message}`); }
-        const chunks = chunkMarkdownText(parsed.text, TG_MAX_LEN);
+        const chunks = chunkMarkdownText(parsed.text, TG_CHUNK_BUDGET);
         const r = await deliverReplies({
           bot,
           send: (b, method, params, m) => tg(b, method, params, m),
@@ -1317,7 +1328,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       // 0.7.0: use markdown-aware chunker + deliverReplies primitive.
       // The old chunkText was newline/byte-only; chunkMarkdownText also
       // respects code-fence boundaries (closes + reopens across chunks).
-      const chunks = chunkMarkdownText(parsed.text, TG_MAX_LEN);
+      const chunks = chunkMarkdownText(parsed.text, TG_CHUNK_BUDGET);
       await deliverReplies({
         bot,
         send: (b, method, params, m) => tg(b, method, params, m),
@@ -1702,6 +1713,18 @@ function createBot(token) {
       user_id: ctx.editedMessage.from?.id || null,
     });
     console.log(`[${BOT_NAME}] edited ${chatId}/${ctx.editedMessage.message_id}`);
+
+    // 0.9.0: typo-correction injection. If the SDK still has this turn
+    // in flight (handler_status in dispatched/processing AND
+    // pm.get(sk).inFlight), inject a `[edit] corrected: <NEW>` note
+    // via the same channel autosteer uses. Lets users fix typos
+    // mid-turn without /stop + resend. No-op when the turn already
+    // completed.
+    try {
+      maybeInjectEditCorrection?.(ctx.editedMessage);
+    } catch (err) {
+      console.error(`[${BOT_NAME}] edit-correction injector error: ${err.message}`);
+    }
   });
 
   bot.on('message:migrate_to_chat_id', async (ctx) => {
@@ -1955,6 +1978,9 @@ async function main() {
   autosteer = createAutosteerHandlers({
     config, pm, autosteeredRefs, logEvent,
   });
+  maybeInjectEditCorrection = createEditCorrectionInjector({
+    pm, db, getSessionKey, config, logEvent, logger: console,
+  });
   recordInbound = createRecordInbound({
     db, dbWrite, config, botName: BOT_NAME, extractAttachments,
   });
@@ -1973,7 +1999,7 @@ async function main() {
     classifyError, isAutoResumable,
     abortGrace, autoResumeTracker,
     chunkMarkdownText, deliverReplies,
-    TG_MAX_LEN,
+    chunkBudget: TG_CHUNK_BUDGET,
     getIsShuttingDown: () => isShuttingDown,
     logger: console,
   }));