switchroom 0.20.6 → 0.20.8

package/telegram-plugin/dist/server.js

@@ -24317,11 +24317,14 @@ function createIpcClient(options) {
   function scheduleReconnect() {
     if (closed)
       return;
+    if (reconnectTimer)
+      return;
     log(`reconnecting in ${currentDelay}ms`);
     reconnectTimer = setTimeout(() => {
       reconnectTimer = null;
-      if (!closed)
-        doConnect();
+      if (!closed) {
+        doConnect().catch(() => {});
+      }
     }, currentDelay);
     currentDelay = Math.min(currentDelay * 2, maxReconnectDelayMs);
   }

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

@@ -83,3 +83,64 @@ export function determineRestartReason(opts: {
   if (sessionMarker != null) return 'crash'
   return 'fresh'
 }
+
+/**
+ * Boot-reason window during which a bridge re-register reuses the reason
+ * the boot path already determined. Matches the restart-marker and
+ * operator-marker freshness windows (5 min) — a bridge that survived a
+ * gateway restart reconnects within seconds of the new gateway's boot,
+ * comfortably inside it.
+ */
+export const BOOT_REASON_REUSE_WINDOW_MS = 5 * 60_000
+
+/**
+ * Determine the restart reason for a BRIDGE RE-REGISTER (gateway.ts
+ * `onClientRegistered`, the `bridge-reconnect` path) — as opposed to the
+ * gateway's own boot path.
+ *
+ * Why this exists (fleet-audit B2, kdogg 2026-08-02 06:27 trace): on a
+ * planned gateway restart (`cli: restart` SIGTERM), the bridge — living
+ * inside the separate claude process — survives and reconnects a few
+ * seconds after the new gateway boots. By then the boot path has already
+ * READ AND CLEARED the restart / clean-shutdown markers (the 2026-05-25
+ * GC, gateway.ts boot path), so re-deriving the reason from disk falls
+ * through to the sessionMarker branch and every such re-register logs —
+ * and, when a chat is resolvable, POSTS a boot card claiming —
+ * `reason=crash` for a perfectly graceful restart. Hundreds of these per
+ * agent fleet-wide (lawgpt 310, reggie 179, ziggy 175, kdogg 174).
+ *
+ * Decision:
+ *   1. Any on-disk marker still present → normal `determineRestartReason`
+ *      (in-gateway /restart flows where the gateway never went down write
+ *      a marker the boot path never consumed — keep honoring it).
+ *   2. No markers, but the gateway booted recently (<5 min) and recorded
+ *      the reason it determined at boot → reuse that reason. The bridge
+ *      is re-registering into the SAME restart episode the boot path
+ *      already classified.
+ *   3. Otherwise (gateway long-lived, markers absent) → fall through to
+ *      `determineRestartReason` — a marker-less bridge re-register hours
+ *      into a gateway's life still classifies conservatively as 'crash'
+ *      (the claude/bridge side genuinely died and came back).
+ */
+export function determineBridgeReconnectReason(opts: {
+  marker: { ts: number } | null
+  cleanMarker: CleanShutdownMarker | null
+  sessionMarker: SessionMarker | null
+  now: number
+  /** `GATEWAY_STARTED_AT_MS` of the running gateway process. */
+  gatewayStartedAtMs: number
+  /** Reason the gateway's own boot path determined (null if it never ran). */
+  bootReason: RestartReason | null
+  bootReasonReuseWindowMs?: number
+  cleanMaxAgeMs?: number
+  markerMaxAgeMs?: number
+  operatorMaxAgeMs?: number
+}): RestartReason {
+  const { gatewayStartedAtMs, bootReason, bootReasonReuseWindowMs = BOOT_REASON_REUSE_WINDOW_MS } = opts
+  if (opts.marker == null && opts.cleanMarker == null
+    && bootReason != null
+    && opts.now - gatewayStartedAtMs < bootReasonReuseWindowMs) {
+    return bootReason
+  }
+  return determineRestartReason(opts)
+}

package/telegram-plugin/gateway/cron-session.ts

@@ -17,6 +17,10 @@
  * target via `cronIdentity()`. Pure string fns — pinned in cron-session.test.ts.
  */
 
+import type { InboundMessage, GatewayToClient } from './ipc-protocol.js'
+import type { InboundSpool } from './inbound-spool.js'
+import { redeliverBufferedInbound, type PendingInboundBuffer } from './pending-inbound-buffer.js'
+
 /** Suffix that distinguishes a cron-session bridge from the main agent bridge. */
 export const CRON_IDENTITY_SUFFIX = "-cron";
 
@@ -140,3 +144,65 @@ export function deliverInjectWithFallback(
   }
   return { target, delivered: false, fellBackToMain: false };
 }
+
+/** Minimal view of the IPC client the cron-bridge register handler needs.
+ *  A structural subset of `IpcClient` so this stays unit-testable without the
+ *  gateway's module-load side effects. */
+export interface CronBridgeRegisterClient {
+  agentName: string | null | undefined;
+  send: (msg: GatewayToClient) => void;
+}
+
+/**
+ * Drain a cheap-cron (`<agent>-cron`) bridge's buffered fires when it
+ * registers — the Tier-1 §2.4/§3.3 status-silent path (#4348).
+ *
+ * The cron bridge is STATUS-SILENT: it must NOT drive the gateway's singleton
+ * machinery (shadow bridge-state, warmup, boot card). But it MUST still flush
+ * any cron fire buffered+spooled during the boot window — a due tick that
+ * arrived before the cron bridge registered.
+ *
+ * THE BUG (#4348): the pre-fix path did a raw `pendingInboundBuffer.drain()` +
+ * `client.send()` loop and returned early WITHOUT ever reaching `spool.ack`.
+ * `spool.ack` lives ONLY inside `redeliverBufferedInbound` — the one chokepoint
+ * every other drain path (bridgeUp, idle-drain, silence-poke, turn-end) routes
+ * through. So the durable spool entry stayed live, boot-replay re-pushed it on
+ * the next restart, and the SAME cron fire re-fired: a duplicate delivery
+ * bounded only by the 15-min escalation sweep. This was the ONLY drain that
+ * bypassed the chokepoint.
+ *
+ * THE FIX: route the drain through `redeliverBufferedInbound` too, so each
+ * delivered fire is spool-acked exactly once and cannot re-fire after a
+ * restart. `beforeRedeliver` (the represent-veto) rides along by construction;
+ * it self-gates and is a no-op for cron-sourced fires. A `send` throw now
+ * re-buffers the fire (lossless) instead of dropping it — strictly safer than
+ * the pre-fix best-effort drop and identical to every sibling drain path.
+ *
+ * Returns the `redeliverBufferedInbound` counts for observability.
+ */
+export function drainCronBridgeOnRegister(
+  client: CronBridgeRegisterClient,
+  buffer: PendingInboundBuffer,
+  spool?: InboundSpool,
+  log?: (line: string) => void,
+): { drained: number; redelivered: number; rebuffered: number; retracted: number } {
+  // Status-silent handshake ack (unchanged from the pre-fix path).
+  client.send({ type: "status", status: "agent_connected" });
+  const send = (msg: InboundMessage): boolean => {
+    try {
+      client.send(msg);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const result = redeliverBufferedInbound(buffer, client.agentName ?? "", send, spool);
+  if (result.drained > 0 && log != null) {
+    log(
+      `telegram gateway: cron-bridge drain agent=${client.agentName} ` +
+        `drained=${result.drained} redelivered=${result.redelivered} ` +
+        `rebuffered=${result.rebuffered}\n`,
+    );
+  }
+  return result;
+}

package/telegram-plugin/gateway/gateway.ts

@@ -461,7 +461,7 @@ import {
   type SendReplyGatewayDeps,
   type DeliverCapturedProseDeps,
 } from './outbound-send-path.js'
-import { handleSessionEvent as handleSessionEventCore, drainParkedTurnStartsForChat, closeFlushCompletionWindows } from './stream-render.js'
+import { handleSessionEvent as handleSessionEventCore, drainParkedTurnStartsForChat, closeFlushCompletionWindows, parkedTurnStartCount } from './stream-render.js'
 import { createNarrativeLane } from './narrative-lane.js'
 import {
   parseAgentCallback,
@@ -659,7 +659,8 @@ import { handleRequestDriveApproval } from './drive-write-approval.js'
 import { handleRequestMs365Approval } from './ms365-write-approval.js'
 import { buildDiffPreviewCard } from './diff-preview-card.js'
 import { createPendingInboundBuffer, redeliverBufferedInbound, idleDrainTick } from './pending-inbound-buffer.js'
-import { isCronIdentity, isCronInjectFire, deliverInjectWithFallback, replyCallerIsForeignSession } from './cron-session.js'
+import { makeRepresentRedeliveryGuard, makeSessionBusyDrainDeferral } from './represent-delivery-guard.js'
+import { isCronIdentity, isCronInjectFire, deliverInjectWithFallback, replyCallerIsForeignSession, drainCronBridgeOnRegister } from './cron-session.js'
 import {
   ObligationLedger,
   obligationEscalationText,
@@ -856,7 +857,7 @@ import {
   resolvePersonaName, shouldSkipDuplicateBootCard,
   type BootCardHandle, type RestartReason,
 } from './boot-card.js'
-import { determineRestartReason } from './boot-reason.js'
+import { determineRestartReason, determineBridgeReconnectReason } from './boot-reason.js'
 import { maybeRenderUpdateAnnouncement } from './update-announce.js'
 import { createIssuesCardHandle, type IssuesCardHandle } from '../issues-card.js'
 import { startIssuesWatcher, type IssuesWatcherHandle } from '../issues-watcher.js'
@@ -9162,6 +9163,8 @@ let activeBootCard: BootCardHandle | null = null
 // dedupe checks this so it can't race against the boot path's await.
 // See issue #489 (klanker msgId 4715 + 4716, 2026-05-01 10:13:15).
 let bootCardPending = false
+// Boot-determined restart reason — see determineBridgeReconnectReason (B2).
+let bootReasonAtStartup: RestartReason | null = null
 
 // Issues card (#428) — pinned per-agent surface listing current
 // unresolved entries from the issue sink (#425). Idempotent across
@@ -9788,6 +9791,11 @@ const pendingInboundBuffer = createPendingInboundBuffer({
   // enqueue chokepoint so a boot-replayed handback (not just the live synthesis
   // push) populates it. Every `subagent_handback` push funnels through here.
   onHandbackEnqueue: (chatId, threadId, ts) => subagentHandbackMarker.record(chatId, threadId, ts),
+  // F1 (fix/represent-double-send-delivery-recheck) — delivery-time represent
+  // retract. Every drain path hands its buffered inbounds through this gate; a
+  // stale `obligation_represent` (its reply landed since the sweep decided it) is
+  // dropped here rather than duplicated into the CLI queue. See represent-delivery-guard.ts.
+  beforeRedeliver: makeRepresentRedeliveryGuard({ enabled: OBLIGATION_LEDGER_ENABLED, historyEnabled: HISTORY_ENABLED, ledger: obligationLedger, hasOutboundDeliveredSince, minReplyChars: OBLIGATION_REPRESENT_GUARD_MIN_REPLY_CHARS, log: (l) => process.stderr.write(l) }),
 })
 
 // PR2 obligation-ledger idle sweep. Re-present an OPEN obligation only at a
@@ -10360,17 +10368,13 @@ if (isGatewayMain) ipcServer = createIpcServer({
 
   onClientRegistered(client: IpcClient) {
     process.stderr.write(`telegram gateway: bridge registered — agent=${client.agentName}\n`)
-    // Cheap-cron (§2.4/§3.3): a `<agent>-cron` bridge is the Tier-1 cheap
-    // session. It is STATUS-SILENT — it must NOT drive the gateway's
-    // singleton machinery (shadow bridge-state, warmup, boot card, which all
-    // track the MAIN agent's liveness). Drain any buffered cron fire to it
-    // (so a fire that triggered a lazy spawn lands), then return early.
+    // Cheap-cron (§2.4/§3.3): a `<agent>-cron` bridge is the Tier-1 cheap,
+    // STATUS-SILENT session — it must NOT drive the gateway's singleton
+    // machinery. Drain any boot-window cron fire to it, then return early.
+    // #4348: the drain routes through `redeliverBufferedInbound` (the shared
+    // ack chokepoint) so a spooled fire is acked and never re-fires on restart.
     if (isCronIdentity(client.agentName)) {
-      client.send({ type: 'status', status: 'agent_connected' })
-      const pending = pendingInboundBuffer.drain(client.agentName ?? '')
-      for (const m of pending) {
-        try { client.send(m) } catch { /* cron fire drop — best-effort, like today's cron */ }
-      }
+      drainCronBridgeOnRegister(client, pendingInboundBuffer, inboundSpool ?? undefined, (l) => process.stderr.write(l))
       return
     }
     // Phase 2b shadow: ONLY emit bridgeUp for the REAL bridge sidecar
@@ -10444,15 +10448,12 @@ if (isGatewayMain) ipcServer = createIpcServer({
       })
     }
 
-    // If the agent reconnected after a /restart (or any restart), post a boot
-    // card. The restart-marker carries the ack chat; if absent we fall back to
-    // resolveBootChatId so crash-recovery reconnects also get a card.
-    //
-    // Skip if the boot path already posted a card OR is currently in-flight
-    // on its sendMessage await (issue #489 — klanker msgId 4715+4716,
-    // 2026-05-01). The original dedupe (msgId 2245+2248, 2026-04-26) only
-    // covered the post-resolution case; bootCardPending closes the in-flight
-    // race window. See `shouldSkipDuplicateBootCard`.
+    // If the agent reconnected after a restart, post a boot card. The
+    // restart-marker carries the ack chat; else fall back to resolveBootChatId
+    // so crash-recovery reconnects also get a card. Skip if the boot path
+    // already posted a card OR its sendMessage is in-flight (issue #489,
+    // klanker 2026-05-01; earlier dedupe 2026-04-26 only covered the
+    // post-resolution case). See `shouldSkipDuplicateBootCard`.
     const dedupeDecision = shouldSkipDuplicateBootCard({ activeBootCard, bootCardPending }, 'bridge-reconnect')
     if (dedupeDecision.skip) {
       process.stderr.write(`telegram gateway: bridge-reconnect: skipping boot card (${dedupeDecision.reason})\n`)
@@ -10469,7 +10470,9 @@ if (isGatewayMain) ipcServer = createIpcServer({
         clearRestartMarker()
       }
 
-      const reason = determineRestartReason({ marker, cleanMarker, sessionMarker: storedSession, now: nowMs })
+      // B2: boot path cleared the markers — reuse its reason (boot-reason.ts).
+      const reason = determineBridgeReconnectReason({ marker, cleanMarker, sessionMarker: storedSession,
+        now: nowMs, gatewayStartedAtMs: GATEWAY_STARTED_AT_MS, bootReason: bootReasonAtStartup })
       const target = resolveBootChatId(marker, markerAgeMs)
 
       if (target) {
@@ -11742,30 +11745,21 @@ if (isGatewayMain) (() => {  // #2996 P0c: gated — starts webhook-ingest UDS s
 })()
 
 // ─── Opportunistic idle-drain of pendingInboundBuffer ─────────────────────
-// pendingInboundBuffer otherwise drains only on (a) bridge re-register
-// (onClientRegistered) or (b) the silence-poke framework fallback
-// clearing a wedged turn (#1546). NEITHER fires when a message is
-// buffered during a bridge-IPC flap that then settles with no
-// subsequent clean re-register AND claude is idle (no active turn →
-// silence-poke never arms). The message orphans until a manual restart
-// (finn, 2026-05-19 — buffered "verify with mff-query.py cashflow"
-// while idle; last `bridge registered` predated the buffer push, so
-// onClientRegistered's drain never ran for it).
-//
-// This is the third drain trigger. It's gated to be zero-cost and
-// zero-churn: skip entirely when nothing is buffered (one Map.get, no
-// log), when the bridge isn't alive (exactly sendToAgent's own guard —
-// so we never drain into a dead bridge and re-buffer/log-spin), OR
-// when a turn is in flight. The turn gate is #1556: a message
-// delivered while a turn is active is NOT safely queued by the bridge
-// — claude types it into its TUI composer and the auto-submit races
-// turn-completion, stranding it (the lawgpt wedge). Draining only at
-// `activeTurnStartedAt.size === 0` guarantees the channel notification
-// lands at an idle prompt and submits as a fresh turn. Only when there
-// IS a buffered message AND a live bridge AND no active turn do we
-// reuse the #1546 `redeliverBufferedInbound` (lossless: re-buffers any
-// per-message miss).
+// The THIRD drain trigger, beside bridge re-register (onClientRegistered) and
+// the silence-poke framework fallback (#1546): neither fires when a message is
+// buffered during a bridge-IPC flap that settles with no clean re-register while
+// claude is idle, so it orphans until a manual restart (finn, 2026-05-19). Gated
+// zero-cost/zero-churn: skip when nothing is buffered, when the bridge is dead,
+// or when a turn is in flight (#1556 — a message delivered mid-turn is typed into
+// claude's TUI composer and the auto-submit races turn-completion, stranding it).
 const IDLE_DRAIN_INTERVAL_MS = 5000
+// F2 (drain half) — bounded busy-defer. A ~5-min poke can clear the machine turn
+// while the CLI is still producing the answer; draining a represent into that busy
+// session re-queues it BEHIND the real reply → a duplicate. Defer while busy,
+// bounded so a wedged session still drains (F1 then retracts it post-reply).
+// staleGap = 3 poll intervals: a longer gap between busy consultations means the
+// buffer drained via a non-idle path so the next one is a NEW episode (#4341 f/u).
+const idleDrainBusyDefer = makeSessionBusyDrainDeferral(OBLIGATION_BACKGROUND_WORK_GRACE_MS, IDLE_DRAIN_INTERVAL_MS * 3)
 if (isGatewayMain && !STATIC) {
   setInterval(() => {
     const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? ''
@@ -11775,8 +11769,11 @@ if (isGatewayMain && !STATIC) {
       () => {
         // #1556: never drain mid-turn — that re-creates the composer
         // wedge this buffer exists to prevent. Gate reads the delivery
-        // machine (turnInFlightForGate).
+        // machine (turnInFlightForGate) AND, per F2, stream-render's live-turn
+        // mirror (a poke can clear the former while the latter is still busy).
         if (turnInFlightForGate()) return false
+        const sessionBusy = (currentTurn != null && currentTurn.endedAt == null) || parkedTurnStartCount() > 0
+        if (idleDrainBusyDefer(sessionBusy, Date.now())) return false
         const c = ipcServer.getClient(selfAgent)
         return c != null && c.isAlive()
       },
@@ -23492,15 +23489,14 @@ async function startGateway(): Promise<void> {  // #2996 P0c: the boot IIFE, now
           } else {
             const markerAgeMs = marker ? nowMs - marker.ts : undefined
             const reason = determineRestartReason({ marker, cleanMarker, sessionMarker: storedSession, now: nowMs })
+            // Markers were cleared above — stash for bridge re-register (B2).
+            bootReasonAtStartup = reason
             const target = resolveBootChatId(marker, markerAgeMs)
 
-            // Issue #92: when reason='crash' AND no chat is resolvable,
-            // the gateway used to silently skip — the only signal a user
-            // got was their next message landing on a fresh process. Now
-            // we always surface unplanned crashes via the operator-events
-            // pipeline, which broadcasts to access.allowFrom (same path
-            // permission requests use). The pipeline's per-agent per-kind
-            // cooldown protects against crash loops spamming the chat.
+            // Issue #92: when reason='crash' AND no chat is resolvable, the
+            // gateway used to silently skip. Always surface unplanned crashes
+            // via the operator-events pipeline (broadcasts to access.allowFrom;
+            // its per-agent per-kind cooldown absorbs crash loops).
             if (reason === 'crash') {
               const cleanMarkerStale = cleanMarker
                 ? !shouldSuppressRecoveryBanner(cleanMarker, nowMs, CLEAN_SHUTDOWN_MAX_AGE_MS)

package/telegram-plugin/gateway/narrative-lane.ts

@@ -56,6 +56,7 @@ import {
   appendActivityLabel, clipNarrative, formatStepSuffix, renderActivityFeedWithNested,
 } from '../tool-activity-summary.js'
 import { evaluatePostAnswerLiveness } from '../turn-liveness-floor.js'
+import { isSilentSentinelCardOutcome } from '../turn-flush-safety.js'
 import { clearActivityCardRecord, writeActivityCardRecord } from './activity-card-store.js'
 import { chatKeyWithSuffix } from './chat-key.js'
 import {
@@ -880,7 +881,26 @@ export function createNarrativeLane(deps: NarrativeLaneDeps) {
       // before the delete. turn-end stays the idempotent backstop: it no-ops
       // once nothing is claimed for the key.
       await reconcileStatusPin(`fg:${statusKey(chat, thread)}`, chat, { pinned: false })
-      if (CLEAR_STATUS_ON_COMPLETION) {
+      // #4348 — silent-sentinel suppression. A turn whose entire user-facing
+      // outcome is a bare NO_REPLY / HEARTBEAT_OK (the sentinel-reply-guard
+      // dropped a sentinel-only reply, or the flush safety net classified the
+      // captured text as silent) said nothing to the user, so its activity/
+      // telemetry card is pure noise — most visibly on the forced-synthesis
+      // handback turns a background sub-agent injects. DELETE the card rather
+      // than finalizing a visible `done · … · ✓ NO_REPLY` record. Deterministic
+      // (reuses the shared `turn-flush-safety` silent predicates, no model
+      // behaviour) and normal-case-safe (`finalAnswerEverDelivered` keeps every
+      // card for a turn that actually delivered a substantive answer). The
+      // `finalHtmlOverride` finalize path is only taken by the foreground
+      // handoff-clear, which fires on a delivered final answer — so this gate
+      // never contends with it.
+      const silentSentinelTurn = isSilentSentinelCardOutcome({
+        replyCalled: turn.replyCalled,
+        lastReplyText: turn.lastReplyText,
+        capturedText: turn.capturedText,
+        finalAnswerEverDelivered: turn.finalAnswerEverDelivered,
+      })
+      if (CLEAR_STATUS_ON_COMPLETION || silentSentinelTurn) {
         try {
           await robustApiCall(
             () => bot.api.deleteMessage(chat, id),

package/telegram-plugin/gateway/obligation-ledger.ts

@@ -178,6 +178,15 @@ export class ObligationLedger {
     return this.open.has(originTurnId)
   }
 
+  /** The open obligation for `originTurnId`, or undefined if none is open. Read-
+   *  only accessor for the delivery-time represent re-check (represent-delivery-
+   *  guard.ts): a represent buffered while the obligation was open must be re-
+   *  evaluated against the obligation's CURRENT cutoff at the moment it is handed
+   *  to the CLI bridge, since a reply may have landed between decision and drain. */
+  get(originTurnId: string): Obligation | undefined {
+    return this.open.get(originTurnId)
+  }
+
   hasOpen(): boolean {
     return this.open.size > 0
   }

package/telegram-plugin/gateway/obligation-wiring.ts

@@ -23,6 +23,7 @@ import { buildObligationRepresentInbound, type Obligation } from './obligation-l
 import { driveEscalation } from './escalation-drive.js'
 import { shouldSuppressRepresent } from './represent-guard.js'
 import { shouldDeferEscalationForBridge } from './escalation-bridge-gate.js'
+import { parkedTurnStartCount } from './stream-render.js'
 
 export function createObligationWiring(deps: ObligationWiringDeps) {
   const {
@@ -161,13 +162,26 @@ function obligationSweep(): void {
   if (turnInFlightForGate()) return // a turn is running — let it finish/answer
   const agent = process.env.SWITCHROOM_AGENT_NAME ?? ''
   const now = Date.now()
+  // Session-busy signal (F2, decision half). A ~5-min silence poke can clear the
+  // machine turn (`turnInFlightForGate()` above → false) while the CLI session is
+  // STILL producing the answer — stream-render's live-turn mirror (`currentTurn`
+  // whose endedAt is null, or a parked turn-start) still knows it is busy. Without
+  // this, the sweep decides + buffers a represent mid-answer; the real reply lands
+  // seconds later and the model consumes the queued represent → a duplicate answer
+  // (the two-authorities-disagree defect). We treat a busy mirror the SAME as
+  // in-flight background work: defer the represent, BOUNDED by the same grace, so a
+  // wedged/hung session cannot silence a genuinely-unanswered turn forever.
+  const liveTurn = getCurrentTurn()
+  const sessionBusy = (liveTurn != null && liveTurn.endedAt == null) || parkedTurnStartCount() > 0
   // Background-work grace: while genuine autonomous sub-agent work is in flight
   // (a running worker, or an orphaned foreground sub-agent — neither visible to
-  // the turn machine), an obligation younger than the ceiling is NOT re-presented
-  // /escalated. Bounded by OBLIGATION_BACKGROUND_WORK_GRACE_MS so escalation
-  // always eventually fires. =0 disables it.
+  // the turn machine), OR the CLI session is still busy behind a poke-cleared
+  // machine turn, an obligation younger than the ceiling is NOT re-presented
+  // /escalated. Bounded by OBLIGATION_BACKGROUND_WORK_GRACE_MS (measured from
+  // openedAt in decideAtIdle) so escalation always eventually fires. =0 disables it.
   const backgroundWorkActive =
-    OBLIGATION_BACKGROUND_WORK_GRACE_MS > 0 && agentHasInFlightBackgroundWork(now)
+    OBLIGATION_BACKGROUND_WORK_GRACE_MS > 0 &&
+    (agentHasInFlightBackgroundWork(now) || sessionBusy)
   // Grace window: skip an obligation whose handling turn ended < grace ago — its
   // trailing slow/worker answer may still be landing (over-escalation fix).
   // Per-represent grace: skip an obligation re-presented < grace ago — prevents
@@ -189,6 +203,7 @@ function obligationSweep(): void {
       lastBgWorkDeferLogMs = now
       process.stderr.write(
         `telegram gateway: obligation sweep deferred — in-flight autonomous sub-agent work ` +
+          `or busy CLI session behind a poke-cleared turn ` +
           `(${obligationLedger.size()} open, bounded ${Math.round(OBLIGATION_BACKGROUND_WORK_GRACE_MS / 60_000)}m from receipt)\n`,
       )
     }

package/telegram-plugin/gateway/pending-inbound-buffer.ts

@@ -49,6 +49,16 @@ export interface PendingInboundBuffer {
   depth: (agent: string) => number
   /** Test-only: total depth across all agents. */
   totalDepth: () => number
+  /**
+   * Delivery-time gate consulted by `redeliverBufferedInbound` for EVERY message
+   * it is about to hand to the bridge. Returns TRUE to proceed, FALSE to RETRACT
+   * (drop) the message (the spool entry is acked so it is not boot-replayed, and
+   * it is NOT re-buffered). The gateway wires this to the represent delivery
+   * re-check (represent-delivery-guard.ts): a represent buffered while its
+   * obligation was open must be re-evaluated at drain time, since a reply may have
+   * landed between the sweep's decision and this drain. Undefined ⇒ never retract.
+   */
+  beforeRedeliver?: (msg: InboundMessage) => boolean
 }
 
 export interface PendingInboundBufferOptions {
@@ -94,6 +104,13 @@ export interface PendingInboundBufferOptions {
    * breaks the push hot path.
    */
   onHandbackEnqueue?: (chatId: string, threadId: number | undefined, ts: number) => void
+  /**
+   * Delivery-time retract gate — see `PendingInboundBuffer.beforeRedeliver`. The
+   * gateway supplies the represent delivery re-check here so EVERY drain path
+   * (idle-drain, bridge re-register, silence-poke fallback, turn-end) inherits it
+   * by construction rather than by per-call-site discipline.
+   */
+  beforeRedeliver?: (msg: InboundMessage) => boolean
 }
 
 /**
@@ -123,16 +140,38 @@ export function redeliverBufferedInbound(
   // silently dropped (clerk 2026-06-03). `send` returning true only means
   // the bytes reached the bridge, NOT that claude consumed them.
   onDelivered?: (merged: InboundMessage, originals: InboundMessage[]) => void,
-): { drained: number; redelivered: number; rebuffered: number } {
+): { drained: number; redelivered: number; rebuffered: number; retracted: number } {
   const pending = buffer.drain(agent)
   let redelivered = 0
   let rebuffered = 0
+  let retracted = 0
   // Collapse consecutive same-sender Telegram user messages into one turn
   // (see planBufferedRedelivery) so a forwarded burst that spanned a turn
   // boundary doesn't fan out into N sequential replies. System inbounds
   // (vault grants, approvals, cron, handbacks — anything with meta.source)
   // are never merged and are delivered individually exactly as before.
   for (const { merged, originals } of planBufferedRedelivery(pending)) {
+    // Delivery-time retract (F1): a buffered `obligation_represent` whose reply
+    // has landed since the sweep decided it is stale — drop it rather than hand
+    // a duplicate to the CLI queue. Ack the spool so it is not boot-replayed and
+    // do NOT re-buffer. The gateway closure closes the ledger + logs the retract.
+    // FAIL-OPEN: a throwing predicate must never silence or lose a real message,
+    // nor abort the drain loop (which would strand every following message and
+    // crash the setInterval tick). On throw we treat it as "deliver".
+    let proceed = true
+    if (buffer.beforeRedeliver != null) {
+      try {
+        proceed = buffer.beforeRedeliver(merged)
+      } catch (e) {
+        proceed = true
+        process.stderr.write(`redeliver beforeRedeliver threw — failing open (deliver): ${String(e)}\n`)
+      }
+    }
+    if (!proceed) {
+      for (const o of originals) spool?.ack(o)
+      retracted += originals.length
+      continue
+    }
     let delivered = false
     try {
       delivered = send(merged)
@@ -157,7 +196,7 @@ export function redeliverBufferedInbound(
       rebuffered += originals.length
     }
   }
-  return { drained: pending.length, redelivered, rebuffered }
+  return { drained: pending.length, redelivered, rebuffered, retracted }
 }
 
 /** True when `msg` is an ordinary Telegram user message eligible to be
@@ -312,7 +351,7 @@ export function idleDrainTick(
   // enrols redelivered inbounds in the deliver-until-acked queue (parity with
   // the bridgeUp drain — clerk lost-message incident, 2026-06-03).
   onDelivered?: (merged: InboundMessage, originals: InboundMessage[]) => void,
-): { drained: number; redelivered: number; rebuffered: number } | null {
+): { drained: number; redelivered: number; rebuffered: number; retracted: number } | null {
   if (!agent) return null
   if (buffer.depth(agent) === 0) return null
   if (!isBridgeAlive()) return null
@@ -412,5 +451,6 @@ export function createPendingInboundBuffer(
       for (const q of queues.values()) n += q.length
       return n
     },
+    beforeRedeliver: opts.beforeRedeliver,
   }
 }