polygram 0.10.0-rc.21 → 0.10.0-rc.23

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.21",
+  "version": "0.10.0-rc.23",
   "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/abort.js

@@ -41,13 +41,37 @@ function createHandleAbort({
 
     const threadId = msg.message_thread_id?.toString();
     const sessionKey = getSessionKey(chatId, threadId, chatConfig);
-    const hadActive = pm.has(sessionKey) && !!pm.get(sessionKey)?.inFlight;
+    const proc = pm.has(sessionKey) ? pm.get(sessionKey) : null;
+    const hadActive = !!proc?.inFlight;
 
     // Mark BEFORE killing: the 'close' event fires almost immediately
     // after interrupt, and the surrounding handleMessage's catch
     // needs to see the flag to skip the generic error-reply.
     if (hadActive) markSessionAborted(sessionKey);
 
+    // Bug 1 (incident 2026-05-18): "Stop" was turn-scoped — it only
+    // looked at an in-flight TURN. But the agent can leave a DETACHED
+    // background shell running (a `run_in_background:true` Bash) that
+    // outlives the turn; the tmux TUI shows an `N shell` indicator.
+    // When there is no live turn, check for such a shell and stop it
+    // so "Stop" acts truthfully instead of replying "Nothing to stop"
+    // while work is still churning. tmux-only — the SDK Process has no
+    // hasBackgroundShell()/killBackgroundShells(); the typeof guards
+    // make this a no-op there.
+    let killedBackgroundShell = false;
+    if (!hadActive && proc
+      && typeof proc.hasBackgroundShell === 'function'
+      && typeof proc.killBackgroundShells === 'function') {
+      try {
+        if (await proc.hasBackgroundShell()) {
+          markSessionAborted(sessionKey);
+          killedBackgroundShell = await proc.killBackgroundShells();
+        }
+      } catch (err) {
+        logger.error?.(`[${botName}] background-shell stop failed: ${err.message}`);
+      }
+    }
+
     // SDK abort: interrupt() + drainQueue(). interrupt() cancels
     // the in-flight turn at SDK level WITHOUT tearing down the
     // Query (cheap to reuse for the user's next message);
@@ -62,6 +86,7 @@ function createHandleAbort({
     logEvent('abort-requested', {
       chat_id: chatId, user_id: msg.from?.id || null,
       had_active: hadActive,
+      killed_background_shell: killedBackgroundShell,
       trigger: cleanText.slice(0, 40),
     });
 
@@ -69,10 +94,23 @@ function createHandleAbort({
     // detection is crude but reliable for ru/en.
     const lang = /[а-яё]/i.test(cleanText) ? 'ru' : 'en';
     const strs = {
-      en: { stopped: 'Stopped.',     nothing: 'Nothing to stop.' },
-      ru: { stopped: 'Остановлено.', nothing: 'Нечего останавливать.' },
+      en: {
+        stopped: 'Stopped.',
+        bgStopped: 'Stopped the background task.',
+        nothing: 'Nothing to stop.',
+      },
+      ru: {
+        stopped: 'Остановлено.',
+        bgStopped: 'Фоновая задача остановлена.',
+        nothing: 'Нечего останавливать.',
+      },
     }[lang];
-    const reply = hadActive ? strs.stopped : strs.nothing;
+    // Truthful ack: a stopped in-flight turn → "Stopped"; a stopped
+    // background shell → "Stopped the background task"; neither →
+    // "Nothing to stop".
+    const reply = hadActive ? strs.stopped
+      : killedBackgroundShell ? strs.bgStopped
+      : strs.nothing;
     try {
       await tg(bot, 'sendMessage', {
         chat_id: chatId, text: reply,

package/lib/process/tmux-process.js

@@ -88,6 +88,16 @@ const DEFAULT_CONTEXT_WINDOW = 200_000;
 const READY_HINTS_RE    = /\?\s+for shortcuts|accept edits on|bypass permissions on/;
 const STREAMING_HINT_RE = /esc to interrupt/;
 
+// Bug 1 (incident 2026-05-18): when the agent leaves a detached
+// background shell running (a `run_in_background:true` Bash), the
+// claude TUI shows a background-shell count in the pane. Verified
+// against claude 2.1.142 — two forms:
+//   - the bottom hint line:  "… · 1 shell · ↓ to manage"
+//   - the status line:       "✻ Baked for 5s · 1 shell still running"
+// Both carry "<N> shell(s)". polygram's turn-scoped Stop is blind to
+// these; this regex lets the abort handler see them.
+const BG_SHELL_RE = /\b\d+\s+shells?\b/;
+
 // L1 fix (spike leftover): the claude TUI shows its welcome banner
 // WITH a ready hint at the bottom during startup — before the user's
 // prompt has been processed:
@@ -135,7 +145,17 @@ const TUI_BANNER_RE = /▐▛███▜▌|▝▜█████▛▘/;
 // The optional `❯` cursor in [^\S\n]*(?:❯[^\S\n]+)?1\. is still
 // bounded to the line containing `1.`, so the security property
 // holds — only a real menu line satisfies it.
-const APPROVAL_PROMPT_RE = /Do you want to (?:proceed|do this|continue)\??[\s\S]{0,400}?(?:^|\n)[^\S\n]*(?:❯[^\S\n]+)?1\.\s+/im;
+//
+// 2026-05-18 incident fix: the verb after "Do you want to" varies by
+// tool — Bash → "do this", Write → "create CLAUDE.md", Edit → "make
+// this edit", etc. A `proceed|do this|continue` whitelist missed
+// "create" and hung the Music topic for 7+ min with no approval card.
+// Match the STRUCTURE, not a verb whitelist: a "Do you want to …?"
+// question (verb is a bounded wildcard, single-line — no newline so
+// it can't swallow past the question) followed within the bounded
+// window by the numbered menu. The verb was never the security
+// control — the required `1.` menu line is, and it is unchanged.
+const APPROVAL_PROMPT_RE = /Do you want to [^\n?]{1,80}\??[\s\S]{0,400}?(?:^|\n)[^\S\n]*(?:❯[^\S\n]+)?1\.\s+/im;
 // Pull the tool name + raw arg snippet from the line preceding the
 // approval prompt. Capture-pane preserves the ⏺ marker.
 const TOOL_INVOCATION_RE = /⏺\s+([A-Za-z_]\w*)\s*\((.*?)\)\s*$/m;
@@ -532,12 +552,26 @@ class TmuxProcess extends Process {
     // Internal turn-done signal — settled by _flushActiveGroup when
     // this turn's group is flushed on a terminal `result`.
     turn.resultPromise = new Promise((resolve) => { turn.settleResult = resolve; });
+    // Bug 3: interrupt signal. `interrupt()` settles `signalInterrupt`
+    // to end this turn's race promptly — without it, an interrupted
+    // turn whose tool was killed by C-c writes no JSONL `result` and
+    // shows no capture-pane completion the race recognises, so
+    // `_runTurn` would hang until the absolute `turnTimeoutMs`.
+    turn.interruptP = new Promise((resolve) => { turn.signalInterrupt = resolve; });
 
     try {
       // 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`,
@@ -596,6 +630,7 @@ class TmuxProcess extends Process {
           turn.resultPromise.then((ev) => ({ kind: 'jsonl', ev })),
           captureRaceP,
           turnDeadlineP,
+          turn.interruptP.then(() => ({ kind: 'interrupt' })),
         ]);
 
         // If capture-pane won but the turn used a tool, the agent is
@@ -603,10 +638,14 @@ class TmuxProcess extends Process {
         // tool calls. Wait for the real terminal result from JSONL, but
         // keep the absolute deadline armed so a JSONL `result` that
         // never arrives still fails the turn rather than hanging it.
+        // The interrupt signal still wins here too — Bug 3: an
+        // interrupted tool turn writes no terminal JSONL `result`, so
+        // without this racer it would hang to `turnTimeoutMs`.
         if (winner.kind === 'capture' && turn.toolUsedThisTurn) {
           winner = await Promise.race([
             turn.resultPromise.then((ev) => ({ kind: 'jsonl', ev })),
             turnDeadlineP,
+            turn.interruptP.then(() => ({ kind: 'interrupt' })),
           ]);
         }
       } finally {
@@ -620,7 +659,18 @@ class TmuxProcess extends Process {
       let text;
       let resultSubtype = 'success';
       let stopReason = null;
-      if (winner.kind === 'jsonl') {
+      if (winner.kind === 'interrupt') {
+        // Bug 3: `interrupt()` ended the turn. C-c was sent to the
+        // TUI; the turn stops here instead of hanging until the
+        // absolute `turnTimeoutMs`. Deliver whatever partial text the
+        // agent streamed before the interrupt (may be empty) with an
+        // explicit `interrupted` subtype so polygram's caller can tell
+        // a stopped turn apart from a clean completion.
+        turn.interrupted = true;
+        text = turn.text || '';
+        resultSubtype = 'interrupted';
+        stopReason = 'interrupted';
+      } else if (winner.kind === 'jsonl') {
         text = turn.text || winner.ev.text || '';
         resultSubtype = winner.ev.subtype || 'success';
         stopReason = winner.ev.stopReason || null;
@@ -796,6 +846,10 @@ class TmuxProcess extends Process {
       startedAt: 0,
       resolve: null, reject: null, callerPromise: null,
       settleResult: null, resultPromise: null,
+      // Bug 3: settled by `interrupt()` to make a live turn's
+      // `_runTurn` race end promptly instead of hanging until
+      // `turnTimeoutMs`. Armed at the top of `_runTurn`.
+      signalInterrupt: null, interruptP: null, interrupted: false,
     };
   }
 
@@ -1237,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');
@@ -1508,10 +1567,78 @@ class TmuxProcess extends Process {
       this.logger.error?.(`[${this.label}] interrupt: ${err.message}`);
       return false;
     }
+    // Bug 3: C-c stops the agent's work in the TUI, but an interrupted
+    // turn (especially a tool turn) writes no terminal JSONL `result`
+    // and shows no capture-pane completion `_runTurn`'s race
+    // recognises — so `_runTurn` would hang until the absolute
+    // `turnTimeoutMs`. Settle the running turn's interrupt signal so
+    // its race ends NOW. The running primary turn is `pendingQueue[0]`
+    // in state 'pasted'/'streaming'.
+    const running = this.pendingQueue.find(
+      (t) => t.state === 'pasted' || t.state === 'streaming',
+    );
+    if (running && typeof running.signalInterrupt === 'function') {
+      running.signalInterrupt();
+    }
     this.emit('interrupt-applied', { backend: 'tmux' });
     return true;
   }
 
+  /**
+   * Bug 1: report whether the TUI currently shows a running
+   * background shell (a detached `run_in_background:true` Bash). This
+   * is work that outlives the turn — polygram's turn-scoped Stop is
+   * blind to it. Reads the pane bottom for the `N shell` indicator.
+   * @returns {Promise<boolean>}
+   */
+  async hasBackgroundShell() {
+    if (this.closed) return false;
+    try {
+      const buf = await this.runner.captureWide(this.tmuxName, { lines: 80 });
+      // The indicator lives in the bottom few lines of the pane.
+      return BG_SHELL_RE.test(String(buf || '').slice(-2000));
+    } catch (err) {
+      this.logger.error?.(`[${this.label}] hasBackgroundShell: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Bug 1: stop every running background shell via the TUI's
+   * background-task panel. Sequence verified against claude 2.1.142:
+   * `/bashes` + Enter opens the "Shell details" panel (legend
+   * "Esc/Enter/Space to close · x to stop"); `x` stops the shell;
+   * Esc closes the panel. Repeats while a shell remains, bounded so a
+   * stuck panel can't loop forever.
+   *
+   * @returns {Promise<boolean>} true if no background shell remains
+   *   after the attempt (all stopped, or none was running).
+   */
+  async killBackgroundShells() {
+    if (this.closed) return false;
+    const maxRounds = 8;   // bound — one round per shell, plus slack
+    for (let round = 0; round < maxRounds; round += 1) {
+      if (!(await this.hasBackgroundShell())) return true;
+      try {
+        // Open the background-task panel.
+        await this.runner.pasteText(this.tmuxName, '/bashes');
+        await this.runner.sendControl(this.tmuxName, 'Enter');
+        await this._sleep(this.pollMs * 4 + 200);
+        // Stop the shell shown in the Shell-details panel.
+        await this.runner.sendControl(this.tmuxName, 'x');
+        await this._sleep(this.pollMs * 4 + 200);
+        // Close the panel.
+        await this.runner.sendControl(this.tmuxName, 'Escape');
+        await this._sleep(this.pollMs * 2 + 100);
+      } catch (err) {
+        this.logger.error?.(`[${this.label}] killBackgroundShells: ${err.message}`);
+        return false;
+      }
+    }
+    // Bounded out — report the residual state honestly.
+    return !(await this.hasBackgroundShell());
+  }
+
   async setModel(model) {
     if (this.closed || !model) return false;
     try {

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

@@ -1379,6 +1379,16 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
           await sendInlineStickers();
           await sendInlineReactions();
           await cleanupArchivedBubbles();
+          // Bug 2 (incident 2026-05-18): this streamed-success branch
+          // returns BEFORE the rc.10 deferred-clear block at the
+          // bottom of the handler — so a turn that streamed its reply
+          // never cleared the reactor. If the turn went quiet
+          // mid-stream long enough to trip STALL (🥱), the emoji
+          // stuck. reactor.stop() in the finally only kills timers,
+          // not the visible reaction. Clear here, mirroring the
+          // rc.10 block — AFTER delivery so there's no visual gap.
+          reactor.clear().catch(() => {});
+          clearAutosteeredReactions(sessionKey).catch(() => {});
           console.log(`[${label}] ${elapsed}s | ${result.text.length} chars | streamed | ${chatConfig.model}/${chatConfig.effort} | $${result.cost?.toFixed(4) || '?'}`);
           markReplied();
           return;
@@ -1426,6 +1436,18 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
         await sendInlineStickers();
           await sendInlineReactions();
         await cleanupArchivedBubbles();
+        // Bug 2 (incident 2026-05-18): same gap as the finalEditOk
+        // branch above — this streamed-redeliver path returns before
+        // the rc.10 deferred-clear block, so the reactor would stay
+        // stuck. Clear it (and autosteered ✍) here, after delivery —
+        // but ONLY on a clean delivery. When r.failed.length>0 the
+        // ERROR state (😨) was set above as the "look here" signal
+        // for the partial-delivery failure; clearing it would wipe
+        // that signal, so leave the reactor as-is in that case.
+        if (r.failed.length === 0) {
+          reactor.clear().catch(() => {});
+        }
+        clearAutosteeredReactions(sessionKey).catch(() => {});
         console.log(`[${label}] ${elapsed}s | ${result.text.length} chars | streamed-redeliver(${reason}, ${chunks.length} chunks${r.failed.length ? `, ${r.failed.length} failed` : ''}) | ${chatConfig.model}/${chatConfig.effort} | $${result.cost?.toFixed(4) || '?'}`);
         markReplied();
         return;