polygram 0.10.0-rc.20 → 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.20",
+  "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/db/sessions.js

@@ -95,4 +95,100 @@ function getClaudeSessionId(db, sessionKey) {
   return row?.claude_session_id || null;
 }
 
-module.exports = { migrateJsonToDb, getClaudeSessionId, countSessions };
+// ─── S2: session-config drift ────────────────────────────────────────
+//
+// A stored `sessions` row records the config the claude session was
+// SPAWNED under (agent / cwd / pm_backend). Those three are
+// spawn-identity: they are baked into the process at spawn time —
+// `--agent`, the tmux/SDK working dir, the backend class — and cannot
+// be changed on a live session. If the chat/topic config has drifted
+// from the stored row, `--resume`-ing the old session forces claude
+// to run under a config it was never built for. shumorobot
+// 2026-05-17 22:03, topic :3: the row was agent=shumabit / cwd=$HOME
+// / sdk (created before the Music topic got its per-topic override);
+// resuming it under agent=music-curation:music-curator /
+// cwd=.../Music/rekordbox / tmux left the TUI never signalling ready.
+//
+// model + effort are deliberately EXCLUDED from the invalidating set.
+// They are NOT spawn-identity: a live `/model` or `/effort` change is
+// pushed into the running session by `pm.setModel` /
+// `pm.applyFlagSettings` with no respawn (lib/handlers/slash-commands.js,
+// lib/handlers/config-callback.js). Including them here would
+// destructively drop the whole session — discarding all context — on
+// every model switch, double-handling what the live-apply path
+// already covers cleanly. The stored model/effort columns are
+// informational, not identity.
+const SPAWN_IDENTITY_FIELDS = ['agent', 'cwd', 'pm_backend'];
+
+/**
+ * Decide whether a stored session can be resumed for the next spawn,
+ * or whether config drift means it must be dropped and re-spawned
+ * fresh.
+ *
+ * On drift the stale row is DELETED here — so the very next spawn
+ * mints a fresh claude_session_id under the correct config and the
+ * `onInit` callback re-upserts the row. This self-heals every
+ * pre-migration stale row across all chats with no manual SQL.
+ *
+ * @param {object|null} db          — DB handle (null → fresh spawn)
+ * @param {string} sessionKey
+ * @param {object} resolved         — freshly-resolved spawn config
+ * @param {string} [resolved.agent]
+ * @param {string} [resolved.cwd]
+ * @param {string} [resolved.backend] — 'sdk' | 'tmux' (resolved by
+ *   process/factory.js pickBackend); compared to the row's pm_backend
+ * @returns {{ existingSessionId: string|null, drift: object|null }}
+ *   existingSessionId — pass to start() for --resume, or null for a
+ *     fresh spawn (no stored row, or drift dropped it)
+ *   drift — null when no drift; otherwise { fields, before, after }
+ *     for the `session-config-drift` telemetry event
+ */
+function resolveSessionForSpawn(db, sessionKey, resolved = {}) {
+  if (!db) return { existingSessionId: null, drift: null };
+  const row = db.getSession(sessionKey);
+  if (!row || !row.claude_session_id) {
+    return { existingSessionId: null, drift: null };
+  }
+
+  // Normalise: a missing field on either side is treated as equal to
+  // a missing field on the other (both null/undefined → no drift).
+  const after = {
+    agent: resolved.agent || null,
+    cwd: resolved.cwd || null,
+    pm_backend: resolved.backend || null,
+  };
+  const before = {
+    agent: row.agent || null,
+    cwd: row.cwd || null,
+    pm_backend: row.pm_backend || null,
+  };
+  const drifted = SPAWN_IDENTITY_FIELDS.filter((f) => {
+    // If the resolved config does not specify a field, do not treat
+    // it as drift — we have nothing to compare against.
+    if (after[f] == null) return false;
+    return before[f] !== after[f];
+  });
+
+  if (drifted.length === 0) {
+    return { existingSessionId: row.claude_session_id, drift: null };
+  }
+
+  // Drift: drop the stale row so the next spawn is fresh + correct.
+  db.clearSessionId(sessionKey);
+  return {
+    existingSessionId: null,
+    drift: {
+      fields: drifted,
+      before: { ...before, claude_session_id: row.claude_session_id },
+      after,
+    },
+  };
+}
+
+module.exports = {
+  migrateJsonToDb,
+  getClaudeSessionId,
+  resolveSessionForSpawn,
+  countSessions,
+  SPAWN_IDENTITY_FIELDS,
+};

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;
@@ -389,21 +409,60 @@ class TmuxProcess extends Process {
         envExtras: ctx.envExtras || {},
       });
 
