switchroom 0.13.26 → 0.13.27

package/telegram-plugin/gateway/subagent-progress-inbound-builder.ts

@@ -0,0 +1,256 @@
+/**
+ * Pure builder for the synthetic `subagent_progress` inbound the
+ * gateway injects when a *background* sub-agent emits a narrative line
+ * (`sub_agent_text`) past a bucket boundary while still running.
+ *
+ * Why this exists (conversational-pacing beat 3 — mid-flight progress
+ * for background workers):
+ *
+ *   - Foreground sub-agents stream their narrative into the parent's
+ *     turn natively; the parent can surface progress in its own voice
+ *     as the work unfolds.
+ *   - Background sub-agents are decoupled from any turn boundary. The
+ *     parent is typically idle while the worker runs. Without a wake,
+ *     the user sees nothing between dispatch and the eventual handback
+ *     (beat 4, #1719). The cross-turn ambient ticker in
+ *     `pending-work-progress.ts` keeps the parent's last reply alive
+ *     ("— still working (Nm)") but says NOTHING about *what's
+ *     happening* — it's liveness, not content.
+ *
+ * The watcher already captures `lastResultText` on every
+ * `sub_agent_text` emission (`subagent-watcher.ts:607-622`). We
+ * piggyback on that event stream: every `progressIntervalMs` worth of
+ * elapsed time, the next narrative line minted by the worker becomes
+ * a synthetic `<channel source="subagent_progress">` inbound. The
+ * parent wakes, sees the cue, and surfaces one user-facing line of
+ * progress in its own voice. No timer-driven polling, no TaskOutput
+ * sampling, no `expected_duration` parameter.
+ *
+ * Two divergences from the #1719 handback envelope:
+ *
+ *   1. Determinism by BUCKET, not by jsonl id alone. The spool dedup
+ *      id is `s:progress:<jsonl_agent_id>:<bucketIdx>` where
+ *      `bucketIdx = floor(elapsedMs / progressIntervalMs)`. A worker
+ *      that emits 10 narrative lines inside a single bucket window
+ *      still produces exactly one envelope; the next bucket gets its
+ *      own envelope. Monotonic, idempotent across restarts.
+ *
+ *   2. TTL — every progress envelope sets `meta.expiresAt` to
+ *      `nowMs + 2 × progressIntervalMs`. A 4-hour-stale
+ *      "still working (5m)" delivered after a long downtime would be a
+ *      lie; handback envelopes don't have this asymmetry (they're
+ *      "deliver-eventually OK"). The spool's `liveEntries()` skips
+ *      expired entries — see `inbound-spool.ts`.
+ *
+ * Shape contract mirrors `subagent-handback-inbound-builder.ts`: the
+ * `meta.source` string is load-bearing for the channel wrapper.
+ */
+
+import type { InboundMessage } from './ipc-protocol.js'
+
+/** Cap on the latest-summary text carried in the inbound. The model
+ *  synthesises a one-line update from it; the full transcript is never
+ *  needed and an unbounded paste bloats the parent's context. */
+export const PROGRESS_RESULT_MAX = 800
+/** Cap on the dispatch-time task description echoed back for context. */
+export const PROGRESS_DESC_MAX = 200
+/** Default bucket size — how often a fresh progress envelope may fire
+ *  for a given sub-agent. 5 min is well past the conversational-pacing
+ *  beat 2/3 boundary and matches the refined RFC. */
+export const DEFAULT_PROGRESS_INTERVAL_MS = 5 * 60 * 1000
+
+export interface SubagentProgressContext {
+  /** Telegram chat the work was dispatched from. */
+  chatId: string
+  /** JSONL-derived sub-agent id (stable per Claude Code spawn). Pinned
+   *  into the spool id so envelopes for the same worker dedup across
+   *  buckets cleanly and survive gateway restarts. */
+  subagentJsonlId: string
+  /** Dispatch-time task description (the sub-agent's `description`). */
+  taskDescription: string
+  /** Worker's most recent narrative line — the cue payload. May be
+   *  empty when the worker emits a tool-use without prose; the
+   *  envelope is still useful (it tells the parent "still alive"). */
+  latestSummary: string
+  /** ms elapsed since the worker was dispatched. */
+  elapsedMs: number
+  /** Bucket index = floor(elapsedMs / progressIntervalMs). The
+   *  determinism axis. */
+  bucketIdx: number
+  /** Window size (ms) used to compute `bucketIdx`. The envelope's TTL
+   *  is `2 × progressIntervalMs` past `nowMs`. */
+  progressIntervalMs: number
+}
+
+function truncate(s: string, max: number): string {
+  const t = s.trim()
+  return t.length > max ? t.slice(0, max) + '…' : t
+}
+
+function formatElapsed(ms: number): string {
+  const totalMin = Math.floor(ms / 60_000)
+  if (totalMin < 60) return `${Math.max(1, totalMin)}m`
+  const h = Math.floor(totalMin / 60)
+  const m = totalMin % 60
+  return m === 0 ? `${h}h` : `${h}h${m}m`
+}
+
+/**
+ * Build the synthetic InboundMessage for a mid-flight background
+ * sub-agent. Deterministic under a fixed `nowMs` for tests.
+ */
+export function buildSubagentProgressInbound(opts: {
+  ctx: SubagentProgressContext
+  nowMs?: number
+}): InboundMessage {
+  const ts = opts.nowMs ?? Date.now()
+  const desc = truncate(opts.ctx.taskDescription, PROGRESS_DESC_MAX) || '(no description)'
+  const summary = truncate(opts.ctx.latestSummary, PROGRESS_RESULT_MAX)
+  const elapsed = formatElapsed(opts.ctx.elapsedMs)
+  const expiresAt = ts + 2 * opts.ctx.progressIntervalMs
+
+  const text =
+    `🔄 A background worker you dispatched is still running.\n\n` +
+    `Task: ${desc}\n` +
+    `Elapsed: ${elapsed}\n\n` +
+    (summary
+      ? `Latest activity:\n${summary}\n\n`
+      : `(no narrative line yet — worker has been tool-only)\n\n`) +
+    `This is beat 3 — mid-flight progress. Surface ONE short line to ` +
+    `the user in your own voice about what the worker is up to. Do ` +
+    `NOT paste this raw, do NOT repeat the elapsed time verbatim, do ` +
+    `NOT promise completion. The handback (beat 4) will come ` +
+    `separately when the worker finishes.`
+
+  return {
+    type: 'inbound',
+    chatId: opts.ctx.chatId,
+    messageId: ts, // synthetic — no Telegram message id exists
+    user: 'subagent-watcher',
+    userId: 0,
+    ts,
+    text,
+    meta: {
+      source: 'subagent_progress',
+      subagent_jsonl_id: opts.ctx.subagentJsonlId,
+      bucket_idx: String(opts.ctx.bucketIdx),
+      expiresAt: String(expiresAt),
+      elapsed_ms: String(opts.ctx.elapsedMs),
+    },
+  }
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Progress decision (pure — unit-testable gate for the gateway onProgress path)
+// ───────────────────────────────────────────────────────────────────────────
+
+export interface SubagentProgressDecisionInput {
+  /** `SWITCHROOM_DISABLE_SUBAGENT_PROGRESS` env var value (any non-empty
+   *  value other than '0' disables progress envelopes entirely). */
+  disableEnvValue: string | undefined
+  /** Whether the sub-agent was a background dispatch. Foreground
+   *  sub-agents already surface narrative inside the parent's turn. */
+  isBackground: boolean
+  /** Chat id from the progress-driver fleet entry; '' if not found. */
+  fleetChatId: string
+  /** Owner chat fallback (access.json allowFrom[0]); '' if none. */
+  ownerChatId: string
+  subagentJsonlId: string
+  taskDescription: string
+  latestSummary: string
+  elapsedMs: number
+  /** Window size (ms). */
+  progressIntervalMs: number
+  /** Last bucket idx already emitted for this sub-agent — null if no
+   *  envelope has fired yet. The gateway tracks this per-agent and
+   *  passes it in; the decision returns the new bucket idx on
+   *  `deliver: true` so the caller can update its tracker. */
+  lastBucketIdx: number | null
+  /** Deterministic clock for tests. */
+  nowMs?: number
+}
+
+export type SubagentProgressSkipReason =
+  | 'env-disabled'
+  | 'foreground'
+  | 'no-chat'
+  | 'bucket-already-fired'
+  | 'first-bucket-suppressed'
+  | 'missing-jsonl-id'
+
+export type SubagentProgressDecision =
+  | { deliver: false; reason: SubagentProgressSkipReason }
+  | { deliver: true; chatId: string; bucketIdx: number; inbound: InboundMessage }
+
+/**
+ * Decide whether to deliver a mid-flight progress envelope. Pure — all
+ * IO (registry lookup, fleet peek, access.json read) is the caller's
+ * job.
+ *
+ * Gates, in order:
+ *   1. kill-switch — `SWITCHROOM_DISABLE_SUBAGENT_PROGRESS=1` disables.
+ *   2. foreground — foreground sub-agents stream natively.
+ *   3. no-chat    — nowhere to deliver.
+ *   4. missing-jsonl-id — the dedup key. Without it we'd lose
+ *      deterministic bucketing across restarts; refuse rather than
+ *      degrade silently.
+ *   5. first-bucket-suppressed — bucket 0 covers the first
+ *      `progressIntervalMs` window when ambient liveness is plenty.
+ *      The earliest envelope is bucket 1 (≥ one full window in).
+ *   6. bucket-already-fired — same bucket → same spoolId → no-op.
+ */
+/**
+ * Parse a boolean-ish env var. Treats `undefined`, empty string, `'0'`,
+ * `'false'`, `'no'`, `'off'` (case-insensitive, trimmed) as OFF. Any
+ * other non-empty value is ON.
+ *
+ * The original gate used `value !== '0'`, which foot-gunned on
+ * `'false'` / `'no'` / `'off'` — treating those as enabled instead of
+ * disabled. Centralising the parse here keeps the kill-switch
+ * interpretation a single hop from the var-read site.
+ */
+export function isEnvFlagOn(value: string | undefined): boolean {
+  if (value == null) return false
+  const v = value.trim().toLowerCase()
+  if (v === '') return false
+  if (v === '0' || v === 'false' || v === 'no' || v === 'off') return false
+  return true
+}
+
+export function decideSubagentProgress(
+  input: SubagentProgressDecisionInput,
+): SubagentProgressDecision {
+  if (isEnvFlagOn(input.disableEnvValue)) {
+    return { deliver: false, reason: 'env-disabled' }
+  }
+  if (!input.isBackground) {
+    return { deliver: false, reason: 'foreground' }
+  }
+  const chatId = input.fleetChatId || input.ownerChatId
+  if (!chatId) {
+    return { deliver: false, reason: 'no-chat' }
+  }
+  if (!input.subagentJsonlId) {
+    return { deliver: false, reason: 'missing-jsonl-id' }
+  }
+  const bucketIdx = Math.floor(input.elapsedMs / input.progressIntervalMs)
+  if (bucketIdx < 1) {
+    return { deliver: false, reason: 'first-bucket-suppressed' }
+  }
+  if (input.lastBucketIdx != null && bucketIdx <= input.lastBucketIdx) {
+    return { deliver: false, reason: 'bucket-already-fired' }
+  }
+  const inbound = buildSubagentProgressInbound({
+    ctx: {
+      chatId,
+      subagentJsonlId: input.subagentJsonlId,
+      taskDescription: input.taskDescription,
+      latestSummary: input.latestSummary,
+      elapsedMs: input.elapsedMs,
+      bucketIdx,
+      progressIntervalMs: input.progressIntervalMs,
+    },
+    ...(input.nowMs !== undefined ? { nowMs: input.nowMs } : {}),
+  })
+  return { deliver: true, chatId, bucketIdx, inbound }
+}

package/telegram-plugin/pending-work-progress.ts

@@ -267,12 +267,16 @@ export function noteTurnEnd(key: string): void {
  * Clear pending-progress for a chat — reasons:
  *   'inbound'   — user sent a new message, they're re-engaged
  *   'handback'  — switchroom injected a subagent_handback channel turn
+ *   'progress'  — switchroom injected a subagent_progress channel turn
+ *                 (#1720) — the model is about to compose an explicit
+ *                 in-voice reply about the worker's status, so the
+ *                 ambient "— still working (Nm)" edit should yield
  *   'timeout'   — exceeded MAX_LIFETIME_MS
  *   'manual'    — test / debug
  */
 export function clearPending(
   key: string,
-  reason: 'inbound' | 'handback' | 'timeout' | 'manual',
+  reason: 'inbound' | 'handback' | 'progress' | 'timeout' | 'manual',
 ): void {
   if (!stateByKey.has(key)) return
   const s = stateByKey.get(key)!

package/telegram-plugin/status-reactions.ts

@@ -1,17 +1,28 @@
 /**
  * Status reaction state machine for Telegram bot messages.
  *
- * Ports the pattern from openclaw's src/channels/status-reactions.ts +
- * extensions/telegram/src/status-reaction-variants.ts. The goal is to give
- * the user a glanceable, non-spammy progress signal on their inbound
- * message: 👀 received → 🤔 thinking → ✍/👨‍💻/⚡ working → 👍 done → 😱 error.
+ * Reflective state machine — see issue #1713 for the canonical contract.
  *
- * Three load-bearing properties (all from openclaw research):
+ * The reaction on a user's inbound message represents CURRENT TURN
+ * ACTIVITY, not delivery state. Working states (`thinking`, `tool`,
+ * `coding`, `web`, `compacting`) cycle freely and bidirectionally —
+ * the same state can re-enter multiple times within one turn. No state
+ * is "higher" than another. Mid-turn replies (plain or streamed) are
+ * non-events for the reaction.
  *
- *  1. Debounce intermediate transitions by 700ms so a model that flashes
- *     thinking → tool → thinking → tool doesn't burn the rate limit.
+ * Only ONE method terminates the controller: `finalize(reason)`. The
+ * Stop hook (delivered to the gateway as the `turn_end` IPC event) is
+ * the single terminal trigger. `setError()` paints 😱 but is NON-
+ * terminal — recovery to a working state is allowed.
  *
- *  2. Terminal states (queued / done / error) bypass the debounce.
+ * Three load-bearing properties (kept from the openclaw port):
+ *
+ *  1. Debounce intermediate transitions (3500ms by default — see #1713
+ *     decision: 3-5s) so a model that flashes thinking → tool →
+ *     thinking → tool doesn't burn the Telegram rate limit. Coalesce
+ *     same-state-within-window into a single emit.
+ *
+ *  2. The terminal `finalize()` bypasses debounce.
  *
  *  3. Serialize all API calls through a single chain promise so two
  *     concurrent transitions never race the Telegram API. Telegram's
@@ -20,12 +31,6 @@
  * Stall watchdogs auto-promote to 🥱 / 😨 if no transition arrives within
  * 30s / 90s, so a stuck/dead inference loop is visually distinguishable
  * from a long but healthy one.
- *
- * Emoji choices use Telegram's bot reaction whitelist
- * (https://core.telegram.org/bots/api#reactiontype). The fallback chain
- * tries each variant in order — if a chat restricts available reactions
- * (admin-configured in some groups) the controller silently no-ops the
- * unsupported choice instead of throwing.
  */
 
 /** Telegram allows only this fixed set of emoji as bot reactions. */
@@ -49,7 +54,6 @@ export type ReactionState =
   | 'tool'
   | 'compacting'
   | 'done'
-  | 'silent'
   | 'error'
   | 'stallSoft'
   | 'stallHard'
@@ -62,26 +66,22 @@ export type ReactionState =
  * Semantic split — do not conflate these three tiers:
  *   READ     👀  = "I have seen your message" (acknowledgement only)
  *   WORKING  ✍   = actively doing something (tools, coding, compacting)
- *   FINISHED 👍/💯/🎉 = definitively done; a reply landed
+ *   FINISHED 👍/💯/🎉 = turn over (turn_end fired)
  *
  * 🔥 is reserved for genuine 5xx server errors (operator-events.ts).
  * It reads as "on fire / broken" — keep it out of normal active-work states.
  */
 export const REACTION_VARIANTS: Record<ReactionState, string[]> = {
   queued:    ['👀', '🤔', '🤓'],     // READ: I see your message
-  thinking:  ['🤔', '🤓', '👀'],     // unchanged
+  thinking:  ['🤔', '🤓', '👀'],
   tool:      ['✍', '⚡', '👌'],      // WORKING: actively using a tool
   coding:    ['👨‍💻', '✍', '⚡'],     // WORKING: writing / running code
-  web:       ['⚡', '🤔', '👌'],      // WORKING: lookup in motion (👀 reserved for READ)
-  compacting:['✍', '🤔', '👀'],      // unchanged
-  done:      ['👍', '💯', '🎉'],      // FINISHED: reply landed
-  // 🙊 — turn ended without producing a user-visible reply. Distinct from
-  // 'done' (which means "reply landed") so the user doesn't read 👍 as
-  // "agent acknowledged" when actually nothing was sent. See issue #132.
-  silent:    ['🙊', '🤔', '😐'],      // unchanged
-  error:     ['😱', '😨', '🤯'],      // unchanged (genuine alarm)
-  stallSoft: ['🥱', '😴', '🤔'],      // unchanged
-  stallHard: ['😨', '🤯', '😱'],      // unchanged
+  web:       ['⚡', '🤔', '👌'],      // WORKING: lookup in motion
+  compacting:['✍', '🤔', '👀'],
+  done:      ['👍', '💯', '🎉'],      // FINISHED: turn_end fired
+  error:     ['😱', '😨', '🤯'],      // NON-TERMINAL — recovery allowed
+  stallSoft: ['🥱', '😴', '🤔'],
+  stallHard: ['😨', '🤯', '😱'],
 }
 
 /**
@@ -100,9 +100,12 @@ export function resolveToolReactionState(toolName: string): ReactionState {
   return 'tool'
 }
 
+/** Reason passed to `finalize()` — selects the terminal emoji.  */
+export type FinalizeReason = 'done' | 'error'
+
 /** Configuration knobs the controller respects. */
 export interface StatusReactionConfig {
-  /** Milliseconds to wait before applying a non-immediate transition. Default 700. */
+  /** Milliseconds to wait before applying a non-immediate transition. Default 3500 (#1713). */
   debounceMs?: number
   /** Milliseconds without progress before promoting to stallSoft. Default 30000. */
   stallSoftMs?: number
@@ -126,8 +129,9 @@ export type ReactionEmitter = (emoji: string) => Promise<void>
  * Controller managing the reaction lifecycle for a single inbound message.
  *
  * Lifecycle: construct → setQueued() → arbitrary intermediate transitions
- * → setDone() / setError() to terminate. After termination, all further
- * setX calls are no-ops.
+ * (setThinking / setTool / setCompacting / setError — all bidirectional
+ * and non-terminal) → finalize() to terminate. Only `finalize()` ends
+ * the controller; after termination, all further calls are no-ops.
  */
 export class StatusReactionController {
   private currentEmoji: string | null = null
@@ -148,7 +152,7 @@ export class StatusReactionController {
     private readonly allowedReactions: Set<string> | null = null,
     config: StatusReactionConfig = {},
   ) {
-    this.debounceMs = config.debounceMs ?? 700
+    this.debounceMs = config.debounceMs ?? 3500
     this.stallSoftMs = config.stallSoftMs ?? 30000
     this.stallHardMs = config.stallHardMs ?? 90000
     this.log = config.log
@@ -159,44 +163,56 @@ export class StatusReactionController {
     this.scheduleState('queued', { immediate: true })
   }
 
-  /** 🤔 — model is generating. Debounced. */
+  /** 🤔 — model is generating. Debounced, non-terminal, bidirectional. */
   setThinking(): void {
     this.scheduleState('thinking')
   }
 
-  /** Tool-specific reaction. Debounced. */
+  /** Tool-specific reaction. Debounced, non-terminal, bidirectional. */
   setTool(toolName?: string): void {
     const state = toolName ? resolveToolReactionState(toolName) : 'tool'
     this.scheduleState(state)
   }
 
-  /** ✍ — context compaction in progress. */
+  /** ✍ — context compaction in progress. Debounced, non-terminal, bidirectional. */
   setCompacting(): void {
     this.scheduleState('compacting')
   }
 
-  /** 👍 — final reply delivered. Terminal, bypasses debounce. */
-  setDone(): void {
-    this.finishWithState('done')
+  /**
+   * 😱 — non-terminal error indicator. Paints the error emoji but does
+   * NOT end the controller — recovery to a working state is permitted
+   * (see #1713). Use `finalize('error')` to actually terminate with
+   * the error emoji as the final state.
+   */
+  setError(): void {
+    this.scheduleState('error')
   }
 
   /**
-   * 🙊 — turn ended without producing a user-visible reply.
+   * Terminal — sets the controller to `finished` and emits the final
+   * emoji (👍 for 'done', 😱 for 'error'). This is the ONLY method
+   * that ends the controller; all other setX calls are non-terminal.
    *
-   * Distinct from `setDone()` so the user doesn't read 👍 as "agent
-   * acknowledged but stayed silent on purpose" when in fact nothing was
-   * actually sent. Common case (#132): agent ran a long Bash chain to
-   * answer a question, never called `reply` / `stream_reply`, and the
-   * orphaned-reply backstop had no captured text to forward either.
-   * Terminal, bypasses debounce.
+   * Driven by the `turn_end` IPC event (Stop hook) and the disconnect
+   * / boot-sweep backstops. Bypasses debounce so the terminal emoji
+   * lands promptly. Subsequent calls are no-ops.
    */
-  setSilent(): void {
-    this.finishWithState('silent')
+  finalize(reason: FinalizeReason = 'done'): void {
+    const state: ReactionState = reason === 'error' ? 'error' : 'done'
+    this.finishWithState(state)
   }
 
-  /** 😱 — generation failed. Terminal, bypasses debounce. */
-  setError(): void {
-    this.finishWithState('error')
+  /**
+   * Back-compat shim — equivalent to `finalize('done')`. Prefer
+   * `finalize()` in new call sites so the terminal contract is
+   * explicit at the call site.
+   *
+   * @deprecated Use `finalize('done')` — kept so external callers don't
+   * break mid-rollout. Will be removed once all callers migrate.
+   */
+  setDone(): void {
+    this.finalize('done')
   }
 
   /** Stop the controller without applying any new reaction. Terminal. */
@@ -216,13 +232,11 @@ export class StatusReactionController {
     if (this.finished) return
     const emoji = this.resolveEmoji(state)
     if (emoji == null) {
-      // No allowed variant for this chat — silently skip rather than fall
-      // through to the chain. We still reset stall timers so that progress
-      // signals continue to keep the watchdogs at bay.
       if (!opts.skipStallReset) this.resetStallTimers()
       return
     }
     if (emoji === this.currentEmoji || emoji === this.pendingEmoji) {
+      // Coalesce same-state-within-window into a single emit.
       if (!opts.skipStallReset) this.resetStallTimers()
       return
     }
@@ -245,15 +259,13 @@ export class StatusReactionController {
     this.clearStallTimers()
     // F1 fix (#553): if a non-terminal reaction is sitting in the
     // debounce window when the turn ends, flush it BEFORE the terminal
-    // emoji emits. Pre-fix, `clearDebounceTimer()` here silently
-    // dropped the pending state — every Class B turn that completed in
-    // under `debounceMs` (default 700ms) collapsed to 👀 → 👍 with no
-    // intermediate signal that the agent did any work.
+    // emoji emits. Without this, every Class B turn that completed in
+    // under `debounceMs` would collapse straight to 👀 → terminal with
+    // no intermediate working-state signal.
     //
     // Gate on `debounceTimer != null`: a `pendingEmoji` with no timer
     // is already enqueued (immediate emit waiting on chainPromise) and
-    // re-enqueuing would produce a duplicate. Only debounced-but-not-
-    // yet-enqueued emojis need to be flushed here.
+    // re-enqueuing would produce a duplicate.
     const flushPending = this.debounceTimer != null && this.pendingEmoji != null
       ? this.pendingEmoji
       : null

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

@@ -207,8 +207,6 @@ export interface StreamReplyDeps {
     charCount: number
     sameAsLast: boolean
   }) => void
-  /** Called on done=true to transition the status reaction controller. */
-  endStatusReaction: (chatId: string, threadId: number | undefined, verdict: 'done') => void
   /**
    * Optional: progress-card driver completion hook. Wired by the gateway
    * to `progressDriver.forceCompleteTurn(...)`. Invoked after a
@@ -568,40 +566,13 @@ export async function handleStreamReply(
     await stream.finalize()
     state.activeDraftStreams.delete(sKey)
     state.activeDraftParseModes?.delete(sKey)
-    // Bug Z fix: fire the terminal 👍 here, gated to the default
-    // (unnamed) lane and only after finalize() resolves so the emoji is
-    // tied to the final edit actually landing in Telegram.
-    //
-    // History (see prior comment removed in this commit): we previously
-    // deferred the 👍 to turn_end on the theory that a turn might call
-    // stream_reply(done=true) mid-flight and continue working. In
-    // practice the dedup-suppress branch in turn_end was firing setDone
-    // off a 500ms-lagged read of local history rather than from a real
-    // delivery confirmation, and the disconnect-flush path was leaving
-    // 👍 firing on disconnect even when the final edit had failed.
-    // Wiring endStatusReaction at the post-finalize callback keeps the
-    // emoji honest — it now means "the final draft edit hit Telegram".
-    //
-    // Gated to the default lane: named lanes (lane:'progress',
-    // lane:'thinking', lane:'activity', etc.) are internal driver
-    // emits, not user-visible answers — they must not be allowed to
-    // claim turn-completion. A lane:'progress' emit firing setDone
-    // would race the actual answer.
-    //
-    // Mid-turn done=true tradeoff: a turn that calls
-    // stream_reply(done=true) on the default lane and then continues
-    // working will fire 👍 early; subsequent intermediate emojis become
-    // no-ops (setDone is terminal). This is the contract: done=true on
-    // the default lane is "the answer is delivered". Agents that need
-    // to continue should use additional `reply` calls or named lanes.
-    const isDefaultLaneForCompletion = args.lane == null || args.lane.length === 0
-    if (isDefaultLaneForCompletion && stream.getMessageId() != null) {
-      try {
-        deps.endStatusReaction(chat_id, threadId, 'done')
-      } catch (err) {
-        deps.writeError(`telegram channel: stream_reply: endStatusReaction hook threw: ${err}\n`)
-      }
-    }
+    // #1713: stream_reply done=true is a NON-EVENT for the status
+    // reaction. The reaction reflects current turn activity, not
+    // delivery state — only the `turn_end` IPC handler finalizes (👍).
+    // Stream completion is "I'm done speaking", not "turn over"; the
+    // model may continue with post-stream tool work. This is a
+    // deliberate revert of the Bug Z fix (PR #602 follow-up) — see
+    // the #1713 issue body for the rationale.
 
     // Hard-fail surface: if the stream finalized without ever assigning
     // a message id, the initial send never landed (4096+ chars hits