switchroom 0.15.45 → 0.16.5

package/telegram-plugin/silence-poke.ts

@@ -48,6 +48,12 @@
  * pacing prompt + draft still apply; only the framework safety net is off.
  */
 
+import {
+  decideMidTurnFloor,
+  midTurnFloorEnabled,
+  type LoopRole,
+} from './turn-liveness-floor.js'
+
 /** #1292: snapshot of an in-flight tool call, surfaced in the 300s
  * framework-fallback message so the user sees the actual observable
  * ("running Grep \"foo\" for 4m") instead of the dishonest generic
@@ -73,6 +79,10 @@ export interface SilencePokeState {
   lastThinkingAt: number | null
   /** True once the 300s framework fallback has fired this turn. */
   fallbackFired: boolean
+  /** #2527: true once the mid-turn liveness floor has fired this turn.
+   *  Independent of `fallbackFired` — the floor is the early (45s) quiet
+   *  beat, the fallback the late (300s) loud unwedge. Fire-once each. */
+  floorFired: boolean
   /** #1292: in-flight tool calls keyed by toolUseId. Populated by
    * `noteToolStart` on every parent-agent `tool_use` event the gateway
    * sees and drained by `noteToolEnd` on the matching `tool_result`.
@@ -99,6 +109,14 @@ export interface ThresholdsMs {
    * defer is on; defaults to no ceiling (Infinity) when omitted.
    */
   fallbackHardCeiling?: number
+  /**
+   * #2527 — mid-turn liveness floor threshold. After this much busy-silence
+   * on a `user` turn that hasn't delivered a substantive answer, the floor
+   * fires ONE quiet (no-ping) interim so the user isn't left staring at the
+   * ambient 👀. Strictly below `fallback` (which owns the beat above it).
+   * Omitted (undefined) disables the floor entirely.
+   */
+  floor?: number
 }
 
 export const DEFAULT_THRESHOLDS: ThresholdsMs = {
@@ -127,8 +145,26 @@ export interface FrameworkFallbackContext {
   inFlightTools: ToolSnapshot[]
 }
 
+/**
+ * #2527 — context handed to the gateway when the mid-turn floor fires. The
+ * gateway formats the honest text (from `inFlightTools`) and sends it through
+ * the SAME path a model reply takes — no parallel send. Mirrors
+ * `FrameworkFallbackContext` minus the wedge semantics: the floor never
+ * unwedges the turn, it just speaks.
+ */
+export interface MidTurnFloorContext {
+  key: string
+  chatId: string
+  threadId: number | null
+  silenceMs: number
+  inFlightTools: ToolSnapshot[]
+  /** True when fired by a user "Status?" mid-turn inbound rather than the timer. */
+  forced: boolean
+}
+
 export type SilencePokeMetric =
   | { kind: 'silence_fallback_sent'; key: string; fallback_kind: 'working' | 'thinking'; silence_ms: number }
+  | { kind: 'mid_turn_floor'; key: string; silence_ms: number; forced: boolean; decision: 'fire' | string }
 
 export interface SilencePokeDeps {
   /** Called when the 300s fallback fires. Caller sends the user-visible
@@ -141,20 +177,40 @@ export interface SilencePokeDeps {
   /** Poll interval (tests). */
   pollIntervalMs?: number
   /**
-   * Fix A — when true, the 300s framework fallback is DEFERRED while a parent
-   * tool is genuinely in flight (`inFlightTools` non-empty): the agent is
-   * demonstrably working, and since #2162 the live activity feed shows that
-   * work, so nulling `currentTurn` (which the fallback does) would darken a feed
-   * the user is actively watching. The defer is bounded by
-   * `thresholdsMs.fallbackHardCeiling` so a hung-mid-tool turn still unwedges; a
-   * turn with NO in-flight tool fires at the base threshold exactly as before.
-   * Default false (legacy behaviour) — enable per-agent to canary.
+   * Feed-survival predicate callback. When provided, the 300s framework
+   * fallback is DEFERRED while this function returns true: the agent is
+   * demonstrably working (in-flight tool, detached background process, or a
+   * human-wait tool like ask_user), and since #2162 the live activity feed
+   * shows that work, so nulling `currentTurn` would darken a feed the user is
+   * actively watching. The defer is bounded by `thresholdsMs.fallbackHardCeiling`
+   * so a hung-or-missing-work-signal turn still unwedges eventually.
    *
-   * A crashed agent is recovered independently by the bridge-disconnect sweep
-   * (`onDanglingTurnsSwept`), so deferring here does not reintroduce the #1556
-   * dangling-turn wedge for the crash case.
+   * This supersedes `deferFallbackWhileToolInFlight`. When present it is ALWAYS
+   * consulted (no extra env flag required). Set SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS=0
+   * in the environment to force-disable the defer even when this callback is wired.
+   */
+  isLegitimatelyWorking?: (key: string) => boolean
+  /**
+   * Legacy boolean flag — honoured when `isLegitimatelyWorking` is absent.
+   * When true, the 300s fallback is deferred while `inFlightTools` is non-empty,
+   * bounded by `thresholdsMs.fallbackHardCeiling`.
+   * @deprecated Prefer `isLegitimatelyWorking` which covers detached work and
+   * human-wait tools in addition to foreground in-flight tool calls.
    */
   deferFallbackWhileToolInFlight?: boolean
+  /**
+   * #2527 — called when the mid-turn liveness floor fires. The gateway sends
+   * the honest "still on it" interim through the shared reply path. Optional:
+   * when absent the floor never fires (back-compat for test harnesses).
+   */
+  onMidTurnFloor?: (ctx: MidTurnFloorContext) => Promise<void> | void
+  /**
+   * #2527 — the gateway-owned half of the floor decision: the turn's loop
+   * role and whether a substantive answer has already landed. silence-poke
+   * owns the timing/working/fire-once half; the pure `decideMidTurnFloor`
+   * combines both. Returns null when there is no live turn for `key`.
+   */
+  floorState?: (key: string) => { role: LoopRole; finalAnswerDelivered: boolean } | null
 }
 
 const state = new Map<string, SilencePokeState>()
@@ -180,6 +236,7 @@ export function startTurn(key: string, now: number): void {
     lastOutboundAt: null,
     lastThinkingAt: null,
     fallbackFired: false,
+    floorFired: false,
     inFlightTools: new Map(),
   })
 }
