polygram 0.8.0-rc.44 → 0.8.0-rc.46

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.44",
+  "version": "0.8.0-rc.46",
   "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,13 +55,20 @@ function createStreamer({
   schedule = setTimeout,
   cancel = clearTimeout,
   logger = console,
-  // rc.44: by default, KEEP intermediate "thinking out loud" bubbles
-  // when forceNewMessage transitions to a fresh bubble for a new
-  // top-level assistant message. Pre-rc.44 those were pushed onto
-  // archived[] and deleted at turn-end, leaving only the final
-  // answer visible — but users wanted the full reasoning trail
-  // visible, especially in DM debugging contexts. Set to false to
-  // restore the 0.7.2 "delete intermediate" behaviour.
+  // 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);
@@ -75,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
@@ -168,12 +188,12 @@ function createStreamer({
   // via editMessageText to the original.
   //
   // rc.44: by default, the previous bubble is PRESERVED (not archived
-  // for end-of-turn deletion). Users wanted the full reasoning trail
-  // visible — "thinking out loud" + tool-use intermediates document
-  // what the agent actually did, which is valuable transparency. The
-  // 0.7.2 deletion behaviour assumed users wanted only the final
-  // answer; for chat-style DM debugging that's wrong. Opt back into
-  // the old behaviour with `preserveIntermediateBubbles: false`.
+  // 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

package/package.json

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

@@ -1947,6 +1947,38 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     }
     return;
   }
+  // 0.8.0-rc.46: /reload — close + respawn the SDK Query while
+  // PRESERVING the persisted claude_session_id. The next user
+  // message resumes the conversation (model has prior context via
+  // SDK resume) but the spawn re-reads agent / skill / plugin files
+  // from disk, so any local edits to ~/.claude/agents/<name>.md or
+  // skill files take effect.
+  //
+  // Difference vs /new:
+  //   /new    → resetSession clears session_id → fresh conversation
+  //   /reload → kill closes Query, session_id preserved → same
+  //              conversation continues with fresh agent/skill code
+  //
+  // Mechanism: pm.kill drains the pending queue (with code 'KILLED')
+  // and closes the SDK Query. Crucially it does NOT call
+  // db.clearSessionId — the contract test
+  // 'pm.kill does NOT call db.clearSessionId' pins this invariant.
+  // The next user message hits getOrSpawn → no warm Query → spawn
+  // fresh with `resume: <session_id>` from sessions table → SDK
+  // restores conversation history → fresh files loaded.
+  if (botAllowsCommands && text === '/reload') {
+    if (pm.has(sessionKey)) {
+      try { await pm.kill(sessionKey); }
+      catch (err) { console.error(`[${label}] kill on /reload: ${err.message}`); }
+    }
+    logEvent('session-reload-command', {
+      chat_id: chatId, command: text,
+      user: cmdUser, user_id: cmdUserId,
+    });
+    await sendReply('🔄 Reloaded. Next message picks up the conversation with fresh skills/agents.');
+    return;
+  }
+
   if (botAllowsCommands && (text === '/new' || text === '/reset')) {
     let drained = 0;
     const target = pm.pickFor(sessionKey);
@@ -2303,10 +2335,15 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     },
     minChars: botCfg.streamMinChars,
     throttleMs: botCfg.streamThrottleMs,
-    // rc.44: preserve intermediate "thinking out loud" bubbles by
-    // 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).
+    // 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
@@ -2317,11 +2354,18 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   // 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() {