-      // v9: tail the per-session JSONL file (the REAL structured-event
-      // channel — v9 probe showed --debug-file emits only infra noise).
-      // Path is deterministic once we have cwd + sessionId. The file
-      // may not exist for ~100ms after spawn; LogTail tolerates ENOENT.
-      this._cwd = cwd;
-      this._armSessionLogTail({ resuming: Boolean(ctx.existingSessionId) });
-
-      // G6 — block until TUI is responsive.
-      await this._waitForReady();
-      this.emit('init', {
-        session_id: this.claudeSessionId,
-        label: this.label,
-        backend: 'tmux',
-        tmux_name: this.tmuxName,
-      });
+      // SPAWN-LIFECYCLE FIX (shumorobot 2026-05-17 22:03, topic :3):
+      // `spawn()` resolving means the tmux session NAME now exists on
+      // the host. From here on, ANY failure — readiness timeout, a
+      // wedged capture-pane, an `init` listener throwing — must tear
+      // that session down before propagating, or the orphan lingers
+      // and every retry's `tmux new-session -s <same-name>` fails
+      // "duplicate session". A transient first-spawn failure would
+      // otherwise become a PERMANENT wedge for the chat/topic until a
+      // human kills the orphan. `_sessionCreated` is the seam that
+      // distinguishes "spawn() itself failed (no session — nothing to
+      // kill)" from "session created, a later step failed (must
+      // kill)". This is a spawn-lifecycle bug, independent of the
+      // turn-ledger concurrency rewrite.
+      const sessionCreated = true;
+
+      try {
+        // v9: tail the per-session JSONL file (the REAL structured-
+        // event channel — v9 probe showed --debug-file emits only
+        // infra noise). Path is deterministic once we have cwd +
+        // sessionId. The file may not exist for ~100ms after spawn;
+        // LogTail tolerates ENOENT.
+        this._cwd = cwd;
+        this._armSessionLogTail({ resuming: Boolean(ctx.existingSessionId) });
+
+        // G6 — block until TUI is responsive.
+        await this._waitForReady();
+        this.emit('init', {
+          session_id: this.claudeSessionId,
+          label: this.label,
+          backend: 'tmux',
+          tmux_name: this.tmuxName,
+        });
+      } catch (err) {
+        // Post-spawn failure — the session exists but is unusable.
+        // Kill it so a retry gets a clean name. Best-effort: the
+        // runner's killSession already swallows its own errors, but
+        // guard anyway so a kill failure can never mask the real
+        // spawn error. Also tear down the just-armed JSONL tail so it
+        // doesn't leak a watcher against a dead session.
+        if (sessionCreated) {
+          if (this._sessionLogTail) {
+            try { this._sessionLogTail.close(); } catch { /* swallow */ }
+            this._sessionLogTail = null;
+          }
+          try {
+            await this.runner.killSession(this.tmuxName);
+          } catch (killErr) {
+            this.logger.warn?.(
+              `[${this.label}] start() cleanup killSession failed: ${killErr.message}`,
+            );
+          }
+        }
+        throw err;
+      }
     })();
 
     try {
@@ -493,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
@@ -557,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
@@ -564,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 {
@@ -581,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;
@@ -757,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,
     };
   }
 
