switchroom 0.14.43 → 0.14.45

package/dist/cli/switchroom.js

@@ -49462,8 +49462,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.43";
-var COMMIT_SHA = "85d37be2";
+var VERSION = "0.14.45";
+var COMMIT_SHA = "8eea0df8";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.43",
+  "version": "0.14.45",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/dist/gateway/gateway.js

@@ -32244,6 +32244,7 @@ class StatusReactionController {
   stallHardTimer = null;
   finished = false;
   held = false;
+  awaitingApproval = false;
   debounceMs;
   stallSoftMs;
   stallHardMs;
@@ -32305,9 +32306,13 @@ class StatusReactionController {
       this.enqueue(working);
     }
   }
+  isAwaiting() {
+    return this.awaitingApproval && !this.finished;
+  }
   scheduleState(state, opts = {}) {
     if (this.finished)
       return;
+    this.awaitingApproval = state === "awaiting";
     const emoji = this.resolveEmoji(state);
     if (emoji == null) {
       if (!opts.skipStallReset)
@@ -38957,8 +38962,17 @@ function noteToolEnd(key, toolUseId, _now) {
 function endTurn(key) {
   state2.delete(key);
 }
-function formatFrameworkFallbackText(fallbackKind, silenceMs, inFlightTools = []) {
+function silenceMsForKey(key, now) {
+  const s = state2.get(key);
+  if (s == null)
+    return null;
+  return now - (s.lastOutboundAt ?? s.turnStartedAt);
+}
+function formatFrameworkFallbackText(fallbackKind, silenceMs, inFlightTools = [], blockedOnApproval = false) {
   const minutes = Math.max(1, Math.round(silenceMs / 60000));
+  if (blockedOnApproval) {
+    return `waiting for your approval \u2014 tap Approve or Deny on the card above (${minutes} min)`;
+  }
   const suffix = `(no update from agent in ${minutes} min)`;
   if (inFlightTools.length > 0) {
     const longest = inFlightTools[0];
@@ -47234,7 +47248,7 @@ function createInboundSpool(opts) {
 }
 
 // gateway/turn-state-purge.ts
-function purgeStaleTurnsForChat(chatId, keys, purger) {
+function purgeStaleTurnsForChat(chatId, keys, purger, isStale = () => true) {
   if (!chatId)
     return { purged: [] };
   const purged = [];
@@ -47248,6 +47262,8 @@ function purgeStaleTurnsForChat(chatId, keys, purger) {
     const keyChat = key.slice(0, sep3);
     if (keyChat !== chatId)
       continue;
+    if (!isStale(key))
+      continue;
     purger(key);
     purged.push(key);
   }
@@ -52008,10 +52024,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.43";
-var COMMIT_SHA = "85d37be2";
-var COMMIT_DATE = "2026-06-03T00:28:58Z";
-var LATEST_PR = 2103;
+var VERSION = "0.14.45";
+var COMMIT_SHA = "8eea0df8";
+var COMMIT_DATE = "2026-06-03T04:26:56Z";
+var LATEST_PR = 2112;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -54075,13 +54091,15 @@ function emitGatewayOperatorEvent(event) {
     return;
   }
   const opEventTopic = resolveAgentOutboundTopic({ kind: "compact-watchdog" });
+  const opEventSupergroup = resolveAgentSupergroupChatId();
   process.stderr.write(`telegram gateway: operator-event posting agent=${agent} kind=${kind} to ${access.allowFrom.length} chat(s)` + (opEventTopic != null ? ` topic=${opEventTopic}` : "") + `
 `);
   for (const chat_id of access.allowFrom) {
+    const opEventThread = topicForRecipient({ recipientChatId: chat_id, resolvedTopic: opEventTopic, supergroupChatId: opEventSupergroup });
     const opts = {
       parse_mode: "HTML",
       ...renderedKeyboard ? { reply_markup: renderedKeyboard } : {},
-      ...opEventTopic != null ? { message_thread_id: opEventTopic } : {}
+      ...opEventThread != null ? { message_thread_id: opEventThread } : {}
     };
     bot.api.sendMessage(chat_id, renderedText, opts).catch((e) => {
       process.stderr.write(`telegram gateway: operator-event send to ${chat_id} failed agent=${agent} kind=${kind}: ${e}
@@ -54233,7 +54251,8 @@ startTimer({
       } catch {}
     }
     if (text == null) {
-      text = formatFrameworkFallbackText(ctx.fallbackKind, ctx.silenceMs, ctx.inFlightTools);
+      const blockedOnApproval = activeStatusReactions.get(statusKey(ctx.chatId, ctx.threadId))?.isAwaiting() ?? false;
+      text = formatFrameworkFallbackText(ctx.fallbackKind, ctx.silenceMs, ctx.inFlightTools, blockedOnApproval);
     }
     try {
       await robustApiCall(() => bot.api.sendMessage(ctx.chatId, text, {
@@ -54292,7 +54311,13 @@ startTimer({
     endTurn(fbKey);
     noteTurnEnd(fbKey);
     purgeReactionTracking(fbKey);
-    const fbExtraPurge = purgeStaleTurnsForChat(fbChatId, activeTurnStartedAt.keys(), purgeReactionTracking);
+    const fbNow = Date.now();
+    const fbExtraPurge = purgeStaleTurnsForChat(fbChatId, activeTurnStartedAt.keys(), purgeReactionTracking, (siblingKey) => {
+      if (siblingKey === fbKey)
+        return true;
+      const sib = silenceMsForKey(siblingKey, fbNow);
+      return sib == null || sib >= DEFAULT_THRESHOLDS.fallback;
+    });
     if (turnMatchesFallback && currentTurn === wedgedTurn)
       currentTurn = null;
     try {
@@ -56816,13 +56841,12 @@ function handleSessionEvent(ev) {
       const ctrl = activeStatusReactions.get(statusKey(turn.sessionChatId, turn.sessionThreadId));
       const name = ev.toolName;
       if (isTelegramReplyTool(name)) {
-        const wasFirstReply = !turn.replyCalled;
         turn.replyCalled = true;
         if (turn.orphanedReplyTimeoutId != null) {
           clearTimeout(turn.orphanedReplyTimeoutId);
           turn.orphanedReplyTimeoutId = null;
         }
-        if (wasFirstReply) {
+        if (turn.finalAnswerDelivered) {
           clearActivitySummary(turn);
         }
       }
@@ -56842,7 +56866,7 @@ function handleSessionEvent(ev) {
         return;
       if (isTelegramSurfaceTool(ev.toolName))
         return;
-      if (turn.replyCalled)
+      if (turn.finalAnswerDelivered)
         return;
       const rendered = appendActivityLabel(turn.mirrorLines, ev.label);
       if (rendered != null) {
@@ -57852,7 +57876,7 @@ ${preBlock(write.output)}`;
       }
     }
   }
-  bot.api.sendChatAction(chat_id, "typing").catch(() => {});
+  bot.api.sendChatAction(chat_id, "typing", messageThreadId != null ? { message_thread_id: messageThreadId } : {}).catch(() => {});
   const parsedSteer = parseSteerPrefix(text);
   const isSteerPrefix = parsedSteer.steering;
   const parsedQueue = isSteerPrefix ? { queued: false, body: parsedSteer.body } : parseQueuePrefix(text);
@@ -58359,9 +58383,10 @@ function resolveBootChatId(marker, ageMs) {
     };
   }
   const supergroupBootTopic = resolveAgentOutboundTopic({ kind: "boot" });
+  const bootSupergroup = resolveAgentSupergroupChatId();
   const envChat = process.env.SUBAGENT_OWNER_CHAT_ID;
   if (envChat)
-    return { chatId: envChat, threadId: supergroupBootTopic, ackMsgId: undefined };
+    return { chatId: envChat, threadId: topicForRecipient({ recipientChatId: envChat, resolvedTopic: supergroupBootTopic, supergroupChatId: bootSupergroup }), ackMsgId: undefined };
   if (HISTORY_ENABLED) {
     try {
       const access = loadAccess();
@@ -58369,7 +58394,7 @@ function resolveBootChatId(marker, ageMs) {
       if (ownerChatId) {
         const recent = query({ chat_id: ownerChatId, limit: 1 });
         if (recent.length > 0)
-          return { chatId: ownerChatId, threadId: supergroupBootTopic, ackMsgId: undefined };
+          return { chatId: ownerChatId, threadId: topicForRecipient({ recipientChatId: ownerChatId, resolvedTopic: supergroupBootTopic, supergroupChatId: bootSupergroup }), ackMsgId: undefined };
       }
     } catch {}
   }

package/telegram-plugin/gateway/gateway.ts

@@ -3537,18 +3537,24 @@ function emitGatewayOperatorEvent(event: OperatorEvent): void {
   // Fleet-shared / DM agents see `undefined` → no `message_thread_id`
   // is added to the broadcast opts → behavior unchanged.
   const opEventTopic = resolveAgentOutboundTopic({ kind: 'compact-watchdog' })
+  const opEventSupergroup = resolveAgentSupergroupChatId()
 
   process.stderr.write(
     `telegram gateway: operator-event posting agent=${agent} kind=${kind} to ${access.allowFrom.length} chat(s)` +
       (opEventTopic != null ? ` topic=${opEventTopic}` : '') + '\n',
   )
   for (const chat_id of access.allowFrom) {
+    // The resolved topic is valid ONLY in the agent's supergroup — attaching
+    // it to an operator DM recipient yields 400 "message thread not found" and
+    // the event silently fails to deliver (the marko #2096 class). Guard it:
+    // DM recipients get a thread-less send; the supergroup owner gets the lane.
+    const opEventThread = topicForRecipient({ recipientChatId: chat_id, resolvedTopic: opEventTopic, supergroupChatId: opEventSupergroup })
     // grammy's Other<...> opts type is generated and stricter than our
     // call shape; runtime accepts both. Cast through unknown.
     const opts = {
       parse_mode: 'HTML' as const,
       ...(renderedKeyboard ? { reply_markup: renderedKeyboard } : {}),
-      ...(opEventTopic != null ? { message_thread_id: opEventTopic } : {}),
+      ...(opEventThread != null ? { message_thread_id: opEventThread } : {}),
     }
     // Comment-only context for the reader; the lint marker on the
     // very next line is what unlocks the raw bot.api call.
@@ -3912,10 +3918,18 @@ silencePoke.startTimer({
       // (CC-4 in `docs/status-ask-cause-classes.md`). Derives "N min" suffix
       // from `ctx.silenceMs` so the wording stays honest if the 300s
       // threshold is tuned.
+      // Honesty: if the turn is parked on an approval card (the dominant
+      // benign "wedge" class — claude is alive, waiting on the operator's
+      // tap), say so instead of "still working…". The reaction controller
+      // already tracks this (setAwaiting on the permission-request park).
+      const blockedOnApproval = activeStatusReactions
+        .get(statusKey(ctx.chatId, ctx.threadId))
+        ?.isAwaiting() ?? false
       text = silencePoke.formatFrameworkFallbackText(
         ctx.fallbackKind,
         ctx.silenceMs,
         ctx.inFlightTools,
+        blockedOnApproval,
       )
     }
     try {
@@ -4033,16 +4047,29 @@ silencePoke.startTimer({
     // SAME chat (different threads, or a `null` vs `undefined`-thread
     // variant left over from a normal turn-end path that nulled
     // currentTurn without invoking purgeReactionTracking — the
-    // gymbro/klanker held-mid-turn symptom, 2026-05-20). Any sibling
-    // for fbChatId is by definition stale when THIS fallback fires
-    // (the chat has been silent ≥5 min); sweep them via the same
-    // purger. Multi-chat-safe — only touches keys for fbChatId, so
+    // gymbro/klanker held-mid-turn symptom, 2026-05-20); sweep them via
+    // the same purger. Multi-chat-safe — only touches keys for fbChatId, so
     // #1546's intentional cross-chat safety guard is preserved.
+    //
+    // BUT a sibling is NOT "by definition stale": in one-agent-owns-supergroup
+    // every forum topic shares fbChatId, so a chatId-only sweep would purge a
+    // LIVE sibling topic's reaction controller + typing loop when THIS topic's
+    // poke fires. Gate each sibling on its OWN silence clock — purge only those
+    // also silent ≥ the fallback threshold (their own poke would fire too),
+    // sparing topics that are actively mid-turn. Use silence, not turn-start
+    // age, so a long-but-narrating turn isn't mistaken for stale.
     // See turn-state-purge.ts.
+    const fbNow = Date.now()
     const fbExtraPurge = purgeStaleTurnsForChat(
       fbChatId,
       activeTurnStartedAt.keys(),
       purgeReactionTracking,
+      (siblingKey) => {
+        if (siblingKey === fbKey) return true // the firing key is genuinely stale
+        const sib = silencePoke.silenceMsForKey(siblingKey, fbNow)
+        // No silence-poke state → dangling (turn ended, key not purged) → stale.
+        return sib == null || sib >= silencePoke.DEFAULT_THRESHOLDS.fallback
+      },
     )
     // Null `currentTurn` if it's still pointing at the wedged turn —
     // when claude eventually fires a late `turn_end` for this session
@@ -8154,17 +8181,19 @@ function handleSessionEvent(ev: SessionEvent): void {
       // Phase tracking removed in #553 PR 5 — phases only fed the
       // placeholder-heartbeat label, which has been retired.
       if (isTelegramReplyTool(name)) {
-        const wasFirstReply = !turn.replyCalled
         turn.replyCalled = true
         if (turn.orphanedReplyTimeoutId != null) {
           clearTimeout(turn.orphanedReplyTimeoutId)
           turn.orphanedReplyTimeoutId = null
         }
-        // The model's real reply takes over as the authoritative
-        // surface, so delete the activity feed message — the user
-        // sees the real reply land in the same beat the feed
-        // disappears. turn_end is the no-reply safety net.
-        if (wasFirstReply) {
+        // Delete the activity feed only when the FINAL answer has landed —
+        // NOT on an ack-first interim reply ("On it"). Gating on the first
+        // reply deleted the feed on the ack, so the post-ack work
+        // (sub-agents/tools) rendered into nothing — the "agent went silent
+        // after On it" gap. `finalAnswerDelivered` is set by executeReply
+        // (isFinalAnswerReply) before this tool_use event fires; turn_end
+        // (below) clears unconditionally as the idempotent no-reply / race net.
+        if (turn.finalAnswerDelivered) {
           clearActivitySummary(turn)
         }
       }
@@ -8195,15 +8224,16 @@ function handleSessionEvent(ev: SessionEvent): void {
       // Surface tools (reply/stream_reply/react) are the conversation, not
       // activity — the hook labels them ("Replying"), so filter by name.
       if (isTelegramSurfaceTool(ev.toolName)) return
-      // Stop feeding once the reply has landed. The first reply is the
-      // hand-off: `clearActivitySummary` deletes the feed so the answer is
-      // the authoritative surface (the validated clean hand-off). Without
-      // this gate a tool called after the reply would re-`sendMessage` a
-      // fresh feed message below the answer — a delete-then-resend flicker.
+      // Stop feeding once the FINAL answer has landed — the hand-off where
+      // `clearActivitySummary` deletes the feed so the answer is the
+      // authoritative surface. Gating on `replyCalled` (any reply) killed the
+      // feed on an ack-first interim "On it", so the post-ack work had no live
+      // surface; gate on `finalAnswerDelivered` so the feed keeps narrating
+      // between the ack and the real answer. Without this a tool called after
+      // the FINAL answer would re-`sendMessage` a fresh feed below it (flicker).
       // Safe ordering: `tool_label` is real-time (PreToolUse, ~250ms) while
-      // `replyCalled` is set from the lagged reply tool_use, so a genuinely
-      // pre-reply label virtually always arrives before the flag flips.
-      if (turn.replyCalled) return
+      // `finalAnswerDelivered` is set from executeReply on the final answer.
+      if (turn.finalAnswerDelivered) return
       const rendered = appendActivityLabel(turn.mirrorLines, ev.label)
       if (rendered != null) {
         // Recompose so any active foreground sub-agent's nested block (Model A)
@@ -10135,7 +10165,14 @@ async function handleInbound(
     // No staged entry to act on — fall through to normal handling.
   }
 
-  void bot.api.sendChatAction(chat_id, 'typing').catch(() => {})
+  // Typing indicator in the ORIGINATING topic — on a supergroup-topic inbound,
+  // an un-threaded sendChatAction shows "typing" in General, not the topic the
+  // user is in. messageThreadId is the inbound's thread (undefined in a DM).
+  void bot.api.sendChatAction(
+    chat_id,
+    'typing',
+    messageThreadId != null ? { message_thread_id: messageThreadId } : {},
+  ).catch(() => {})
 
   // Parse explicit prefixes first. `/steer ` / `/s ` opts IN to steering;
   // `/queue ` / `/q ` are legacy aliases that opt in to the new default (queued).
@@ -11064,10 +11101,14 @@ function resolveBootChatId(
   // → behavior unchanged (lands at chat-root as today). PR4b of
   // supergroup-mode rollout (docs/rfcs/supergroup-mode.md).
   const supergroupBootTopic = resolveAgentOutboundTopic({ kind: 'boot' })
+  const bootSupergroup = resolveAgentSupergroupChatId()
+  // The boot topic is valid only in the agent's supergroup — attach it per
+  // recipient so a DM owner doesn't 400 (marko #2096 class); the supergroup
+  // owner gets the boot/alerts lane, a DM gets a thread-less boot card.
 
   // 2. Env var
   const envChat = process.env.SUBAGENT_OWNER_CHAT_ID
-  if (envChat) return { chatId: envChat, threadId: supergroupBootTopic, ackMsgId: undefined }
+  if (envChat) return { chatId: envChat, threadId: topicForRecipient({ recipientChatId: envChat, resolvedTopic: supergroupBootTopic, supergroupChatId: bootSupergroup }), ackMsgId: undefined }
   // 3. Most-recent inbound from history
   if (HISTORY_ENABLED) {
     try {
@@ -11075,7 +11116,7 @@ function resolveBootChatId(
       const ownerChatId = access.allowFrom[0]
       if (ownerChatId) {
         const recent = queryHistory({ chat_id: ownerChatId, limit: 1 })
-        if (recent.length > 0) return { chatId: ownerChatId, threadId: supergroupBootTopic, ackMsgId: undefined }
+        if (recent.length > 0) return { chatId: ownerChatId, threadId: topicForRecipient({ recipientChatId: ownerChatId, resolvedTopic: supergroupBootTopic, supergroupChatId: bootSupergroup }), ackMsgId: undefined }
       }
     } catch {}
   }

package/telegram-plugin/gateway/turn-state-purge.ts

@@ -50,6 +50,19 @@ export function purgeStaleTurnsForChat(
   chatId: string,
   keys: Iterable<string>,
   purger: (key: string) => void,
+  /**
+   * Per-sibling staleness gate. A sibling key for `chatId` is purged only when
+   * this returns true. CRITICAL for one-agent-owns-supergroup: all of an
+   * agent's forum topics share the SAME chatId, so a chatId-only match would
+   * purge a LIVE sibling topic's reaction controller + typing loop when ANOTHER
+   * topic's 300s silence-poke fires (the gymbro/klanker wedge class). The
+   * caller passes a predicate true only for siblings themselves silent ≥ the
+   * fallback threshold (their own poke would also fire) — preserving the #1556
+   * dangling-key cleanup while sparing live siblings. Defaults to always-stale
+   * for back-compat (DM / single-topic callers, where every sibling is
+   * genuinely dangling).
+   */
+  isStale: (key: string) => boolean = () => true,
 ): PurgeStaleTurnsResult {
   if (!chatId) return { purged: [] }
   const purged: string[] = []
@@ -64,6 +77,7 @@ export function purgeStaleTurnsForChat(
     if (sep < 0) continue // malformed / non-statusKey shape — skip
     const keyChat = key.slice(0, sep)
     if (keyChat !== chatId) continue
+    if (!isStale(key)) continue // live sibling topic — leave its turn state intact
     purger(key)
     purged.push(key)
   }

package/telegram-plugin/hooks/tool-label-pretool.mjs

@@ -133,8 +133,9 @@ export function computeLabel(toolName, input) {
     }
   }
 
-  // MCP allowlist.
+  // MCP tools.
   if (typeof toolName === 'string' && toolName.startsWith('mcp__')) {
+    // Explicit labels / suppressions for the built-in servers.
     switch (toolName) {
       case 'mcp__switchroom-telegram__reply':
       case 'mcp__switchroom-telegram__stream_reply':
@@ -150,15 +151,46 @@ export function computeLabel(toolName, input) {
         return 'Searching memory'
       case 'mcp__hindsight__retain':
         return 'Saving memory'
-      // Explicit suppressions — return null so we don't emit a sidecar
-      // line at all. (Falling through to the default below produces the
-      // same effect, but listing these makes the intent obvious.)
+      // Explicit suppressions — return null so we don't emit a sidecar line.
       case 'mcp__switchroom-telegram__send_typing':
       case 'mcp__hindsight__sync_retain':
         return null
     }
-    // Any other mcp__* tool: not on the allowlist, no label.
-    return null
+    // Generic fallback for ANY other MCP tool (operator-configured servers
+    // — perplexity, webkite, gdrive, notion, …). These previously returned
+    // null → invisible in the live activity feed, so a research turn driven
+    // entirely by MCP tools read as pure silence (only a typing dot + the
+    // 👀 reaction) — the "I can't see what it's doing" report. Mirror the
+    // gateway's describeToolUse: friendly per-server labels, else a
+    // model-authored field, else a humanized tool name. NEVER label
+    // switchroom-telegram surface/control tools (they ARE the conversation).
+    const m = /^mcp__(.+?)__(.+)$/.exec(toolName)
+    if (!m) return null
+    const server = m[1].toLowerCase()
+    const tool = m[2].toLowerCase()
+    if (server === 'switchroom-telegram') return null
+    if (server === 'hindsight') return 'Working with memory'
+    if (server === 'google-workspace' || server === 'claude_ai_google_calendar')
+      return 'Checking your calendar'
+    if (server === 'claude_ai_gmail') return 'Checking your email'
+    if (server === 'claude_ai_google_drive' || server === 'gdrive')
+      return 'Looking through your files'
+    if (server === 'notion' || server === 'claude_ai_notion') return 'Checking your notes'
+    if (server === 'perplexity') {
+      const q = clip(String(i.query ?? i.description ?? ''), 60).trim()
+      return q ? `Searching the web for ${q}` : 'Searching the web'
+    }
+    if (server === 'webkite') {
+      const u = clip(urlHostPath(i.url ?? ''), 60).trim()
+      return u ? `Reading ${u}` : 'Reading the web'
+    }
+    // Unknown MCP server: prefer a model-authored field, else humanized tool.
+    const desc =
+      clip(String(i.description ?? ''), 60).trim() ||
+      clip(String(i.query ?? ''), 50).trim() ||
+      clip(String(i.title ?? ''), 50).trim()
+    if (desc) return desc
+    return `Using ${tool.replace(/[-_]+/g, ' ')}`
   }
 
   return null

package/telegram-plugin/silence-poke.ts

@@ -244,6 +244,23 @@ export function endTurn(key: string): void {
   state.delete(key)
 }
 
+/**
+ * Current silence duration (ms) for a key — `now - (lastOutboundAt ??
+ * turnStartedAt)`, the same clock `tick()` uses to decide the 300s fallback —
+ * or null when no turn state exists for the key. Lets the sibling-topic purge
+ * distinguish a STALE/wedged sibling (silent ≥ the fallback threshold, so its
+ * own poke would also fire) from a LIVE one mid-turn (recent outbound, low
+ * silence), so a silence-poke on one supergroup topic doesn't purge a live
+ * sibling topic's reaction controller + typing loop. NB: this is silence, NOT
+ * turn-start age — a long but actively-narrating turn has low silence and must
+ * not be treated as stale.
+ */
+export function silenceMsForKey(key: string, now: number): number | null {
+  const s = state.get(key)
+  if (s == null) return null
+  return now - (s.lastOutboundAt ?? s.turnStartedAt)
+}
+
 /**
  * Verbatim framework-fallback text — the user-visible "still working / still
  * thinking" message the gateway sends at the 300s threshold when the model
@@ -264,8 +281,17 @@ export function formatFrameworkFallbackText(
   fallbackKind: 'working' | 'thinking',
   silenceMs: number,
   inFlightTools: ToolSnapshot[] = [],
+  blockedOnApproval = false,
 ): string {
   const minutes = Math.max(1, Math.round(silenceMs / 60_000))
+  // The turn isn't stalled — it's parked on an approval card waiting for YOUR
+  // tap (the dominant live "wedge" class is benign approval-latency, not a
+  // hang). Saying "still working…" here actively lies; name the real blocker so
+  // the operator knows the ball is in their court. Takes precedence over the
+  // in-flight-tool framing (a tool awaiting approval isn't "running").
+  if (blockedOnApproval) {
+    return `waiting for your approval — tap Approve or Deny on the card above (${minutes} min)`
+  }
   const suffix = `(no update from agent in ${minutes} min)`
   // #1292 case (a): tools in flight. Name the longest-running one
   // (entry[0] — caller pre-sorts by startedAt ascending). Avoid the

package/telegram-plugin/status-reactions.ts

@@ -144,6 +144,10 @@ export class StatusReactionController {
   private stallHardTimer: ReturnType<typeof setTimeout> | null = null
   private finished = false
   private held = false
+  // True while parked on the awaiting-approval state (🙏): the turn is blocked
+  // on the operator's tap, not stalled. Read by the silence-poke fallback so it
+  // says "waiting for your approval" instead of the dishonest "still working…".
+  private awaitingApproval = false
   private readonly debounceMs: number
   private readonly stallSoftMs: number
   private readonly stallHardMs: number
@@ -272,11 +276,21 @@ export class StatusReactionController {
 
   // ──────────────────────────────────────────────────────────────────────
 
+  /** True while the turn is parked awaiting the operator's approval tap (🙏).
+   *  The silence-poke fallback reads this to phrase its 300s message honestly
+   *  ("waiting for your approval") instead of "still working…". */
+  isAwaiting(): boolean {
+    return this.awaitingApproval && !this.finished
+  }
+
   private scheduleState(
     state: ReactionState,
     opts: { immediate?: boolean; skipStallReset?: boolean } = {},
   ): void {
     if (this.finished) return
+    // Track the awaiting-approval state for isAwaiting(). Any non-awaiting
+    // state transition (setThinking/setTool/… on verdict resume) clears it.
+    this.awaitingApproval = state === 'awaiting'
     const emoji = this.resolveEmoji(state)
     if (emoji == null) {
       if (!opts.skipStallReset) this.resetStallTimers()

package/telegram-plugin/tests/silence-poke.test.ts

@@ -7,6 +7,7 @@ import {
   noteToolEnd,
   noteToolLabel,
   endTurn,
+  silenceMsForKey,
   silencePokeEnabled,
   formatFrameworkFallbackText,
   __tickForTests,
@@ -275,6 +276,26 @@ describe('silence-poke — #1292 tool-aware framework fallback', () => {
     ).toBe('still working… (no update from agent in 5 min)')
   })
 
+  it('blockedOnApproval names the real blocker instead of the dishonest "still working…"', () => {
+    expect(
+      formatFrameworkFallbackText('working', 305_000, [], true),
+    ).toBe('waiting for your approval — tap Approve or Deny on the card above (5 min)')
+  })
+
+  it('blockedOnApproval takes precedence over an in-flight tool (a tool awaiting approval is not "running")', () => {
+    expect(
+      formatFrameworkFallbackText('working', 305_000, [
+        { name: 'Bash', label: 'rm -rf build', durationMs: 305_000 },
+      ], true),
+    ).toBe('waiting for your approval — tap Approve or Deny on the card above (5 min)')
+  })
+
+  it('blockedOnApproval=false keeps the existing wording (default, back-compat)', () => {
+    expect(
+      formatFrameworkFallbackText('working', 305_000, [], false),
+    ).toBe('still working… (no update from agent in 5 min)')
+  })
+
   it('tool-aware wording wins over "thinking" — the actual observable beats the inferred kind', () => {
     const text = formatFrameworkFallbackText('thinking', 305_000, [
       { name: 'Grep', label: '"foo"', durationMs: 305_000 },
@@ -340,6 +361,21 @@ describe('silence-poke — #1292 tool-aware framework fallback', () => {
     expect(fx.fallbacks).toHaveLength(1)
   })
 
+  it('silenceMsForKey reports silence from last outbound (or turn start), null when unknown', () => {
+    setupDeps()
+    startTurn('k', 1_000)
+    // No outbound yet → silence measured from turnStartedAt.
+    expect(silenceMsForKey('k', 1_000 + 120_000)).toBe(120_000)
+    noteOutbound('k', 1_000 + 50_000)
+    // After an outbound → silence measured from lastOutboundAt.
+    expect(silenceMsForKey('k', 1_000 + 120_000)).toBe(70_000)
+    // Unknown key / ended turn → null (used by the sibling purge to treat a
+    // dangling key as stale).
+    expect(silenceMsForKey('never-started', 999_999)).toBeNull()
+    endTurn('k')
+    expect(silenceMsForKey('k', 999_999)).toBeNull()
+  })
+
   it('Task tool populates inFlightTools so the fallback names it as the observable', () => {
     const fx = setupDeps()
     startTurn('k', 0)

package/telegram-plugin/tests/status-reactions.test.ts

@@ -94,6 +94,22 @@ describe('StatusReactionController', () => {
     expect(calls).toEqual(['👀'])
   })
 
+  it('isAwaiting() tracks the awaiting-approval state (for the honest silence-poke copy)', async () => {
+    const { emit } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    expect(ctrl.isAwaiting()).toBe(false)
+    ctrl.setAwaiting()
+    expect(ctrl.isAwaiting()).toBe(true)
+    // The verdict resume (setThinking) un-parks → no longer awaiting.
+    ctrl.setThinking()
+    expect(ctrl.isAwaiting()).toBe(false)
+    // Re-park, then finish → isAwaiting is false once the turn ends.
+    ctrl.setAwaiting()
+    expect(ctrl.isAwaiting()).toBe(true)
+    ctrl.finalize()
+    expect(ctrl.isAwaiting()).toBe(false)
+  })
+
   it('setThinking is debounced by 3500ms (#1713)', async () => {
     const { emit, calls } = makeEmitter()
     const ctrl = new StatusReactionController(emit)

package/telegram-plugin/tests/turn-state-purge.test.ts

@@ -106,4 +106,32 @@ describe('purgeStaleTurnsForChat', () => {
     expect(r.purged.sort()).toEqual(['123:7', '123:_'])
     expect([...map.keys()]).toEqual(['999:_']) // multi-chat safety preserved
   })
+
+  // #2 supergroup sibling-topic fix: one agent owns the supergroup, so all
+  // forum topics share the chatId. A 300s poke on topic A must NOT purge a
+  // LIVE sibling topic B's turn state — only siblings that are themselves stale.
+  it('isStale predicate spares live sibling topics (the supergroup fix)', () => {
+    const purged: string[] = []
+    const live = new Set(['-100:7']) // topic 7 is actively mid-turn
+    const r = purgeStaleTurnsForChat(
+      '-100',
+      ['-100:4', '-100:7', '999:_'],
+      (k) => purged.push(k),
+      (k) => !live.has(k), // stale iff not live
+    )
+    expect(r.purged).toEqual(['-100:4']) // only the stale topic purged
+    expect(purged).toEqual(['-100:4']) // live topic 7 + other chat untouched
+  })
+
+  it('isStale=false for every sibling purges nothing (all topics live)', () => {
+    const purged: string[] = []
+    purgeStaleTurnsForChat('-100', ['-100:4', '-100:7'], (k) => purged.push(k), () => false)
+    expect(purged).toEqual([])
+  })
+
+  it('default isStale (omitted) purges every chatId match — back-compat', () => {
+    const purged: string[] = []
+    const r = purgeStaleTurnsForChat('123', ['123:_', '123:7', '999:_'], (k) => purged.push(k))
+    expect(r.purged.sort()).toEqual(['123:7', '123:_'])
+  })
 })

package/telegram-plugin/uat/scenarios/fuzz-supergroup-channel.test.ts

@@ -121,12 +121,17 @@ describe("uat: supergroup human-style fuzz — JTBD invariants in a channel", ()
         const meaningful = isMeaningfulReply(reply.text);
         expect(meaningful.ok, `[sg-fuzz] ${fc.name}: ${meaningful.reason}`).toBe(true);
 
-        // Invariant 4 (optional): shape match when predictable.
-        if (fc.expectMatch) {
-          expect(
-            fc.expectMatch.test(reply.text),
-            `[sg-fuzz] ${fc.name}: reply did not match ${fc.expectMatch}`,
-          ).toBe(true);
+        // Invariant 4 (SOFT): shape match when predictable. Like the DM
+        // fuzz, this is a "did the model engage the topic at all" diagnostic,
+        // NOT a correctness gate — different runs produce different valid
+        // wording (e.g. a clarifying question, or "use the package manager"
+        // without the literal "apt"). Log and continue; the load-bearing
+        // invariants are 1-3 (meaningful, leak-free, in the supergroup).
+        if (fc.expectMatch && !fc.expectMatch.test(reply.text)) {
+          console.warn(
+            `[sg-fuzz] ${fc.name}: reply didn't match ${fc.expectMatch} (soft) — ` +
+              `preview: ${JSON.stringify(reply.text.slice(0, 200))}`,
+          );
         }
       } finally {
         await sc.tearDown();

package/telegram-plugin/uat/scenarios/jtbd-foreground-subagent-activity-channel.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Foreground sub-agent live activity nesting in a SUPERGROUP (#2032 + #2099) — UAT.
+ *
+ * Channel twin of `jtbd-foreground-subagent-activity-dm`. A FOREGROUND
+ * sub-agent (Agent/Task `run_in_background:false`) dispatched from a supergroup
+ * — after an ack-first "On it" reply — must nest its live steps into the
+ * parent's activity-summary feed IN the supergroup. Proves the foreground
+ * sub-agent status surface has DM/channel parity (and exercises #2099's
+ * tool-step nesting + #2032's render-regardless-of-replyCalled in a channel).
+ *
+ * Asserts the load-bearing proof: an activity-summary feed message carrying the
+ * nested "↳" marker appears IN the supergroup AFTER the ack, then the turn
+ * completes cleanly. Self-skips when no test supergroup is wired. Uses the
+ * General topic (mtcute here has no forum-topic create API). NOT a draft —
+ * the activity-summary feed is a real sendMessage/editMessageText, so mtcute
+ * can observe it.
+ */
+
+import { describe, expect, it } from "vitest";
+import { spinUp } from "../harness.js";
+import { expectMessage } from "../assertions.js";
+
+const AGENT = "test-harness";
+const SUPERGROUP_ID = Number.parseInt(process.env.SWITCHROOM_UAT_CHAT_ID ?? "", 10);
+
+const FG_DISPATCH_PROMPT =
+  `First, immediately send me a one-line acknowledgement that you're starting ` +
+  `(just "On it — running a check now."). Then use the Agent tool with ` +
+  `subagent_type "general-purpose" and run_in_background: false (a FOREGROUND ` +
+  `sub-agent) with this exact task: "Do eight steps, ONE AT A TIME, k = 1 ` +
+  `through 8. Before each step write a brief one-sentence narration of what ` +
+  `you are about to do, then run \`sleep 2\` via the Bash tool, then run ` +
+  `\`echo step-k\` via the Bash tool (substitute the real number for k). Run ` +
+  `every sleep and every echo as its OWN separate Bash call — never batch or ` +
+  `chain them with && — and narrate before each so progress surfaces ` +
+  `incrementally. Do not stop early; complete all eight steps, then return a ` +
+  `one-line summary." Wait for the foreground sub-agent to finish, then send ` +
+  `me a brief reply telling me it's done.`;
+
+const NESTED_RE = /↳/;
+
+describe("uat: foreground sub-agent activity nesting in a supergroup (#2032/#2099 channel parity)", () => {
+  it(
+    "surfaces nested foreground activity in the feed IN the supergroup, after the ack",
+    async () => {
+      if (!Number.isFinite(SUPERGROUP_ID)) {
+        console.warn("[fg-activity channel UAT] SWITCHROOM_UAT_CHAT_ID unset — skipping");
+        return;
+      }
+      const sc = await spinUp({ agent: AGENT, settleMs: 0 });
+      try {
+        await sc.driver.primeDialogs();
+        if (!(await sc.driver.canResolve(SUPERGROUP_ID))) {
+          console.warn(`[fg-activity channel UAT] supergroup ${SUPERGROUP_ID} not resolvable — skipping`);
+          return;
+        }
+        await sc.driver.sendText(SUPERGROUP_ID, FG_DISPATCH_PROMPT);
+
+        // Ack-first reply in the supergroup — sets replyCalled=true before the
+        // foreground sub-agent runs (the condition that broke #2027).
+        const ack = await expectMessage(sc.driver, SUPERGROUP_ID, /.+/, {
+          timeout: 60_000,
+          senderFilter: { notUserId: sc.driverUserId },
+        });
+        console.log(`[fg-activity channel UAT] ack-first reply: ${JSON.stringify(ack.text)}`);
+
+        // The activity-summary feed carrying the NESTED foreground narrative —
+        // must land IN the supergroup. Its presence after the ack is the proof.
+        const feed = await expectMessage(sc.driver, SUPERGROUP_ID, NESTED_RE, {
+          timeout: 90_000,
+          senderFilter: { notUserId: sc.driverUserId },
+        });
+        console.log(
+          `[fg-activity channel UAT] nested feed paint (id=${feed.messageId}, chat=${feed.chatId}): ${JSON.stringify(feed.text)}`,
+        );
+        expect(feed.chatId).toBe(SUPERGROUP_ID); // parity proof: nested feed in the channel
+        expect(feed.fromBot).toBe(true);
+        expect(feed.text).toMatch(NESTED_RE);
+
+        // Live edit: re-fetch the SAME message after a few sub-agent steps.
+        const before = feed.text;
+        await new Promise((r) => setTimeout(r, 10_000));
+        const mid = await sc.driver.getMessage(SUPERGROUP_ID, feed.messageId);
+        console.log(
+          `[fg-activity channel UAT] same feed after 10s (id=${feed.messageId}): ${JSON.stringify(mid?.text ?? null)}`,
+        );
+
+        // Final answer — parent resumes after the foreground sub-agent returns.
+        const done = await expectMessage(sc.driver, SUPERGROUP_ID, /done|complete|finished|step-8|wrapped/i, {
+          timeout: 120_000,
+          senderFilter: { notUserId: sc.driverUserId },
+        });
+        console.log(`[fg-activity channel UAT] final answer: ${JSON.stringify(done.text)}`);
+        expect(done.text.length).toBeGreaterThan(0);
+        if (mid?.text != null) {
+          console.log(`[fg-activity channel UAT] body moved in-flight: ${mid.text !== before}`);
+        }
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    300_000,
+  );
+});

package/telegram-plugin/uat/scenarios/jtbd-supergroup-handback-channel.test.ts

@@ -0,0 +1,77 @@
+/**
+ * JTBD scenario — background-worker HANDBACK lands in the supergroup (#2098).
+ *
+ * This is the live validation of the headline channel fix: when a background
+ * sub-agent (Task/Agent `run_in_background:true`) dispatched from a supergroup
+ * finishes, the agent's in-voice "here's what the worker found" handback (beat
+ * 4) must land IN the supergroup — not the operator DM (the pre-#2098 bug,
+ * where the synthesized handback inbound was thread-blind and the reply fell
+ * back to the chat's last-seen topic / owner DM).
+ *
+ * Mechanism exercised: dispatch a bg worker that returns a unique token →
+ * onFinish → buildSubagentHandbackInbound (now carrying the origin topic) →
+ * the parent relays the token. We assert the token appears in a BOT message
+ * IN the supergroup. Pre-#2098 that handback would not have been threaded to
+ * the supergroup; post-#2098 it is.
+ *
+ * Best-effort + model-dependent: the agent must actually background the task
+ * (not inline it) and relay the worker's token. The prompt is explicit. Self-
+ * skips when no test supergroup is wired. Uses the General topic (mtcute here
+ * has no forum-topic create API); topic-among-many routing is pinned by the
+ * #2098 unit thread-assertions.
+ */
+
+import { describe, it, expect } from "vitest";
+import { spinUp } from "../harness.js";
+import { expectMessage } from "../assertions.js";
+
+const AGENT = "test-harness";
+const SUPERGROUP_ID = Number.parseInt(process.env.SWITCHROOM_UAT_CHAT_ID ?? "", 10);
+
+/** Worker dispatch + run + onFinish + handback relay — generous budget. */
+const HANDBACK_TIMEOUT_MS = 150_000;
+
+describe("uat: supergroup background-worker handback (#2098)", () => {
+  it("a dispatched background worker's result is handed back IN the supergroup", async () => {
+    if (!Number.isFinite(SUPERGROUP_ID)) {
+      console.warn("[uat] SWITCHROOM_UAT_CHAT_ID unset — skipping handback channel scenario");
+      return;
+    }
+    const sc = await spinUp({ agent: AGENT, settleMs: 0 });
+    try {
+      await sc.driver.primeDialogs();
+      if (!(await sc.driver.canResolve(SUPERGROUP_ID))) {
+        console.warn(`[uat] supergroup ${SUPERGROUP_ID} not resolvable — skipping handback channel scenario`);
+        return;
+      }
+
+      // Unique token the worker must echo back, so the handback relay is
+      // unambiguous and can't latch onto unrelated chatter.
+      const token = `HBK${Date.now().toString(36).toUpperCase()}`;
+      await sc.driver.sendText(
+        SUPERGROUP_ID,
+        `Dispatch a BACKGROUND worker (a Task with run_in_background:true) that ` +
+          `runs a shell sleep of about 8 seconds and then returns exactly the ` +
+          `token ${token}. Do NOT do it inline — it must be a background Task so ` +
+          `you can acknowledge first. Acknowledge now, and when the worker reports ` +
+          `back, relay its token (${token}) here in this group.`,
+      );
+
+      // The handback relay — a bot message in the supergroup carrying the
+      // worker's token. (The interim "on it" ack may arrive first; we wait
+      // for the message that actually carries the token, which is the
+      // post-handback relay.)
+      const relay = await expectMessage(
+        sc.driver,
+        SUPERGROUP_ID,
+        (m) => m.text.includes(token),
+        { timeout: HANDBACK_TIMEOUT_MS, senderFilter: { notUserId: sc.driverUserId } },
+      );
+
+      expect(relay.chatId).toBe(SUPERGROUP_ID);
+      expect(relay.fromBot).toBe(true);
+    } finally {
+      await sc.tearDown();
+    }
+  }, HANDBACK_TIMEOUT_MS + 30_000);
+});

package/telegram-plugin/uat/scenarios/jtbd-worker-activity-feed-channel.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Live worker-activity feed in a SUPERGROUP (#2000 + #2098 routing) — UAT.
+ *
+ * Channel twin of `jtbd-worker-activity-feed-dm`. A background sub-agent
+ * (Agent/Task `run_in_background:true`) dispatched from a supergroup must
+ * surface its live `🛠 Worker · …` feed message IN the supergroup — not the
+ * operator DM (the pre-v0.14.32 "always route to DM" bug). Proves the
+ * background-worker status surface has DM/channel parity.
+ *
+ * Asserts: (1) a worker-feed message appears IN the supergroup, from the bot;
+ * (2) it edits in place while work is in flight; (3) it finalizes to the
+ * terminal recap; (4) no raw Markdown leaks (#94-class guard).
+ *
+ * Self-skips when no test supergroup is wired. Uses the General topic (mtcute
+ * here has no forum-topic create API). Same paced-narration dispatch as the
+ * DM version so the worker's jsonl ticks under the test-harness 5s stall floor.
+ */
+
+import { describe, expect, it } from "vitest";
+import { spinUp } from "../harness.js";
+import { expectMessage } from "../assertions.js";
+
+const AGENT = "test-harness";
+const SUPERGROUP_ID = Number.parseInt(process.env.SWITCHROOM_UAT_CHAT_ID ?? "", 10);
+
+const BG_DISPATCH_PROMPT =
+  `Use the Agent tool with subagent_type "general-purpose" and ` +
+  `run_in_background: true to dispatch a worker with this exact task: ` +
+  `"Do ten steps, ONE AT A TIME, k = 1 through 10. Before each step ` +
+  `write a brief one-sentence narration of what you are about to do, ` +
+  `then run \`sleep 2\` via the Bash tool, then run \`echo step-k\` via ` +
+  `the Bash tool (substitute the real number for k). Run every sleep and ` +
+  `every echo as its OWN separate Bash call — never batch or chain them ` +
+  `with && — and narrate before each so progress surfaces incrementally. ` +
+  `Do not stop early; complete all ten steps." After dispatching, send a ` +
+  `brief reply saying you've kicked off the background worker so I can ` +
+  `watch its progress.`;
+
+const WORKER_FEED_RE = /🛠\s*Worker|running\s*·|finished\s*·/i;
+const WORKER_DONE_RE = /finished\s*·\s*(completed|failed)/i;
+
+describe("uat: live worker-activity feed in a supergroup (#2000 channel parity)", () => {
+  it(
+    "surfaces a background worker as a live, editing message IN the supergroup",
+    async () => {
+      if (!Number.isFinite(SUPERGROUP_ID)) {
+        console.warn("[worker-feed channel UAT] SWITCHROOM_UAT_CHAT_ID unset — skipping");
+        return;
+      }
+      const sc = await spinUp({ agent: AGENT, settleMs: 0 });
+      try {
+        await sc.driver.primeDialogs();
+        if (!(await sc.driver.canResolve(SUPERGROUP_ID))) {
+          console.warn(`[worker-feed channel UAT] supergroup ${SUPERGROUP_ID} not resolvable — skipping`);
+          return;
+        }
+        await sc.driver.sendText(SUPERGROUP_ID, BG_DISPATCH_PROMPT);
+
+        // Parent ack in the supergroup so we know the parent turn closed.
+        const ack = await expectMessage(sc.driver, SUPERGROUP_ID, /.+/, {
+          timeout: 45_000,
+          senderFilter: { notUserId: sc.driverUserId },
+        });
+        console.log(`[worker-feed channel UAT] parent ack: ${JSON.stringify(ack.text)}`);
+
+        // The worker-feed message — must land IN the supergroup.
+        const feed = await expectMessage(sc.driver, SUPERGROUP_ID, WORKER_FEED_RE, {
+          timeout: 75_000,
+          senderFilter: { notUserId: sc.driverUserId },
+        });
+        console.log(
+          `[worker-feed channel UAT] first feed paint (id=${feed.messageId}, chat=${feed.chatId}): ${JSON.stringify(feed.text)}`,
+        );
+        expect(feed.chatId).toBe(SUPERGROUP_ID); // parity proof: in the channel, not the DM
+        expect(feed.fromBot).toBe(true);
+        expect(feed.messageId).toBeGreaterThan(0);
+
+        // Live edit: re-fetch the SAME message after the throttle.
+        const before = feed.text;
+        await new Promise((r) => setTimeout(r, 12_000));
+        const mid = await sc.driver.getMessage(SUPERGROUP_ID, feed.messageId);
+        console.log(
+          `[worker-feed channel UAT] after 12s (id=${feed.messageId}): ${JSON.stringify(mid?.text ?? null)}`,
+        );
+        expect(mid, "worker-feed message vanished mid-flight").not.toBeNull();
+
+        // Terminal recap — poll the same message until done/failed.
+        let doneText: string | null = null;
+        const deadline = Date.now() + 120_000;
+        while (Date.now() < deadline) {
+          const m = await sc.driver.getMessage(SUPERGROUP_ID, feed.messageId);
+          if (m != null && WORKER_DONE_RE.test(m.text)) {
+            doneText = m.text;
+            break;
+          }
+          await new Promise((r) => setTimeout(r, 5_000));
+        }
+        console.log(
+          `[worker-feed channel UAT] terminal (id=${feed.messageId}): ${JSON.stringify(doneText)}`,
+        );
+        expect(doneText, "worker-feed never reached a terminal recap").not.toBeNull();
+        expect(doneText!).toMatch(/tools?|tool ·/i);
+        expect(doneText).not.toBe(before);
+        // #94-class regression guard: no raw Markdown in the native card.
+        expect(doneText!, "raw ** leaked into the card").not.toMatch(/\*\*/);
+        expect(doneText!, "raw backtick leaked into the card").not.toContain("`");
+        expect(doneText!, "raw --- rule leaked into the card").not.toMatch(/(^|\n)\s*-{3,}\s*(\n|$)/);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    240_000,
+  );
+});