polygram 0.12.0-rc.22 → 0.12.0-rc.24

package/lib/handlers/abort.js

@@ -96,15 +96,28 @@ function createHandleAbort({
       }
     }
 
-    // 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);
-    // drainQueue() rejects every queued pending with
-    // err.code='INTERRUPTED' so the abort-grace classifier
-    // suppresses error replies.
-    await pm.interrupt(sessionKey).catch((err) =>
-      logger.error?.(`[${botName}] interrupt failed: ${err.message}`));
+    // Reject queued pendings first (err.code='INTERRUPTED' → the abort-grace
+    // classifier suppresses their error replies AND each turn's finally clears
+    // its reactor + typing), THEN stop the live work.
     pm.drainQueue(sessionKey, 'INTERRUPTED');
+    if (hadActive && proc && proc.backend === 'cli') {
+      // Channels HARD stop (user decision 2026-06-04: "/stop should stop
+      // everything including background, like the SDK backend"). A soft C-c
+      // interrupt leaves detached background shells + subagents running and
+      // can't clear a ghost (no-pending-turn) busy state — the symptom was
+      // "Stopped." with the reaction + typing still going. Kill the session: the
+      // whole process tree (claude + every subagent + all background shells)
+      // dies at once, the close drains the in-flight turn (clearing its
+      // reactor/typing), and the next message respawns fresh (--resume restores
+      // the conversation). This is what makes channels /stop "stop everything".
+      await pm.kill(sessionKey, 'abort').catch((err) =>
+        logger.error?.(`[${botName}] abort kill failed: ${err.message}`));
+    } else {
+      // SDK (or nothing active): non-destructive interrupt cancels the in-flight
+      // Query turn WITHOUT tearing down the Query (cheap to reuse next message).
+      await pm.interrupt(sessionKey).catch((err) =>
+        logger.error?.(`[${botName}] interrupt failed: ${err.message}`));
+    }
 
     clearAutosteeredReactions(sessionKey).catch(() => {});
     logEvent('abort-requested', {

package/lib/process/cli-process.js

@@ -248,6 +248,9 @@ class CliProcess extends Process {
     // at one read-only self-check per continuous background-work window.
     this._bgWorkSince = null;
     this._bgWorkEscalations = 0;
+    // Visibility (Use 3): whether a "⏳ working in background" status message is
+    // currently shown, so we emit exactly one running→cleared pair per window.
+    this._bgWorkStatusShown = false;
     // Review P2 ADV-6: token-bucket rate limit on Claude's reply tool calls.
     // Without this, a prompt-injected or runaway Claude can fire reply() 1000×
     // in a tight loop, flooding TG + saturating the daemon event loop.
@@ -1643,16 +1646,24 @@ class CliProcess extends Process {
     if (!live) {
       if (this._bgWorkSince !== null) {
         this._logEvent('cli-bg-work-cleared', { idle_ms: Date.now() - this._bgWorkSince });
+        // Visibility: tear down the status indicator once work clears.
+        if (this._bgWorkStatusShown) {
+          this.emit('bg-work-status', { state: 'cleared' });
+          this._bgWorkStatusShown = false;
+        }
       }
       this._bgWorkSince = null;
       this._bgWorkEscalations = 0;
       return;
     }
     if (this._bgWorkSince === null) {
-      // First idle observation of a live background shell — start the clock.
+      // First idle observation of a live background shell — start the clock AND
+      // raise the visibility indicator so a long job reads as working, not stuck.
       this._bgWorkSince = Date.now();
       this._bgWorkEscalations = 0;
       this._logEvent('cli-bg-work-detected', { shell_count: count });
+      this.emit('bg-work-status', { state: 'running', count });
+      this._bgWorkStatusShown = true;
       return;
     }
     const idleMs = Date.now() - this._bgWorkSince;

package/lib/process-manager.js

@@ -47,6 +47,12 @@ const CALLBACK_TO_EVENT = {
   // auto-compacting now. The callback posts a chat message proposing /compact
   // — opt-in per chat. See docs/0.12.0-file-send.md / lib/compaction-warn.js.
   onCompactionWarn:             'compaction-warn',
+  // 0.12.0 background-work visibility (Use 3). CliProcess emits 'bg-work-status'
+  // {state:'running'|'cleared', count?} when a detached background shell is first
+  // observed running idle past its turn, and again when it clears. The callback
+  // posts/edits a "⏳ working in background" status message so a long job reads as
+  // working, not stuck. See docs/0.12.0-background-work-lifecycle-plan.md.
+  onBgWorkStatus:               'bg-work-status',
   onQueueDrop:                  'queue-drop',
   onThinking:                   'thinking',
   // Tmux backend: TUI shows in-pane approval prompt. SDK backend

package/lib/sdk/callbacks.js

@@ -60,6 +60,10 @@ function createSdkCallbacks({
   // because the TUI's queue is FIFO and we only watch one extra turn
   // at a time per session.
   const extraTurnTracker = new Map(); // sessionKey → { msgId, intervalHandle, chatId }
+  // 0.12.0 background-work visibility (Use 3): sessionKey → message_id of the live
+  // "⏳ working in background" status message, so the cleared/close paths can edit
+  // it to a final state instead of leaving it dangling as "working".
+  const bgStatusMsgIds = new Map();
 
   function startExtraTurnVisuals(sessionKey, msgId) {
     if (!bot) return;
@@ -152,6 +156,17 @@ function createSdkCallbacks({
       // visuals so we don't leak the interval and aren't stuck
       // showing "writing…" on a dead session.
       stopExtraTurnVisuals(sessionKey, null);
+      // 0.12.0 bg-work visibility: if a "⏳ working in background" status is still
+      // up when the session closes, its shell died with the session — edit to a
+      // final state so it doesn't dangle as "working" forever.
+      const bgMid = bgStatusMsgIds.get(sessionKey);
+      if (bgMid != null && bot) {
+        bgStatusMsgIds.delete(sessionKey);
+        tg(bot, 'editMessageText', {
+          chat_id: entry.chatId, message_id: bgMid,
+          text: '⏹ Background work ended (session restarted).',
+        }, { source: 'bg-work-status', botName }).catch(() => {});
+      }
     },
 
     onStreamChunk: (sessionKey, partial, entry) => {
@@ -324,6 +339,49 @@ function createSdkCallbacks({
       }
     },
 
+    // 0.12.0 background-work visibility (Use 3). CliProcess emits this when a
+    // detached `run_in_background` shell is first observed running idle past its
+    // turn ('running') and again when it clears ('cleared'). We post ONE bot
+    // status message and edit it to done — so a long job reads as working, not
+    // stuck. Direct tg send (NOT via claude — this is a bot status indicator),
+    // keyed by sessionKey so the cleared/close paths can find it to edit.
+    onBgWorkStatus: async (sessionKey, payload) => {
+      try {
+        if (!bot) return;
+        const chatId = getChatIdFromKey(sessionKey);
+        const threadIdRaw = getThreadIdFromKey(sessionKey);
+        const threadId = threadIdRaw ? parseInt(threadIdRaw, 10) : null;
+        const state = payload?.state;
+        if (state === 'running') {
+          if (bgStatusMsgIds.has(sessionKey)) return; // already showing one
+          const res = await tg(bot, 'sendMessage', {
+            chat_id: chatId,
+            text: '⏳ Working in the background — I\'ll keep an eye on it and report when it\'s done.',
+            ...(Number.isInteger(threadId) && { message_thread_id: threadId }),
+          }, { source: 'bg-work-status', botName });
+          const mid = res?.message_id ?? res?.result?.message_id ?? null;
+          if (mid != null) bgStatusMsgIds.set(sessionKey, mid);
+          logEvent('bg-work-status', {
+            chat_id: chatId, session_key: sessionKey, thread_id: threadIdRaw,
+            state: 'running', message_id: mid,
+          });
+        } else if (state === 'cleared') {
+          const mid = bgStatusMsgIds.get(sessionKey);
+          bgStatusMsgIds.delete(sessionKey);
+          if (mid == null) return;
+          await tg(bot, 'editMessageText', {
+            chat_id: chatId, message_id: mid, text: '✅ Background work finished.',
+          }, { source: 'bg-work-status', botName }).catch(() => {});
+          logEvent('bg-work-status', {
+            chat_id: chatId, session_key: sessionKey, thread_id: threadIdRaw,
+            state: 'cleared', message_id: mid,
+          });
+        }
+      } catch (err) {
+        logger.error?.(`[${botName}] bg-work-status handler: ${err.message}`);
+      }
+    },
+
     // rc.9: pair-of with onExtraTurnReply. Fires the moment
     // TmuxProcess sees the dequeued user-message in JSONL → turn 2
     // is starting. Re-engages typing indicator + ✍ on the

package/package.json

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