polygram 0.10.0-rc.7 → 0.10.0-rc.9

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.10.0-rc.7",
+  "version": "0.10.0-rc.9",
   "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/process/tmux-process.js

@@ -696,6 +696,17 @@ class TmuxProcess extends Process {
         const { msgId } = this._pendingAutosteers[idx];
         this._pendingAutosteers.splice(idx, 1);
         this._extraTurnState = { msgId, text: '' };
+        // rc.9: signal that turn 2 just started for the autosteered
+        // msg. Polygram subscribes to re-engage typing indicator + ✍
+        // reaction on msgId during the gap (clearAutosteeredReactions
+        // had fired when primary turn 1 succeeded under SDK-style
+        // fold assumption — for tmux NEW-TURN that clear was
+        // premature; this event lets polygram restore the visual).
+        this.emit('extra-turn-started', {
+          msgId,
+          sessionId: this.claudeSessionId,
+          backend: 'tmux',
+        });
       }
     } else if (ev.type === 'last-prompt') {
       // Fallback complete signal. If 'result' didn't fire (rare; some

package/lib/process-manager.js

@@ -56,6 +56,14 @@ const CALLBACK_TO_EVENT = {
   // backend never emits this — its PostToolBatch fold path
   // guarantees one combined reply.
   onExtraTurnReply:             'extra-turn-reply',
+  // rc.9: pair-of with onExtraTurnReply. Fires the MOMENT TmuxProcess
+  // sees the dequeued user-message in JSONL, which is the start of
+  // turn 2 — gives polygram a hook to re-engage typing indicator and
+  // re-apply the ✍ reaction on the autosteered msg (otherwise the
+  // user sees a silent gap from when clearAutosteeredReactions fired
+  // at primary turn 1 success until the extra-turn reply lands).
+  // Payload: { msgId, sessionId, backend }.
+  onExtraTurnStarted:           'extra-turn-started',
 };
 
 class ProcessManager {

package/lib/sdk/callbacks.js

@@ -37,6 +37,64 @@ function createSdkCallbacks({
   getThreadIdFromKey,
   logger = console,
 } = {}) {
+  // rc.9: typing-indicator state for autosteer NEW-TURN extraction.
+  // Keyed by sessionKey. extra-turn-started installs a 4-second
+  // sendChatAction loop + tracks the autosteered msgId; extra-turn-
+  // reply tears it down and clears ✍. SDK backend never installs
+  // entries (it doesn't emit either event). Per-session, not per-msg,
+  // because the TUI's queue is FIFO and we only watch one extra turn
+  // at a time per session.
+  const extraTurnTracker = new Map(); // sessionKey → { msgId, intervalHandle, chatId }
+
+  function startExtraTurnVisuals(sessionKey, msgId) {
+    if (!bot) return;
+    const chatId = getChatIdFromKey(sessionKey);
+    // Re-apply ✍ on the autosteered msg — clearAutosteeredReactions
+    // fired when primary turn 1 succeeded, so the reaction is gone.
+    // Best-effort; failures don't block.
+    tg(bot, 'setMessageReaction', {
+      chat_id: chatId,
+      message_id: msgId,
+      reaction: [{ type: 'emoji', emoji: '✍' }],
+    }, { source: 'extra-turn-started', botName }).catch((err) => {
+      logger.error?.(`[${botName}] extra-turn ✍ re-apply failed: ${err.message}`);
+    });
+    // Typing indicator loop — Telegram's typing action expires after
+    // ~5s of inactivity, so we re-emit every 4s. Stops on extra-turn-
+    // reply (or session close — see kill cleanup at the bottom of
+    // this comment chain if needed).
+    const tick = () => {
+      tg(bot, 'sendChatAction', {
+        chat_id: chatId,
+        action: 'typing',
+      }, { source: 'extra-turn-typing', botName }).catch(() => {});
+    };
+    tick();
+    const handle = setInterval(tick, 4_000);
+    const prev = extraTurnTracker.get(sessionKey);
+    if (prev?.intervalHandle) clearInterval(prev.intervalHandle);
+    extraTurnTracker.set(sessionKey, { msgId, intervalHandle: handle, chatId });
+  }
+
+  function stopExtraTurnVisuals(sessionKey, msgId) {
+    const entry = extraTurnTracker.get(sessionKey);
+    if (!entry) return;
+    if (entry.intervalHandle) clearInterval(entry.intervalHandle);
+    extraTurnTracker.delete(sessionKey);
+    // Clear ✍ on the autosteered msg — the reply itself is now the
+    // "answered" signal. Use the tracker's chatId so we don't depend
+    // on the caller passing it.
+    if (bot && entry.chatId != null) {
+      tg(bot, 'setMessageReaction', {
+        chat_id: entry.chatId,
+        message_id: msgId ?? entry.msgId,
+        reaction: [],
+      }, { source: 'extra-turn-reply-clear', botName }).catch((err) => {
+        logger.error?.(`[${botName}] extra-turn ✍ clear failed: ${err.message}`);
+      });
+    }
+  }
+
   return {
     onInit: (sessionKey, event, entry) => {
       dbWrite(() => db.upsertSession({
@@ -54,6 +112,11 @@ function createSdkCallbacks({
     onClose: (sessionKey, code, entry) => {
       logger.log?.(`[${entry.label}] Process exited (code ${code})`);
       logEvent('process-close', { chat_id: entry.chatId, session_key: sessionKey, code });
+      // rc.9: if a session closes mid-extra-turn (turn 2 crashed,
+      // user /stop, daemon kill), tear down typing-indicator + ✍
+      // visuals so we don't leak the interval and aren't stuck
+      // showing "writing…" on a dead session.
+      stopExtraTurnVisuals(sessionKey, null);
     },
 
     onStreamChunk: (sessionKey, partial, entry) => {
@@ -153,6 +216,30 @@ function createSdkCallbacks({
       }
     },
 
+    // rc.9: pair-of with onExtraTurnReply. Fires the moment
+    // TmuxProcess sees the dequeued user-message in JSONL → turn 2
+    // is starting. Re-engages typing indicator + ✍ on the
+    // autosteered msg so the user has a visible "still working on
+    // this" signal during the gap between primary turn 1 ending and
+    // the extra reply landing. Without this, Ivan saw a few seconds
+    // of nothing (✍ cleared by clearAutosteeredReactions, no
+    // typing).
+    onExtraTurnStarted: (sessionKey, payload /* , entry */) => {
+      try {
+        const msgId = payload?.msgId;
+        if (msgId == null) return;
+        startExtraTurnVisuals(sessionKey, msgId);
+        logEvent('extra-turn-started', {
+          chat_id: getChatIdFromKey(sessionKey),
+          session_key: sessionKey,
+          msg_id: msgId,
+          backend: payload?.backend || 'tmux',
+        });
+      } catch (err) {
+        logger.error?.(`[${botName}] extra-turn-started handler: ${err.message}`);
+      }
+    },
+
     // rc.7: tmux backend autosteer NEW-TURN extra reply. Fires when
     // the TUI's queue dequeued an autosteered paste as a fresh user
     // turn — typically when the primary turn was a short / cached
@@ -169,6 +256,10 @@ function createSdkCallbacks({
       try {
         const text = payload?.text;
         const msgId = payload?.msgId;
+        // rc.9: ALWAYS tear down extra-turn visuals first, even if
+        // text/msgId are missing — otherwise the typing-indicator
+        // loop would run forever for that session.
+        stopExtraTurnVisuals(sessionKey, msgId);
         if (!text || msgId == null) return;
         const chatId = getChatIdFromKey(sessionKey);
         const threadIdRaw = getThreadIdFromKey(sessionKey);

package/lib/tmux/session-log-parser.js

@@ -109,12 +109,24 @@ function parseLine(line) {
   if (obj.type === 'assistant' && obj.message) {
     const content = obj.message.content;
     if (Array.isArray(content)) {
+      // Cross-backend parity (rc.8): SDK's extractAssistantText
+      // (lib/process/sdk-process.js:62-73) joins all text blocks of
+      // one assistant message into a single string and applies a
+      // trailing-colon → ellipsis transform: "Listing deps:" →
+      // "Listing deps…". This keeps streamed-but-not-final text from
+      // reading as half-formed during the pause while a tool runs.
+      // The CLI/tmux backend previously emitted one assistant-chunk
+      // per text block with no normalisation — Telegram bubbles
+      // would briefly show "files are in place:" while the agent
+      // ran follow-up tools. Now we mirror SDK byte-for-byte.
+      const textParts = [];
+      const toolUses = [];
       for (const block of content) {
         if (!block || typeof block !== 'object') continue;
         if (block.type === 'text' && typeof block.text === 'string' && block.text.length > 0) {
-          out.push({ type: 'assistant-chunk', text: block.text });
+          textParts.push(block.text);
         } else if (block.type === 'tool_use' && block.name) {
-          out.push({
+          toolUses.push({
             type: 'tool-use',
             name: block.name,
             input: block.input ?? null,
@@ -122,6 +134,16 @@ function parseLine(line) {
           });
         }
       }
+      // Emit text FIRST then tool-uses — matches the pre-rc.8 order
+      // (when the per-block iteration interleaved them in source
+      // order, but text-then-tool is the dominant real-world shape).
+      if (textParts.length > 0) {
+        const joined = textParts.join('\n\n').trim().replace(/([^:]):\s*$/, '$1…');
+        if (joined.length > 0) {
+          out.push({ type: 'assistant-chunk', text: joined });
+        }
+      }
+      for (const t of toolUses) out.push(t);
     }
     // Token-usage telemetry. Every assistant message carries the
     // cumulative usage snapshot — input_tokens + cache_creation +

package/package.json

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