switchroom 0.15.45 → 0.16.5

package/telegram-plugin/worker-activity-feed.ts

@@ -34,11 +34,11 @@
 
 import {
   cleanWorkerResultParagraph,
-  escapeHtml,
-  formatDuration,
   stripMarkdown,
   truncate,
 } from './card-format.js'
+import { STATUS_ROLLING_LINES } from './status-no-truncate.js'
+import { renderStatusCard, formatFeedElapsed } from './tool-activity-summary.js'
 
 /** Worker-activity feed is ON by default; an operator opts out with
  *  SWITCHROOM_WORKER_ACTIVITY_FEED=0. */
@@ -86,103 +86,82 @@ export interface BotApiForWorkerFeed {
   ): Promise<unknown>
 }
 
+/** Dispatch-time task description cap for the worker header. */
 const DESC_MAX = 80
-const STEP_MAX = 100
-const RESULT_MAX = 320
-/** Subtle horizontal rule between the running feed and the finished result. */
-const RULE = '─────'
-/**
- * How many trailing narrative lines the live feed keeps visible. The feed
- * grows like the main agent's answer but can't grow unbounded — Telegram
- * caps message length and a wall of stale lines buries the live one. Six
- * keeps recent context without dominating the chat.
- */
-const NARRATIVE_MAX_LINES = 6
 
 /**
- * Append the accumulated step feed to `lines`, mirroring the main agent's
- * activity card (`renderActivityFeed`): prior steps render done (`✓`, italic),
- * the newest renders in-progress (`→`, bold) unless `allDone`, and an overflow
- * header (`✓ +N earlier…`) appears when the feed exceeds NARRATIVE_MAX_LINES.
- * `steps` are already cleaned + escaped HTML.
- */
-function appendStepFeed(lines: string[], steps: string[], allDone: boolean): void {
-  if (steps.length === 0) return
-  const shown = steps.slice(-NARRATIVE_MAX_LINES)
-  const hidden = steps.length - shown.length
-  if (hidden > 0) lines.push(`<i>✓ +${hidden} earlier…</i>`)
-  const lastIdx = shown.length - 1
-  shown.forEach((s, i) => {
-    lines.push(!allDone && i === lastIdx ? `<b>→ ${s}</b>` : `<i>✓ ${s}</i>`)
-  })
-}
-
-/**
- * Render the worker-activity message body as native Telegram HTML, matching
- * the main agent's activity card (`renderActivityFeed` in
- * tool-activity-summary.ts): a `🛠 Worker · <desc>` header, a one-line status,
- * then a `✓`/`→` step feed. Worker narration is authored as Markdown, so every
- * text fragment is run through `stripMarkdown` before escaping — without it the
- * raw `**`/`` ` ``/`---` leak through as literal characters (the "half-done"
- * look we're fixing).
+ * Thin adapter over the unified `renderStatusCard` primitive (emoji 🛠, label
+ * 'Worker'): builds the header, passes raw narrative steps (the primitive runs
+ * stripMarkdown → collapse ws → clip → escape per line), and on finish passes
+ * the cleaned result paragraph as the `result` block.
  *
  * Layout (running):
  *   🛠 <b>Worker</b> · <i>{description}</i>
- *   <i>running · {elapsed} · {n} tools</i>
+ *   <i>{elapsed} · {n} tools</i>
  *   <i>✓ {earlier step}</i>
  *   <b>→ {newest step}</b>
  *
  * Layout (finished): the feed renders all-done, then a rule + cleaned result:
  *   🛠 <b>Worker</b> · <i>{description}</i>
- *   <i>finished · completed · {n} tools · {elapsed}</i>
+ *   <i>done · {n} tools · {elapsed}</i>
  *   <i>✓ {step}</i>
  *   ─────
  *   ✅ <i>{cleaned result paragraph}</i>
  */
