polygram 0.8.0-rc.43 → 0.8.0-rc.45

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.43",
+  "version": "0.8.0-rc.45",
   "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/process-manager-sdk.js

@@ -458,22 +458,51 @@ class ProcessManagerSdk {
         }
       }
 
-      // forceNewMessage trigger fires BEFORE the new bubble's first
-      // chunk: detect message-id transition with non-empty prior
-      // streamText, then advance lastAssistantMessageId, THEN emit
-      // onStreamChunk for the new content.
+      // rc.45: multi-segment same-bubble streaming.
+      //
+      // Pre-rc.45: every message-id transition fired
+      // onAssistantMessageStart (= forceNewMessage on the streamer),
+      // producing a fresh bubble per SDK assistant message even
+      // though the user only sent one input. Tool-heavy turns
+      // showed 2-6 bubbles per logical user-input cycle.
+      //
+      // rc.45: only fire onAssistantMessageStart when the user
+      // STEERED (injectUserMessage set pendingSteerCausesNewBubble).
+      // Otherwise, accumulate the prior segment's text into
+      // priorMessagesText and append the new segment to it — same
+      // bubble grows naturally. Same-message-id events (cumulative
+      // streaming within a single SDKAssistantMessage) still
+      // REPLACE the segment text; the carry-over only kicks in on
+      // message-id TRANSITIONS.
       if (added) {
         const isNewMessage = head.lastAssistantMessageId != null
           && messageId != null
           && head.lastAssistantMessageId !== messageId
           && head.streamText
           && head.streamText.length > 0;
-        if (isNewMessage && this.onAssistantMessageStart) {
-          try { await this.onAssistantMessageStart(entry.sessionKey, entry); }
-          catch (err) { this.logger.error?.(`[${entry.label}] onAssistantMessageStart: ${err.message}`); }
+        if (isNewMessage) {
+          if (head.pendingSteerCausesNewBubble) {
+            // Steered: fire onAssistantMessageStart so the streamer
+            // forceNewMessage's. Reset the prior carry-over so the
+            // new bubble starts clean.
+            if (this.onAssistantMessageStart) {
+              try { await this.onAssistantMessageStart(entry.sessionKey, entry); }
+              catch (err) { this.logger.error?.(`[${entry.label}] onAssistantMessageStart: ${err.message}`); }
+            }
+            head.priorMessagesText = '';
+            head.pendingSteerCausesNewBubble = false;
+          } else {
+            // No steer: roll the just-finished segment's full text
+            // into priorMessagesText so the new segment appends to it.
+            head.priorMessagesText = head.streamText;
+          }
         }
         if (messageId != null) head.lastAssistantMessageId = messageId;
-        head.streamText = added;
+        // Compose visible bubble text: carry-over (prior segments in
+        // this bubble) + the current segment's cumulative text.
+        head.streamText = head.priorMessagesText
+          ? head.priorMessagesText + '\n\n' + added
+          : added;
         if (this.onStreamChunk) {
           try { this.onStreamChunk(entry.sessionKey, head.streamText, entry); }
           catch (err) { this.logger.error?.(`[${entry.label}] onStreamChunk: ${err.message}`); }
@@ -615,6 +644,17 @@ class ProcessManagerSdk {
         transientRetries: 0,
         firstAssistantSeen: false,
         thinkingFired: false,                  // rc.29: extended-thinking → reactor THINKING
+        // rc.45: multi-segment same-bubble streaming. priorMessagesText
+        // accumulates the full text of completed assistant-message
+        // segments in the SAME bubble. On message-id transition WITHOUT
+        // a steer, the just-finished segment rolls into priorMessagesText
+        // and the new segment's text appends to it (one bubble grows).
+        // On message-id transition WITH a steer, priorMessagesText
+        // resets and a new bubble starts. pendingSteerCausesNewBubble is
+        // set by injectUserMessage; consumed + cleared on the next
+        // message-id transition.
+        priorMessagesText: '',
+        pendingSteerCausesNewBubble: false,
       };
 
       pending.fireFirstStream = () => {
@@ -881,6 +921,15 @@ class ProcessManagerSdk {
       if (priority !== undefined) msg.priority = priority;
       if (shouldQuery !== undefined) msg.shouldQuery = shouldQuery;
       entry.inputController.push(msg);
+      // rc.45: signal the streamer to start a new bubble at the next
+      // assistant-message-id transition. Without this flag,
+      // _handleEvent would APPEND the post-steer assistant text into
+      // the same bubble as the pre-steer text, hiding the user's
+      // intervention. Only set when there's a head pending — if the
+      // session is idle, the next pm.send will start a fresh bubble
+      // anyway.
+      const head = entry.pendingQueue?.[0];
+      if (head) head.pendingSteerCausesNewBubble = true;
       this._logEvent('inject-user-message', {
         session_key: sessionKey,
         chat_id: entry.chatId,

package/lib/stream-reply.js

@@ -55,6 +55,21 @@ function createStreamer({
   schedule = setTimeout,
   cancel = clearTimeout,
   logger = console,
+  // rc.44: by default, KEEP intermediate text bubbles when
+  // forceNewMessage transitions to a fresh bubble for a new
+  // top-level assistant message. These are NOT "thinking" tokens
+  // (those are filtered out by extractAssistantText —
+  // b.type === 'text' only). They're regular text segments the
+  // model emitted as part of the reply (e.g. "Let me check that..."
+  // → tool runs → "Found it. Here's the answer..."). Pre-0.7.2
+  // these were preserved (the original 0.7.0 multi-bubble design);
+  // 0.7.2 added archive-and-delete-at-turn-end as OpenClaw-parity
+  // cleanup. rc.44 reverts to the 0.7.0 preserve-all default
+  // because the intermediate text is substantive reply content,
+  // not noise. Set to false to restore the 0.7.2 deletion behaviour
+  // (only final bubble visible) for partner-facing chats that
+  // prefer terse output.
+  preserveIntermediateBubbles = true,
 } = {}) {
   throttleMs = Math.max(THROTTLE_FLOOR_MS, throttleMs);
   let state = 'idle';       // 'idle' | 'live' | 'finalized'
@@ -67,9 +82,22 @@ function createStreamer({
   // 0.7.2: msg_ids of bubbles that have been superseded by
   // forceNewMessage(). The caller (polygram.js handleMessage at
   // end-of-turn) reads getArchived() and issues deleteMessage on
-  // each — matches OpenClaw's archivedAnswerPreviews cleanup so
-  // the user sees only the final answer's bubble, not every
-  // "thinking out loud" intermediate from a tool-heavy turn.
+  // each.
+  //
+  // History note (rc.44 correction): the 0.7.2 commit claimed this
+  // was "OpenClaw-parity / archivedAnswerPreviews cleanup" — that
+  // was wrong. The OFFICIAL OpenClaw + pi-telegram model is
+  // single-bubble-per-turn edited in place via sendMessageDraft (or
+  // sendMessage + editMessageText fallback); intermediate text
+  // segments don't exist there because the streamer concatenates
+  // everything into the same bubble. Polygram's multi-bubble shape
+  // is a 0.7.0 polygram-specific decision (one bubble per top-level
+  // assistant-message id, motivated by the SDK's segmentation), and
+  // the 0.7.2 archive-and-delete was a polygram-specific terseness
+  // cleanup, not OpenClaw porting. rc.44 made preserve-all the
+  // default again — archived[] only fills when
+  // preserveIntermediateBubbles=false (opt-out for partner-facing
+  // chats that prefer only-final-answer-visible output).
   const archived = [];
 
   // LIVE-EDIT truncation only — used during streaming when latestText
@@ -158,15 +186,26 @@ function createStreamer({
   // emits a new top-level assistant message mid-turn (post tool-result):
   // we want it in its own bubble below the previous one, not appended
   // via editMessageText to the original.
+  //
+  // rc.44: by default, the previous bubble is PRESERVED (not archived
+  // for end-of-turn deletion). Intermediate text segments are
+  // substantive reply content the user typed up — not "thinking"
+  // tokens (those are filtered upstream). Pre-0.7.2 polygram kept
+  // them all; 0.7.2 added deletion for OpenClaw-parity terseness.
+  // rc.44 reverts to the 0.7.0 preserve-all default. Opt back into
+  // the 0.7.2 behaviour with `preserveIntermediateBubbles: false`.
+  //
+  // When preserving, we still cancel the pending throttled edit (it
+  // wouldn't fire after we transition to a new bubble anyway) but
+  // there may be a recently-flushed edit in flight whose result we
+  // don't await — the bubble will display whatever its last
+  // successful edit landed, which is typically very close to the
+  // segment's final text (throttle is 250ms; segments take seconds).
   function forceNewMessage() {
     if (pendingEdit) { cancel(pendingEdit); pendingEdit = null; }
-    // Don't await flushPromise — the caller has decided to start a new
-    // message; whatever the old bubble shows is "done".
-    // 0.7.2: track the previous bubble's msgId for end-of-turn cleanup.
-    // Without this, every intermediate "thinking out loud" assistant
-    // message in a tool-heavy turn leaves a permanent bubble in the
-    // chat — the user wants only the final answer's bubble visible.
-    if (msgId != null) archived.push(msgId);
+    if (msgId != null && !preserveIntermediateBubbles) {
+      archived.push(msgId);
+    }
     msgId = null;
     currentText = '';
     latestText = '';

package/package.json

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

@@ -2303,16 +2303,37 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     },
     minChars: botCfg.streamMinChars,
     throttleMs: botCfg.streamThrottleMs,
+    // rc.44: preserve intermediate bubbles by default. These are
+    // regular text segments the model emits across an agentic
+    // multi-step turn ("Let me check..." → tool runs → "Found it.
+    // Here's the answer..."). Pre-0.7.2 polygram preserved them;
+    // 0.7.2 added archive-and-delete-at-turn-end for terseness.
+    // rc.44 reverts to preserve-all (the 0.7.0 default). Per-chat /
+    // per-bot opt-out via `preserveIntermediateBubbles: false` for
+    // chats where the partner-facing UX wants only the final answer
+    // (e.g. UMI Group).
+    preserveIntermediateBubbles: chatConfig.preserveIntermediateBubbles != null
+      ? chatConfig.preserveIntermediateBubbles
+      : (botCfg.preserveIntermediateBubbles != null
+        ? botCfg.preserveIntermediateBubbles
+        : true),
     logger: { error: (m) => console.error(`[${label}] ${m}`) },
   });
   // streamer is registered with this turn via pm.send's context (below)
 
   // 0.7.2: clean up bubbles superseded by forceNewMessage() — the
-  // intermediate "thinking out loud" assistant messages that fired in
-  // a tool-heavy turn. Without this, every tool-result cycle leaves a
-  // permanent bubble in the chat (see the screenshot from the post-
-  // 0.7.1 deploy where six bubbles appeared for one logical turn).
-  // Matches OpenClaw's archivedAnswerPreviews end-of-turn cleanup.
+  // intermediate text segments that fired across a tool-heavy turn.
+  // Pre-0.7.2 (since 0.7.0 multi-bubble landed) those bubbles were
+  // kept; 0.7.2 added cleanup motivated by a post-0.7.1 deploy
+  // screenshot of six bubbles per logical turn — terseness goal,
+  // NOT OpenClaw porting. (Earlier comments mis-cited OpenClaw
+  // parity; the official OpenClaw + pi-telegram model is
+  // single-bubble-per-turn edited in place. Polygram's
+  // multi-bubble shape is its own decision.)
+  // rc.44 made preservation the default again — getArchived()
+  // returns [] unless the chat opted out via
+  // `preserveIntermediateBubbles: false`. This function still runs
+  // unconditionally because the opt-out path needs it to fire.
   // Call AFTER finalize/discard decisions so we never delete the
   // bubble that's the final reply.
   async function cleanupArchivedBubbles() {