polygram 0.10.0-rc.21 → 0.10.0-rc.22

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.22",
   "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,6 +552,12 @@ 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
@@ -596,6 +622,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 +630,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 +651,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 +838,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,
     };
   }
 
@@ -1508,10 +1554,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/package.json

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