switchroom 0.15.44 → 0.16.4

package/telegram-plugin/registry/turns-schema.test.ts

@@ -23,6 +23,30 @@ import {
   getTurnByKey,
 } from './turns-schema.js'
 
+// ---------------------------------------------------------------------------
+// Concurrency PRAGMAs — applySchema must arm busy_timeout so concurrent
+// writers (the subagent-tracker hooks + the gateway watcher) wait-and-retry
+// instead of failing with SQLITE_BUSY ("database is locked").
+// ---------------------------------------------------------------------------
+
+describe('registry concurrency PRAGMAs', () => {
+  it('arms busy_timeout (5000ms) on every opened connection', () => {
+    const db = openTurnsDbInMemory()
+    const row = db.prepare('PRAGMA busy_timeout').get() as { timeout: number }
+    expect(row.timeout).toBe(5000)
+    db.close()
+  })
+
+  it('uses WAL journal mode for concurrent readers', () => {
+    const db = openTurnsDbInMemory()
+    const row = db.prepare('PRAGMA journal_mode').get() as { journal_mode: string }
+    // `:memory:` reports 'memory'; a file DB reports 'wal'. Either way the
+    // exec ran without error — the file-path open (openTurnsDb) yields 'wal'.
+    expect(['wal', 'memory']).toContain(String(row.journal_mode).toLowerCase())
+    db.close()
+  })
+})
+
 // ---------------------------------------------------------------------------
 // Test 1 — empty DB
 // ---------------------------------------------------------------------------

package/telegram-plugin/registry/turns-schema.ts

