polygram 0.9.0-rc.4 → 0.9.0-rc.5

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.5",
   "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/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.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": {

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');
@@ -525,6 +526,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 /
@@ -1702,6 +1704,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 +1969,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,
   });