switchroom 0.14.65 → 0.14.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.65",
+  "version": "0.14.67",
   "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

@@ -39034,6 +39034,13 @@ function noteOutbound2(key, now) {
   s.lastOutboundAt = now;
   s.fallbackFired = false;
 }
+function noteProduction(key, now) {
+  const s = state2.get(key);
+  if (s == null)
+    return;
+  s.lastOutboundAt = now;
+  s.fallbackFired = false;
+}
 function noteThinking(key, now) {
   const s = state2.get(key);
   if (s == null)
@@ -47936,6 +47943,10 @@ function resolveAnswerThreadId(input) {
     return input.explicitThreadId;
   if (input.originResolved)
     return input.originThreadId;
+  if (input.liveThreadId != null)
+    return input.liveThreadId;
+  if (input.lastEndedResolvedForChat)
+    return input.lastEndedThreadIdForChat;
   return input.liveThreadId;
 }
 
@@ -52759,11 +52770,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.65";
-var COMMIT_SHA = "ff6f75c4";
-var COMMIT_DATE = "2026-06-05T04:09:09Z";
-var LATEST_PR = 2165;
-var COMMITS_AHEAD_OF_TAG = 0;
+var VERSION = "0.14.67";
+var COMMIT_SHA = "dcade213";
+var COMMIT_DATE = "2026-06-05T08:22:01Z";
+var LATEST_PR = 2171;
+var COMMITS_AHEAD_OF_TAG = 4;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -54061,6 +54072,33 @@ function findTurnByOriginId(originTurnId) {
     return currentTurn;
   return recentTurnsById.get(originTurnId) ?? null;
 }
+var LATE_REPLY_TOPIC_RECOVERY_ENABLED = process.env.SWITCHROOM_LATE_REPLY_TOPIC_RECOVERY !== "0";
+function findLatestEndedTurnForChat(chatId) {
+  let latest = null;
+  for (const t of recentTurnsById.values()) {
+    if (t.sessionChatId === chatId)
+      latest = t;
+  }
+  return latest;
+}
+function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, liveTurn, surface) {
+  const recovered = LATE_REPLY_TOPIC_RECOVERY_ENABLED && explicitThreadId == null && originTurn == null && liveTurn == null ? findLatestEndedTurnForChat(chatId) : null;
+  const threadId = resolveAnswerThreadId({
+    explicitThreadId,
+    originResolved: originTurn != null,
+    originThreadId: originTurn?.sessionThreadId,
+    liveThreadId: liveTurn?.sessionThreadId,
+    lastEndedResolvedForChat: recovered != null,
+    lastEndedThreadIdForChat: recovered?.sessionThreadId
+  });
+  const via = explicitThreadId != null ? "explicit" : originTurn != null ? "origin" : liveTurn?.sessionThreadId != null ? "live" : recovered != null ? "recovered" : "none";
+  const ownerTurn = originTurn ?? recovered ?? liveTurn;
+  const isSupergroup = chatId.startsWith("-100");
+  const unrouted = isSupergroup && threadId == null;
+  process.stderr.write(`telegram gateway: reply-route surface=${surface} chat=${chatId} resolved_thread=${threadId ?? "-"} via=${via} late=${liveTurn == null} originTurn=${ownerTurn?.turnId ?? "-"} origin_thread=${ownerTurn?.sessionThreadId ?? "-"}` + (via === "recovered" ? " RECOVERED" : "") + (unrouted ? " UNROUTED(supergroup\u2192no-topic)" : "") + `
+`);
+  return threadId;
+}
 function closeObligationOnSubstantiveReply(args, liveTurn) {
   if (!OBLIGATION_LEDGER_ENABLED)
     return;
@@ -55229,6 +55267,7 @@ function parsePositiveMsEnv(name, fallbackMs) {
 var SILENCE_FALLBACK_MS = parsePositiveMsEnv("SWITCHROOM_SILENCE_FALLBACK_MS", 300000);
 var SILENCE_FALLBACK_HARD_MS = parsePositiveMsEnv("SWITCHROOM_SILENCE_FALLBACK_HARD_MS", 900000);
 var SILENCE_DEFER_INFLIGHT_TOOLS = process.env.SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS === "1";
+var SILENCE_LIVENESS_PRODUCTION = process.env.SWITCHROOM_SILENCE_LIVENESS_PRODUCTION !== "0";
 startTimer({
   thresholdsMs: { fallback: SILENCE_FALLBACK_MS, fallbackHardCeiling: SILENCE_FALLBACK_HARD_MS },
   deferFallbackWhileToolInFlight: SILENCE_DEFER_INFLIGHT_TOOLS,
@@ -55320,8 +55359,11 @@ startTimer({
       const sib = silenceMsForKey(siblingKey, fbNow);
       return sib == null || sib >= DEFAULT_THRESHOLDS.fallback;
     });
-    if (turnMatchesFallback && currentTurn === wedgedTurn)
+    if (turnMatchesFallback && currentTurn === wedgedTurn && wedgedTurn != null) {
+      process.stderr.write(`telegram gateway: ${formatTurnLifecycle("clear", "silence_fallback", wedgedTurn, Date.now())}
+`);
       currentTurn = null;
+    }
     try {
       clearSilentEndState(fbKey);
     } catch {}
@@ -56291,12 +56333,7 @@ ${url}`;
   if (TURN_ORIGIN_ROUTING_ENABLED) {
     const explicit = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
     const originTurn = findTurnByOriginId(args.origin_turn_id);
-    threadId = resolveAnswerThreadId({
-      explicitThreadId: Number.isFinite(explicit) ? explicit : undefined,
-      originResolved: originTurn != null,
-      originThreadId: originTurn?.sessionThreadId,
-      liveThreadId: turn?.sessionThreadId
-    });
+    threadId = resolveAnswerThreadWithLog(chat_id, Number.isFinite(explicit) ? explicit : undefined, originTurn, turn, "reply");
   } else {
     threadId = resolveThreadId(chat_id, args.message_thread_id ?? (turn?.sessionThreadId != null ? turn.sessionThreadId : undefined));
   }
@@ -56656,12 +56693,7 @@ async function executeStreamReply(args) {
     let injected;
     if (TURN_ORIGIN_ROUTING_ENABLED) {
       const originTurn = findTurnByOriginId(args.origin_turn_id);
-      injected = resolveAnswerThreadId({
-        explicitThreadId: undefined,
-        originResolved: originTurn != null,
-        originThreadId: originTurn?.sessionThreadId,
-        liveThreadId: turn?.sessionThreadId
-      });
+      injected = resolveAnswerThreadWithLog(String(args.chat_id), undefined, originTurn, turn, "stream_reply");
     } else {
       injected = turn?.sessionThreadId;
     }
@@ -58055,6 +58087,9 @@ function handleSessionEvent(ev) {
       const rendered = appendActivityLabel(turn.mirrorLines, ev.label);
       if (rendered != null) {
         turn.lastToolLabelAt = Date.now();
+        if (SILENCE_LIVENESS_PRODUCTION && currentTurn === turn) {
+          noteProduction(statusKey(turn.sessionChatId, turn.sessionThreadId), Date.now());
+        }
         turn.activityPendingRender = composeTurnActivity(turn) ?? rendered;
         if (turn.activityInFlight == null) {
           turn.activityInFlight = drainActivitySummary(turn);
@@ -58109,6 +58144,9 @@ function handleSessionEvent(ev) {
               logStreamingEvent(metricEv);
               if (currentTurn === turn) {
                 noteSignal(statusKey(turn.sessionChatId, turn.sessionThreadId), Date.now());
+                if (SILENCE_LIVENESS_PRODUCTION) {
+                  noteProduction(statusKey(turn.sessionChatId, turn.sessionThreadId), Date.now());
+                }
               }
             },
             checkDedup: (text) => {

package/telegram-plugin/gateway/answer-thread-resolve.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest'
+import { resolveAnswerThreadId } from './answer-thread-resolve.js'
+
+describe('resolveAnswerThreadId — precedence', () => {
+  it('(1) explicit model thread wins over everything', () => {
+    expect(
+      resolveAnswerThreadId({
+        explicitThreadId: 7,
+        originResolved: true,
+        originThreadId: 3,
+        liveThreadId: 4,
+        lastEndedResolvedForChat: true,
+        lastEndedThreadIdForChat: 9,
+      }),
+    ).toBe(7)
+  })
+
+  it('(2) origin turn thread wins over the live turn (the Brevo→Meta fix)', () => {
+    expect(
+      resolveAnswerThreadId({ originResolved: true, originThreadId: 3, liveThreadId: 4 }),
+    ).toBe(3)
+  })
+
+  it('(2) a DM origin (resolved, thread undefined) pins to undefined, not the live thread', () => {
+    expect(
+      resolveAnswerThreadId({ originResolved: true, originThreadId: undefined, liveThreadId: 4 }),
+    ).toBeUndefined()
+  })
+
+  it('(3) no origin → falls back to the live turn thread (legacy #1664)', () => {
+    expect(
+      resolveAnswerThreadId({ originResolved: false, liveThreadId: 4 }),
+    ).toBe(4)
+  })
+
+  // ── tier (4): late-reply topic recovery (2026-06-05) ──────────────────────
+  it('(4) no explicit, no origin, NO live turn → recovers the most-recent ended turn thread', () => {
+    // The marko bug: a reply that fired after the orphaned-reply backstop ended
+    // its turn. Pre-fix this returned undefined (General); now it recovers topic 3.
+    expect(
+      resolveAnswerThreadId({
+        originResolved: false,
+        liveThreadId: undefined,
+        lastEndedResolvedForChat: true,
+        lastEndedThreadIdForChat: 3,
+      }),
+    ).toBe(3)
+  })
+
+  it('(4) a recovered DM turn (ended, thread undefined) stays threadless', () => {
+    expect(
+      resolveAnswerThreadId({
+        originResolved: false,
+        liveThreadId: undefined,
+        lastEndedResolvedForChat: true,
+        lastEndedThreadIdForChat: undefined,
+      }),
+    ).toBeUndefined()
+  })
+
+  it('(4) recovery does NOT override a live turn — live thread still wins at tier 3', () => {
+    expect(
+      resolveAnswerThreadId({
+        originResolved: false,
+        liveThreadId: 4,
+        lastEndedResolvedForChat: true,
+        lastEndedThreadIdForChat: 3,
+      }),
+    ).toBe(4)
+  })
+
+  it('(4) no recovery candidate → legacy result (undefined), unchanged', () => {
+    expect(
+      resolveAnswerThreadId({
+        originResolved: false,
+        liveThreadId: undefined,
+        lastEndedResolvedForChat: false,
+      }),
+    ).toBeUndefined()
+  })
+
+  it('pure DM (every tier undefined) → undefined', () => {
+    expect(resolveAnswerThreadId({ originResolved: false })).toBeUndefined()
+  })
+})

package/telegram-plugin/gateway/answer-thread-resolve.ts

@@ -26,10 +26,14 @@
  *   3. Else the LIVE turn's thread — but ONLY when the live turn IS the
  *      origin turn (no flip happened) OR no origin turn could be resolved
  *      at all (origin id absent/unknown; legacy / pre-stamp path).
- *   4. Else (origin resolved AND it differs from the live turn) we pin to
- *      the origin thread and explicitly DO NOT fall through to the chat's
- *      last-seen `chatThreadMap` thread. For answer surfaces the chat
- *      last-seen heuristic is exactly what produced the wrong-topic bug.
+ *   4. Else (no explicit, no origin echoed, no live turn) — a LATE reply that
+ *      fired after its turn already ended (the orphaned-reply backstop case) —
+ *      recover the origin topic from the most-recently-ended turn for this
+ *      chat. Without this, such a reply defaults to the main chat (General in a
+ *      supergroup) and its answer vanishes from the topic the user is reading
+ *      (the 2026-06-05 marko triage). Still NOT the `chatThreadMap` last-seen
+ *      heuristic — the recovered turn is the chat's own most-recent turn, not
+ *      whichever topic last received any message.
  *
  * The `chatThreadMap` last-seen fallback is preserved for NON-answer
  * surfaces (`send_typing`, `forward_message`, `progress_update`) by NOT
@@ -53,6 +57,20 @@ export interface AnswerThreadInput {
    *  (no live turn, or a DM live turn). The legacy (#1664) fallback when
    *  no origin turn is resolvable. */
   liveThreadId?: number | undefined
+  /**
+   * Late-reply topic recovery (2026-06-05). Thread of the most-recently-ended
+   * turn for THIS chat (from `recentTurnsById`), used as a deterministic
+   * fallback when the model echoed no `origin_turn_id` AND there is no live
+   * turn — the late-reply-after-turn-end case. Without it, a reply that fires
+   * after the orphaned-reply backstop closed its turn defaults to the main chat
+   * (General topic in a supergroup), so its answer vanishes from the topic the
+   * user is reading. Only consulted at tier (4); a DM origin yields undefined,
+   * which is correct.
+   */
+  lastEndedThreadIdForChat?: number | undefined
+  /** Whether a recently-ended turn exists for this chat — distinguishes
+   *  "ended turn exists, DM (thread undefined)" from "no ended turn at all". */
+  lastEndedResolvedForChat?: boolean
 }
 
 /**
@@ -75,5 +93,13 @@ export function resolveAnswerThreadId(input: AnswerThreadInput): number | undefi
   if (input.originResolved) return input.originThreadId
   // (3) no origin resolved (legacy / pre-stamp / evicted) → fall back to
   //     the live turn's thread, the existing turn-pinned behaviour (#1664).
+  if (input.liveThreadId != null) return input.liveThreadId
+  // (4) no explicit, no origin echoed, no live turn — a LATE reply that fired
+  //     after its turn already ended (the orphaned-reply backstop case).
+  //     Recover the origin topic from the most-recently-ended turn for this
+  //     chat so the answer lands in the topic it belongs to instead of
+  //     defaulting to the main chat (General). When no ended turn is known,
+  //     fall through to liveThreadId (undefined) — the legacy result.
+  if (input.lastEndedResolvedForChat) return input.lastEndedThreadIdForChat
   return input.liveThreadId
 }

package/telegram-plugin/gateway/gateway.ts

@@ -1888,6 +1888,89 @@ function findTurnByOriginId(originTurnId: string | null | undefined): CurrentTur
   return recentTurnsById.get(originTurnId) ?? null
 }
 
+// Late-reply topic recovery (2026-06-05 marko triage). Default ON; kill switch
+// SWITCHROOM_LATE_REPLY_TOPIC_RECOVERY=0 restores the legacy behaviour (a late
+// reply with no echoed origin and no live turn defaults to General).
+const LATE_REPLY_TOPIC_RECOVERY_ENABLED =
+  process.env.SWITCHROOM_LATE_REPLY_TOPIC_RECOVERY !== '0'
+
+/**
+ * The most-recently-started turn for a chat from the bounded recently-ended
+ * registry — the deterministic fallback for a LATE answer reply when the model
+ * echoed no `origin_turn_id` and `currentTurn` has already cleared. Iterates in
+ * insertion order so the last match is the most recent turn for that chat.
+ * Returns null when the chat has no remembered turn (so the caller keeps the
+ * legacy result). NB: this is the chat's own most-recent TURN, not the
+ * `chatThreadMap` last-seen-any-message heuristic that caused the wrong-topic
+ * bug — a late reply almost always belongs to the turn that just ended.
+ */
+function findLatestEndedTurnForChat(chatId: string): CurrentTurn | null {
+  let latest: CurrentTurn | null = null
+  for (const t of recentTurnsById.values()) {
+    if (t.sessionChatId === chatId) latest = t
+  }
+  return latest
+}
+
+/**
+ * Resolve the answer-reply thread AND emit `reply-route` telemetry. The
+ * 2026-06-05 triage showed reply routing was the blind spot: `reply: invoked`
+ * logged only chat + char count, so a late reply landing in the wrong topic was
+ * invisible without hand-correlating raw tg-post threads against turn-lifecycle
+ * timestamps. This wrapper logs, per reply: which precedence tier won (`via`),
+ * the resolved thread, the origin turn + its thread, and whether the reply was
+ * late (turn already ended). `via=recovered` marks a late reply this fix saved
+ * from General; `UNROUTED` flags a supergroup reply that still resolved to no
+ * topic (the residual gap to watch).
+ */
+function resolveAnswerThreadWithLog(
+  chatId: string,
+  explicitThreadId: number | undefined,
+  originTurn: CurrentTurn | null,
+  liveTurn: CurrentTurn | null,
+  surface: 'reply' | 'stream_reply',
+): number | undefined {
+  // Recover ONLY for a genuinely LATE reply — no live turn at all. Gating on
+  // `liveTurn?.sessionThreadId == null` (the original) also fired for a
+  // threadless DM that still had a live turn, marking every DM reply
+  // `via=recovered`/RECOVERED in the telemetry (routing result unchanged —
+  // DM → undefined — but it drowned the real supergroup recoveries the marker
+  // exists to surface). `liveTurn == null` is the precise late-reply condition.
+  const recovered =
+    LATE_REPLY_TOPIC_RECOVERY_ENABLED &&
+    explicitThreadId == null &&
+    originTurn == null &&
+    liveTurn == null
+      ? findLatestEndedTurnForChat(chatId)
+      : null
+  const threadId = resolveAnswerThreadId({
+    explicitThreadId,
+    originResolved: originTurn != null,
+    originThreadId: originTurn?.sessionThreadId,
+    liveThreadId: liveTurn?.sessionThreadId,
+    lastEndedResolvedForChat: recovered != null,
+    lastEndedThreadIdForChat: recovered?.sessionThreadId,
+  })
+  const via =
+    explicitThreadId != null ? 'explicit'
+    : originTurn != null ? 'origin'
+    : liveTurn?.sessionThreadId != null ? 'live'
+    : recovered != null ? 'recovered'
+    : 'none'
+  const ownerTurn = originTurn ?? recovered ?? liveTurn
+  const isSupergroup = chatId.startsWith('-100')
+  const unrouted = isSupergroup && threadId == null
+  process.stderr.write(
+    `telegram gateway: reply-route surface=${surface} chat=${chatId} ` +
+      `resolved_thread=${threadId ?? '-'} via=${via} late=${liveTurn == null} ` +
+      `originTurn=${ownerTurn?.turnId ?? '-'} origin_thread=${ownerTurn?.sessionThreadId ?? '-'}` +
+      (via === 'recovered' ? ' RECOVERED' : '') +
+      (unrouted ? ' UNROUTED(supergroup→no-topic)' : '') +
+      '\n',
+  )
+  return threadId
+}
+
 /**
  * PR2 obligation-ledger CLOSE. Called when a SUBSTANTIVE final answer lands
  * (not a bare interim ack — using finalAnswerSubstantive, the #2141 signal): the
@@ -4596,6 +4679,12 @@ function parsePositiveMsEnv(name: string, fallbackMs: number): number {
 const SILENCE_FALLBACK_MS = parsePositiveMsEnv('SWITCHROOM_SILENCE_FALLBACK_MS', 300_000)
 const SILENCE_FALLBACK_HARD_MS = parsePositiveMsEnv('SWITCHROOM_SILENCE_FALLBACK_HARD_MS', 900_000)
 const SILENCE_DEFER_INFLIGHT_TOOLS = process.env.SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS === '1'
+// Production-liveness (2026-06-05 UAT finding). Count an activity-feed render or
+// an answer-stream draft update as liveness for the silence clock, so a long
+// tool/composition turn that's visibly producing doesn't trip the 300s fallback
+// and null currentTurn mid-work. Default ON; SWITCHROOM_SILENCE_LIVENESS_PRODUCTION=0
+// restores the legacy "only a real reply resets the clock" behaviour.
+const SILENCE_LIVENESS_PRODUCTION = process.env.SWITCHROOM_SILENCE_LIVENESS_PRODUCTION !== '0'
 
 silencePoke.startTimer({
   thresholdsMs: { fallback: SILENCE_FALLBACK_MS, fallbackHardCeiling: SILENCE_FALLBACK_HARD_MS },
@@ -4812,7 +4901,16 @@ silencePoke.startTimer({
     // returns null and the regular teardown short-circuits. Without
     // this, the late event would re-emit `turn_ended` AND clobber
     // whatever fresh turn the next inbound started.
-    if (turnMatchesFallback && currentTurn === wedgedTurn) currentTurn = null
+    if (turnMatchesFallback && currentTurn === wedgedTurn && wedgedTurn != null) {
+      // Status-surface observability: emit the lifecycle CLEAR for the
+      // silence-poke teardown so a fallback-nulled turn has a turn-lifecycle
+      // line like every other clear path (the framework-fallback line below is
+      // its own format — this makes the dark-out greppable in the same shape).
+      process.stderr.write(
+        `telegram gateway: ${formatTurnLifecycle('clear', 'silence_fallback', wedgedTurn, Date.now())}\n`,
+      )
+      currentTurn = null
+    }
     // Best-effort: clear any pending silent-end marker so the Stop hook
     // doesn't double-block when claude eventually exits the wedged turn.
     try {
@@ -6522,12 +6620,13 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   if (TURN_ORIGIN_ROUTING_ENABLED) {
     const explicit = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
     const originTurn = findTurnByOriginId(args.origin_turn_id as string | undefined)
-    threadId = resolveAnswerThreadId({
-      explicitThreadId: Number.isFinite(explicit as number) ? (explicit as number) : undefined,
-      originResolved: originTurn != null,
-      originThreadId: originTurn?.sessionThreadId,
-      liveThreadId: turn?.sessionThreadId,
-    })
+    threadId = resolveAnswerThreadWithLog(
+      chat_id,
+      Number.isFinite(explicit as number) ? (explicit as number) : undefined,
+      originTurn,
+      turn,
+      'reply',
+    )
   } else {
     threadId = resolveThreadId(
       chat_id,
@@ -7178,12 +7277,13 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
     let injected: number | undefined
     if (TURN_ORIGIN_ROUTING_ENABLED) {
       const originTurn = findTurnByOriginId(args.origin_turn_id as string | undefined)
-      injected = resolveAnswerThreadId({
-        explicitThreadId: undefined,
-        originResolved: originTurn != null,
-        originThreadId: originTurn?.sessionThreadId,
-        liveThreadId: turn?.sessionThreadId,
-      })
+      injected = resolveAnswerThreadWithLog(
+        String(args.chat_id),
+        undefined,
+        originTurn,
+        turn,
+        'stream_reply',
+      )
     } else {
       injected = turn?.sessionThreadId
     }
@@ -9373,6 +9473,16 @@ function handleSessionEvent(ev: SessionEvent): void {
         // the " · Ns" elapsed restarts from this step (and the feed itself just
         // advanced, so it isn't stale).
         turn.lastToolLabelAt = Date.now()
+        // Production-liveness: a NEW model-driven activity label is genuine
+        // liveness (the model emitted a new step), so reset the silence-poke
+        // clock — this is the safe site, NOT drainActivitySummary, because the
+        // framework feedHeartbeatTick also drains (climbing-elapsed re-renders)
+        // and would falsely reset the clock forever on a hung-mid-tool turn,
+        // reintroducing the #1556 dangling-turn wedge. Only the model emitting a
+        // fresh label reaches here.
+        if (SILENCE_LIVENESS_PRODUCTION && currentTurn === turn) {
+          silencePoke.noteProduction(statusKey(turn.sessionChatId, turn.sessionThreadId), Date.now())
+        }
         // Recompose so any active foreground sub-agent's nested block (Model A)
         // is preserved when the parent appends its own step. composeTurnActivity
         // == the flat render when no foreground sub-agent is active.
@@ -9533,6 +9643,15 @@ function handleSessionEvent(ev: SessionEvent): void {
                   statusKey(turn.sessionChatId, turn.sessionThreadId),
                   Date.now(),
                 )
+                // Production-liveness: a draft update is the agent visibly
+                // composing — reset the silence-poke clock so a long
+                // compose-only turn (no tools, no reply yet) isn't torn down.
+                if (SILENCE_LIVENESS_PRODUCTION) {
+                  silencePoke.noteProduction(
+                    statusKey(turn.sessionChatId, turn.sessionThreadId),
+                    Date.now(),
+                  )
+                }
               }
             },
             // #646 — wire the shared outboundDedup into the answer-stream

package/telegram-plugin/silence-poke.ts

@@ -196,6 +196,31 @@ export function noteOutbound(key: string, now: number): void {
   s.fallbackFired = false
 }
 
+/**
+ * Record observable PRODUCTION that isn't a final reply — an activity-feed
+ * render (`→/✓` edit-in-place message) or an answer-stream draft update. Resets
+ * the silence clock exactly like a reply.
+ *
+ * Why this exists (2026-06-05): the header's "only a real reply counts; tool
+ * churn / the model ripping through 20 tool calls is still SILENT to the user"
+ * rule predates the live activity feed (#2162) and the compose draft. Those
+ * surfaces ARE user-visible now, so a turn actively rendering them is NOT
+ * silent — yet the 300s fallback (which nulls `currentTurn` and kills the very
+ * feed/draft the user is watching) still fired on a long tool/composition turn,
+ * darkening the live status mid-work. Counting production as liveness makes the
+ * fallback fire only on GENUINE silence (no reply, no feed, no draft, no tool
+ * events for the window) — a real wedge. A wedged agent produces nothing
+ * observable, so its clock is never reset and it still recovers.
+ *
+ * No-op when the kill switch is on or the key has no turn.
+ */
+export function noteProduction(key: string, now: number): void {
+  const s = state.get(key)
+  if (s == null) return
+  s.lastOutboundAt = now
+  s.fallbackFired = false
+}
+
 /**
  * Record a `thinking` session event. Used to pick "still thinking…" vs
  * "still working…" wording for the 300s framework fallback.

package/telegram-plugin/tests/multitopic-routing-wiring.test.ts

@@ -45,13 +45,15 @@ describe('component 3 — turn-origin reply routing', () => {
     const fn = gatewaySrc.split('async function executeReply')[1]?.split('\nasync function ')[0] ?? ''
     expect(fn).toMatch(/TURN_ORIGIN_ROUTING_ENABLED/)
     expect(fn).toMatch(/findTurnByOriginId\(args\.origin_turn_id/)
-    expect(fn).toMatch(/resolveAnswerThreadId\(/)
+    // The resolution + reply-route telemetry go through resolveAnswerThreadWithLog,
+    // which calls the pure resolveAnswerThreadId internally (incl. tier-4 recovery).
+    expect(fn).toMatch(/resolveAnswerThread\w*\(/)
   })
 
   it('executeStreamReply resolves the answer thread via the origin turn too', () => {
     const fn = gatewaySrc.split('async function executeStreamReply')[1]?.split('\nasync function ')[0] ?? ''
     expect(fn).toMatch(/findTurnByOriginId\(args\.origin_turn_id/)
-    expect(fn).toMatch(/resolveAnswerThreadId\(/)
+    expect(fn).toMatch(/resolveAnswerThread\w*\(/)
   })
 
   it('the reply + stream_reply tool schemas expose origin_turn_id to the model', () => {

package/telegram-plugin/tests/silence-liveness-wiring.test.ts

@@ -0,0 +1,67 @@
+/**
+ * Silence-poke production-liveness — heartbeat-safety guard (2026-06-05).
+ *
+ * The production-liveness fix resets the silence clock on observable production
+ * so a long WORKING turn doesn't dark out. The load-bearing constraint: the
+ * reset must fire ONLY on MODEL-driven production, NEVER from the framework
+ * `feedHeartbeatTick` — a model-INDEPENDENT setInterval that re-renders a
+ * climbing " · Ns" elapsed every 6s (defeating the feed's content-dedup). If the
+ * reset lived in `drainActivitySummary` (which the heartbeat drains), a
+ * hung-but-bridge-connected agent would have its 300s silence clock reset every
+ * 6s forever, the load-bearing silence-poke unwedge would NEVER fire, and the
+ * conversation would be pinned — the #1556 permanent dangling-turn wedge.
+ *
+ * An adversarial review panel caught exactly this in an earlier revision. These
+ * are STRUCTURAL assertions (the gateway IIFE can't be instantiated in-process —
+ * same pattern as multitopic-routing-wiring.test) that pin the reset to the
+ * model-driven sites so a refactor can't silently reintroduce the regression.
+ * The behavioural counterpart (noteProduction resets; STOP producing → fires)
+ * lives in silence-poke.test.ts; this guards the WIRING the heartbeat must not
+ * cross.
+ */
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const gatewaySrc = readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf-8')
+
+function between(src: string, startMarker: string, endMarker: string): string {
+  const after = src.split(startMarker)[1] ?? ''
+  return after.split(endMarker)[0] ?? ''
+}
+
+describe('silence-poke production-liveness — heartbeat safety', () => {
+  it('drainActivitySummary must NOT reset the silence clock (the framework heartbeat drains here)', () => {
+    const body = between(gatewaySrc, 'async function drainActivitySummary', '\nfunction feedHeartbeatTick')
+    expect(body.length).toBeGreaterThan(100) // sanity: the slice found the function body
+    expect(body).not.toMatch(/noteProduction/)
+  })
+
+  it('feedHeartbeatTick itself must NOT reset the silence clock (model-independent re-render)', () => {
+    const body = between(gatewaySrc, 'function feedHeartbeatTick(): void {', '\n}')
+    expect(body.length).toBeGreaterThan(50)
+    expect(body).not.toMatch(/noteProduction/)
+  })
+
+  it('the MODEL-driven tool-label append IS the reset site, gated on the live turn', () => {
+    // appendActivityLabel returns a fresh render only when the model emits a NEW
+    // labelled step — the genuine liveness signal the heartbeat can never forge.
+    const block = between(
+      gatewaySrc,
+      'const rendered = appendActivityLabel(turn.mirrorLines, ev.label)',
+      '\n      return',
+    )
+    expect(block).toMatch(/silencePoke\.noteProduction/)
+    expect(block).toMatch(/currentTurn === turn/)
+  })
+
+  it('the answer-stream draft onMetric reset is model-driven and gated on the live turn', () => {
+    const block = between(gatewaySrc, 'onMetric: (metricEv) => {', '\n            },')
+    expect(block).toMatch(/silencePoke\.noteProduction/)
+    expect(block).toMatch(/currentTurn === turn/)
+  })
+
+  it('production-liveness is behind the default-ON SWITCHROOM_SILENCE_LIVENESS_PRODUCTION kill switch', () => {
+    expect(gatewaySrc).toMatch(/SWITCHROOM_SILENCE_LIVENESS_PRODUCTION !== '0'/)
+  })
+})

package/telegram-plugin/tests/silence-poke.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 import {
   startTurn,
   noteOutbound,
+  noteProduction,
   noteThinking,
   noteToolStart,
   noteToolEnd,
@@ -136,6 +137,47 @@ describe('silence-poke — outbound resets the silence clock', () => {
   })
 })
 
+// Production-liveness (2026-06-05): an activity-feed render or draft update is
+// the agent visibly working — it resets the silence clock so a long
+// tool/composition turn isn't torn down mid-work.
+describe('silence-poke — noteProduction resets the silence clock', () => {
+  it('a feed/draft render at 250s pushes the fallback measurement to it', () => {
+    const fx = setupDeps()
+    startTurn('k', 0)
+    noteProduction('k', 250_000)
+    __tickForTests(300_000) // 50s since production — no fire
+    expect(fx.fallbacks).toHaveLength(0)
+    __tickForTests(550_000) // 300s since production — fires
+    expect(fx.fallbacks).toHaveLength(1)
+  })
+
+  it('repeated production every 60s keeps a long turn alive indefinitely', () => {
+    const fx = setupDeps()
+    startTurn('k', 0)
+    for (let t = 60_000; t <= 600_000; t += 60_000) {
+      noteProduction('k', t)
+      __tickForTests(t)
+    }
+    // 10 min of steady feed/draft renders — never torn down.
+    expect(fx.fallbacks).toHaveLength(0)
+  })
+
+  it('production STOPS → the fallback fires 300s after the last render (genuine wedge)', () => {
+    const fx = setupDeps()
+    startTurn('k', 0)
+    noteProduction('k', 100_000) // last render at 100s, then silence
+    __tickForTests(390_000) // 290s since last render — no fire
+    expect(fx.fallbacks).toHaveLength(0)
+    __tickForTests(401_000) // 301s since last render — fires
+    expect(fx.fallbacks).toHaveLength(1)
+  })
+
+  it('is a no-op for an unknown key (no turn state)', () => {
+    setupDeps()
+    expect(() => noteProduction('nope', 1_000)).not.toThrow()
+  })
+})
+
 // Pin the contract the gateway must uphold for ABNORMAL turn-ends:
 // every code path that abandons a turn before turn_end (context-
 // exhaust bail, gateway-side wedge timeout, silent-end recovery)