switchroom 0.13.57 → 0.13.59

package/telegram-plugin/gateway/gateway.ts

@@ -53,7 +53,12 @@ import { OutboundDedupCache } from '../recent-outbound-dedup.js'
 import { createInboundCoalescer, inboundCoalesceKey } from './inbound-coalesce.js'
 import { StatusReactionController } from '../status-reactions.js'
 import { isTelegramReplyTool, isTelegramSurfaceTool } from '../tool-names.js'
-import { deriveIntentSurface } from '../tool-intent-surface.js'
+import { allocateDraftId } from '../draft-transport.js'
+import {
+  makeEmptyActivityState,
+  registerAndRender,
+  type ActivityState,
+} from '../tool-activity-summary.js'
 import { toolLabel } from '../tool-labels.js'
 import { createTypingWrapper } from '../typing-wrap.js'
 import { type DraftStreamHandle } from '../draft-stream.js'
@@ -81,7 +86,6 @@ import { classifyInbound } from '../inbound-classifier.js'
 import * as silencePoke from '../silence-poke.js'
 import * as pendingProgress from '../pending-work-progress.js'
 import { writeSilentEndState, clearSilentEndState, recordUndeliveredTurnEnd } from '../silent-end.js'
-import { markAckSent, clearAckSent } from '../ack-flag.js'
 import { isFinalAnswerReply } from '../final-answer-detect.js'
 import { createAnswerStream, type AnswerStreamHandle } from '../answer-stream.js'
 import { type SessionEvent } from '../session-tail.js'
@@ -1292,15 +1296,39 @@ type CurrentTurn = {
   // Phase 1 of #332: count of tool_use events in the current turn, for
   // the tool_call_count column in the turns registry.
   toolCallCount: number
-  // Tool-intent surface (the human-feel UX follow-up to #1921's
-  // PreToolUse gate). When the model emits its first non-reply tool_use
-  // of a turn AND no outbound has happened yet, the gateway lifts the
-  // tool's already-formed intent (name + input → `toolLabel()`) into a
-  // user-visible "<i>running</i>: ls -la /var/log" message. One-shot
-  // per turn — subsequent tool_use events stay quiet so a multi-tool
-  // turn doesn't spam. The model never has to call reply just to ack;
-  // its own intent stream IS the ack source.
-  intentSurfaceFired: boolean
+  // Tool-activity summary — mirrors Claude Code's native chat-UI
+  // rendering ("Ran 5 commands, read a file"). Counters are
+  // incremented in `case 'tool_use'`; `activityMessageId` holds the
+  // Telegram message id we send/edit so a single message accumulates
+  // the summary in place. Stops updating once `replyCalled` flips —
+  // the model's own reply lands below the summary as the actual
+  // content.
+  //
+  // Parallel-tool-use coalescing (PR #1926 review): modern Claude
+  // emits multiple tool_uses in a tight synchronous loop (e.g. 3
+  // parallel Reads). Without coalescing, each would see
+  // `activityMessageId == null` and fire its own sendMessage,
+  // producing N messages instead of one editable summary. Pattern
+  // mirrors `telegram-plugin/answer-stream.ts`:
+  //   - `activityInFlight` — promise that resolves when the current
+  //     send/edit settles. While set, NEW tool_uses just update
+  //     `activityState` and `activityPendingRender` and return.
+  //   - When the in-flight resolves, it picks the latest
+  //     `activityPendingRender`, fires the next send/edit, and
+  //     repeats until the pending matches the last-sent.
+  // Result: at most one Telegram call in flight at a time; the
+  // final state always lands.
+  toolActivity: ActivityState
+  activityMessageId: number | null
+  // Draft-transport id when the activity summary is streamed via
+  // sendMessageDraft (DM-only, no thread). Each call to
+  // sendMessageDraft(chat, draftId, text) REPLACES the draft text —
+  // simpler than send+edit. Cleared by `clearActivitySummary` (which
+  // sends an empty draft) when the model's reply takes over.
+  activityDraftId: number | null
+  activityInFlight: Promise<void> | null
+  activityPendingRender: string | null
+  activityLastSentRender: string | null
   // Issue #195 — answer-lane streaming. Lazily created on the first text
   // event of a turn (once enough text has accumulated, the stream itself
   // gates on minInitialChars). Materialized and cleared at turn_end.
@@ -4955,16 +4983,6 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   // silence-poke clock so the next poke is measured from this send.
   signalTracker.noteOutbound(statusKey(chat_id, threadId), Date.now())
   silencePoke.noteOutbound(statusKey(chat_id, threadId), Date.now())
-  // Ack-first gate (`reference/conversational-pacing.md` beat 1):
-  // touch the state-dir flag so the ack-first-pretool hook lets
-  // subsequent non-reply tool calls through this turn. Cleared at
-  // turn_started. Best-effort — a write failure shouldn't break
-  // reply, and the hook is kill-switched anyway.
-  try {
-    markAckSent()
-  } catch (err) {
-    process.stderr.write(`telegram gateway: markAckSent failed: ${err}\n`)
-  }
   // #1741 — only clear silent-end state on a plausibly-final reply.
   // An interim ack (disable_notification:true, short text, no done)
   // must NOT clear the state file; otherwise a turn that ends with
@@ -5560,13 +5578,6 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
       const sKey = statusKey(streamChatId, streamThreadId)
       signalTracker.noteOutbound(sKey, Date.now())
       silencePoke.noteOutbound(sKey, Date.now())
-      // Ack-first gate: stream_reply's first emit also unlocks subsequent
-      // tool calls. See ack-flag.ts + ack-first-pretool.ts.
-      try {
-        markAckSent()
-      } catch (err) {
-        process.stderr.write(`telegram gateway: markAckSent (stream_reply) failed: ${err}\n`)
-      }
       // #1741 — see executeReply for the rationale: only a plausibly-
       // final stream_reply clears the silent-end state. An interim
       // ack via stream_reply must NOT clear; the Stop hook needs
@@ -6777,6 +6788,120 @@ function closeProgressLane(chatId: string, threadId: number | undefined): void {
   }
 }
 
