switchroom 0.14.42 → 0.14.44

package/dist/cli/switchroom.js

@@ -49462,8 +49462,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.42";
-var COMMIT_SHA = "6da4313d";
+var VERSION = "0.14.44";
+var COMMIT_SHA = "90836113";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.42",
+  "version": "0.14.44",
   "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);
   }
@@ -47942,6 +47958,7 @@ ${result}
   return {
     type: "inbound",
     chatId: opts.ctx.chatId,
+    ...opts.ctx.threadId != null ? { threadId: opts.ctx.threadId } : {},
     messageId: ts,
     user: "subagent-watcher",
     userId: 0,
@@ -47950,6 +47967,7 @@ ${result}
     meta: {
       source: "subagent_handback",
       outcome: opts.ctx.outcome,
+      ...opts.ctx.threadId != null ? { message_thread_id: String(opts.ctx.threadId) } : {},
       ...opts.ctx.jsonlAgentId ? { subagent_jsonl_id: opts.ctx.jsonlAgentId } : {}
     }
   };
@@ -47968,9 +47986,11 @@ function decideSubagentHandback(input) {
   if (!chatId) {
     return { deliver: false, reason: "no-chat" };
   }
+  const threadId = input.fleetChatId && input.originThreadId != null ? input.originThreadId : undefined;
   const inbound = buildSubagentHandbackInbound({
     ctx: {
       chatId,
+      ...threadId != null ? { threadId } : {},
       taskDescription: input.taskDescription,
       resultText: input.resultText,
       outcome: input.outcome,
@@ -48017,6 +48037,7 @@ ${summary}
   return {
     type: "inbound",
     chatId: opts.ctx.chatId,
+    ...opts.ctx.threadId != null ? { threadId: opts.ctx.threadId } : {},
     messageId: ts,
     user: "subagent-watcher",
     userId: 0,
@@ -48024,6 +48045,7 @@ ${summary}
     text,
     meta: {
       source: "subagent_progress",
+      ...opts.ctx.threadId != null ? { message_thread_id: String(opts.ctx.threadId) } : {},
       subagent_jsonl_id: opts.ctx.subagentJsonlId,
       bucket_idx: String(opts.ctx.bucketIdx),
       expiresAt: String(expiresAt),
@@ -48062,9 +48084,11 @@ function decideSubagentProgress(input) {
   if (input.lastBucketIdx != null && bucketIdx <= input.lastBucketIdx) {
     return { deliver: false, reason: "bucket-already-fired" };
   }
+  const threadId = input.fleetChatId && input.originThreadId != null ? input.originThreadId : undefined;
   const inbound = buildSubagentProgressInbound({
     ctx: {
       chatId,
+      ...threadId != null ? { threadId } : {},
       subagentJsonlId: input.subagentJsonlId,
       taskDescription: input.taskDescription,
       latestSummary: input.latestSummary,
@@ -49498,6 +49522,113 @@ function redactSecrets(text) {
     out = out.replace(re, "[redacted]");
   return out;
 }
+
+// tool-activity-summary.ts
+function baseName(p) {
+  if (typeof p !== "string" || p.length === 0)
+    return null;
+  const parts = p.split("/").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : p;
+}
+function hostName(u) {
+  if (typeof u !== "string" || u.length === 0)
+    return null;
+  try {
+    return new URL(u).hostname.replace(/^www\./, "");
+  } catch {
+    return u.replace(/^https?:\/\//, "").split("/")[0] || null;
+  }
+}
+function clip(s, n) {
+  if (typeof s !== "string")
+    return null;
+  const t = s.trim();
+  if (t.length === 0)
+    return null;
+  return t.length > n ? t.slice(0, n - 1) + "\u2026" : t;
+}
+function describeToolUse(toolName, input) {
+  if (!toolName)
+    return null;
+  const inp = input ?? {};
+  const mcpMatch = /^mcp__(.+?)__(.+)$/.exec(toolName);
+  if (mcpMatch) {
+    const server = mcpMatch[1].toLowerCase();
+    const tool = mcpMatch[2].toLowerCase();
+    if (server === "switchroom-telegram")
+      return null;
+    if (server === "hindsight") {
+      if (tool === "recall" || tool === "reflect")
+        return "Searching memory";
+      if (tool === "retain" || tool === "update_memory" || tool === "sync_retain")
+        return "Saving to memory";
+      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")
+      return "Looking through your files";
+    if (server === "notion" || server === "claude_ai_notion") {
+      return "Checking your notes";
+    }
+    const desc = clip(inp.description, 60) ?? clip(inp.query, 50) ?? clip(inp.title, 50);
+    if (desc)
+      return desc;
+    return "Using " + tool.replace(/[-_]+/g, " ");
+  }
+  switch (toolName) {
+    case "Bash": {
+      return clip(inp.description, 70) ?? "Running a command";
+    }
+    case "BashOutput":
+    case "KillShell":
+      return "Managing a background command";
+    case "Read": {
+      const f = baseName(inp.file_path);
+      return f ? `Reading ${f}` : "Reading a file";
+    }
+    case "Edit":
+    case "MultiEdit":
+    case "NotebookEdit": {
+      const f = baseName(inp.file_path) ?? baseName(inp.notebook_path);
+      return f ? `Editing ${f}` : "Editing a file";
+    }
+    case "Write": {
+      const f = baseName(inp.file_path);
+      return f ? `Writing ${f}` : "Writing a file";
+    }
+    case "Grep":
+    case "Glob": {
+      const p = clip(inp.pattern, 40);
+      return p ? `Searching for ${p}` : "Searching files";
+    }
+    case "WebFetch": {
+      const h = hostName(inp.url);
+      return h ? `Reading ${h}` : "Reading a web page";
+    }
+    case "WebSearch": {
+      const q = clip(inp.query, 50);
+      return q ? `Searching the web for ${q}` : "Searching the web";
+    }
+    case "Task":
+    case "Agent": {
+      const d = clip(inp.description, 60);
+      return d ? `Delegating: ${d}` : "Delegating to a sub-agent";
+    }
+    case "TodoWrite":
+    case "TaskCreate":
+    case "TaskUpdate":
+    case "TaskList":
+      return "Updating the plan";
+    case "ToolSearch":
+      return "Finding the right tool";
+    default:
+      return "Working\u2026";
+  }
+}
 // registry/subagents-schema.ts
 function countRunningBackgroundSubagents(db2) {
   const row = db2.prepare("SELECT count(*) AS n FROM subagents WHERE background = 1 AND status = 'running'").get();
@@ -49745,6 +49876,28 @@ function readSubTail(entry, tail, now, onDescriptionUpdate, fs2, log, db2, paren
             name: ev.toolName,
             sanitisedArg: sanitiseToolArg(ev.toolName, ev.input ?? {})
           };
+          if (onProgress != null && entry.state === "running" && !entry.historical) {
+            const toolLine = describeToolUse(ev.toolName, ev.input ?? {});
+            if (toolLine != null && toolLine.length > 0) {
+              try {
+                onProgress({
+                  agentId: entry.agentId,
+                  description: entry.description,
+                  latestSummary: entry.lastResultText,
+                  elapsedMs: now - entry.dispatchedAt,
+                  prevBucketIdx: entry.lastProgressBucketIdx,
+                  setBucketIdx: (b) => {
+                    entry.lastProgressBucketIdx = b;
+                  },
+                  lastTool: entry.lastTool,
+                  toolCount: entry.toolCount,
+                  progressLine: toolLine
+                });
+              } catch (cbErr) {
+                log?.(`subagent-watcher: onProgress (tool) callback error ${entry.agentId}: ${cbErr.message}`);
+              }
+            }
+          }
         } else if (ev.kind === "sub_agent_text") {
           entry.lastSummaryLine = ev.text.split(`
 `)[0].trim().slice(0, 120);
@@ -51871,10 +52024,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.42";
-var COMMIT_SHA = "6da4313d";
-var COMMIT_DATE = "2026-06-02T22:14:58Z";
-var LATEST_PR = 2097;
+var VERSION = "0.14.44";
+var COMMIT_SHA = "90836113";
+var COMMIT_DATE = "2026-06-03T02:30:59Z";
+var LATEST_PR = 2110;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -54096,7 +54249,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, {
@@ -54155,7 +54309,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 {
@@ -55075,7 +55235,7 @@ ${url}`;
     effectiveText = text;
   }
   assertAllowedChat(chat_id);
-  let threadId = resolveThreadId(chat_id, args.message_thread_id);
+  let threadId = resolveThreadId(chat_id, args.message_thread_id ?? (turn?.sessionThreadId != null ? turn.sessionThreadId : undefined));
   if (reply_to == null && quoteOptIn && HISTORY_ENABLED) {
     try {
       const latest = getLatestInboundMessageId(chat_id, threadId ?? null);
@@ -55414,6 +55574,9 @@ async function executeStreamReply(args) {
     throw new Error("stream_reply: chat_id is required");
   if (args.text == null || args.text === "")
     throw new Error("stream_reply: text is required and cannot be empty");
+  if (args.message_thread_id == null && turn?.sessionThreadId != null) {
+    args.message_thread_id = String(turn.sessionThreadId);
+  }
   args.text = redactOutboundText(args.text, "stream_reply");
   {
     const scrub = scrubVoice(args.text);
@@ -56676,13 +56839,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);
         }
       }
@@ -56702,7 +56864,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) {
@@ -62863,11 +63025,13 @@ var didOneTimeSetup = false;
                     state: outcome === "failed" ? "failed" : "done"
                   });
                 }
+                const handbackOrigin = resolveSubagentOriginChat(agentId);
                 const decision = decideSubagentHandback({
                   handbackEnvValue: process.env.SWITCHROOM_SUBAGENT_HANDBACK,
                   outcome,
                   isBackground,
-                  fleetChatId: resolveSubagentOriginChat(agentId)?.chatId || fleetChatId,
+                  fleetChatId: handbackOrigin?.chatId || fleetChatId,
+                  ...handbackOrigin?.threadId != null ? { originThreadId: handbackOrigin.threadId } : {},
                   ownerChatId: loadAccess().allowFrom[0] ?? "",
                   taskDescription: description,
                   resultText,
@@ -62895,7 +63059,7 @@ var didOneTimeSetup = false;
                 process.stderr.write(`telegram gateway: subagent-handback queued agent=${agentId} outcome=${outcome} chat=${decision.chatId} resultChars=${resultText.length}
 `);
               },
-              onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount }) => {
+              onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount, progressLine }) => {
                 let fleetChatId = "";
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? [];
@@ -62922,7 +63086,7 @@ var didOneTimeSetup = false;
                     replyCalled: turn.replyCalled
                   }))
                     return;
-                  const child = latestSummary.trim().slice(0, 120);
+                  const child = (progressLine ?? latestSummary).trim().slice(0, 120);
                   if (child.length === 0)
                     return;
                   let narrative = turn.foregroundSubAgents.get(agentId);
@@ -62957,10 +63121,12 @@ var didOneTimeSetup = false;
                   }, origin?.threadId);
                   return;
                 }
+                const progressOrigin = resolveSubagentOriginChat(agentId);
                 const decision = decideSubagentProgress({
                   disableEnvValue: process.env.SWITCHROOM_DISABLE_SUBAGENT_PROGRESS,
                   isBackground,
-                  fleetChatId: resolveSubagentOriginChat(agentId)?.chatId || fleetChatId,
+                  fleetChatId: progressOrigin?.chatId || fleetChatId,
+                  ...progressOrigin?.threadId != null ? { originThreadId: progressOrigin.threadId } : {},
                   ownerChatId: loadAccess().allowFrom[0] ?? "",
                   subagentJsonlId: agentId,
                   taskDescription: description,
@@ -62973,7 +63139,7 @@ var didOneTimeSetup = false;
                   return;
                 setBucketIdx(decision.bucketIdx);
                 pendingInboundBuffer.push(process.env.SWITCHROOM_AGENT_NAME ?? "", decision.inbound);
-                clearPending(statusKey(decision.chatId, undefined), "progress");
+                clearPending(statusKey(decision.chatId, progressOrigin?.threadId), "progress");
                 process.stderr.write(`telegram gateway: subagent-progress queued agent=${agentId} bucket=${decision.bucketIdx} elapsed_ms=${elapsedMs} chat=${decision.chatId}
 `);
               }

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
@@ -5603,7 +5624,21 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
 
   assertAllowedChat(chat_id)
 
-  let threadId = resolveThreadId(chat_id, args.message_thread_id as string | undefined)
+  // Thread resolution precedence: (1) an explicit message_thread_id the
+  // model passed, else (2) THIS turn's own originating topic
+  // (turn-pinned, #1664), else (3) the chat's last-seen topic
+  // (chatThreadMap). Preferring the turn's own thread over the chat
+  // last-seen heuristic fixes synthetic turns (subagent handback/progress,
+  // cron) — whose topic the model is never told and which never write
+  // chatThreadMap — and is strictly more correct under multi-topic
+  // concurrency (a reply lands in the topic the turn came from, not
+  // whichever topic most recently received a message). DM: both are
+  // undefined → unchanged.
+  let threadId = resolveThreadId(
+    chat_id,
+    (args.message_thread_id as string | undefined) ??
+      (turn?.sessionThreadId != null ? turn.sessionThreadId : undefined),
+  )
 
   if (reply_to == null && quoteOptIn && HISTORY_ENABLED) {
     try {
@@ -6202,6 +6237,16 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
   const turn = currentTurn
   if (!args.chat_id) throw new Error('stream_reply: chat_id is required')
   if (args.text == null || args.text === '') throw new Error('stream_reply: text is required and cannot be empty')
+  // Thread precedence (matches executeReply): when the model passes no
+  // explicit message_thread_id, fall back to THIS turn's originating
+  // topic before handleStreamReply's chatThreadMap last-seen heuristic.
+  // Injecting here threads every downstream consumer consistently — the
+  // dedup key, the voice-scrub metric, the draft transport, and the send
+  // — so a streamed handback/synthetic-turn reply lands in the right
+  // supergroup topic. DM: sessionThreadId undefined → unchanged.
+  if (args.message_thread_id == null && turn?.sessionThreadId != null) {
+    args.message_thread_id = String(turn.sessionThreadId)
+  }
 
   // Outbound secret scrub (#2044): mask before the dedup key, the draft
   // stream sends, and the history record. stream_reply carries the FULL
@@ -8130,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)
         }
       }
@@ -8171,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)
@@ -18631,6 +18679,7 @@ void (async () => {
                   })
                 }
 
+                const handbackOrigin = resolveSubagentOriginChat(agentId)
                 const decision = decideSubagentHandback({
                   handbackEnvValue: process.env.SWITCHROOM_SUBAGENT_HANDBACK,
                   outcome,
@@ -18639,11 +18688,18 @@ void (async () => {
                   // turn) back to the conversation the Task was dispatched
                   // from, so the result lands where the user asked — not the
                   // agent's DM. Falls back to fleetChatId/ownerChatId.
-                  fleetChatId: resolveSubagentOriginChat(agentId)?.chatId || fleetChatId,
+                  fleetChatId: handbackOrigin?.chatId || fleetChatId,
+                  // Supergroup topic the Task was dispatched from. Plumbed
+                  // through so the handback turn (and the model's in-voice
+                  // "here's what the worker found" reply) land in the
+                  // originating topic — not the chat's last-seen topic.
+                  // Applied only when the origin chat resolved (DM fallback
+                  // is topic-less).
+                  ...(handbackOrigin?.threadId != null
+                    ? { originThreadId: handbackOrigin.threadId }
+                    : {}),
                   // Owner-chat fallback: if the parent-turn chat can't be
-                  // resolved, route to the owner chat. Every switchroom fleet
-                  // agent is DM-shaped, so allowFrom[0] is the conversation
-                  // that dispatched.
+                  // resolved, route to the owner chat.
                   ownerChatId: loadAccess().allowFrom[0] ?? '',
                   taskDescription: description,
                   resultText,
@@ -18704,7 +18760,7 @@ void (async () => {
               // suppresses stale-after-restart delivery (a 4-h-old
               // "still working (5m)" would be a lie). Sweep on handback
               // lives in the `onFinish` block just above.
-              onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount }) => {
+              onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount, progressLine }) => {
                 let fleetChatId = ''
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? []
@@ -18744,7 +18800,15 @@ void (async () => {
                     nestingEnabled: foregroundNestingEnabled,
                     replyCalled: turn.replyCalled,
                   })) return
-                  const child = latestSummary.trim().slice(0, 120)
+                  // Prefer the tick's own display line: `progressLine` (a
+                  // friendly tool-step label) on tool ticks, else the
+                  // worker's narrative (`latestSummary`) on text ticks. This
+                  // lets a foreground sub-agent that runs tools without
+                  // emitting prose still nest its steps under the parent
+                  // feed (the foreground blindspot) — mirroring the
+                  // main-turn activity feed, which surfaces both tool labels
+                  // and prose.
+                  const child = (progressLine ?? latestSummary).trim().slice(0, 120)
                   if (child.length === 0) return
                   let narrative = turn.foregroundSubAgents.get(agentId)
                   if (narrative == null) {
@@ -18796,12 +18860,18 @@ void (async () => {
                   return
                 }
 
+                const progressOrigin = resolveSubagentOriginChat(agentId)
                 const decision = decideSubagentProgress({
                   disableEnvValue: process.env.SWITCHROOM_DISABLE_SUBAGENT_PROGRESS,
                   isBackground,
                   // Prefer the conversation the Task was dispatched from over
                   // the owner DM (see resolveSubagentOriginChat).
-                  fleetChatId: resolveSubagentOriginChat(agentId)?.chatId || fleetChatId,
+                  fleetChatId: progressOrigin?.chatId || fleetChatId,
+                  // Carry the dispatching topic so the progress wake lands in
+                  // it (applied only when the origin chat resolved).
+                  ...(progressOrigin?.threadId != null
+                    ? { originThreadId: progressOrigin.threadId }
+                    : {}),
                   ownerChatId: loadAccess().allowFrom[0] ?? '',
                   subagentJsonlId: agentId,
                   taskDescription: description,
@@ -18819,10 +18889,11 @@ void (async () => {
                 // model is about to compose an explicit in-voice
                 // progress line — letting the "— still working (Nm)"
                 // edit fire in parallel would double-surface the
-                // signal. Progress envelopes target the chat level
-                // (no thread id), matching how the inbound lands.
+                // signal. Key the clear on the topic the envelope lands
+                // in (origin thread) so the right lane is yielded in a
+                // supergroup; chat-level for DM-shaped agents.
                 pendingProgress.clearPending(
-                  statusKey(decision.chatId, undefined),
+                  statusKey(decision.chatId, progressOrigin?.threadId),
                   'progress',
                 )
                 process.stderr.write(