switchroom 0.14.10 → 0.14.12

package/telegram-plugin/gateway/boot-card.ts

@@ -625,17 +625,21 @@ export async function startBootCard(
     ...(opts.updateOutcomeLine ? { updateOutcomeLine: opts.updateOutcomeLine } : {}),
   })
 
-  // Silence the notification for operator-initiated redeploys. A
-  // routine `switchroom update` should land in the chat as a record
-  // but not buzz every user's phone — every agent posts a card, so
-  // a fleet update with N agents produces N notifications otherwise.
-  // We key on the reason-text prefix `operator:` (today only
-  // `operator: switchroom update` writes this) so user-initiated
-  // restarts (`user: /restart from chat`, `cli: switchroom restart`)
-  // and unplanned events (crash, fresh, planned-marker) keep their
-  // normal notification behaviour — the user explicitly asked for
-  // those, or they need to know something went wrong.
-  const silentBootCard = opts.restartReasonDetail?.startsWith('operator:') === true
+  // Boot cards are ALWAYS delivered silently (no Telegram
+  // notification). They land in the chat as a record — the operator
+  // can scroll up to see "✅ <agent> back up · vX.Y.Z" — but they
+  // never buzz a phone. Rationale: every agent posts a card on every
+  // restart, so a fleet redeploy of N agents produced N notifications;
+  // even a single user `/restart` or a crash-recovery is a status
+  // record, not something that should pull attention. Operator
+  // decision (2026-05-29): silence them all, unconditionally.
+  //
+  // Previously this was keyed on the `operator:` reason-detail prefix
+  // (only routine `switchroom update` was silent); user `/restart`,
+  // `cli: switchroom restart` rollouts, crashes, and fresh boots all
+  // still notified. That distinction is gone — the card is the record,
+  // the chat is where you look, and nothing here warrants a push.
+  const silentBootCard = true
 
   let messageId: number
   try {

package/telegram-plugin/gateway/gateway.ts

@@ -3407,11 +3407,13 @@ function ensureIssuesCard(chatId: string, threadId: number | undefined): void {
 }
 
 // #1122: framework safety-net for "model is silent to the user for >5min."
-// Starts a single setInterval poll that walks active turns and arms
-// soft/firm poke reminders piggybacked on the next tool result. At 300s
-// the framework itself sends a user-visible "still working… / still
-// thinking…" message. Honours SWITCHROOM_DISABLE_SILENCE_POKE=1 kill
-// switch (no-op if set).
+// Starts a single setInterval poll that walks active turns; at 300s of
+// silence the framework itself sends a user-visible "still working… /
+// still thinking…" message AND unwedges the turn. The model-targeted
+// nudge ladder (ack/soft/firm) and the 60s awareness ping were retired
+// once the live-updating reply/draft took over the pacing job — only
+// this single unwedge fallback remains. Honours
+// SWITCHROOM_DISABLE_SILENCE_POKE=1 kill switch (no-op if set).
 // Set when this gateway dispatches an `update_apply` to hostd that
 // returns `started`; cleared when the dispatch poll resolves (terminal
 // / not-configured / timeout). While set, the framework silence
@@ -3425,43 +3427,6 @@ silencePoke.startTimer({
     // Re-emit through the unified runtime-metrics fan-out (PostHog + JSONL).
     emitRuntimeMetric(event)
   },
-  onAwarenessPing: async (ctx) => {
-    // Early framework-owned awareness signal (~60s) so the user never
-    // faces a silent chat while the model is busy / held / thinking.
-    // Distinct from the 300s onFrameworkFallback: fires earlier, sends
-    // a SILENT message (disable_notification: true — ambient liveness,
-    // not a device buzz), and is bounded to ONE per turn by the silence-
-    // poke module's `awarenessPingFired` flag. Reuses
-    // `formatFrameworkFallbackText` so the wording stays consistent and
-    // in-flight tools are named when known. If the model has been
-    // silent long enough to cross 300s, the heavier framework_fallback
-    // escalates with a notification.
-    //
-    // Late-fire guard mirrors the framework_fallback handler: skip if
-    // the turn ended cleanly between the silence-poke arming and this
-    // timer-fired handler so we don't talk over a clean response.
-    if (activeTurnStartedAt.get(ctx.key) == null && currentTurn == null) {
-      return
-    }
-    const text = silencePoke.formatFrameworkFallbackText(
-      ctx.fallbackKind,
-      ctx.silenceMs,
-      ctx.inFlightTools,
-    )
-    try {
-      await robustApiCall(
-        () => bot.api.sendMessage(ctx.chatId, text, {
-          ...(ctx.threadId != null ? { message_thread_id: ctx.threadId } : {}),
-          disable_notification: true,
-        }),
-        { chat_id: ctx.chatId, ...(ctx.threadId != null ? { threadId: ctx.threadId } : {}) },
-      )
-    } catch (err) {
-      process.stderr.write(
-        `silence-poke awareness-ping sendMessage failed chat=${ctx.chatId} thread=${ctx.threadId}: ${err}\n`,
-      )
-    }
-  },
   onFrameworkFallback: async (ctx) => {
     // Late-fire short-circuit (2026-05-23 audit finding). The fallback
     // can race a clean turn-end: the model's actual reply lands inside
@@ -4052,25 +4017,6 @@ const ipcServer: IpcServer = createIpcServer({
     process.stderr.write(`telegram gateway: ipc: tool_call tool=${msg.tool} agent=${client.agentName ?? '-'} clientId=${client.id ?? '-'} callId=${msg.id}\n`)
     try {
       const result = await executeToolCall(msg.tool, msg.args)
-      // #1122 silence-poke chokepoint: piggyback any armed poke onto the
-      // tool result's content text. The model sees the [silence-poke]
-      // system-reminder block as part of the next conversational turn.
-      // No-op when nothing is armed (the common case) — cost is one
-      // map iteration over <=N active turns (typically 1).
-      const reminder = silencePoke.consumeArmedPoke()
-      if (reminder != null && result != null && typeof result === 'object') {
-        const r = result as { content?: Array<{ type: string; text: string }> }
-        if (Array.isArray(r.content) && r.content.length > 0 && r.content[0]!.type === 'text') {
-          r.content[0]!.text = `${r.content[0]!.text}\n\n<system-reminder>\n${reminder}\n</system-reminder>`
-        } else {
-          // Tool result didn't carry a text block to wrap — re-shape so
-          // the reminder still reaches the model.
-          r.content = [
-            ...(Array.isArray(r.content) ? r.content : []),
-            { type: 'text', text: `<system-reminder>\n${reminder}\n</system-reminder>` },
-          ]
-        }
-      }
       return { type: 'tool_call_result', id: msg.id, success: true, result }
     } catch (err) {
       return {
@@ -4094,17 +4040,13 @@ const ipcServer: IpcServer = createIpcServer({
     progressDriver?.ingest(ev, chatHint, threadHint)
     handleSessionEvent(ev)
     // #1122 silence-poke: surface activity signals from the session
-    // stream so the fallback message wording is honest and so
-    // subagent-dispatch waits don't fire spurious soft pokes.
+    // stream so the 300s framework-fallback message wording is honest
+    // (thinking vs working, plus the longest-running in-flight tool).
     if (currentTurn != null) {
       const key = statusKey(currentTurn.sessionChatId, currentTurn.sessionThreadId)
       if (ev.kind === 'thinking') {
         silencePoke.noteThinking(key, Date.now())
       } else if (ev.kind === 'tool_use') {
-        if (ev.toolName === 'Task' || ev.toolName === 'Agent') {
-          // Built-in claude sub-agent dispatch — extends soft threshold to 5min.
-          silencePoke.noteSubagentDispatch(key)
-        }
         // #1292: track in-flight tool calls so the 300s framework
         // fallback message can name the actual observable (e.g.
         // "running Grep \"foo\" for 4m") instead of the dishonest

package/telegram-plugin/runtime-metrics.ts

@@ -19,7 +19,6 @@
 import { existsSync, mkdirSync, appendFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { captureEvent } from './analytics-posthog.js'
-import type { PokeLevel } from './silence-poke.js'
 
 export type RuntimeMetricEvent =
   /**
@@ -63,40 +62,14 @@ export type RuntimeMetricEvent =
       ended_via: 'reply' | 'stream_reply_done' | 'silent' | 'forced' | 'framework_fallback'
     }
   /**
-   * Framework safety-net: a silence-poke was armed. `ack` is the early
-   * (~10s) ack-budget poke — the model has sent NOTHING this turn and is
-   * leaving the user on a silent chat. `soft` (75s) / `firm` (180s) are
-   * the silence-since-last-outbound ladder. The system-reminder appended
-   * to the next tool result nudges the model to send an update. Doubles
-   * as a design-health signal — if these fire frequently, the
-   * conversational-pacing prompt isn't doing its job.
-   */
-  | {
-      kind: 'silence_poke_fired'
-      key: string
-      level: PokeLevel
-      silence_ms: number
-      subagent_wait: boolean
-    }
-  /**
-   * The model sent an outbound message within the success window
-   * (default 15s) after a poke fired. Pair with `silence_poke_fired`
-   * to compute success rate — the design target is >80%. (`ack`-level
-   * success is not currently emitted — the ack poke sits outside the
-   * `pokesFired` ladder noteOutbound measures against; the type admits
-   * `ack` only so the silence-poke metric union stays assignable.)
-   */
-  | {
-      kind: 'silence_poke_succeeded'
-      key: string
-      level: PokeLevel
-      latency_ms: number
-    }
-  /**
-   * Last-resort: 5 minutes silent, the framework itself sent a
-   * user-visible "still working… / still thinking…" message. Should
-   * be rare (target <5 per 1000 turns); a high rate means the model
-   * is genuinely stuck or the soft/firm pokes aren't being honoured.
+   * Last-resort safety net: 5 minutes silent, the framework itself sent
+   * a user-visible "still working… / still thinking…" message AND
+   * unwedged the turn (cleared activeTurnStartedAt, nulled currentTurn,
+   * drained buffered inbound). Should be rare (target <5 per 1000 turns);
+   * a high rate means turns are genuinely getting stuck. This is the only
+   * remaining framework safety-net signal — the model-targeted nudge
+   * ladder (ack/soft/firm) and the 60s awareness ping were retired once
+   * the live-updating reply/draft took over the pacing job.
    */
   | {
       kind: 'silence_fallback_sent'
@@ -104,23 +77,6 @@ export type RuntimeMetricEvent =
       fallback_kind: 'working' | 'thinking'
       silence_ms: number
     }
-  /**
-   * Awareness ping (~60s, default): framework-owned user-visible
-   * "still working… / still thinking…" message sent BEFORE the 300s
-   * fallback so the user never faces a silent chat for the full 5
-   * minutes. Silent (no device ping); one-shot per turn; suppressed
-   * by any outbound or sub-agent dispatch. A high rate is the
-   * diagnostic signal that frequent silences exist (held-inbound,
-   * extended-thinking, slow startup), and the rate of the heavier
-   * silence_fallback_sent that still follows tells us how many of
-   * those escalate all the way to 5 min.
-   */
-  | {
-      kind: 'awareness_ping_sent'
-      key: string
-      fallback_kind: 'working' | 'thinking'
-      silence_ms: number
-    }
   /**
    * #1445 cross-turn pending-async ambient lifecycle. `started` fires
    * when a turn ends with a captured anchor AND a pending Agent/Task/