+/**
+ * Drain the tool-activity summary's pending render queue. Single-flight
+ * by construction (caller assigns the returned promise to
+ * `turn.activityInFlight`; while set, new tool_uses only update
+ * `turn.activityPendingRender` and return).
+ *
+ * Transport priority (mirrors the existing answer-stream pattern):
+ *
+ *   1. DM with no thread AND sendMessageDraft API available →
+ *      DRAFT TRANSPORT. Each call REPLACES the draft text (no
+ *      edit-in-place needed); the user sees a live preview in their
+ *      Telegram compose area as the agent works. When the model's
+ *      reply tool lands, `clearActivitySummary` sends an empty draft
+ *      to wipe it — only the real reply persists.
+ *
+ *   2. Anything else (forum topic, draft API absent) → fall through
+ *      to sendMessage + editMessageText. The activity message is a
+ *      real chat message; `clearActivitySummary` deletes it when the
+ *      reply tool takes over.
+ *
+ * The drain holds a reference to `turn`, so a turn-swap mid-drain
+ * doesn't corrupt the next turn's atom — late writes land on the
+ * captured `turn` (already-completed turn, harmless).
+ */
+async function drainActivitySummary(turn: CurrentTurn): Promise<void> {
+  try {
+    while (turn.activityPendingRender !== turn.activityLastSentRender) {
+      const target = turn.activityPendingRender
+      if (target == null) break
+      const html = `<i>${target}</i>`
+      const chat = turn.sessionChatId
+      const thread = turn.sessionThreadId
+      // sendMessageDraft doesn't support forum threads.
+      const useDraft = turn.isDm && thread == null && sendMessageDraftFn != null
+      try {
+        if (useDraft) {
+          if (turn.activityDraftId == null) {
+            turn.activityDraftId = allocateDraftId()
+          }
+          const draftId = turn.activityDraftId
+          await sendMessageDraftFn!(chat, draftId, html, undefined)
+        } else if (turn.activityMessageId == null) {
+          const sent = await robustApiCall(
+            () => bot.api.sendMessage(chat, html, {
+              ...(thread != null ? { message_thread_id: thread } : {}),
+              parse_mode: 'HTML',
+              disable_notification: true,
+            }),
+            { chat_id: chat, ...(thread != null ? { threadId: thread } : {}), verb: 'activity-summary.send' },
+          )
+          turn.activityMessageId = sent.message_id
+        } else {
+          const id = turn.activityMessageId
+          await robustApiCall(
+            () => bot.api.editMessageText(chat, id, html, { parse_mode: 'HTML' }),
+            { chat_id: chat, ...(thread != null ? { threadId: thread } : {}), verb: 'activity-summary.edit' },
+          )
+        }
+        turn.activityLastSentRender = target
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        if (!msg.includes('message is not modified')) {
+          process.stderr.write(`telegram gateway: activity-summary drain failed: ${msg}\n`)
+        }
+        // Mark as sent so we don't infinite-loop on a stuck render.
+        turn.activityLastSentRender = target
+      }
+    }
+  } finally {
+    turn.activityInFlight = null
+  }
+}
+
+/**
+ * Clear the activity summary when the model's reply tool takes over
+ * as the authoritative surface. Awaits any in-flight render so we
+ * don't race a stale write against the clear, then either sends an
+ * empty draft (clears the compose-area preview) or deletes the
+ * persisted message. Idempotent + best-effort — failure stderr-logs
+ * but does not block.
+ *
+ * Called from `case 'tool_use'` the moment we see a Telegram reply
+ * tool fire, so the user sees the real reply land in the same beat
+ * the summary disappears.
+ */
+function clearActivitySummary(turn: CurrentTurn): void {
+  const chat = turn.sessionChatId
+  const thread = turn.sessionThreadId
+  const inFlight = turn.activityInFlight ?? Promise.resolve()
+  void inFlight.then(async () => {
+    if (turn.activityDraftId != null && sendMessageDraftFn != null) {
+      const draftId = turn.activityDraftId
+      turn.activityDraftId = null
+      try {
+        // Empty text → Telegram clears the draft.
+        await sendMessageDraftFn(chat, draftId, '', undefined)
+      } catch (err) {
+        process.stderr.write(`telegram gateway: activity-summary draft-clear failed: ${err}\n`)
+      }
+    } else if (turn.activityMessageId != null) {
+      const id = turn.activityMessageId
+      turn.activityMessageId = null
+      try {
+        await robustApiCall(
+          () => bot.api.deleteMessage(chat, id),
+          { chat_id: chat, ...(thread != null ? { threadId: thread } : {}), verb: 'activity-summary.delete' },
+        )
+      } catch (err) {
+        process.stderr.write(`telegram gateway: activity-summary delete failed: ${err}\n`)
+      }
+    }
+  })
+}
+
 function handleSessionEvent(ev: SessionEvent): void {
   switch (ev.kind) {
     case 'enqueue': {
@@ -6801,14 +6926,6 @@ function handleSessionEvent(ev: SessionEvent): void {
           statusKey(ev.chatId, enqThreadId),
           'handback',
         )
-        // Ack-first gate (`reference/conversational-pacing.md` beat 1):
-        // wipe the prior turn's `ack-sent.flag` so the ack-first-
-        // pretool hook re-arms for this fresh turn. Centralised HERE
-        // (not in handleInbound) because `enqueue` is the single
-        // canonical fresh-turn atom — fires for real inbounds, cron
-        // fires, subagent-handback channel wakes, vault-grant resumes,
-        // and restart markers alike. Best-effort — see ack-flag.ts.
-        clearAckSent()
       }
       if (ev.chatId) {
         // Issue #195: if a previous turn left an answer-lane stream open
@@ -6842,7 +6959,12 @@ function handleSessionEvent(ev: SessionEvent): void {
           lastAssistantMsgId: null,
           lastAssistantDone: false,
           toolCallCount: 0,
-          intentSurfaceFired: false,
+          toolActivity: makeEmptyActivityState(),
+          activityMessageId: null,
+          activityDraftId: null,
+          activityInFlight: null,
+          activityPendingRender: null,
+          activityLastSentRender: null,
           answerStream: null,
           isDm: isDmChatId(ev.chatId),
         }
@@ -6954,70 +7076,47 @@ 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. Clear the activity summary — for drafts, send an
+        // empty draft to wipe the compose-area preview; for persisted
+        // messages, delete. The user sees the real reply land in the
+        // same beat the summary disappears.
+        if (wasFirstReply) {
+          clearActivitySummary(turn)
+        }
       }
       // Tool-intent surface — companion to the PreToolUse ack-first gate
       // (#1921). On the FIRST non-reply tool_use of a turn AND only when
-      // no outbound has happened yet, the gateway lifts the model's tool
-      // intent (name + input → `toolLabel()`) into a brief framework-voice
-      // status: `<i>running:</i> ls -la /var/log`. The model never has to
-      // call reply just to ack — its own intent stream IS the ack. The
-      // gate continues to fire IN PARALLEL: if it produces a model-voice
-      // ack first (`replyCalled=true`), the surface stays quiet by the
-      // condition below. One-shot per turn.
-      if (
-        !turn.replyCalled
-        && !turn.intentSurfaceFired
-        && !isTelegramSurfaceTool(name)
-      ) {
-        turn.intentSurfaceFired = true
-        // `ev.input` is the canonical SessionEvent property
-        // (`telegram-plugin/session-tail.ts:95`). All other tool_use
-        // sites in this file use `ev.input` — keep that consistent.
-        const surface = deriveIntentSurface(name, ev.input, ev.precomputedLabel)
-        if (surface.text != null) {
-          // Mark the ack-flag synchronously BEFORE the async send so a
-          // PreToolUse ack-first hook (#1921) firing concurrently for this
-          // same tool call sees the flag already present and allows the
-          // tool through. The Telegram send is fire-and-forget; failure
-          // is logged but does not block the model.
-          try {
-            markAckSent()
-          } catch (err) {
-            process.stderr.write(`telegram gateway: intent-surface markAckSent failed: ${err}\n`)
+      // Tool-activity summary — same shape Claude Code natively renders
+      // in its CLI/chat UI ("Ran 5 commands, read a file"). The gateway
+      // accumulates non-reply tool_use events into `turn.toolActivity`
+      // and sends ONE Telegram message that edits in place as more tools
+      // land. Stops editing once the model calls `reply` — the summary
+      // line stays as the final state. No model-side prompting; no per-
+      // tool labels. Just surface what's already in the stream.
+      //
+      // Single-flight coalescing (PR #1926 review): modern Claude emits
+      // multiple tool_uses in a synchronous burst (parallel Reads,
+      // Bashes, etc.). All would otherwise race past the message-id
+      // capture and produce N messages. Pattern mirrors answer-stream:
+      // update `activityPendingRender` synchronously here; a single
+      // worker promise drains the pending state, sending or editing
+      // exactly once at a time and re-running until pending matches
+      // the last-sent. Captures `turn` so a late drain after turn-swap
+      // can't corrupt the next turn's atom.
+      if (!turn.replyCalled && !isTelegramSurfaceTool(name)) {
+        const rendered = registerAndRender(turn.toolActivity, name)
+        if (rendered != null) {
+          turn.activityPendingRender = rendered
+          if (turn.activityInFlight == null) {
+            turn.activityInFlight = drainActivitySummary(turn)
           }
-          const surfaceChat = turn.sessionChatId
-          const surfaceThread = turn.sessionThreadId
-          const surfaceText = surface.text
-          void (async () => {
-            try {
-              await robustApiCall(
-                () => bot.api.sendMessage(surfaceChat, surfaceText, {
-                  ...(surfaceThread != null ? { message_thread_id: surfaceThread } : {}),
-                  parse_mode: 'HTML',
-                  // Framework-narrating beat — silent, ambient, not a
-                  // device buzz. The user is meant to glance and know
-                  // the model is alive + on-task.
-                  disable_notification: true,
-                }),
-                { chat_id: surfaceChat, ...(surfaceThread != null ? { threadId: surfaceThread } : {}), verb: 'intent-surface' },
-              )
-              // Deliberately NOT calling signalTracker.noteOutbound /
-              // silencePoke.noteOutbound here — framework-owned
-              // ambient messages are not model-author outbounds, so
-              // they should not reset the TTFO clock or short-circuit
-              // the silence-poke ladder. Mirrors the sibling
-              // `onAwarenessPing` handler (silence-poke.ts:169
-              // contract: "Caller must NOT call back into noteOutbound
-              // for this — it's a framework-sourced message").
-            } catch (err) {
-              process.stderr.write(`telegram gateway: intent-surface send failed: ${err}\n`)
-            }
-          })()
         }
       }
       if (!ctrl) return

package/telegram-plugin/tests/tool-activity-summary.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect } from "vitest";
+import {
+  makeEmptyActivityState,
+  register,
+  formatSummary,
+  registerAndRender,
+  verbForTool,
+} from "../tool-activity-summary.js";
+
+describe("verbForTool — tool name → past-tense verb", () => {
+  it("maps standard CLI tools to readable verbs", () => {
+    expect(verbForTool("Read")).toBe("read");
+    expect(verbForTool("Write")).toBe("created");
+    expect(verbForTool("Edit")).toBe("edited");
+    expect(verbForTool("MultiEdit")).toBe("edited");
+    expect(verbForTool("NotebookEdit")).toBe("edited");
+    expect(verbForTool("Bash")).toBe("ran");
+    expect(verbForTool("BashOutput")).toBe("ran");
+    expect(verbForTool("WebSearch")).toBe("searched");
+    expect(verbForTool("Grep")).toBe("searched");
+    expect(verbForTool("Glob")).toBe("searched");
+    expect(verbForTool("WebFetch")).toBe("fetched");
+    expect(verbForTool("Task")).toBe("dispatched");
+    expect(verbForTool("Agent")).toBe("dispatched");
+    expect(verbForTool("TodoWrite")).toBe("noted");
+  });
+
+  it("skips user-facing switchroom-telegram tools (those ARE the surface)", () => {
+    expect(verbForTool("mcp__switchroom-telegram__reply")).toBeNull();
+    expect(verbForTool("mcp__switchroom-telegram__stream_reply")).toBeNull();
+    expect(verbForTool("mcp__switchroom-telegram__edit_message")).toBeNull();
+    expect(verbForTool("mcp__switchroom-telegram__react")).toBeNull();
+  });
+
+  it("returns 'used' for unknown / non-switchroom MCP tools", () => {
+    expect(verbForTool("mcp__google-workspace__list_files")).toBe("used");
+    expect(verbForTool("mcp__notion__query_database")).toBe("used");
+    expect(verbForTool("SomeFutureUnknownTool")).toBe("used");
+  });
+
+  it("returns null for empty toolName (defensive)", () => {
+    expect(verbForTool("")).toBeNull();
+  });
+});
+
+describe("register + formatSummary — Claude Code-style summary", () => {
+  it("formats a single Read as 'Read a file'", () => {
+    const s = makeEmptyActivityState();
+    register(s, "Read");
+    expect(formatSummary(s)).toBe("Read a file");
+  });
+
+  it("formats multiple Reads as 'Read N files'", () => {
+    const s = makeEmptyActivityState();
+    register(s, "Read");
+    register(s, "Read");
+    register(s, "Read");
+    expect(formatSummary(s)).toBe("Read 3 files");
+  });
+
+  it("formats single Bash as 'Ran a command'", () => {
+    const s = makeEmptyActivityState();
+    register(s, "Bash");
+    expect(formatSummary(s)).toBe("Ran a command");
+  });
+
+  it("formats multiple Bash as 'Ran N commands'", () => {
+    const s = makeEmptyActivityState();
+    for (let i = 0; i < 5; i++) register(s, "Bash");
+    expect(formatSummary(s)).toBe("Ran 5 commands");
+  });
+
+  it("joins multiple verb-classes with commas (first-occurrence order)", () => {
+    const s = makeEmptyActivityState();
+    // Tools fire in this order: Read → Bash → Edit
+    register(s, "Read");
+    register(s, "Bash");
+    register(s, "Edit");
+    // The summary renders chronologically: read, ran, edited.
+    expect(formatSummary(s)).toBe("Read a file, ran a command, edited a file");
+  });
+
+  it("matches the Claude Code screenshot examples", () => {
+    // "Ran 5 commands, read a file"
+    const s1 = makeEmptyActivityState();
+    for (let i = 0; i < 5; i++) register(s1, "Bash");
+    register(s1, "Read");
+    expect(formatSummary(s1)).toBe("Ran 5 commands, read a file");
+
+    // "Edited a file, read a file, ran a command"
+    const s2 = makeEmptyActivityState();
+    register(s2, "Edit");
+    register(s2, "Read");
+    register(s2, "Bash");
+    expect(formatSummary(s2)).toBe("Edited a file, read a file, ran a command");
+
+    // "Created a file, ran a command"
+    const s3 = makeEmptyActivityState();
+    register(s3, "Write");
+    register(s3, "Bash");
+    expect(formatSummary(s3)).toBe("Created a file, ran a command");
+  });
+
+  it("returns null when state is empty", () => {
+    expect(formatSummary(makeEmptyActivityState())).toBeNull();
+  });
+
+  it("ignores user-facing tools (reply/stream_reply etc.)", () => {
+    const s = makeEmptyActivityState();
+    register(s, "mcp__switchroom-telegram__reply");
+    register(s, "mcp__switchroom-telegram__stream_reply");
+    expect(formatSummary(s)).toBeNull(); // nothing tracked
+  });
+
+  it("includes generic 'used' for unknown MCP tools", () => {
+    const s = makeEmptyActivityState();
+    register(s, "mcp__google-workspace__list_files");
+    expect(formatSummary(s)).toBe("Used a tool");
+    register(s, "mcp__google-workspace__create_file");
+    expect(formatSummary(s)).toBe("Used 2 tools");
+  });
+
+  it("tracks firstToolName for forensic / telemetry use", () => {
+    const s = makeEmptyActivityState();
+    register(s, "Read");
+    register(s, "Bash");
+    expect(s.firstToolName).toBe("Read");
+  });
+});
+
+describe("parallel-tool-use coalescing — render only reflects accumulated state", () => {
+  it("synchronous burst of N tool_uses produces the right summary at each step", () => {
+    // Modern Claude emits parallel tool_uses in a tight sync loop. The
+    // gateway calls register() N times before any async drain runs.
+    // After N registers, the rendered string should reflect ALL of them
+    // — so when the drain fires once with the latest pendingRender, the
+    // sent text is correct and complete.
+    const s = makeEmptyActivityState();
+    register(s, "Read");
+    register(s, "Read");
+    register(s, "Read");
+    register(s, "Bash");
+    register(s, "Bash");
+    expect(formatSummary(s)).toBe("Read 3 files, ran 2 commands");
+  });
+
+  it("ordering is preserved across a chronological burst", () => {
+    const s = makeEmptyActivityState();
+    // Simulates: Bash, then Read, then Bash, then Read, then Edit
+    register(s, "Bash");
+    register(s, "Read");
+    register(s, "Bash");
+    register(s, "Read");
+    register(s, "Edit");
+    // Bash was first, then Read, then Edit. Counts: bash 2, read 2, edit 1.
+    expect(formatSummary(s)).toBe(
+      "Ran 2 commands, read 2 files, edited a file",
+    );
+  });
+
+  it("registerAndRender returns null on user-facing tools (no race contribution)", () => {
+    const s = makeEmptyActivityState();
+    register(s, "Read");
+    // A reply tool fires concurrently — should not enter the activity state.
+    expect(
+      registerAndRender(s, "mcp__switchroom-telegram__reply"),
+    ).toBeNull();
+    // State still reflects only the Read.
+    expect(formatSummary(s)).toBe("Read a file");
+  });
+});
+
+describe("registerAndRender — ergonomic full-pipeline call", () => {
+  it("returns the updated rendered text on a real tool (chronological)", () => {
+    const s = makeEmptyActivityState();
+    expect(registerAndRender(s, "Read")).toBe("Read a file");
+    // Bash fires AFTER Read — chronological order shows read first.
+    expect(registerAndRender(s, "Bash")).toBe(
+      "Read a file, ran a command",
+    );
+  });
+
+  it("returns null on a surface tool (no-op)", () => {
+    const s = makeEmptyActivityState();
+    expect(
+      registerAndRender(s, "mcp__switchroom-telegram__reply"),
+    ).toBeNull();
+    // State unchanged
+    expect(s.firstToolName).toBeNull();
+  });
+});