polygram 0.10.0-rc.22 → 0.10.0-rc.24

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

@@ -563,7 +563,15 @@ class TmuxProcess extends Process {
       // rc.13.1: pasteAndEnter holds a per-session async lock around
       // paste + Enter so a concurrent injectUserMessage paste cannot
       // interleave keystrokes with this primary prompt.
-      const result = await this._pasteAndEnter(this._embedToken(turn.prompt, turn.token));
+      //
+      // confirmSubmit: this is a PRIMARY turn pasting into an idle TUI
+      // (the previous turn finished before _runTurn drained this one).
+      // A production polygram prompt is ~1-2KB → the TUI collapses it
+      // into a bracketed-paste block whose single Enter can be
+      // absorbed (2026-05-18 incident). confirmSubmit re-sends Enter
+      // until the input box clears, or fails loud.
+      const result = await this._pasteAndEnter(
+        this._embedToken(turn.prompt, turn.token), { confirmSubmit: true });
       if (result.stripped > 0) {
         this.logger.warn?.(
           `[${this.label}] stripped ${result.stripped} control chars from prompt`,
@@ -1283,13 +1291,18 @@ class TmuxProcess extends Process {
    * asynchronously (on confirm/timeout) so it gates only the NEXT
    * paste, never delays this caller.
    */
-  async _pasteAndEnter(text) {
+  async _pasteAndEnter(text, { confirmSubmit = false } = {}) {
     const token = this._extractTokens(text)[0] || null;
     const release = await this._pasteLock.acquire(this.tmuxName);
     let result;
     try {
       if (typeof this.runner.pasteAndEnter === 'function') {
-        result = await this.runner.pasteAndEnter(this.tmuxName, text);
+        // 2026-05-18 incident: confirmSubmit re-sends Enter if a large
+        // bracketed paste didn't submit. ONLY for a primary turn's
+        // paste into an idle TUI — never for an autosteer paste into a
+        // mid-turn TUI (the TUI parks that in its own queue; the input
+        // box holding it is expected, not a failed submit).
+        result = await this.runner.pasteAndEnter(this.tmuxName, text, { confirmSubmit });
       } else {
         result = await this.runner.pasteText(this.tmuxName, text);
         await this.runner.sendControl(this.tmuxName, 'Enter');
@@ -1350,6 +1363,40 @@ class TmuxProcess extends Process {
   async _waitForReady() {
     const deadline = this._now() + this.readyTimeoutMs;
     let lastBuf = '';
+    // B6 (shumorobot 2026-05-18, Music topic, twice): a slow
+    // custom-agent spawn (`music-curation:music-curator` loading
+    // several MCP servers) leaves the claude TUI mid-startup for
+    // SECONDS — the production debug log shows MCP connections
+    // spanning 14:45:31→14:45:40 (playwright 2.9s, context7 3.1s,
+    // serena 3.8s, …) with the screen repainting hard the whole time
+    // ("High write ratio: 100.0% writes"). Throughout that window the
+    // TUI ALREADY renders its ready hint (`? for shortcuts` /
+    // `bypass permissions on`) at the bottom of its startup banner.
+    //
+    // The old `_waitForReady` returned the INSTANT `READY_HINTS_RE`
+    // matched — i.e. on the first poll, while MCP servers were still
+    // loading. `start()` resolved early; the first `send()` pasted
+    // the prompt into a TUI still ingesting startup, and the
+    // submitted Enter was dropped → the prompt sat unsubmitted → the
+    // turn never began (a fake THINKING→STALL followed). On a
+    // no-agent TUI the startup window is sub-poll so it never bit; a
+    // slow custom-agent spawn opens a multi-second window every time.
+    //
+    // The banner is NOT a usable "not ready" signal — it stays on the
+    // pane indefinitely (the agent emits nothing pre-turn, so it
+    // never scrolls into scrollback). The real discriminator is
+    // QUIESCENCE: a genuinely-ready idle TUI produces a BYTE-STABLE
+    // `capture-pane` between polls (static banner + empty input box +
+    // ready hint), whereas a mid-startup TUI repaints every tick.
+    //
+    // Fix: require the ready hint to be present AND the captured pane
+    // to be UNCHANGED across consecutive polls for `quiesceMs`
+    // continuously before declaring ready — the same "must hold this
+    // long" idea `_awaitTurnComplete` already uses for turn
+    // completion. Bounded by `readyTimeoutMs`, so a genuinely wedged
+    // spawn still throws TMUX_READY_TIMEOUT.
+    let readySinceAt = null;   // when the (hint + stable-pane) state began
+    let prevBuf = null;        // last poll's capture, for the stability compare
     if (this.pollScheduler) this.pollScheduler.acquire();
     try {
       while (this._now() < deadline) {
@@ -1357,7 +1404,20 @@ class TmuxProcess extends Process {
         // pane. Polling 1000 lines each tick is wasteful — cap at 80
         // for a ~12× cheaper tmux subprocess.
         lastBuf = await this.runner.captureWide(this.tmuxName, { lines: 80 });
-        if (READY_HINTS_RE.test(lastBuf)) return;
+        // Ready ⇔ the hint is on the pane AND the pane is identical to
+        // the previous poll (the MCP-loading repaint storm has
+        // stopped). The first poll has no previous buffer to compare,
+        // so it can never satisfy stability — readiness needs at
+        // least two matching captures, which is the point.
+        const hintPresent = READY_HINTS_RE.test(lastBuf);
+        const paneStable = prevBuf !== null && lastBuf === prevBuf;
+        if (hintPresent && paneStable) {
+          if (readySinceAt == null) readySinceAt = this._now();
+          if (this._now() - readySinceAt >= this.quiesceMs) return;
+        } else {
+          readySinceAt = null;   // pane moved / hint gone → reset the clock
+        }
+        prevBuf = lastBuf;
         await this._waitForNextTick();
       }
     } finally {

package/lib/tmux/tmux-runner.js

@@ -46,6 +46,62 @@ const MULTILINE_SEPARATOR = ' / ';
 // via MULTILINE_SEPARATOR.
 const CONTROL_CHAR_RE = /[\x00-\x08\x0b-\x1f\x7f]/g;
 
+// 2026-05-18 incident: a ~1.2KB polygram prompt is collapsed by the
+// claude TUI into a bracketed-paste block rendered as "[Pasted text
+// #1]". A single Enter sent after the fixed paste drain does NOT
+// submit it — the Enter is absorbed while the TUI is still ingesting
+// the block, so the prompt sits unsubmitted in the input box and the
+// turn never starts. `pasteAndEnter` confirms the submit landed by
+// capture-pane and re-sends Enter if it didn't.
+
+// The claude TUI draws its input box bracketed by horizontal-rule
+// lines (long runs of the box-drawing char `─`). The input prompt is
+// a `❯`-prefixed line BETWEEN those rules. CRUCIALLY, a SUBMITTED
+// message is ALSO echoed with a `❯` prefix up in the conversation
+// area — so a naive "any ❯ line with paste content" check
+// false-positives on the echo of a just-submitted prompt. The input
+// box must be identified structurally: it is the `❯` line adjacent
+// to a horizontal rule.
+const TUI_RULE_RE = /^[^\S\n]*─{20,}[^\S\n]*$/;
+
+// Markers that mean "this line is holding an un-submitted paste":
+// the bracketed-paste collapse marker, or a polygram-prompt opening
+// tag (polygram only ever sends those as a paste body).
+const HELD_PASTE_RE = /\[Pasted text|<polygram-info|<session-context|<channel\b/;
+
+/**
+ * 2026-05-18 incident detector. Returns true when the claude TUI's
+ * INPUT BOX still holds an un-submitted paste — i.e. the prompt was
+ * pasted but the Enter did not submit it.
+ *
+ * Identifies the input box structurally: the `❯`-prefixed line that
+ * is adjacent to a horizontal-rule line. That distinguishes the live
+ * input box from the `❯`-prefixed echo of an already-submitted
+ * message in the conversation area (which would otherwise
+ * false-positive). An empty input box (`❯ ` with nothing after it)
+ * returns false — that is a clean, submitted state.
+ */
+function inputBoxHoldsPaste(pane) {
+  const lines = String(pane || '').split('\n');
+  for (let i = 0; i < lines.length; i += 1) {
+    const m = lines[i].match(/^[^\S\n]*❯[^\S\n]?(.*)$/);
+    if (!m) continue;
+    // Adjacent to a horizontal rule above or below ⇒ this is the
+    // input box, not a submitted-message echo.
+    const ruleAbove = i > 0 && TUI_RULE_RE.test(lines[i - 1]);
+    const ruleBelow = i + 1 < lines.length && TUI_RULE_RE.test(lines[i + 1]);
+    if (!ruleAbove && !ruleBelow) continue;
+    if (HELD_PASTE_RE.test(m[1])) return true;
+  }
+  return false;
+}
+
+// Submit-confirmation defaults — overridable per construction for
+// tests. `retries` extra Enter presses after the first; `pollMs` the
+// settle wait before each capture-pane check; `drainMs` the wait
+// after a re-sent Enter before re-checking.
+const DEFAULT_SUBMIT_CONFIRM = { retries: 4, pollMs: 200, drainMs: 250 };
+
 // ─── execFile wrapper ────────────────────────────────────────────────
 
 /**
@@ -139,8 +195,15 @@ function ensureLogDir(logPath) {
  * @param {object} [opts.logger=console]
  * @param {Function} [opts.runFn] — override the underlying execFile
  *   wrapper (for tests). Same signature: (cmd, args, opts?) → Promise.
+ * @param {object} [opts.submitConfirm] — large-paste submit-confirm
+ *   tunables { retries, pollMs, drainMs }; tests shorten these.
  */
-function createTmuxRunner({ logger = console, runFn = run } = {}) {
+function createTmuxRunner({
+  logger = console,
+  runFn = run,
+  submitConfirm = {},
+} = {}) {
+  const submitCfg = { ...DEFAULT_SUBMIT_CONFIRM, ...submitConfirm };
 
   async function spawn({
     name,
@@ -212,7 +275,24 @@ function createTmuxRunner({ logger = console, runFn = run } = {}) {
   // sessions don't block each other. Within one session, pasteText
   // + sendControl(Enter) hold the lock atomically.
   const inputLock = createAsyncLock();
-  async function pasteAndEnter(name, text) {
+  /**
+   * Paste a prompt body + press Enter, atomically per session.
+   *
+   * @param {string} name  tmux session
+   * @param {string} text  prompt body
+   * @param {object} [opts]
+   * @param {boolean} [opts.confirmSubmit=false] — when true, CONFIRM
+   *   the Enter actually submitted the prompt (capture-pane the input
+   *   box, re-send Enter if it still holds the paste, throw if it
+   *   never clears). Use ONLY for a primary turn's paste into an
+   *   IDLE TUI — the 2026-05-18 large-bracketed-paste bug. Must be
+   *   FALSE for an autosteer paste into a BUSY (mid-turn) TUI: there
+   *   the TUI legitimately parks the paste in its own input queue
+   *   (`queue-operation enqueue`), so the input box holding the paste
+   *   is EXPECTED, not a failed submit — re-sending Enter into a
+   *   streaming TUI would corrupt the queue.
+   */
+  async function pasteAndEnter(name, text, { confirmSubmit = false } = {}) {
     const release = await inputLock.acquire(name);
     try {
       const res = await pasteText(name, text);
@@ -226,7 +306,46 @@ function createTmuxRunner({ logger = console, runFn = run } = {}) {
       // Enter's processing. 50ms is enough on the TUI we tested
       // against (claude v2.1.142); see AGENTS.md pinned version.
       await new Promise((r) => setTimeout(r, 50));
-      return res;
+
+      // 2026-05-18 incident: a large (~1.2KB) bracketed paste is NOT
+      // submitted by that single Enter — the Enter is absorbed while
+      // the TUI is still ingesting the "[Pasted text #1]" block. The
+      // fixed drain is a timing guess that fails for big pastes.
+      // CONFIRM the submit landed by capture-pane; if the input box
+      // still holds the paste, re-send Enter (bounded retries). If it
+      // never clears, throw — pasteAndEnter must not report success
+      // for an unsubmitted prompt (a fake THINKING state otherwise).
+      //
+      // ONLY for a primary paste into an idle TUI (confirmSubmit). An
+      // autosteer paste into a mid-turn TUI is DELIBERATELY parked in
+      // the TUI's input queue — the input box holding it is correct,
+      // not a failure; re-sending Enter there would corrupt the queue.
+      if (!confirmSubmit) return res;
+      for (let attempt = 0; attempt <= submitCfg.retries; attempt += 1) {
+        await new Promise((r) => setTimeout(r, submitCfg.pollMs));
+        let pane;
+        try {
+          pane = await capturePane(name, { lines: 60 });
+        } catch (err) {
+          // capture-pane itself failed — can't confirm. Don't claim
+          // success; surface it.
+          throw Object.assign(
+            new Error(`pasteAndEnter: submit confirmation failed: ${err.message}`),
+            { code: 'TMUX_SUBMIT_FAILED', cause: err },
+          );
+        }
+        if (!inputBoxHoldsPaste(pane)) return res;   // submitted ✓
+        if (attempt === submitCfg.retries) break;    // out of retries
+        // Still stuck — the paste sits in the input box. Re-send
+        // Enter and give the TUI a moment before re-checking.
+        logger.debug?.(`[tmux-runner] ${name}: paste not submitted, re-sending Enter (attempt ${attempt + 1})`);
+        await sendControl(name, 'Enter');
+        await new Promise((r) => setTimeout(r, submitCfg.drainMs));
+      }
+      throw Object.assign(
+        new Error(`pasteAndEnter: prompt never submitted after ${submitCfg.retries + 1} Enter attempts`),
+        { code: 'TMUX_SUBMIT_FAILED', tmuxName: name },
+      );
     } finally {
       release();
     }

package/package.json

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