polygram 0.10.0-rc.13 → 0.10.0-rc.15

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.13",
+  "version": "0.10.0-rc.15",
   "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

@@ -54,7 +54,16 @@ const DEFAULT_CONTEXT_WINDOW = 200_000;
 // for the next prompt. Under `--permission-mode acceptEdits` (our
 // default), the bottom-of-pane indicator can also read "accept edits
 // on" instead; treat either as ready.
-const READY_HINTS_RE    = /\?\s+for shortcuts|accept edits on/;
+// claude TUI shows a different ready hint depending on permission
+// mode:
+//   - default:           "? for shortcuts"
+//   - acceptEdits:       "accept edits on"
+//   - bypassPermissions: "bypass permissions on (shift+tab to cycle)"
+// All three are valid ready states. Polygram production uses
+// 'default', but the spike harness + tests exercising
+// bypassPermissions need the third matcher (caught by the rc.14
+// autosteer-tui-real.mjs spike).
+const READY_HINTS_RE    = /\?\s+for shortcuts|accept edits on|bypass permissions on/;
 const STREAMING_HINT_RE = /esc to interrupt/;
 
 // TUI approval-prompt indicators. When a chat is spawned WITHOUT
@@ -387,14 +396,18 @@ class TmuxProcess extends Process {
     try {
       // R2-F1: sanitization happens inside runner.pasteText; we also
       // log when chars get stripped.
-      const result = await this.runner.pasteText(this.tmuxName, prompt);
+      // rc.13.1: pasteAndEnter holds a per-session async lock around
+      // paste + Enter so a concurrent injectUserMessage paste can't
+      // interleave keystrokes with this primary turn's prompt
+      // (shumorobot 2026-05-15 saw msg 696's prompt truncated at
+      // `chat_id="-1003` by msg 698's autosteer paste cutting in).
+      const result = await this._pasteAndEnter(prompt);
       if (result.stripped > 0) {
         this.logger.warn?.(
           `[${this.label}] stripped ${result.stripped} control chars from prompt`,
         );
         this.emit('prompt-sanitized', { stripped: result.stripped, source: 'send' });
       }
-      await this.runner.sendControl(this.tmuxName, 'Enter');
 
       // Race: JSONL result event vs capture-pane quiescence fallback
       // vs hard timeout. JSONL is the primary signal (carries structured
@@ -692,14 +705,35 @@ class TmuxProcess extends Process {
       // its terminal result fires; only AFTER _extraTurnState is
       // flushed do subsequent events go to the next primary turn.
       if (this._extraTurnState) {
+        // rc.14.3: don't flush an empty extra-turn-state. The
+        // agent may emit a `thinking`-only assistant message
+        // (kinds=['thinking']) with stop_reason=end_turn BEFORE
+        // emitting the real text reply. parseLine fires a result
+        // event for the thinking message (empty text) — if we
+        // flush here we'd emit empty extra-turn-reply events and
+        // the subsequent real-text message would have no state to
+        // accumulate into (would leak to autonomous-assistant-
+        // message instead). Wait for a result that has actual
+        // text accumulated. Spike multi-2-rapid hit this.
+        if (!this._extraTurnState.text) {
+          return;
+        }
         const flushed = this._extraTurnState;
         this._extraTurnState = null;
-        this.emit('extra-turn-reply', {
-          msgId: flushed.msgId,
-          text: flushed.text,
-          sessionId: this.claudeSessionId,
-          backend: 'tmux',
-        });
+        // rc.14.1: _extraTurnState carries an array of msgIds (one
+        // dequeued user-message may resolve N pending autosteers
+        // when the TUI's queue concatenated multiple pastes). Emit
+        // one extra-turn-reply per msgId with the shared text so
+        // polygram delivers a Telegram reply per autosteered msg.
+        const msgIds = Array.isArray(flushed.msgIds) ? flushed.msgIds : [flushed.msgId];
+        for (const msgId of msgIds) {
+          this.emit('extra-turn-reply', {
+            msgId,
+            text: flushed.text,
+            sessionId: this.claudeSessionId,
+            backend: 'tmux',
+          });
+        }
       } else if (this._turnState && this._turnState.resolveResult) {
         this._turnState.resultEvent = ev;
         this._turnState.resolveResult(ev);
@@ -749,49 +783,74 @@ class TmuxProcess extends Process {
       // 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);
-      // rc.12.1: user-message handler can run while _turnState is
-      // still set (the prior turn's send() hasn't called
-      // _completeTurn yet — it's behind a pending microtask after
-      // its result resolved). Don't gate on _turnState being null
-      // here; the assistant-chunk + result routing above already
-      // ensures turn 2's events flow into _extraTurnState even when
-      // _turnState (for turn 3) exists. The only thing we need
-      // exclusive of is another in-progress _extraTurnState.
-      if (idx >= 0 && !this._extraTurnState) {
-        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',
-        });
-        // rc.11.1: also emit observability event so post-hoc
-        // diagnosis can confirm which path each autosteer took.
-        this.emit('autosteer-resolution', {
-          msgId,
-          via: 'new-turn',
-          sessionId: this.claudeSessionId,
-          backend: 'tmux',
-        });
+      // rc.14.1: SUBSTRING match. When two injectUserMessage calls
+      // land in the same tick (back-to-back autosteer), the TUI's
+      // queue concatenates their pastes into ONE queue entry
+      // separated by `\r` (Enter bytes), then dequeues as a SINGLE
+      // top-level user message containing BOTH contents. Caught by
+      // the 50-scenario spike's multi-2-rapid:
+      //   QUEUE-ENQUEUE: 'Inject 1...\rInject 2...'
+      //   USER:          'Inject 1...\rInject 2...'
+      // Pre-rc.14.1 strict equality matched neither pending → both
+      // orphaned. Substring match pops ALL pending whose content
+      // appears in ev.text. The result handler emits one
+      // extra-turn-reply per msgId (best UX given they got
+      // submitted as one TUI input — agent's reply addresses
+      // all of them).
+      const matchedIdxs = [];
+      for (let i = 0; i < this._pendingAutosteers.length; i++) {
+        if (ev.text.includes(this._pendingAutosteers[i].content)) {
+          matchedIdxs.push(i);
+        }
+      }
+      if (matchedIdxs.length > 0) {
+        const matched = matchedIdxs.map((i) => this._pendingAutosteers[i]);
+        // Remove from pending (reverse so earlier indices stay valid).
+        for (let i = matchedIdxs.length - 1; i >= 0; i--) {
+          this._pendingAutosteers.splice(matchedIdxs[i], 1);
+        }
+        if (!this._extraTurnState) {
+          this._extraTurnState = { msgIds: matched.map((m) => m.msgId), text: '' };
+        } else {
+          // rc.14.2: when the TUI dequeues multiple queued pastes
+          // and emits them as SEPARATE user-message events but
+          // produces ONE combined assistant reply (caught in spike
+          // multi-2-rapid: two QUEUE-dequeue events at same ms,
+          // two USER events sequentially, ONE ASST end_turn), the
+          // additional user-messages must APPEND to the in-flight
+          // _extraTurnState — they're all addressing the same turn.
+          this._extraTurnState.msgIds.push(...matched.map((m) => m.msgId));
+        }
+        for (const m of matched) {
+          this.emit('extra-turn-started', {
+            msgId: m.msgId,
+            sessionId: this.claudeSessionId,
+            backend: 'tmux',
+          });
+          this.emit('autosteer-resolution', {
+            msgId: m.msgId,
+            via: 'new-turn',
+            sessionId: this.claudeSessionId,
+            backend: 'tmux',
+          });
+        }
       } else if (this._pendingAutosteers.length > 0 && !this._turnState) {
         // user-message arrived, pending autosteer exists, no
-        // turn in flight — but content didn't match. This is the
-        // EXACT signature of the rc.11.1 bug (oneLine ' / ' vs
-        // newline mismatch). Surface for forensics.
+        // turn in flight — but content didn't match. Forensic dump
+        // includes both head + tail snippets + lengths so we can
+        // diff identical-looking but byte-different content.
+        const text = ev.text || '';
+        const pending = this._pendingAutosteers[0];
+        const pContent = pending?.content || '';
         this.emit('autosteer-match-miss', {
           phase: 'user-message',
-          text_head: (ev.text || '').slice(0, 80),
+          text_len: text.length,
+          text_head: text.slice(0, 80),
+          text_tail: text.slice(-80),
           pending_count: this._pendingAutosteers.length,
-          pending_head: this._pendingAutosteers[0]
-            ? (this._pendingAutosteers[0].content || '').slice(0, 80) : null,
+          pending_len: pContent.length,
+          pending_head: pContent.slice(0, 80),
+          pending_tail: pContent.slice(-80),
           sessionId: this.claudeSessionId,
           backend: 'tmux',
         });
@@ -814,6 +873,31 @@ class TmuxProcess extends Process {
     }
   }
 
+  /**
+   * rc.13.1: paste a prompt body AND press Enter as an atomic
+   * per-session operation. The production runner provides
+   * `pasteAndEnter(name, text)` which holds a per-session async lock
+   * across the paste+Enter pair so concurrent pasteText calls from
+   * a primary pm.send and a parallel injectUserMessage cannot
+   * interleave keystrokes in the TUI input box (root cause of the
+   * shumorobot 2026-05-15 reply-mis-attribution bug: msg 696's
+   * paste was truncated at `chat_id="-1003` when msg 698's autosteer
+   * paste cut in).
+   *
+   * Test runners without pasteAndEnter fall back to the sequential
+   * pasteText + sendControl(Enter) pair. Behaviour-equivalent for
+   * non-concurrent test scenarios; only production with a real tmux
+   * + concurrent injects exposes the race.
+   */
+  async _pasteAndEnter(text) {
+    if (typeof this.runner.pasteAndEnter === 'function') {
+      return this.runner.pasteAndEnter(this.tmuxName, text);
+    }
+    const result = await this.runner.pasteText(this.tmuxName, text);
+    await this.runner.sendControl(this.tmuxName, 'Enter');
+    return result;
+  }
+
   // ─── completion detection (§4.A capture-pane diff path — fallback) ──
 
   /**
@@ -1207,9 +1291,13 @@ class TmuxProcess extends Process {
     // intended extra-turn-reply path with reply_to=msg 686).
     const oneLine = safe.replace(/\r?\n/g, ' / ');
 
-    Promise.resolve()
-      .then(() => this.runner.pasteText(this.tmuxName, safe))
-      .then(() => this.runner.sendControl(this.tmuxName, 'Enter'))
+    // rc.13.1: use pasteAndEnter so the autosteer's paste+Enter pair
+    // serialises behind any in-flight pm.send paste+Enter. Without
+    // the lock, the autosteer paste could interleave keystrokes into
+    // the middle of a primary turn's prompt (caught on shumorobot
+    // 2026-05-15: msg 696's prompt got truncated mid-attribute when
+    // msg 698's autosteer paste cut in).
+    this._pasteAndEnter(safe)
       .catch((err) => this.emit('inject-fail', { err: err.message }));
 
     // Tell the next assistant-chunk to open a fresh Telegram bubble

package/lib/tmux/tmux-runner.js

@@ -32,6 +32,7 @@ const childProcess = require('child_process');
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
+const { createAsyncLock } = require('../async-lock');
 
 // ─── Constants ───────────────────────────────────────────────────────
 
@@ -196,6 +197,32 @@ function createTmuxRunner({ logger = console, runFn = run } = {}) {
     await runFn('tmux', ['send-keys', '-t', name, key]);
   }
 
+  // rc.13.1: paste+Enter must be ATOMIC per session. Pre-rc.13.1 two
+  // concurrent pasteText+sendControl pairs could interleave in the
+  // TUI's bracketed-paste buffer — Ivan caught this on shumorobot
+  // 2026-05-15 (the 2233-char user JSONL entry contained one
+  // truncated polygram channel + a full nested polygram prompt for
+  // a different msg_id). Symptom: msg 696's paste was at byte
+  // `chat_id="-1003` when msg 698's autosteer paste cut in,
+  // concatenating two pastes into one TUI user message → the agent
+  // saw a malformed input → the reply attribution went sideways
+  // (msg 697 got msg 698's answer, msg 696 got served last).
+  //
+  // The async-lock is keyed by tmux session name, so different
+  // sessions don't block each other. Within one session, pasteText
+  // + sendControl(Enter) hold the lock atomically.
+  const inputLock = createAsyncLock();
+  async function pasteAndEnter(name, text) {
+    const release = await inputLock.acquire(name);
+    try {
+      const res = await pasteText(name, text);
+      await sendControl(name, 'Enter');
+      return res;
+    } finally {
+      release();
+    }
+  }
+
   /**
    * Push a multi-line text prompt into the pane.
    *
@@ -293,6 +320,7 @@ function createTmuxRunner({ logger = console, runFn = run } = {}) {
     spawn,
     sendControl,
     pasteText,
+    pasteAndEnter,
     capturePane,
     captureWide,
     sessionExists,

package/package.json

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