@@ -409,6 +466,76 @@ function truncateLabel(label: string): string {
   return label.slice(0, MAX - 1) + '…'
 }
 
+/** Snapshot in-flight tools sorted longest-running first — for the honest
+ *  floor/fallback message body. */
+function snapshotInFlight(s: SilencePokeState, now: number): ToolSnapshot[] {
+  return Array.from(s.inFlightTools.values())
+    .sort((a, b) => a.startedAt - b.startedAt)
+    .map((t) => ({ name: t.name, label: t.label, durationMs: now - t.startedAt }))
+}
+
+/**
+ * #2527 — evaluate and (if eligible) fire the mid-turn liveness floor for one
+ * turn. silence-poke owns the timing/working/fire-once half; the gateway
+ * provides the role + delivery half via `floorState`; the pure
+ * `decideMidTurnFloor` combines them so the policy lives in one tested place.
+ * `forced=true` is a user "Status?" poke (bypasses timing + working).
+ */
+function tryMidTurnFloor(key: string, s: SilencePokeState, now: number, forced: boolean): void {
+  if (activeDeps == null) return
+  const { onMidTurnFloor, floorState, isLegitimatelyWorking } = activeDeps
+  if (onMidTurnFloor == null || floorState == null) return
+  const thresholds = activeDeps.thresholdsMs ?? DEFAULT_THRESHOLDS
+  if (thresholds.floor == null) return
+  const fs = floorState(key)
+  if (fs == null) return
+  const silence = now - (s.lastOutboundAt ?? s.turnStartedAt)
+  if (silence < 0) return
+  const decision = decideMidTurnFloor({
+    enabled: midTurnFloorEnabled(),
+    role: fs.role,
+    finalAnswerDelivered: fs.finalAnswerDelivered,
+    silenceMs: silence,
+    floorThresholdMs: thresholds.floor,
+    fallbackThresholdMs: thresholds.fallback,
+    legitimatelyWorking: isLegitimatelyWorking?.(key) ?? false,
+    alreadyFired: s.floorFired,
+    force: forced,
+  })
+  if (decision.kind !== 'fire') {
+    // Per-tick skips are noise; only surface a declined FORCED poke (the
+    // user asked "Status?" and we chose not to speak — worth seeing).
+    if (forced) {
+      activeDeps.emitMetric({ kind: 'mid_turn_floor', key, silence_ms: silence, forced, decision: decision.reason })
+    }
+    return
+  }
+  s.floorFired = true
+  activeDeps.emitMetric({ kind: 'mid_turn_floor', key, silence_ms: silence, forced, decision: 'fire' })
+  const { chatId, threadId } = parseKey(key)
+  try {
+    const r = onMidTurnFloor({ key, chatId, threadId, silenceMs: silence, inFlightTools: snapshotInFlight(s, now), forced })
+    if (r != null && typeof (r as Promise<void>).catch === 'function') {
+      ;(r as Promise<void>).catch((err) => {
+        process.stderr.write(`silence-poke: mid-turn floor handler rejected: ${err}\n`)
+      })
+    }
+  } catch (err) {
+    process.stderr.write(`silence-poke: mid-turn floor handler threw: ${err}\n`)
+  }
+}
+
+/**
+ * #2527 — fire the mid-turn floor immediately for `key` (a user "Status?"
+ * mid-turn inbound landed during a silent stretch). No-op if there is no
+ * live turn for the key or the floor is ineligible/already-fired.
+ */
+export function pokeFloorNow(key: string, now: number): void {
+  const s = state.get(key)
+  if (s == null) return
+  tryMidTurnFloor(key, s, now, true)
+}
+
 /**
  * Internal tick — iterates active states and fires the 300s framework
  * fallback (which the gateway turns into a user-visible message + an
@@ -423,20 +550,39 @@ function tick(now: number): void {
     const silence = now - zeroAt
     if (silence < 0) continue
 
+    // #2527 — the early, quiet mid-turn liveness beat (below the fallback
+    // window). Evaluated every tick; fires at most once per turn.
+    tryMidTurnFloor(key, s, now, false)
+
     if (!s.fallbackFired && silence >= thresholds.fallback) {
-      // Fix A: defer the unwedge while a parent tool is genuinely in flight —
-      // the agent is demonstrably working and the live activity feed is showing
-      // it, so firing here (which nulls currentTurn) would darken that feed
-      // mid-work. Bounded by the hard ceiling so a hung-mid-tool turn still
-      // unwedges. `continue` WITHOUT setting fallbackFired so the next tick
-      // re-checks — once the tool ends and the turn stays silent past the base
-      // threshold, or the ceiling is crossed, it fires normally.
-      if (
-        activeDeps.deferFallbackWhileToolInFlight === true &&
-        s.inFlightTools.size > 0 &&
-        silence < (thresholds.fallbackHardCeiling ?? Number.POSITIVE_INFINITY)
-      ) {
-        continue
+      // Feed-survival defer: hold back the unwedge while the agent is
+      // demonstrably working — an in-flight tool, a detached background process,
+      // or a human-wait tool (ask_user). Since #2162 the live activity feed
+      // renders that work, so nulling currentTurn would darken a feed the user
+      // is actively watching. Bounded by fallbackHardCeiling so a
+      // hung-or-leaked-signal turn still unwedges eventually.
+      //
+      // Two defer paths (tried in priority order):
+      //   1. `isLegitimatelyWorking(key)` — new single source of truth covering
+      //      foreground in-flight tools, detached background work, and human-wait
+      //      tools. Active by default when the callback is wired; force-disabled
+      //      by SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS=0.
+      //   2. Legacy `deferFallbackWhileToolInFlight` boolean — covers only
+      //      `inFlightTools.size > 0`; kept for test fixtures that set it
+      //      directly without wiring the callback.
+      //
+      // In both cases: `continue` WITHOUT setting fallbackFired so the next
+      // tick re-checks. Once the work signal clears and the turn stays silent
+      // past the base threshold, or the ceiling is crossed, the fallback fires.
+      const ceiling = thresholds.fallbackHardCeiling ?? Number.POSITIVE_INFINITY
+      const underCeiling = silence < ceiling
+      if (underCeiling) {
+        const forceDisable = process.env.SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS === '0'
+        if (!forceDisable && activeDeps.isLegitimatelyWorking != null) {
+          if (activeDeps.isLegitimatelyWorking(key)) continue
+        } else if (!forceDisable && activeDeps.deferFallbackWhileToolInFlight === true && s.inFlightTools.size > 0) {
+          continue
+        }
       }
       s.fallbackFired = true
       const { chatId, threadId } = parseKey(key)

package/telegram-plugin/slot-banner-driver.ts

@@ -110,6 +110,9 @@ export async function refreshBanner(
       sent = await args.bot.api.sendMessage(args.ownerChatId, action.text, {
         parse_mode: 'HTML',
         link_preview_options: { is_disabled: true },
+        // OAuth slot banner is a status notice — silence the open ping.
+        // (the pin below is already silent; the edit path doesn't ping.)
+        disable_notification: true,
       });
     } catch (err) {
       args.onError?.('pin', err);

package/telegram-plugin/status-no-truncate.ts

@@ -0,0 +1,44 @@
+/**
+ * Status-card shared constants.
+ *
+ * Both status surfaces — the main-session agent activity card
+ * (`tool-activity-summary.ts`) and the background-worker activity feed
+ * (`worker-activity-feed.ts`) — render through the single
+ * `renderStatusCard` primitive in `tool-activity-summary.ts`. This module
+ * holds the tuning constants that primitive (and its internal helpers)
+ * read, so a forked renderer never re-derives them.
+ *
+ * The former `SWITCHROOM_STATUS_NO_TRUNCATE` feature flag was retired:
+ * rolling-window-with-char-budget is now the only behaviour. The per-line
+ * cap (`STATUS_LINE_MAX`) and rolling window (`STATUS_ROLLING_LINES`) apply
+ * universally on BOTH surfaces; the total char budget
+ * (`STATUS_CARD_CHAR_BUDGET`) is the wire-limit backstop.
+ */
+
+/**
+ * Number of trailing narrative/step lines shown in the rolling window.
+ * The feed is a fixed-height rolling window: oldest drops off as new arrive.
+ * Overflow surfaces a `+N earlier…` header on BOTH surfaces.
+ */
+export const STATUS_ROLLING_LINES = 5
+
+/**
+ * Per-line character cap, applied to every step + child step on BOTH
+ * surfaces before HTML-escaping (clip raw → escape last). A line longer
+ * than this is truncated with a trailing `…`.
+ */
+export const STATUS_LINE_MAX = 200
+
+/**
+ * The safe char budget for a rendered Telegram status card. Telegram's hard
+ * cap is 4096; we use 4000 to leave 96 chars of headroom for HTML framing,
+ * emoji, and escape expansion — matching the convention in
+ * pending-work-progress.ts (TELEGRAM_MSG_CAP = 4000).
+ *
+ * With STATUS_ROLLING_LINES=5 lines each ≤ STATUS_LINE_MAX this backstop
+ * effectively never fires in practice, but is kept as a wire-limit safety net.
+ */
+export const STATUS_CARD_CHAR_BUDGET = 4000
+
+/** Indent marker for a nested (foreground sub-agent) step line. */
+export const NESTED_PREFIX = '   ↳ '