-export function renderWorkerActivity(v: WorkerActivityView): string {
+export function renderWorkerActivity(v: WorkerActivityView, liveSuffix = ''): string {
   const desc = truncate(stripMarkdown(v.description).trim() || 'background task', DESC_MAX)
-  const elapsed = formatDuration(v.elapsedMs)
-  const toolWord = v.toolCount === 1 ? 'tool' : 'tools'
-  const header = `🛠 <b>Worker</b> · <i>${escapeHtml(desc)}</i>`
   const finished = v.state === 'done' || v.state === 'failed'
 
-  const steps = (v.narrativeLines ?? [])
-    // A narrative entry can itself be multi-line (e.g. a worker's final
-    // "Done.\n\n## Summary\n…"). Collapse to one visual line so a step
-    // slot stays single-line after the per-line markdown strip.
-    .map((s) => stripMarkdown(s).replace(/\s+/g, ' ').trim())
-    .filter((s) => s.length > 0)
-    .map((s) => escapeHtml(truncate(s, STEP_MAX)))
+  // Raw narrative steps (unstripped/unescaped) — the unified renderer runs the
+  // full per-line pipeline (stripMarkdown → collapse ws → clip → escape).
+  const rawSteps = (v.narrativeLines ?? []).filter((s) => s != null && s.trim().length > 0)
+
+  // Back-compat for direct render callers that pass only latestSummary while
+  // RUNNING; the manager always supplies narrativeLines. On the FINISHED path
+  // latestSummary is the worker's RESULT (below), never a narrative step — so
+  // the fallback only applies while running.
+  let steps = rawSteps
+  if (steps.length === 0 && !finished) {
+    const summary = stripMarkdown(v.latestSummary).replace(/\s+/g, ' ').trim()
+    if (summary.length > 0) steps = [v.latestSummary]
+  }
+
+  const header: Parameters<typeof renderStatusCard>[0]['header'] = {
+    emoji: '🛠',
+    label: 'Worker',
+    description: desc,
+    elapsedMs: v.elapsedMs,
+    toolCount: v.toolCount,
+    state: v.state,
+  }
 
+  // Terminal: latestSummary carries the worker's final result text (gateway
+  // onFinish), distinct from the running narrative steps. Pass it as `result`.
+  let result: { emoji: string; text: string } | undefined
   if (finished) {
-    const verb = v.state === 'done' ? 'completed' : 'failed'
-    const lines = [header, `<i>finished · ${verb} · ${v.toolCount} ${toolWord} · ${elapsed}</i>`]
-    appendStepFeed(lines, steps, true)
-    // On terminal, latestSummary carries the worker's final result text
-    // (gateway onFinish), distinct from the running narrative steps.
-    const result = cleanWorkerResultParagraph(v.latestSummary)
-    if (result.length > 0) {
-      const emoji = v.state === 'done' ? '✅' : '⚠️'
-      lines.push(RULE)
-      lines.push(`${emoji} <i>${escapeHtml(truncate(result, RESULT_MAX))}</i>`)
-    }
-    return lines.join('\n')
+    const text = cleanWorkerResultParagraph(v.latestSummary)
+    if (text.length > 0) result = { emoji: v.state === 'done' ? '✅' : '⚠️', text }
   }
 
-  const lines = [header, `<i>running · ${elapsed} · ${v.toolCount} ${toolWord}</i>`]
-  if (steps.length > 0) {
-    appendStepFeed(lines, steps, false)
-  } else {
-    // Back-compat for direct render callers that pass only latestSummary;
-    // the manager always supplies narrativeLines.
-    const summary = stripMarkdown(v.latestSummary).replace(/\s+/g, ' ').trim()
-    if (summary.length > 0) {
-      lines.push(`<b>→ ${escapeHtml(truncate(summary, STEP_MAX))}</b>`)
-    } else {
-      lines.push('<i>starting…</i>')
-    }
+  // `renderStatusCard` always returns content when a header is supplied. When
+  // running with no steps it shows just the header — append a "starting…" line
+  // for parity with the prior behaviour.
+  const card = renderStatusCard({
+    header,
+    steps,
+    final: finished,
+    liveSuffix: finished ? '' : liveSuffix,
+    result,
+  })
+  if (card == null) {
+    // Unreachable (header always present) — defensive.
+    return `🛠 <b>Worker</b> · <i>starting…</i>`
   }
-  return lines.join('\n')
+  if (!finished && steps.length === 0) {
+    // Header-only running render → append the starting placeholder.
+    return `${card}\n<i>starting…</i>`
+  }
+  return card
 }
 
 export interface WorkerActivityFeedOpts {
@@ -205,6 +184,19 @@ export interface WorkerActivityFeedOpts {
   firstPaintMinMs?: number
   /** stderr-style log sink. Defaults to noop. */
   log?: (msg: string) => void
+  /**
+   * Heartbeat timer factory. Injectable for tests. Defaults to the real
+   * `setInterval`, `.unref()`'d so it never keeps the process alive.
+   */
+  setInterval?: (cb: () => void, ms: number) => unknown
+  /** Heartbeat timer disposer. Injectable for tests. Defaults to `clearInterval`. */
+  clearInterval?: (handle: unknown) => void
+  /**
+   * Heartbeat tick cadence in ms. On each tick a stale, running worker is
+   * re-rendered with a climbing `· Ns` suffix so a worker that emits no new
+   * narrative still visibly advances. Default 6000ms.
+   */
+  heartbeatTickMs?: number
 }
 
 interface WorkerHandle {
@@ -218,12 +210,20 @@ interface WorkerHandle {
   cooldownUntil: number
   /**
    * Accumulated narrative lines (oldest→newest), deduped against the
-   * immediately-preceding line and capped to NARRATIVE_MAX_LINES. Grows the
-   * live render so the feed reads like the main agent's answer.
+   * immediately-preceding line. Rolling-window capped to STATUS_ROLLING_LINES.
+   * Grows the live render so the feed reads like the main agent's answer.
    */
   narrative: string[]
   /** Per-worker serialization chain so ticks can't interleave sends. */
   chain: Promise<void>
+  /** Last view rendered into the message (drives the heartbeat re-render). */
+  lastView: WorkerActivityView | null
+  /**
+   * Wall-clock ms the worker was dispatched, derived from `now - view.elapsedMs`
+   * on the first update. The heartbeat computes a live elapsed from this so the
+   * `· Ns` suffix climbs even when no fresh view arrives.
+   */
+  dispatchAtMs: number | null
 }
 
 const COOLDOWN_JITTER_MS = 500
@@ -257,6 +257,10 @@ export interface WorkerActivityFeed {
   finish(agentId: string, view: WorkerActivityView): Promise<void>
   /** Forget a worker's state without editing (e.g. error path). */
   drop(agentId: string): void
+  /** Clear the heartbeat interval (gateway shutdown). Idempotent. */
+  stop(): void
+  /** Manually fire one heartbeat tick (test hook). */
+  heartbeatTick(): void
   /** Number of tracked workers (test/inspection hook). */
   readonly size: number
 }
@@ -266,12 +270,28 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
   const nowFn = opts.now ?? Date.now
   const minEditInterval = opts.minEditIntervalMs ?? 2500
   const firstPaintMin = opts.firstPaintMinMs ?? 8000
+  const heartbeatTickMs = opts.heartbeatTickMs ?? 6000
+  const setIntervalFn =
+    opts.setInterval ??
+    ((cb: () => void, ms: number): unknown => {
+      const t = setInterval(cb, ms)
+      // Never keep the process alive on the heartbeat alone.
+      ;(t as { unref?: () => void }).unref?.()
+      return t
+    })
+  const clearIntervalFn = opts.clearInterval ?? ((handle: unknown) => clearInterval(handle as ReturnType<typeof setInterval>))
   const handles = new Map<string, WorkerHandle>()
+  let heartbeatTimer: unknown = null
 
   function sendOptsFor(h: WorkerHandle): Record<string, unknown> {
     return {
       parse_mode: 'HTML',
       disable_web_page_preview: true,
+      // Sub-agent progress card is a status surface, never the user's
+      // answer — silence the open ping. (editMessageText ignores
+      // disable_notification, so this is a no-op on the in-place edits
+      // that share these opts.)
+      disable_notification: true,
       ...(h.threadId != null ? { message_thread_id: h.threadId } : {}),
     }
   }
@@ -290,17 +310,25 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
     // same narrative across ticks while a tool runs; we only grow on change.
     if (h.narrative[h.narrative.length - 1] === line) return
     h.narrative.push(line)
-    if (h.narrative.length > NARRATIVE_MAX_LINES) {
-      h.narrative.splice(0, h.narrative.length - NARRATIVE_MAX_LINES)
+    // Rolling window — keep only the last STATUS_ROLLING_LINES in memory. The
+    // render shows exactly those lines (clipped per-line by the unified pipeline);
+    // fitCardToBudget is the wire-limit backstop.
+    if (h.narrative.length > STATUS_ROLLING_LINES) {
+      h.narrative.splice(0, h.narrative.length - STATUS_ROLLING_LINES)
     }
   }
 
-  async function doUpdate(h: WorkerHandle, view: WorkerActivityView): Promise<void> {
+  async function doUpdate(h: WorkerHandle, view: WorkerActivityView, liveSuffix = ''): Promise<void> {
     // Accumulate before any gate so a throttled/cooled-down tick still grows
     // the narrative — the line surfaces on the next edit that does fire.
     accumulateNarrative(h, view)
+    // Stamp the dispatch wall-clock once so the heartbeat can climb a live
+    // elapsed even between fresh views. lastView feeds the heartbeat re-render.
+    const merged: WorkerActivityView = { ...view, narrativeLines: [...h.narrative] }
+    h.lastView = merged
+    if (h.dispatchAtMs == null) h.dispatchAtMs = nowFn() - view.elapsedMs
     if (nowFn() < h.cooldownUntil) return
-    const body = renderWorkerActivity({ ...view, narrativeLines: h.narrative })
+    const body = renderWorkerActivity(merged, liveSuffix)
 
     // First paint: hold off until the worker has run long enough to be
     // worth a message; trivial workers stay silent (handback covers them).
@@ -371,6 +399,44 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
     }
   }
 
+  /**
+   * Heartbeat — option (a), suffix-only, NEVER opens a new message. For each
+   * handle with a posted message, enqueue a re-render through the existing
+   * chain → doUpdate path (never editMessageText directly). Skips:
+   *   - handles with no posted message (messageId == null),
+   *   - handles inside a 429 cooldown,
+   *   - handles edited within minEditInterval (no stampede),
+   *   - non-running handles (terminal/deleted).
+   * The `· Ns` liveSuffix is applied ONLY when the worker's current step is
+   * stale (now - lastEditAt >= heartbeatTickMs) so a normally-ticking worker is
+   * untouched and its body stays byte-stable for the dedup.
+   */
+  function heartbeatTick(): void {
+    const now = nowFn()
+    for (const h of handles.values()) {
+      if (h.messageId == null) continue
+      if (h.lastView == null) continue
+      if (h.lastView.state !== 'running') continue
+      if (now < h.cooldownUntil) continue
+      if (now - h.lastEditAt < minEditInterval) continue
+      const stale = now - h.lastEditAt >= heartbeatTickMs
+      if (!stale) continue
+      const liveElapsed = h.dispatchAtMs != null ? now - h.dispatchAtMs : h.lastView.elapsedMs
+      const liveSuffix = ' · ' + formatFeedElapsed(liveElapsed)
+      // Re-render THROUGH the chain + doUpdate path — never editMessageText directly.
+      const view = h.lastView
+      h.chain = h.chain
+        .then(() => doUpdate(h, view, liveSuffix))
+        .catch((err) => {
+          log(`worker-feed: heartbeat chain error ${h.agentId}: ${(err as Error).message}`)
+        })
+    }
+  }
+
+  // Arm the heartbeat once at construction. The real timer is `.unref()`'d so
+  // it never keeps the process alive; tests inject setInterval/clearInterval.
+  heartbeatTimer = setIntervalFn(heartbeatTick, heartbeatTickMs)
+
   return {
     has(agentId) {
       return handles.get(agentId)?.messageId != null
@@ -394,6 +460,8 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
           cooldownUntil: 0,
           narrative: [],
           chain: Promise.resolve(),
+          lastView: null,
+          dispatchAtMs: null,
         }
         handles.set(agentId, h)
       }
@@ -419,5 +487,12 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
     drop(agentId) {
       handles.delete(agentId)
     },
+    heartbeatTick,
+    stop() {
+      if (heartbeatTimer != null) {
+        clearIntervalFn(heartbeatTimer)
+        heartbeatTimer = null
+      }
+    },
   }
 }

package/telegram-plugin/draft-transport.ts

@@ -1,122 +0,0 @@
-/**
- * Shared draft-transport helpers for answer-stream and draft-stream.
- *
- * Extracted from answer-stream.ts so both the narrative answer-lane and the
- * model-driven stream_reply lane can share the same regex constants and
- * fallback logic without duplicating them.
- *
- * answer-stream.ts re-exports these symbols so existing callers (including
- * tests that import directly from answer-stream.ts) continue to work.
- */
-
-// Error patterns matching OpenClaw's shouldFallbackFromDraftTransport.
-// Exported for tests.
-export const DRAFT_METHOD_UNAVAILABLE_RE =
-  /(unknown method|method .*not (found|available|supported)|unsupported)/i
-export const DRAFT_CHAT_UNSUPPORTED_RE = /(can't be used|can be used only)/i
-
-/**
- * Returns true when a sendMessageDraft rejection means "this API is not
- * available" rather than a transient network error.
- */
-export function shouldFallbackFromDraftTransport(err: unknown): boolean {
-  const text =
-    typeof err === 'string'
-      ? err
-      : err instanceof Error
-        ? err.message
-        : typeof err === 'object' && err != null && 'description' in err
-          ? typeof (err as { description: unknown }).description === 'string'
-            ? (err as { description: string }).description
-            : ''
-          : ''
-  if (!/sendMessageDraft/i.test(text)) return false
-  return DRAFT_METHOD_UNAVAILABLE_RE.test(text) || DRAFT_CHAT_UNSUPPORTED_RE.test(text)
-}
-
-/**
- * PR D — extract the `retry_after` seconds from a grammY 429 error.
- * Returns null when the error isn't a 429 (or has no retry_after).
- *
- * Shared with `issues-card.ts:extractRetryAfterSecs`. Duck-typed on the
- * documented grammY `GrammyError` shape to keep this module
- * test-friendly without importing `GrammyError` directly.
- */
-export function extractDraft429RetryAfterSecs(err: unknown): number | null {
-  if (err == null || typeof err !== 'object') return null
-  const e = err as { error_code?: unknown; parameters?: { retry_after?: unknown } }
-  if (e.error_code !== 429) return null
-  const ra = e.parameters?.retry_after
-  if (typeof ra === 'number' && Number.isFinite(ra) && ra > 0) return ra
-  return null
-}
-
-/**
- * PR D — was this a 429 from `sendMessageDraft` specifically? Used by
- * draft-stream to differentiate "draft is rate-limited" (transient,
- * just back off this stream) from a non-429 send error (handled
- * separately by `shouldFallbackFromDraftTransport`).
- *
- * Both cases trigger fallback to message transport for the rest of
- * the stream, but the 429 case ALSO bumps the throttle window to
- * honor Telegram's `retry_after` — so the message-transport fallback
- * doesn't immediately fire a fresh send before Telegram's cooldown
- * elapses and re-429s.
- */
-export function isDraft429(err: unknown): boolean {
-  if (extractDraft429RetryAfterSecs(err) == null) return false
-  // grammY GrammyError carries the method name in its `method` field.
-  // Best-effort: match either the structured method or the error text.
-  if (typeof err === 'object' && err != null && 'method' in err) {
-    const m = (err as { method?: unknown }).method
-    if (typeof m === 'string' && /sendMessageDraft/i.test(m)) return true
-  }
-  const text =
-    typeof err === 'string'
-      ? err
-      : err instanceof Error
-        ? err.message
-        : typeof err === 'object' && err != null && 'description' in err
-          ? typeof (err as { description: unknown }).description === 'string'
-            ? (err as { description: string }).description
-            : ''
-          : ''
-  return /sendMessageDraft/i.test(text)
-}
-
-/**
- * Symbol-keyed shared counter for draft-id allocation across concurrent
- * streams (mirrors openclaw's getDraftStreamState). Using Symbol.for ensures
- * the same counter is shared even if this module is loaded multiple times
- * (e.g. from different bundle chunks).
- */
-const DRAFT_STREAM_STATE_KEY = Symbol.for('switchroom.draftStreamState')
-
-interface DraftStreamState {
-  nextDraftId: number
-}
-
-function getDraftStreamState(): DraftStreamState {
-  const g = globalThis as Record<PropertyKey, unknown>
-  let state = g[DRAFT_STREAM_STATE_KEY] as DraftStreamState | undefined
-  if (!state) {
-    state = { nextDraftId: 0 }
-    g[DRAFT_STREAM_STATE_KEY] = state
-  }
-  return state
-}
-
-/**
- * Allocate a unique draft ID, wrapping at 2_147_483_647 (Telegram's int32
- * max for draft_id). IDs start at 1 and cycle.
- */
-export function allocateDraftId(): number {
-  const state = getDraftStreamState()
-  state.nextDraftId = state.nextDraftId >= 2_147_483_647 ? 1 : state.nextDraftId + 1
-  return state.nextDraftId
-}
-
-/** Reset the shared draft-id counter — for tests only. */
-export function __resetDraftIdForTests(): void {
-  getDraftStreamState().nextDraftId = 0
-}

package/telegram-plugin/tests/draft-retirement-wiring.test.ts

@@ -1,82 +0,0 @@
-/**
- * Answer-lane wiring guards — draft retirement + flash decoupling.
- *
- * History:
- *  - v0.14.52 turned the VISIBLE answer-stream OFF by default to remove the
- *    "raw preview appears, formatted reply lands, raw preview deleted" flash.
- *  - v0.14.68 retired the invisible compose-box DRAFT transport. The original
- *    wiring (and the first version of this test) conflated the two flags —
- *    `ANSWER_STREAM_VISIBLE_ENABLED || DRAFT_ANSWER_LANE_RETIRED` — so retiring
- *    the draft (default) silently forced a VISIBLE preview (minInitialChars:1)
- *    even with the visible flag off, re-introducing the flash FLEET-WIDE
- *    (v0.14.68 undid v0.14.52). The first revision of this file pinned that
- *    conflation as a "guard" — i.e. it asserted the bug.
- *  - 2026-06-05 flash-decouple: the VISIBLE preview now gates on the visible
- *    flag ALONE; DRAFT_ANSWER_LANE_RETIRED controls only the TRANSPORT. With
- *    defaults (visible off, draft retired) the lane is DORMANT — no preview, the
- *    reply tool is the single formatted message, no flash. The no-reply text-only
- *    answer is delivered by the turn-flush backstop (the pre-v0.14.68 path).
- *
- * gateway IIFE can't be instantiated in-process, so these are source-level
- * assertions (same pattern as silence-liveness-wiring.test).
- */
-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')
-
-describe('answer-lane wiring (draft retirement + flash decoupling)', () => {
-  it('sendMessageDraftFn is gated on the retirement (the single transport chokepoint)', () => {
-    expect(gatewaySrc).toMatch(/!DRAFT_ANSWER_LANE_RETIRED && typeof _rawSendMessageDraft === 'function'/)
-  })
-
-  it('DRAFT_ANSWER_LANE_RETIRED is declared before its first use (no TDZ at boot)', () => {
-    const declIdx = gatewaySrc.indexOf('const DRAFT_ANSWER_LANE_RETIRED =')
-    const firstUseIdx = gatewaySrc.indexOf('!DRAFT_ANSWER_LANE_RETIRED && typeof _rawSendMessageDraft')
-    expect(declIdx).toBeGreaterThan(0)
-    expect(firstUseIdx).toBeGreaterThan(declIdx)
-  })
-
-  it('the lane behaviour is resolved by the single-source-of-truth pure function', () => {
-    // The flag→config decision lives in resolveAnswerLaneConfig (total-enumerated
-    // in answer-stream-flag.test.ts); the gateway delegates so the three use-sites
-    // can never drift apart.
-    expect(gatewaySrc).toMatch(/const ANSWER_LANE = resolveAnswerLaneConfig\(\{/)
-    expect(gatewaySrc).toMatch(/visibleEnabled: ANSWER_STREAM_VISIBLE_ENABLED/)
-    expect(gatewaySrc).toMatch(/draftFnAvailable: sendMessageDraftFn != null/)
-  })
-
-  it('FLASH GUARD: the createAnswerStream config is driven by ANSWER_LANE (preview gated on the visible flag alone)', () => {
-    // The minInitialChars / draft-transport choice comes from the resolved lane,
-    // never from a `visible || retired` inline conflation.
-    expect(gatewaySrc).toMatch(/\.\.\.\(ANSWER_LANE\.usesDraftTransport/)
-    expect(gatewaySrc).toMatch(/minInitialChars: ANSWER_LANE\.minInitialChars/)
-  })
-
-  it('FLASH GUARD: the visible-OR-retired conflation is GONE everywhere (it pinned the flash)', () => {
-    // No answer-lane path may re-introduce `VISIBLE || RETIRED` — that is the
-    // exact regression this fix removes.
-    expect(gatewaySrc).not.toMatch(/ANSWER_STREAM_VISIBLE_ENABLED \|\| DRAFT_ANSWER_LANE_RETIRED/)
-  })
-
-  it('LOST-ANSWER GUARD: materialize-as-answer gates on ANSWER_LANE.opensVisiblePreview (only fires when a preview actually opened)', () => {
-    // A text-only no-reply turn materializes (ping + keep) ONLY when a visible
-    // preview opened. With visible off the lane is dormant (minInitialChars:MAX),
-    // so this branch is unreachable and the answer is delivered by turn-flush
-    // instead — never retracted away.
-    expect(gatewaySrc).toMatch(/\n\s*ANSWER_LANE\.opensVisiblePreview\s*\n\s*&& !turn\.replyCalled/)
-  })
-
-  it('LOST-ANSWER GUARD: turn-flush is skipped ONLY when the stream finalized as the answer (so dormant-lane no-reply turns still flush)', () => {
-    // flushDecision skips only on streamFinalizedAsAnswer; with the lane dormant
-    // that stays false, so decideTurnFlush runs and delivers the no-reply answer.
-    expect(gatewaySrc).toMatch(/const flushDecision = streamFinalizedAsAnswer\s*\n?\s*\?/)
-  })
-
-  it('the #2169 onMetric silence-liveness reset is still wired (fires on visible sends when opted in)', () => {
-    const onMetric = (gatewaySrc.split('onMetric: (metricEv) => {')[1] ?? '').split('\n            },')[0]
-    expect(onMetric).toMatch(/silencePoke\.noteProduction/)
-    expect(onMetric).toMatch(/currentTurn === turn/)
-  })
-})