polygram 0.10.0-rc.6 → 0.10.0-rc.7

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.6",
+  "version": "0.10.0-rc.7",
   "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/handlers/autosteer.js

@@ -69,9 +69,15 @@ function createAutosteerHandlers({
     if (!entry?.inFlight) return { autosteered: false };
 
     const priority = priorityFor(chatConfig, config);
+    // rc.7: pass the autosteered msg_id through to the backend so the
+    // tmux backend can route an extra-turn reply back to Telegram if
+    // the TUI dequeues the paste as a fresh user turn (NEW-TURN path).
+    // SDK backend ignores msgId — its PostToolBatch fold path
+    // guarantees one combined reply via the primary pm.send.
     const ok = pm.injectUserMessage(sessionKey, {
       content: prompt,
       priority,
+      msgId: msg.message_id,
     });
     if (!ok) return { autosteered: false };
 

package/lib/process/tmux-process.js

@@ -167,6 +167,29 @@ class TmuxProcess extends Process {
     // getContextUsage() so polygram's post-turn auto-hint works on
     // the tmux backend just like SDK.
     this._lastUsage = null;
+
+    // rc.7: autosteer fold-vs-queue tracking. When polygram autosteers
+    // a user message via injectUserMessage({content, msgId}), we
+    // record (content, msgId) here. The TUI's queue may consume that
+    // paste in two ways (see SessionLogParser docs):
+    //
+    //   A) FOLD — JSONL emits `attachment.type="queued_command"`.
+    //      We pop the matching entry. The primary turn's reply
+    //      already covers both messages — no extra delivery needed.
+    //
+    //   B) NEW TURN — JSONL emits a top-level `user` message with
+    //      matching content. We pop the matching entry and start an
+    //      `_extraTurnState` accumulator. Subsequent assistant-chunks
+    //      (while no _turnState is active — i.e. primary pm.send
+    //      already returned) feed the accumulator; the next `result`
+    //      event flushes it as an `'extra-turn-reply'` { msgId, text }
+    //      event for polygram to route to Telegram.
+    //
+    // FIFO matching by content text — multiple pending autosteers are
+    // resolved in submission order, which matches how Telegram
+    // delivers messages anyway.
+    this._pendingAutosteers = [];  // Array<{ content, msgId }>
+    this._extraTurnState = null;   // null | { msgId, text }
   }
 
   get cost() { return 3; }
@@ -468,6 +491,14 @@ class TmuxProcess extends Process {
 
   _completeTurn() {
     this.inFlight = false;
+    // rc.7: clear _turnState so JSONL events arriving BETWEEN turns
+    // (autonomous assistant messages, queue-dequeued user prompts
+    // becoming fresh turns) don't incorrectly route to the just-
+    // completed turn. Without this, the rc.7 autosteer extra-turn
+    // path can't distinguish "primary turn done, watch for queue
+    // dequeue" from "still in primary turn". The next send() call
+    // freshly sets _turnState so existing callers are unaffected.
+    this._turnState = null;
     // Shift the HEAD pending (just-completed turn). After this, the
     // queue contains only items queued while inFlight (each carrying
     // their own resolve/reject pair). If any, re-enter send() on the
@@ -560,6 +591,13 @@ class TmuxProcess extends Process {
           ? `${this._turnState.text}\n\n${ev.text}`
           : ev.text;
         this.emit('stream-chunk', this._turnState.text);
+      } else if (this._extraTurnState) {
+        // rc.7: autosteer NEW-TURN extraction in progress. Accumulate
+        // this chunk into the extra-turn buffer. It will be flushed
+        // when the next 'result' event fires (see below).
+        this._extraTurnState.text = this._extraTurnState.text
+          ? `${this._extraTurnState.text}\n\n${ev.text}`
+          : ev.text;
       } else {
         // No turn in flight — this is an autonomous assistant message
         // (claude self-initiated; typically ScheduleWakeup firing).
@@ -614,10 +652,51 @@ class TmuxProcess extends Process {
       if (this._turnState && this._turnState.resolveResult) {
         this._turnState.resultEvent = ev;
         this._turnState.resolveResult(ev);
+      } else if (this._extraTurnState) {
+        // rc.7: extra-turn (autosteer NEW-TURN) just completed. Flush
+        // the accumulated text as 'extra-turn-reply' so polygram can
+        // send it to Telegram as a reply to the autosteered msgId.
+        // Only flush on the 'success' subtype (end_turn) — non-terminal
+        // result subtypes like 'tool_use' shouldn't close the
+        // extra-turn (the model may still emit more chunks).
+        if (ev.subtype === 'success') {
+          const flushed = this._extraTurnState;
+          this._extraTurnState = null;
+          this.emit('extra-turn-reply', {
+            msgId: flushed.msgId,
+            text: flushed.text,
+            sessionId: this.claudeSessionId,
+            backend: 'tmux',
+          });
+        }
+      }
+      // If no turn in flight and no extra-turn, result event just
+      // marks the end of an autonomous message segment — already
+      // handled by the assistant-chunk branch above.
+    } else if (ev.type === 'queue-folded') {
+      // rc.7: TUI consumed an autosteered paste inside the current
+      // turn (FOLD). Pop the matching pending autosteer so a later
+      // 'user-message' with the same content doesn't spuriously
+      // trigger extra-turn extraction. The primary turn's reply
+      // already covers both messages — no extra delivery needed.
+      const idx = this._pendingAutosteers.findIndex((a) => a.content === ev.prompt);
+      if (idx >= 0) {
+        this._pendingAutosteers.splice(idx, 1);
+      }
+    } else if (ev.type === 'user-message') {
+      // rc.7: top-level user message in JSONL — may be the TUI
+      // dequeuing an autosteered paste as a fresh user turn
+      // (NEW-TURN path). Match by content. If found AND no primary
+      // turn is currently in flight (the autosteered second turn
+      // runs AFTER the first turn returned), start an extra-turn
+      // accumulator. Subsequent assistant-chunks + the next 'result'
+      // event will flush it as 'extra-turn-reply'.
+      const idx = this._pendingAutosteers.findIndex((a) => a.content === ev.text);
+      if (idx >= 0 && !this._turnState && !this._extraTurnState) {
+        const { msgId } = this._pendingAutosteers[idx];
+        this._pendingAutosteers.splice(idx, 1);
+        this._extraTurnState = { msgId, text: '' };
       }
-      // If no turn in flight, the result event simply marks the end of
-      // an autonomous message segment — already handled by the
-      // assistant-chunk branch above.
     } else if (ev.type === 'last-prompt') {
       // Fallback complete signal. If 'result' didn't fire (rare; some
       // claude versions may write last-prompt instead of stop_reason),
@@ -996,10 +1075,15 @@ class TmuxProcess extends Process {
    * Inject text into the in-flight turn. Fire-and-forget paste; errors
    * surface via 'inject-fail' event, never as a thrown exception.
    *
+   * @param {object} [opts.msgId]  — rc.7: when provided, registers
+   *   the (content, msgId) for autosteer fold-vs-queue tracking so
+   *   the NEW-TURN case (queue dequeued as a fresh user turn) can
+   *   route its reply back to Telegram via 'extra-turn-reply'.
+   *
    * @returns {boolean} false if no live turn (caller falls through to
    *   pm.send queue path) OR if content sanitized to empty.
    */
-  injectUserMessage({ content, priority = 'next', shouldQuery } = {}) {
+  injectUserMessage({ content, priority = 'next', shouldQuery, msgId } = {}) {
     if (!this.inFlight || this.closed) return false;
     // Mirror R2-F1: sanitize even though pasteText also sanitizes.
     // We need to detect empty-after-sanitize here so caller can fall
@@ -1020,7 +1104,17 @@ class TmuxProcess extends Process {
       this._turnState.pendingSteerCausesNewBubble = true;
     }
 
-    this.emit('inject-user-message', { text_len: safe.length, priority, shouldQuery });
+    // rc.7: register the autosteer for fold-vs-queue tracking. The
+    // JSONL parser will later emit either 'queue-folded' (FOLD) or
+    // 'user-message' (NEW TURN) with the same content, and
+    // _handleSessionEvent matches by content to resolve which path
+    // ran. msgId is optional — when omitted, the inject is still
+    // delivered but no extra-turn extraction is attempted.
+    if (msgId != null) {
+      this._pendingAutosteers.push({ content: safe, msgId });
+    }
+
+    this.emit('inject-user-message', { text_len: safe.length, priority, shouldQuery, msgId });
     return true;
   }
 

package/lib/process-manager.js

@@ -48,6 +48,14 @@ const CALLBACK_TO_EVENT = {
   // onApprovalRequired to route tmux prompts through the SAME
   // approval card UI used by SDK's canUseTool flow.
   onApprovalRequired:           'approval-required',
+  // rc.7: tmux backend autosteer "NEW-TURN" extra reply. Fires when
+  // the TUI's queue dequeued an autosteered paste as a fresh user
+  // turn (because primary turn ended before fold could happen). The
+  // payload is { msgId, text, sessionId, backend } and polygram
+  // routes it to Telegram as a reply to the autosteered msgId. SDK
+  // backend never emits this — its PostToolBatch fold path
+  // guarantees one combined reply.
+  onExtraTurnReply:             'extra-turn-reply',
 };
 
 class ProcessManager {

package/lib/sdk/callbacks.js

@@ -153,6 +153,54 @@ function createSdkCallbacks({
       }
     },
 
+    // 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
+    // reply that finished before the paste could fold in. The
+    // payload carries { msgId, text, sessionId, backend }; msgId is
+    // the Telegram message_id of the autosteered user message
+    // (so the reply lands as a Telegram reply to that message,
+    // matching how Ivan visually expects autosteer to behave).
+    //
+    // SDK backend NEVER emits this — its PostToolBatch fold path
+    // guarantees one combined reply via the primary pm.send().
+    // This is purely a tmux-backend bridge.
+    onExtraTurnReply: (sessionKey, payload /* , entry */) => {
+      try {
+        const text = payload?.text;
+        const msgId = payload?.msgId;
+        if (!text || msgId == null) return;
+        const chatId = getChatIdFromKey(sessionKey);
+        const threadIdRaw = getThreadIdFromKey(sessionKey);
+        const threadId = threadIdRaw ? parseInt(threadIdRaw, 10) : null;
+        if (!bot) {
+          logger.error?.(`[${botName}] extra-turn-reply: bot not ready, dropping ${text.length} chars`);
+          return;
+        }
+        const params = {
+          chat_id: chatId,
+          text,
+          reply_to_message_id: msgId,
+          ...(Number.isInteger(threadId) && { message_thread_id: threadId }),
+        };
+        // Don't await — keep the pm event loop unblocked.
+        tg(bot, 'sendMessage', params,
+          { source: 'extra-turn-reply', botName }).catch((err) => {
+            logger.error?.(`[${botName}] extra-turn-reply send failed: ${err.message}`);
+          });
+        logEvent('extra-turn-reply', {
+          chat_id: chatId,
+          session_key: sessionKey,
+          thread_id: threadIdRaw,
+          msg_id: msgId,
+          text_len: text.length,
+          backend: payload?.backend || 'tmux',
+        });
+      } catch (err) {
+        logger.error?.(`[${botName}] extra-turn-reply handler: ${err.message}`);
+      }
+    },
+
     // SDK auto-compaction observability. Fires when SDK emits
     // SDKCompactBoundaryMessage. Surfaces a quiet system status note
     // to the chat so the user knows the bot is busy reorganising

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

@@ -24,6 +24,16 @@
  * - assistant with `content[].type === 'tool_use'` → emit 'tool-use' { name, input }
  * - assistant with `message.stop_reason`         → emit 'result' { subtype, text, ... }
  * - last-prompt                                  → emit 'last-prompt' (fallback complete signal)
+ * - user (top-level, content is string)          → emit 'user-message' { text }
+ *     The queue-becomes-new-turn signal: when the TUI dequeues a
+ *     queued paste as a fresh user turn (because the prior turn
+ *     ended before fold could happen). Note: when content is an
+ *     ARRAY containing a `tool_result` block, that's API-shaped
+ *     tool_result feedback (not a user prompt) — must NOT emit.
+ * - attachment with `attachment.type === 'queued_command'` → emit 'queue-folded' { prompt }
+ *     The fold-confirmed signal: a paste IS being consumed inside
+ *     the current turn. Polygram uses this to know it does NOT
+ *     need to extract a second reply for the autosteered msg.
  *
  * Robust against malformed lines: returns null and skips.
  *
@@ -147,6 +157,23 @@ function parseLine(line) {
     }
   } else if (obj.type === 'last-prompt') {
     out.push({ type: 'last-prompt', text: obj.lastPrompt ?? '' });
+  } else if (obj.type === 'user' && obj.message) {
+    // Top-level user message — only emit when content is a non-empty
+    // string. Array content carries tool_result blocks (API-shaped
+    // tool feedback), which are NOT user prompts and must be skipped
+    // — they would otherwise trigger spurious "extra-turn" extraction
+    // in TmuxProcess.
+    const content = obj.message.content;
+    if (typeof content === 'string' && content.length > 0) {
+      out.push({ type: 'user-message', text: content });
+    }
+  } else if (obj.type === 'attachment' && obj.attachment) {
+    // queued_command attachment is the FOLD signal — the TUI consumed
+    // an autosteered paste inside the current in-flight turn.
+    const a = obj.attachment;
+    if (a.type === 'queued_command' && typeof a.prompt === 'string' && a.prompt.length > 0) {
+      out.push({ type: 'queue-folded', prompt: a.prompt });
+    }
   }
 
   return out;

package/package.json

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