package/telegram-plugin/status-reactions.ts

@@ -55,6 +55,7 @@ export type ReactionState =
   | 'compacting'
   | 'awaiting'
   | 'done'
+  | 'undelivered'
   | 'error'
   | 'stallSoft'
   | 'stallHard'
@@ -80,7 +81,11 @@ export const REACTION_VARIANTS: Record<ReactionState, string[]> = {
   web:       ['⚡', '🤔', '👌'],      // WORKING: lookup in motion
   compacting:['✍', '🤔', '👀'],
   awaiting:  ['🙏', '🤔', '👀'],      // BLOCKED ON HUMAN: parked on a permission card
-  done:      ['👍', '💯', '🎉'],      // FINISHED: turn_end fired
+  done:      ['👍', '💯', '🎉'],      // FINISHED: turn_end delivered an answer
+  // #2527 — FINISHED but the user turn produced NO answer. A gentle,
+  // non-celebratory terminal so the ambient signal never reads as "done"
+  // over an undelivered turn. The silent-end fallback text carries the why.
+  undelivered:['😐', '🤷', '🤔'],
   error:     ['😱', '😨', '🤯'],      // NON-TERMINAL — recovery allowed
   stallSoft: ['🥱', '😴', '🤔'],
   stallHard: ['😨', '🤯', '😱'],
@@ -103,7 +108,7 @@ export function resolveToolReactionState(toolName: string): ReactionState {
 }
 
 /** Reason passed to `finalize()` — selects the terminal emoji.  */
-export type FinalizeReason = 'done' | 'error'
+export type FinalizeReason = 'done' | 'undelivered' | 'error'
 
 /** Configuration knobs the controller respects. */
 export interface StatusReactionConfig {
@@ -115,6 +120,14 @@ export interface StatusReactionConfig {
   stallHardMs?: number
   /** Optional logger for debugging — receives a single string per event. */
   log?: (msg: string) => void
+  /**
+   * Optional structured callback fired on every emoji transition (after the
+   * API call succeeds). Used by the gateway to emit `status_reaction_transition`
+   * streaming-metrics events for #2527 observability. Kept out of the main
+   * `log` callback so callers that only want the human-readable log string
+   * don't need to parse it.
+   */
+  onTransition?: (emoji: string) => void
 }
 
 /**
@@ -152,6 +165,7 @@ export class StatusReactionController {
   private readonly stallSoftMs: number
   private readonly stallHardMs: number
   private readonly log?: (msg: string) => void
+  private readonly onTransition?: (emoji: string) => void
 
   constructor(
     private readonly emit: ReactionEmitter,
@@ -163,6 +177,7 @@ export class StatusReactionController {
     this.stallSoftMs = config.stallSoftMs ?? 30000
     this.stallHardMs = config.stallHardMs ?? 90000
     this.log = config.log
+    this.onTransition = config.onTransition
   }
 
   /** 👀 — message received and queued for processing. Bypasses debounce. */
@@ -222,7 +237,8 @@ export class StatusReactionController {
    * lands promptly. Subsequent calls are no-ops.
    */
   finalize(reason: FinalizeReason = 'done'): void {
-    const state: ReactionState = reason === 'error' ? 'error' : 'done'
+    const state: ReactionState =
+      reason === 'error' ? 'error' : reason === 'undelivered' ? 'undelivered' : 'done'
     this.finishWithState(state)
   }
 
@@ -348,6 +364,7 @@ export class StatusReactionController {
         this.currentEmoji = emoji
         if (this.pendingEmoji === emoji) this.pendingEmoji = null
         this.log?.(`reaction → ${emoji}`)
+        this.onTransition?.(emoji)
       } catch (err) {
         this.log?.(`reaction emit failed (${emoji}): ${(err as Error).message}`)
       }

package/telegram-plugin/stream-controller.ts

@@ -16,7 +16,7 @@
  * entire server.ts top-level initialization.
  */
 
-import { createDraftStream, type DraftStreamHandle, type StreamDraftFn } from './draft-stream.js'
+import { createDraftStream, type DraftStreamHandle } from './draft-stream.js'
 import { htmlToPlainText } from './html-sanitize.js'
 
 /**
@@ -152,30 +152,15 @@ export interface StreamControllerConfig {
    */
   log?: (msg: string) => void
   /**
-   * Optional warning logger. Used for transport fallback notices.
+   * Optional warning logger. Used for fallback notices.
    */
   warn?: (msg: string) => void
-  /**
-   * Transport selector passed to createDraftStream.
-   * - "auto" (default): use draft transport for DMs only
-   * - "draft": always prefer draft (if sendMessageDraft is available)
-   * - "message": always use sendMessage/editMessageText
-   *
-   * The gateway forces "message" for forum topics (threads), since
-   * sendMessageDraft does not support threaded chats.
-   */
-  previewTransport?: 'auto' | 'message' | 'draft'
   /**
    * True when the chat is a private DM. Passed to createDraftStream so
-   * "auto" transport knows whether to activate draft.
+   * the throttle default (400 ms for DMs vs 1000 ms for groups) is applied
+   * correctly when no explicit throttleMs is set.
    */
   isPrivateChat?: boolean
-  /**
-   * sendMessageDraft callback. When provided (and transport allows it),
-   * intermediate stream updates use the draft API. On finalize(), a real
-   * sendMessage is posted for push notification and the draft is cleared.
-   */
-  sendMessageDraft?: StreamDraftFn
   /**
    * If set, the controller is initialized as if a previous send had
    * landed with this `message_id`. The first `update()` invokes
@@ -214,9 +199,7 @@ export function createStreamController(cfg: StreamControllerConfig): DraftStream
     quoteText,
     protectContent,
     replyMarkup,
-    previewTransport,
     isPrivateChat,
-    sendMessageDraft,
     initialMessageId,
   } = cfg
 
@@ -314,9 +297,7 @@ export function createStreamController(cfg: StreamControllerConfig): DraftStream
       ...(idleMs != null ? { idleMs } : {}),
       ...(log != null ? { log } : {}),
       ...(warn != null ? { warn } : {}),
-      ...(previewTransport != null ? { previewTransport } : {}),
       ...(isPrivateChat != null ? { isPrivateChat } : {}),
-      ...(sendMessageDraft != null ? { sendMessageDraft } : {}),
       ...(initialMessageId != null ? { initialMessageId } : {}),
       chatId,
     },

package/telegram-plugin/stream-reply-handler.ts

@@ -16,7 +16,7 @@
  *     wraps into an MCP content response.
  */
 
-import type { DraftStreamHandle, StreamDraftFn } from './draft-stream.js'
+import type { DraftStreamHandle } from './draft-stream.js'
 import {
   createStreamController,
   type StreamBotApi,
@@ -240,13 +240,6 @@ export interface StreamReplyDeps {
   /** Error-path stderr. */
   writeError: (line: string) => void
   throttleMs?: number
-  /**
-   * sendMessageDraft callback. When provided, stream_reply uses the draft
-   * API for intermediate updates (DM transport). On done=true, a real
-   * sendMessage fires for push notification, then the draft is cleared.
-   * Optional — omit to keep the existing sendMessage/editMessageText path.
-   */
-  sendMessageDraft?: StreamDraftFn
   /**
    * Idempotency hook for the duplicate-message class (issue #626).
    *
@@ -275,12 +268,12 @@ export interface StreamReplyDeps {
   }) => number | null | undefined
   /**
    * True when the current chat is a private DM. Passed to the stream
-   * controller so "auto" transport activates draft in DMs only.
+   * controller so the DM throttle default (400 ms) is applied instead of
+   * the group default (1000 ms) when no explicit throttleMs is set.
    */
   isPrivateChat?: boolean
   /**
-   * True when the current chat is a forum topic. Forum topics do not
-   * support sendMessageDraft — this forces message transport.
+   * True when the current chat is a forum topic.
    */
   isForumTopic?: boolean
   /**
@@ -464,14 +457,6 @@ export async function handleStreamReply(
       }
     }
 
-    // Resolve draft-transport options. Forum topics force message transport
-    // because sendMessageDraft does not support threads.
-    const isForumTopic = deps.isForumTopic === true
-    const resolvedTransport: 'auto' | 'message' | 'draft' =
-      isForumTopic || deps.sendMessageDraft == null
-        ? 'message'
-        : 'auto'
-
     // Idempotency hook (#626): if an external authority (e.g. the
     // gateway's pin manager) already knows the anchor message id for
     // this lane+turn, initialize the stream with it so the next update
@@ -504,8 +489,8 @@ export async function handleStreamReply(
       threadId,
       parseMode,
       disableLinkPreview: deps.disableLinkPreview,
-      // PR B: pass undefined when caller didn't override, so draft-stream's
-      // transport-aware default (300 ms draft / 1000 ms message) wins.
+      // Pass undefined when caller didn't override, so draft-stream's
+      // DM/group throttle defaults apply (400 ms DMs, 1000 ms groups).
       ...(deps.throttleMs != null ? { throttleMs: deps.throttleMs } : {}),
       retry: deps.retry,
       ...(replyToMessageId != null ? { replyToMessageId } : {}),
@@ -513,9 +498,7 @@ export async function handleStreamReply(
       ...(args.protect_content === true ? { protectContent: true } : {}),
       ...(args.disable_notification === true ? { disableNotification: true } : {}),
       ...(args.reply_markup != null ? { replyMarkup: args.reply_markup } : {}),
-      previewTransport: resolvedTransport,
       isPrivateChat: deps.isPrivateChat === true,
-      ...(deps.sendMessageDraft != null ? { sendMessageDraft: deps.sendMessageDraft } : {}),
       ...(initialMessageId != null ? { initialMessageId } : {}),
       onSend: (messageId, charCount) =>
         deps.logStreamingEvent({ kind: 'draft_send', chatId: chat_id, messageId, charCount }),
@@ -539,7 +522,6 @@ export async function handleStreamReply(
           || msg.startsWith('stream → edited')
           || msg.startsWith('stream → not modified')
           || msg.startsWith('stream finalized')
-          || msg.startsWith('stream → draft')
           || msg.startsWith('stream → materialized')
         ) return
         deps.writeError(`telegram channel: stream_reply ${msg}\n`)

package/telegram-plugin/streaming-metrics.ts

@@ -93,6 +93,97 @@ export type StreamingEvent =
       chatId: string
       messageId: number | undefined
     }
+  /**
+   * Emitted when maybeEarlyAckReaction fires the 👀 pre-coalesce reaction
+   * for a private-chat inbound. Lets operators see how often the fast-ack
+   * path triggers vs. the regular StatusReactionController path (#553 F2).
+   */
+  | {
+      kind: 'early_ack_reaction'
+      chatId: string
+      messageId: number
+      emoji: string
+    }
+  /**
+   * Emitted when a fresh StatusReactionController is installed for a new turn
+   * (group / non-DM path where the controller manages the whole reaction lifecycle).
+   */
+  | {
+      kind: 'status_reaction_install'
+      chatId: string
+      turnId: string
+      messageId: number
+    }
+  /**
+   * Emitted on every emoji transition inside a StatusReactionController.
+   * Lets operators trace the full queued→thinking→tool→done lifecycle and
+   * see how many state changes occur in a silent turn.
+   */
+  | {
+      kind: 'status_reaction_transition'
+      chatId: string
+      turnId: string
+      emoji: string
+    }
+  /**
+   * Emitted when StatusReactionController.finalize() / setDone() runs
+   * (controller disposed at turn_end or disconnect-flush). Terminal event.
+   */
+  | {
+      kind: 'status_reaction_dispose'
+      chatId: string
+      turnId: string
+      reason: 'done' | 'error' | 'disconnect' | 'undelivered'
+    }
+  /**
+   * Emitted when the FIRST text reply (reply or stream_reply) of a turn is
+   * sent to the user. `timeToFirstTextReplyMs` is the wall-clock delta from
+   * the inbound-received timestamp to the moment this reply tool fires.
+   * Issue #2527 instrumentation: reveals when a turn is reaction-only.
+   */
+  | {
+      kind: 'turn_reply_timing'
+      chatId: string
+      threadId: number | undefined
+      turnId: string
+      timeToFirstTextReplyMs: number
+    }
+  /**
+   * Emitted at turn_end when the turn produced ZERO text replies (only
+   * reaction-emoji transitions). This is the primary observable for the
+   * #2527 failure mode — the user sees only an emoji and the turn is done.
+   */
+  | {
+      kind: 'turn_no_reply_warn'
+      chatId: string
+      threadId: number | undefined
+      turnId: string
+      turnDurationMs: number
+      reactionCount: number
+    }
+  /**
+   * Emitted when the silence-poke framework-fallback fires and sends its
+   * "still working…" ping. Records the silence duration so operators can
+   * correlate with reaction-only turns.
+   */
+  | {
+      kind: 'silence_poke_fire'
+      chatId: string
+      threadId: number | undefined
+      silenceMs: number
+      fallbackKind: string
+    }
+  /**
+   * Emitted when the silence-poke handler short-circuits because the turn
+   * already ended cleanly during the silence window (the late-fire race).
+   */
+  | {
+      kind: 'silence_poke_skip'
+      chatId: string
+      threadId: number | undefined
+      silenceMs: number
+      skipReason: string
+    }
 
 /**
  * True iff the env gate is on. Re-read on every call so tests can toggle