@@ -172,6 +172,15 @@ const PHASE2_MIGRATIONS = [
 function applySchema(db: SqliteDatabase): void {
   db.exec('PRAGMA journal_mode = WAL')
   db.exec('PRAGMA synchronous = NORMAL')
+  // Concurrency: multiple writers contend on this registry (the PreToolUse
+  // subagent-tracker hook, the gateway's subagent-watcher backfill, the turns
+  // writer) — especially when several sub-agents dispatch at once. Without a
+  // busy_timeout, bun:sqlite/better-sqlite3 default to 0ms and the second
+  // contending write fails IMMEDIATELY with SQLITE_BUSY ("database is locked"),
+  // which the watcher swallows → jsonl_agent_id / parent_turn_key left NULL →
+  // worker card mis-routes to the operator DM + false silent-stall synthesis.
+  // 5s of wait-and-retry serializes the contenders instead of dropping writes.
+  db.exec('PRAGMA busy_timeout = 5000')
   db.exec(SCHEMA_SQL)
   // Run migrations. SQLite doesn't support "ADD COLUMN IF NOT EXISTS", so
   // we swallow the "duplicate column" error to stay idempotent on

package/telegram-plugin/runtime-metrics.ts

@@ -77,6 +77,19 @@ export type RuntimeMetricEvent =
       fallback_kind: 'working' | 'thinking'
       silence_ms: number
     }
+  /**
+   * #2527 — mid-turn liveness floor decision. `decision: 'fire'` when the
+   * quiet "still on it" beat was sent; otherwise the machine-readable skip
+   * reason for a declined forced ("Status?") poke. `forced` distinguishes
+   * the timer beat from a user-asked one.
+   */
+  | {
+      kind: 'mid_turn_floor'
+      key: string
+      silence_ms: number
+      forced: boolean
+      decision: string
+    }
   /**
    * #1445 cross-turn pending-async ambient lifecycle. `started` fires
    * when a turn ends with a captured anchor AND a pending Agent/Task/

package/telegram-plugin/session-tail.ts

@@ -98,7 +98,17 @@ export type SessionEvent =
   // the lazily-flushed transcript. The draft-mirror drives off THIS, not
   // the flush-gated `tool_use`, so activity streams deterministically.
   | { kind: 'tool_label'; toolUseId: string; label: string; toolName: string }
-  | { kind: 'text'; text: string }
+  // `blockIndex` = index of this text block in the assistant message's
+  // content[] — load-bearing: it keys the returned Map so callers emit
+  // events in source order. `lastInMessage` = true iff no tool_use block
+  // follows it in the SAME message. NOTE: `lastInMessage` is a PROJECTION
+  // ARTIFACT only — the current reducer-side narrative-dedup gate
+  // (narrative-dedup.ts) decides draft-then-send vs working-narration by
+  // LOOKAHEAD (the next tool_use / turn_end), NOT by reading this flag. It
+  // is retained as a stable projection output (pinned by the kernel test)
+  // and reserved for a future staging-skip optimization; do not assume the
+  // gate keys on it.
+  | { kind: 'text'; text: string; blockIndex: number; lastInMessage: boolean }
   | { kind: 'tool_result'; toolUseId: string; toolName: string | null; isError?: boolean; errorText?: string }
   | { kind: 'turn_end'; durationMs: number }
   // Multi-agent: sub-agent-scoped events. agentId is the sub-agent JSONL
@@ -106,8 +116,12 @@ export type SessionEvent =
   // as parent events; the reducer fans them out to per-sub-agent state.
   | { kind: 'sub_agent_started'; agentId: string; firstPromptText: string; subagentType?: string }
   | { kind: 'sub_agent_tool_use'; agentId: string; toolUseId: string | null; toolName: string; input?: Record<string, unknown>; precomputedLabel?: string }
-  | { kind: 'sub_agent_text'; agentId: string; text: string }
-  | { kind: 'sub_agent_narrative'; agentId: string; text: string }
+  // Same shared contract as the main-agent `text` kind — see its doc above
+  // (including the `lastInMessage` projection-artifact note). The wire-kind
+  // stays distinct (the gateway/watcher split is load-bearing) but the
+  // payload + `lastInMessage` derivation are identical so ONE shared dedup
+  // gate handles both tiers.
+  | { kind: 'sub_agent_text'; agentId: string; text: string; blockIndex: number; lastInMessage: boolean }
   | { kind: 'sub_agent_tool_result'; agentId: string; toolUseId: string; isError?: boolean; errorText?: string }
   | { kind: 'sub_agent_turn_end'; agentId: string }
   | { kind: 'sub_agent_nested_spawn'; agentId: string }
@@ -182,6 +196,49 @@ function extractToolResultErrorText(content: unknown): string {
   return ''
 }
 
+/**
+ * THE single text→narrative projection primitive. Both projectTranscriptLine
+ * and projectSubagentLine derive their text events through this helper so
+ * main-agent, sub-agent, worker, and every other execution shape inherit
+ * identical text-block semantics from ONE place: empty/whitespace blocks are
+ * dropped, and each surviving block carries its `blockIndex` plus the
+ * `lastInMessage` signal (no tool_use follows it in this message). NOTE:
+ * `lastInMessage` is a projection artifact — the reducer-side dedup gate
+ * decides SHOW/SUPPRESS by lookahead, not by reading this flag (see the
+ * SessionEvent `text` doc); it is reserved for a future staging-skip
+ * optimization.
+ *
+ * `make` adapts the shared payload into the tier-specific wire kind
+ * (`text` vs `sub_agent_text`); the contract — what counts as a text block,
+ * how `lastInMessage` is computed — lives here, not in the callers.
+ *
+ * Returns a `Map<blockIndex, SessionEvent>` keyed by the text block's source
+ * index, NOT a flat list. This is the load-bearing design choice: the callers
+ * must emit thinking / tool_use / text events in SOURCE ORDER (the reducer
+ * pairs a preamble to the immediately-next tool_use), so they iterate
+ * `content` once and, at each text position, emit the precomputed event from
+ * this map. The kernel owns the contract; the caller owns only the ordering.
+ */
+export function projectAssistantTextBlocks(
+  content: Array<Record<string, unknown>>,
+  make: (text: string, blockIndex: number, lastInMessage: boolean) => SessionEvent,
+): Map<number, SessionEvent> {
+  const out = new Map<number, SessionEvent>()
+  // Precompute the index of the last tool_use so each text block knows
+  // whether a tool_use follows it in THIS message (the draft-then-send signal).
+  let lastToolUseIdx = -1
+  content.forEach((c, i) => {
+    if (c.type === 'tool_use') lastToolUseIdx = i
+  })
+  content.forEach((c, i) => {
+    if (c.type !== 'text') return
+    const text = (c.text as string | undefined) ?? ''
+    if (text.trim().length === 0) return // drop empty/whitespace-only blocks
+    out.set(i, make(text, i, i > lastToolUseIdx))
+  })
+  return out
+}
+
 /**
  * Project a single transcript line into a SessionEvent (or null if it's
  * uninteresting noise). Caller is responsible for the JSON parse — if a
@@ -218,7 +275,16 @@ export function projectTranscriptLine(line: string): SessionEvent[] {
     const content = message?.content as Array<Record<string, unknown>> | undefined
     if (!Array.isArray(content)) return []
     const events: SessionEvent[] = []
-    for (const c of content) {
+    // Text→narrative projection comes from the ONE shared kernel
+    // (projectAssistantTextBlocks): it owns the empty-drop + blockIndex +
+    // lastInMessage contract. We emit its events at their source positions
+    // so thinking / tool_use / text stay in source order (the reducer pairs
+    // a preamble to the immediately-next tool_use).
+    const textEvents = projectAssistantTextBlocks(
+      content,
+      (text, blockIndex, lastInMessage): SessionEvent => ({ kind: 'text', text, blockIndex, lastInMessage }),
+    )
+    content.forEach((c, i) => {
       const ct = c.type as string | undefined
       if (ct === 'thinking') {
         events.push({ kind: 'thinking' })
@@ -237,10 +303,10 @@ export function projectTranscriptLine(line: string): SessionEvent[] {
           input: input && typeof input === 'object' ? input : undefined,
         })
       } else if (ct === 'text') {
-        const text = (c.text as string | undefined) ?? ''
-        events.push({ kind: 'text', text })
+        const ev = textEvents.get(i)
+        if (ev != null) events.push(ev)
       }
-    }
+    })
     return events
   }
 
@@ -357,7 +423,25 @@ export function projectSubagentLine(
     const content = message?.content as Array<Record<string, unknown>> | undefined
     if (!Array.isArray(content)) return []
     const events: SessionEvent[] = []
-    for (const c of content) {
+    // Text→narrative projection comes from the SAME shared kernel as the
+    // main agent (projectAssistantTextBlocks): one source for the empty-drop
+    // + blockIndex + lastInMessage contract. The `make` adapter only changes
+    // the wire kind to `sub_agent_text`. A nested Agent/Task tool_use still
+    // counts as a tool_use that follows a preceding text block — handled by
+    // the kernel — so a sub-agent preamble before a nested spawn is correctly
+    // NOT `lastInMessage`. We emit at source positions so text + tool_use
+    // stay in source order (the reducer pairs preamble → next tool_use).
+    const textEvents = projectAssistantTextBlocks(
+      content,
+      (text, blockIndex, lastInMessage): SessionEvent => ({
+        kind: 'sub_agent_text',
+        agentId,
+        text,
+        blockIndex,
+        lastInMessage,
+      }),
+    )
+    content.forEach((c, i) => {
       const ct = c.type as string | undefined
       if (ct === 'tool_use') {
         const name = (c.name as string | undefined) ?? ''
@@ -386,10 +470,11 @@ export function projectSubagentLine(
         // in the SAME assistant message must be emitted in source order
         // so the reducer consumes the preamble on the immediately-next
         // tool_use and sibling tool_uses fall back to filename/pattern.
-        const text = (c.text as string | undefined) ?? ''
-        events.push({ kind: 'sub_agent_text', agentId, text })
+        // The event itself comes from the shared kernel (textEvents above).
+        const ev = textEvents.get(i)
+        if (ev != null) events.push(ev)
       }
-    }
+    })
     // Authoritative early terminal: a background `Agent` worker's JSONL on
     // claude ≥2.1.156 never writes the `system/turn_duration` line below, so
     // the watcher used to only learn the worker finished via the ~5-min

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}`)
       }