switchroom 0.14.43 → 0.14.44

package/telegram-plugin/gateway/gateway.ts

@@ -3912,10 +3912,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 +4041,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 +8175,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 +8218,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)

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/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,
+  );
+});