@@ -1469,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.20",
+  "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

@@ -24,7 +24,9 @@ const fs = require('fs');
 const path = require('path');
 const processGuard = require('./lib/process-guard');
 const dbClient = require('./lib/db');
-const { migrateJsonToDb, getClaudeSessionId } = require('./lib/db/sessions');
+const {
+  migrateJsonToDb, getClaudeSessionId, resolveSessionForSpawn,
+} = require('./lib/db/sessions');
 const { buildPrompt } = require('./lib/prompt');
 const { filterAttachments } = require('./lib/attachments');
 // 0.9.0: SDK ProcessManager is the only pm. CLI pm
@@ -38,7 +40,7 @@ const { filterAttachments } = require('./lib/attachments');
 // per-session mechanics. The pre-0.10.0 monolithic ProcessManagerSdk
 // is deleted; SdkProcess inherits its per-entry guts.
 const { ProcessManager } = require('./lib/process-manager');
-const { createProcessFactory } = require('./lib/process/factory');
+const { createProcessFactory, pickBackend } = require('./lib/process/factory');
 const { extractAssistantText } = require('./lib/process/sdk-process');
 const { createTmuxRunner } = require('./lib/tmux/tmux-runner');
 const { sweepTmuxOrphans } = require('./lib/tmux/orphan-sweep');
@@ -396,12 +398,56 @@ function buildSpawnContext(sessionKey) {
   const chatConfig = config.chats[chatId];
   if (!chatConfig) return null;
   const threadId = sessionKey.includes(':') ? sessionKey.split(':')[1] : null;
+
+  // S2: a stored session is valid ONLY for the config it was spawned
+  // under. agent / cwd / pm_backend are spawn-identity — baked into
+  // the process at spawn time, never mutable on a live session.
+  // Resolve them the same way the backends do (topic override merged
+  // over chat-level) and compare to the stored `sessions` row. On
+  // drift, resolveSessionForSpawn drops the stale row and returns
+  // existingSessionId:null → the spawn starts fresh under the correct
+  // config instead of `--resume`-ing a stale one. This self-heals the
+  // pre-per-topic-config rows (e.g. shumorobot's Music topic :3,
+  // stored agent=shumabit / cwd=$HOME / sdk vs the current
+  // music-curation:music-curator / .../Music/rekordbox / tmux).
+  // model/effort are NOT compared — they apply live via setModel /
+  // applyFlagSettings with no respawn.
+  //
+  // The drift check runs only at COLD spawn (no warm process). A warm
+  // process already runs under its spawn-time config; getOrSpawn
+  // returns it without using this context, so dropping its row here
+  // would be premature — defer to the next cold spawn.
+  const isColdSpawn = !pm || !pm.has(sessionKey) || pm.get(sessionKey)?.closed;
+  let existingSessionId;
+  if (isColdSpawn) {
+    const topicConfig = getTopicConfig(chatConfig, threadId || null);
+    const resolved = {
+      agent: topicConfig.agent || chatConfig.agent || null,
+      cwd: topicConfig.cwd || chatConfig.cwd || null,
+      backend: pickBackend({ config, chatId, threadId: threadId || null }),
+    };
+    const r = resolveSessionForSpawn(db, sessionKey, resolved);
+    existingSessionId = r.existingSessionId;
+    if (r.drift) {
+      logEvent('session-config-drift', {
+        chat_id: chatId,
+        thread_id: threadId || null,
+        session_key: sessionKey,
+        fields: r.drift.fields,
+        before: r.drift.before,
+        after: r.drift.after,
+      });
+    }
+  } else {
+    existingSessionId = getClaudeSessionId(db, sessionKey);
+  }
+
   return {
     chatConfig,
     chatId,
     threadId: threadId || null,
     label: getSessionLabel(chatConfig, threadId),
-    existingSessionId: getClaudeSessionId(db, sessionKey),
+    existingSessionId,
   };
 }
 
@@ -1333,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;
@@ -1380,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;