switchroom 0.20.6 → 0.20.8

package/telegram-plugin/gateway/represent-delivery-guard.ts

@@ -0,0 +1,188 @@
+/**
+ * represent-delivery-guard.ts — the DELIVERY-time half of the duplicate-represent
+ * defence (fix/represent-double-send-delivery-recheck).
+ *
+ * Background — the race this closes (verified from history.db, 2026):
+ *   1. A ~5-min silence poke fires the framework fallback, which clears the
+ *      machine turn (`turnInFlightForGate()` → false) while the CLI session is
+ *      STILL producing the answer (it lands ~17s later). stream-render's live-turn
+ *      mirror (`currentTurn`/`parkedTurnStarts`) still knows the session is busy.
+ *   2. With the machine turn cleared, `obligationSweep` runs; `shouldSuppressRepresent`
+ *      correctly returns false (nothing has been sent YET) and the represent is
+ *      buffered; the idle-drain flushes it into the live CLI queue.
+ *   3. ~13s later the real answer is delivered + recorded (ledger closed by the
+ *      normal path). Then the model consumes the already-queued represent and
+ *      answers a SECOND time → the duplicate.
+ *
+ * The represent guard never FAILED — it was consulted BEFORE the reply existed,
+ * and there was no re-check between decision → delivery → model consumption. This
+ * module adds that missing re-check (F1) plus the bounded busy-defer for the
+ * idle-drain gate (F2). Layer F2 (obligation-wiring's sweep + this drain defer)
+ * keeps the represent BUFFERED while the session is busy so that, by the time a
+ * drain actually hands it to the bridge, the real answer has landed and been
+ * recorded — at which point F1 retracts the now-stale represent. `recordOutbound`
+ * is a synchronous SQLite write that completes before the reply tool result
+ * returns, so a post-reply drain observes the row.
+ *
+ * Both halves are PURE-ish factories (no Telegram, no SQLite) so the whole
+ * decision is executable in a unit test; the gateway injects the ledger accessor,
+ * the outbound-history predicate, and the logger.
+ */
+
+import type { InboundMessage } from './ipc-protocol.js'
+import { shouldSuppressRepresent, type RepresentGuardObligation } from './represent-guard.js'
+
+/** The minimal ledger surface the delivery re-check needs. */
+export interface RepresentDeliveryLedger {
+  /** The CURRENTLY-open obligation for `originTurnId`, or undefined if none is
+   *  open (already closed — answered or cancelled — since the represent was
+   *  buffered). */
+  get(originTurnId: string): RepresentGuardObligation | undefined
+  /** Close the obligation. Idempotent; returns whether an entry was removed. */
+  close(originTurnId: string | null | undefined): boolean
+}
+
+export interface RepresentRedeliveryGuardDeps {
+  /** OBLIGATION_LEDGER_ENABLED — when off, never retract (nothing is tracked). */
+  enabled: boolean
+  /** HISTORY_ENABLED — forwarded to the pure guard (no history ⇒ never suppress). */
+  historyEnabled: boolean
+  ledger: RepresentDeliveryLedger
+  /** history.hasOutboundDeliveredSince, already curried with the chat query. */
+  hasOutboundDeliveredSince: (
+    chatId: string,
+    sinceMs: number,
+    threadId?: number,
+    minChars?: number,
+  ) => boolean
+  /** The represent guard's OWN low reply-length threshold (a terse-but-real reply
+   *  must still suppress the duplicate — #2472/#2474). */
+  minReplyChars: number
+  log: (line: string) => void
+}
+
+/**
+ * Build the `beforeRedeliver` predicate the pending-inbound buffer consults for
+ * EVERY message it is about to hand to the CLI bridge. Returns TRUE to proceed
+ * with delivery, FALSE to RETRACT (drop) the message.
+ *
+ * Only `obligation_represent` inbounds are ever retracted; everything else always
+ * proceeds. A represent is retracted when, AT DELIVERY TIME:
+ *   - the obligation is no longer open (a reply landed and the normal close path
+ *     fired, or it was cancelled) — re-delivering would duplicate / re-ask a
+ *     resolved question; OR
+ *   - it IS still open but `shouldSuppressRepresent` now returns true against the
+ *     obligation's CURRENT cutoff (a reply landed since decision, but the normal
+ *     close path missed it because its routing did not resolve back to the origin
+ *     — the exact #2472 gap, now caught at delivery instead of only at decision).
+ *
+ * The cutoff is the obligation's own (`openedAt` for the first represent,
+ * `lastRepresentedAt` thereafter) — encoded inside `shouldSuppressRepresent`, so
+ * an OLD reply to a DIFFERENT earlier question does not suppress a legitimate new
+ * represent (#2472 second-represent semantics). The genuine plain-text-no-reply
+ * case (#2788) records NO outbound row, so the predicate reports false at BOTH
+ * decision and here ⇒ the represent still fires exactly once.
+ */
+export function makeRepresentRedeliveryGuard(
+  deps: RepresentRedeliveryGuardDeps,
+): (msg: InboundMessage) => boolean {
+  return (msg) => {
+    if (!deps.enabled) return true
+    if (msg.meta?.source !== 'obligation_represent') return true
+    const originTurnId = msg.meta?.origin_turn_id
+    if (originTurnId == null) return true
+
+    const o = deps.ledger.get(originTurnId)
+    if (o == null) {
+      // Closed since this represent was buffered — a reply landed (normal close)
+      // or the turn was cancelled/interrupted. Either way the buffered represent
+      // is stale: drop it rather than re-ask an already-resolved obligation.
+      deps.log(
+        `telegram gateway: represent retracted at delivery — obligation already ` +
+          `closed since decision (no re-fire) origin=${originTurnId}\n`,
+      )
+      return false
+    }
+
+    const suppress = shouldSuppressRepresent(o, {
+      historyEnabled: deps.historyEnabled,
+      hasOutboundDeliveredSince: (chatId, sinceMs, threadId) =>
+        deps.hasOutboundDeliveredSince(chatId, sinceMs, threadId, deps.minReplyChars),
+    })
+    if (suppress) {
+      // A reply landed since this obligation's cutoff but the normal close path
+      // missed it. Close the ledger entry ourselves and drop the represent.
+      deps.ledger.close(originTurnId)
+      deps.log(
+        `telegram gateway: represent retracted at delivery — reply landed since ` +
+          `decision (no re-fire) origin=${originTurnId}\n`,
+      )
+      return false
+    }
+    return true
+  }
+}
+
+/**
+ * Build the BOUNDED busy-defer predicate for the idle-drain gate (F2, drain
+ * half). Returns TRUE while the drain should be DEFERRED because the session is
+ * busy (stream-render's live-turn mirror), FALSE once it is safe to drain.
+ *
+ * Why bounded: the drain must not hand a buffered represent to a session that is
+ * mid-answer (that re-queues it BEHIND the real answer → the duplicate). But a
+ * session that is WEDGED busy forever must not silence a buffered represent
+ * forever (red-team #2). So the deferral is capped: once the session has been
+ * continuously busy for longer than `boundMs`, the drain proceeds regardless. The
+ * clock resets to "not deferring" the moment the session reads idle, so an
+ * ordinary busy turn (which ends well within the bound) defers cleanly and never
+ * consumes the wedge budget.
+ *
+ * Episode isolation (#4341 follow-up): `deferringSince` used to reset ONLY on a
+ * `busy=false` call, but the predicate is not consulted on every drain path. When
+ * a buffer is emptied by a bridge re-register (`onClientRegistered`) while the
+ * session is still busy, the idle-drain gate is never invoked with `busy=false`,
+ * so `deferringSince` stays pinned at the old t0. A later, UNRELATED deferral
+ * episode then computes `now - t0 >= boundMs` immediately and drains a represent
+ * into a mid-answer session — reopening the duplicate window this guard closes.
+ * Fix: a fresh deferral episode also starts the clock at `now` when the predicate
+ * has not been consulted within `staleGapMs`. The idle-drain gate polls on a
+ * fixed short interval while (and only while) the buffer is non-empty, so a gap
+ * between consecutive consultations longer than a few poll intervals means the
+ * prior episode's buffer drained via a non-idle path and this is a new episode.
+ *
+ * `boundMs <= 0` disables the busy-defer entirely (kill switch / parity with the
+ * background-work grace being disabled). `staleGapMs <= 0` disables the
+ * gap-based episode reset (leaving only the `busy=false` reset).
+ */
+export const DEFAULT_DRAIN_DEFER_STALE_GAP_MS = 15_000
+
+export function makeSessionBusyDrainDeferral(
+  boundMs: number,
+  staleGapMs: number = DEFAULT_DRAIN_DEFER_STALE_GAP_MS,
+): (busy: boolean, now: number) => boolean {
+  let deferringSince: number | null = null
+  let lastCallAt: number | null = null
+  return (busy, now) => {
+    const gapSinceLastCall = lastCallAt == null ? null : now - lastCallAt
+    lastCallAt = now
+    if (!busy || boundMs <= 0) {
+      deferringSince = null
+      return false
+    }
+    // Start (or restart) the clock at the top of a NEW deferral episode:
+    //   - we were not deferring (deferringSince cleared by a busy=false call), OR
+    //   - the predicate has not been consulted within staleGapMs, which means the
+    //     prior episode's buffer drained via a path that never calls us with
+    //     busy=false (bridge re-register) and left deferringSince pinned at a
+    //     stale t0. Either way a fresh episode's bound must run from `now`.
+    if (
+      deferringSince == null ||
+      (staleGapMs > 0 && gapSinceLastCall != null && gapSinceLastCall > staleGapMs)
+    ) {
+      deferringSince = now
+    }
+    // Bounded: stop deferring once we have been busy past the ceiling, so a
+    // wedged/hung session still eventually drains the buffered represent.
+    return now - deferringSince < boundMs
+  }
+}

package/telegram-plugin/gateway/stream-render.ts

@@ -279,6 +279,19 @@ export function __resetParkedTurnStartsForTest(): void {
 export function __parkedTurnStartCountForTest(): number {
   return parkedTurnStarts.length
 }
+/**
+ * Production accessor for the parked-turn-start count — the second half of the
+ * stream-render "session busy" signal (the first being a live `currentTurn`
+ * whose `endedAt == null`). A parked turn-start means the CLI has an enqueued
+ * message it is about to turn on, so the session is NOT idle even when the
+ * gateway's machine-turn gate (`turnInFlightForGate`) reads clear — the exact
+ * disagreement a ~5-min silence poke opens (it clears the machine turn while the
+ * CLI is still producing the answer). The obligation sweep and the idle-drain
+ * consult this so they do not treat a poke-cleared-but-busy session as idle.
+ */
+export function parkedTurnStartCount(): number {
+  return parkedTurnStarts.length
+}
 
 /**
  * Silence-fallback unwedge for the parked store (the two-state desync fix).
@@ -1125,8 +1138,17 @@ export function handleSessionEvent(deps: StreamRenderDeps, ev: SessionEvent): vo
       }
       if (QUEUED_CARD_ENABLED && !handbackOwnsSurface) {
         const cardChatId = ev.chatId
-        const replyToRaw = ev.messageId != null ? Number(ev.messageId) : null
-        const replyTo = replyToRaw != null && Number.isFinite(replyToRaw) ? replyToRaw : null
+        // Reply-anchor ONLY to a plausible real Telegram message id. Synthetic
+        // enqueues (subagent handback, boot resume, cron) fabricate `messageId`
+        // from `Date.now()` (~1.78e13) — finite, so a bare `Number.isFinite`
+        // guard passes it, but `reply_parameters.message_id` hard-rejects
+        // anything beyond signed int32 with 400 `field "message_id" must be a
+        // valid Number` (`allow_sending_without_reply` does NOT bypass the
+        // range check), killing the whole card send (overlord
+        // gateway-supervisor.log 2026-08-04, e.g. msg=1785846295635). Same bug
+        // class as the resume-dark-feed incident — reuse its guard, don't
+        // re-derive a weaker one. An unanchored card is fine; no card is not.
+        const replyTo = parseSourceMessageId(ev.messageId)
         void openQueuedCard(deps, cardChatId, enqThreadIdNum ?? null, replyTo).then((cardId) => {
           if (cardId == null) return
           // Still parked → adopt on the next dequeue. Otherwise the entry already

package/telegram-plugin/tests/boot-card-reason.test.ts

@@ -164,3 +164,91 @@ describe('determineRestartReason', () => {
     expect(result).toBe('crash')
   })
 })
+
+// ── determineBridgeReconnectReason (fleet-audit B2) ────────────────────────
+//
+// Live trace this pins (kdogg gateway-supervisor.log, 2026-08-02):
+//   06:27:43  shutdown.clean_marker_written reason="cli: restart"
+//   06:27:46  boot.clean_shutdown_detected → boot path logs reason=graceful
+//             …and CLEARS the clean-shutdown marker (2026-05-25 GC)
+//   06:27:55  surviving bridge re-registers → old code re-derived from the
+//             now-empty disk and logged reason=crash for a graceful restart.
+// Fleet-wide: lawgpt 310 / reggie 179 / ziggy 175 / kdogg 174 such lines.
+
+import { determineBridgeReconnectReason } from '../gateway/boot-reason.js'
+
+describe('determineBridgeReconnectReason', () => {
+  it('reuses the boot-determined reason when the boot path consumed the markers (kdogg 2026-08-02 trace)', () => {
+    const result = determineBridgeReconnectReason({
+      marker: null,               // cleared by the boot path
+      cleanMarker: null,          // cleared by the boot path
+      sessionMarker: sessionMarker(),
+      now: NOW,
+      gatewayStartedAtMs: NOW - 10_000, // bridge re-registered 10s after boot
+      bootReason: 'graceful',
+    })
+    // Old behavior (plain determineRestartReason on the empty disk state)
+    // returned 'crash' here — the B2 mislabel.
+    expect(result).toBe('graceful')
+  })
+
+  it('a still-present fresh restart marker wins over the cached boot reason', () => {
+    const result = determineBridgeReconnectReason({
+      marker: recentMarker(10_000),
+      cleanMarker: null,
+      sessionMarker: sessionMarker(),
+      now: NOW,
+      gatewayStartedAtMs: NOW - 10_000,
+      bootReason: 'graceful',
+    })
+    expect(result).toBe('planned')
+  })
+
+  it('a still-present fresh clean-shutdown marker wins over the cached boot reason', () => {
+    const result = determineBridgeReconnectReason({
+      marker: null,
+      cleanMarker: recentCleanMarker(5_000),
+      sessionMarker: sessionMarker(),
+      now: NOW,
+      gatewayStartedAtMs: NOW - 10_000,
+      bootReason: 'crash',
+    })
+    expect(result).toBe('graceful')
+  })
+
+  it('late re-register (gateway up past the reuse window) still classifies as crash', () => {
+    const result = determineBridgeReconnectReason({
+      marker: null,
+      cleanMarker: null,
+      sessionMarker: sessionMarker(),
+      now: NOW,
+      gatewayStartedAtMs: NOW - 6 * 60_000, // gateway alive 6 min — bridge side died
+      bootReason: 'graceful',
+    })
+    expect(result).toBe('crash')
+  })
+
+  it('no recorded boot reason falls back to the plain derivation', () => {
+    const result = determineBridgeReconnectReason({
+      marker: null,
+      cleanMarker: null,
+      sessionMarker: sessionMarker(),
+      now: NOW,
+      gatewayStartedAtMs: NOW - 10_000,
+      bootReason: null,
+    })
+    expect(result).toBe('crash')
+  })
+
+  it('fresh first boot (no session marker) reuses bootReason fresh', () => {
+    const result = determineBridgeReconnectReason({
+      marker: null,
+      cleanMarker: null,
+      sessionMarker: null,
+      now: NOW,
+      gatewayStartedAtMs: NOW - 3_000,
+      bootReason: 'fresh',
+    })
+    expect(result).toBe('fresh')
+  })
+})

package/telegram-plugin/tests/cron-bridge-drain-spool-ack.test.ts

@@ -0,0 +1,150 @@
+/**
+ * #4348 — the Tier-1 cheap-cron bridge-register drain must route through the
+ * shared `redeliverBufferedInbound` chokepoint so a delivered cron fire is
+ * `spool.ack`'d exactly once and CANNOT re-fire after a restart.
+ *
+ * The bug: `onClientRegistered`'s `<agent>-cron` branch did a raw
+ * `pendingInboundBuffer.drain()` + `client.send()` loop and returned early,
+ * never reaching `spool.ack` (which lives only inside
+ * `redeliverBufferedInbound`). A due cron tick spooled during the boot window
+ * (before the cron bridge registered) stayed live in the durable spool, so
+ * boot-replay re-pushed it on the next restart and the SAME fire was delivered
+ * a second time — a duplicate cron delivery bounded only by the 15-min
+ * escalation sweep.
+ *
+ * These tests assert the OUTCOME on the real drain seam
+ * (`drainCronBridgeOnRegister`), against a REAL spool + buffer:
+ *   1. the boot-window fire is delivered to the cron bridge, AND
+ *   2. its durable spool entry is acked (liveCount → 0), AND
+ *   3. a simulated restart's boot-replay finds nothing to re-push, so the fire
+ *      does NOT re-fire.
+ *
+ * RED-before-GREEN: with the pre-#4348 raw-drain body the fire is delivered but
+ * the spool entry stays live, so assertions (2)+(3) fail. With the fix routing
+ * through `redeliverBufferedInbound` they pass.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  createInboundSpool,
+  type InboundSpoolFsSeam,
+  type InboundSpool,
+} from '../gateway/inbound-spool.js'
+import { createPendingInboundBuffer } from '../gateway/pending-inbound-buffer.js'
+import { drainCronBridgeOnRegister, cronIdentity } from '../gateway/cron-session.js'
+import type { InboundMessage } from '../gateway/ipc-protocol.js'
+
+const SPOOL_PATH = '/state/agent/telegram/inbound-spool.jsonl'
+
+/** In-memory fake fs for the spool — models append + atomic-rename compaction.
+ *  Shared across "restarts" so the durable JSONL survives, exactly like the
+ *  persistent per-agent volume. */
+function fakeFs(): InboundSpoolFsSeam {
+  const files = new Map<string, string>()
+  return {
+    appendFileSync: (p, d) => files.set(p, (files.get(p) ?? '') + d),
+    readFileSync: (p) => files.get(p) ?? '',
+    writeFileSync: (p, d) => files.set(p, d),
+    renameSync: (from, to) => {
+      files.set(to, files.get(from) ?? '')
+      files.delete(from)
+    },
+    existsSync: (p) => files.has(p),
+    statSizeSync: (p) => Buffer.byteLength(files.get(p) ?? ''),
+    fsyncFileSync: () => {},
+    fsyncDirSync: () => {},
+  }
+}
+
+function cronFire(over: Partial<InboundMessage> = {}): InboundMessage {
+  return {
+    type: 'inbound',
+    chatId: 'c1',
+    messageId: 0, // synthetic — cron fires carry no Telegram messageId
+    user: 'system',
+    userId: 0,
+    ts: 1000,
+    text: 'Time for the daily digest',
+    meta: { source: 'cron', session: 'cron' },
+    ...over,
+  } as InboundMessage
+}
+
+/** A capturing stand-in for the just-registered cron IPC client. */
+function fakeClient(agentName: string): {
+  agentName: string
+  send: (msg: unknown) => void
+  sent: unknown[]
+} {
+  const sent: unknown[] = []
+  return { agentName, send: (m) => void sent.push(m), sent }
+}
+
+/** Simulate the gateway's boot-replay: re-push every live (un-acked) spool
+ *  entry into a fresh in-memory buffer, exactly as gateway.ts does at boot. */
+function bootReplayInto(spool: InboundSpool): ReturnType<typeof createPendingInboundBuffer> {
+  const buffer = createPendingInboundBuffer({ log: () => {}, spool })
+  for (const { agent, msg } of spool.liveEntries()) buffer.push(agent, msg)
+  return buffer
+}
+
+describe('#4348 cron-bridge drain routes through the spool-ack chokepoint', () => {
+  it('acks the boot-window cron fire and does not re-fire after restart', () => {
+    const fs = fakeFs()
+    const spool = createInboundSpool({ path: SPOOL_PATH, fs, log: () => {} })
+    const cronAgent = cronIdentity('overlord') // "overlord-cron"
+
+    // Boot window: a due cron tick arrives BEFORE the cron bridge registers.
+    // It is buffered (in-memory) AND durably spooled by the same push.
+    const buffer = createPendingInboundBuffer({ log: () => {}, spool })
+    buffer.push(cronAgent, cronFire())
+    expect(spool.liveCount()).toBe(1) // durably recorded, not yet delivered
+
+    // The cron bridge registers → the drain seam under test runs.
+    const client = fakeClient(cronAgent)
+    const result = drainCronBridgeOnRegister(client, buffer, spool)
+
+    // (1) The fire was delivered to the cron bridge.
+    expect(result.drained).toBe(1)
+    expect(result.redelivered).toBe(1)
+    const deliveredFires = client.sent.filter(
+      (m): m is InboundMessage => (m as InboundMessage).type === 'inbound',
+    )
+    expect(deliveredFires).toHaveLength(1)
+    expect(deliveredFires[0]!.text).toBe('Time for the daily digest')
+
+    // (2) The durable spool entry is tombstoned — the whole point of #4348.
+    expect(spool.liveCount()).toBe(0)
+    expect(spool.liveEntries()).toHaveLength(0)
+
+    // (3) Simulated restart: boot-replay finds nothing to re-push, so the SAME
+    //     fire does NOT re-fire. (Pre-fix this replayed the un-acked entry.)
+    const afterRestart = bootReplayInto(spool)
+    expect(afterRestart.drain(cronAgent)).toHaveLength(0)
+  })
+
+  it('a send failure re-buffers the fire and leaves the spool entry live (lossless)', () => {
+    const fs = fakeFs()
+    const spool = createInboundSpool({ path: SPOOL_PATH, fs, log: () => {} })
+    const cronAgent = cronIdentity('overlord')
+
+    const buffer = createPendingInboundBuffer({ log: () => {}, spool })
+    buffer.push(cronAgent, cronFire())
+
+    // Client whose send throws for inbound fires (bridge wedged mid-drain).
+    const throwing = {
+      agentName: cronAgent,
+      send: (m: unknown) => {
+        if ((m as InboundMessage).type === 'inbound') throw new Error('socket gone')
+      },
+    }
+    const result = drainCronBridgeOnRegister(throwing, buffer, spool)
+
+    // Not delivered → re-buffered, and the spool entry stays LIVE so the next
+    // register (or boot-replay) retries it. Nothing is dropped, nothing acked.
+    expect(result.redelivered).toBe(0)
+    expect(result.rebuffered).toBe(1)
+    expect(spool.liveCount()).toBe(1)
+    expect(buffer.drain(cronAgent)).toHaveLength(1)
+  })
+})

package/telegram-plugin/tests/ipc-client-reconnect-rejection.test.ts

@@ -0,0 +1,70 @@
+/**
+ * Regression test for fleet-audit B2 — the bridge's background reconnect
+ * loop must never surface a failed connect attempt as a process-level
+ * unhandledRejection.
+ *
+ * Live evidence (kdogg, 2026-07-17):
+ *   bridge-crash.log: `unhandledRejection … Error: Failed to connect
+ *     | at doConnect (dist/server.js:24188) …`
+ *
+ * Mechanism: `scheduleReconnect()`'s timer invoked `doConnect()` without a
+ * rejection handler. `doConnect` returns a promise that REJECTS whenever
+ * the `Bun.connect` attempt fails (gateway restarting out from under a
+ * long-lived bridge — the exact window every planned `docker restart`
+ * opens). The initial-connect call sites attach a `.catch`; the retry
+ * timer did not, so every failed background retry escaped as an
+ * unhandledRejection. Pre-#3033 that killed the bridge process outright
+ * (Claude Code never respawns a dead MCP server → mute agent); post-#3033
+ * it still spams `bridge-crash.log` with pseudo-crash breadcrumbs and
+ * leans on a global process handler for survival.
+ *
+ * Outcome asserted: with nothing listening on the socket path, the client
+ * runs through its initial attempt AND several background retries without
+ * a single unhandledRejection reaching the process. RED without the
+ * `.catch` in scheduleReconnect's timer, GREEN with it.
+ *
+ * Run with: bun test telegram-plugin/tests/ipc-client-reconnect-rejection.test.ts
+ */
+import { describe, it, expect } from "bun:test";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createIpcClient } from "../bridge/ipc-client.js";
+
+describe("ipc-client background reconnect", () => {
+  it("a failed reconnect attempt never escapes as a process-level unhandledRejection", async () => {
+    const captured: unknown[] = [];
+    const onUnhandled = (err: unknown) => {
+      captured.push(err);
+    };
+    process.on("unhandledRejection", onUnhandled);
+
+    // Nothing listens here — every connect attempt fails, exercising both
+    // the (already-handled) initial attempt and the retry-timer path.
+    const socketPath = join(tmpdir(), `ipc-b2-${crypto.randomUUID()}.sock`);
+
+    const handle = await createIpcClient({
+      socketPath,
+      agentName: "b2-test",
+      onInbound: () => {},
+      onPermission: () => {},
+      onStatus: () => {},
+      log: () => {},
+      reconnectDelayMs: 15,
+      maxReconnectDelayMs: 30,
+    });
+
+    try {
+      // Long enough for several background retries (15ms, 30ms, 30ms, …)
+      // plus the macrotask on which unhandledRejection is delivered.
+      await new Promise((resolve) => setTimeout(resolve, 300));
+    } finally {
+      handle.close();
+      // Give any in-flight rejection its delivery tick before detaching.
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      process.off("unhandledRejection", onUnhandled);
+    }
+
+    expect(handle.isConnected()).toBe(false);
+    expect(captured).toEqual([]);
+  });
+});

package/telegram-plugin/tests/narrative-lane-golden.test.ts

@@ -282,6 +282,92 @@ describe('narrative-lane golden — clearActivitySummary finalize', () => {
   })
 })
 
+// ── #4348 — silent-sentinel activity card is SUPPRESSED (deleted, not finalized) ─
+// A turn whose entire user-facing outcome is a bare NO_REPLY / HEARTBEAT_OK
+// (the sentinel-reply-guard dropped the sentinel-only reply, or the flush net
+// classified the captured text as silent) must leave NO visible telemetry card
+// in the chat — most visibly on the forced-synthesis handback turns a
+// background sub-agent injects. A real reply's card must still finalize.
+describe('narrative-lane golden — silent-sentinel card suppression (#4348)', () => {
+  // Open the feed card on a fresh (working) turn FIRST — the card-open gate
+  // (mayOpenActivityCard) won't open one once the answer is already delivered —
+  // then stamp the turn's terminal outcome, exactly as the real turn does:
+  // the card opens mid-work, and lastReplyText / finalAnswerEverDelivered are
+  // only known at turn end.
+  async function openThenClear(over: Partial<CurrentTurn>) {
+    const { lane, calls } = makeLane()
+    const turn = makeLaneTurn(lane)
+    lane.showNarrativeStep(turn, 'Doing the work now')
+    await turn.activityInFlight
+    const cardId = turn.activityMessageId
+    expect(cardId).not.toBeNull()
+    Object.assign(turn, over)
+    lane.clearActivitySummary(turn)
+    await settle()
+    return { calls, cardId, turn }
+  }
+
+  it('reply("NO_REPLY") turn: DELETES the card, never edits a done record', async () => {
+    // The guard drops the sentinel-only reply before chat, but the blocked
+    // tool_use still stamps lastReplyText — the exact `✓ NO_REPLY` noise card.
+    const { calls, cardId, turn } = await openThenClear({
+      replyCalled: true,
+      lastReplyText: 'NO_REPLY',
+      finalAnswerEverDelivered: false,
+    })
+    expect(calls.filter((c) => c.method === 'deleteMessage' && c.message_id === cardId)).toHaveLength(1)
+    expect(calls.filter((c) => c.method === 'editMessageText' && c.message_id === cardId)).toHaveLength(0)
+    expect(turn.activityMessageId).toBeNull()
+  })
+
+  it('HEARTBEAT_OK. (trailing punctuation, case-insensitive) is also suppressed', async () => {
+    const { calls, cardId } = await openThenClear({
+      replyCalled: true,
+      lastReplyText: 'heartbeat_ok.',
+      finalAnswerEverDelivered: false,
+    })
+    expect(calls.filter((c) => c.method === 'deleteMessage' && c.message_id === cardId)).toHaveLength(1)
+    expect(calls.filter((c) => c.method === 'editMessageText' && c.message_id === cardId)).toHaveLength(0)
+  })
+
+  it('flush path (no reply): prose + trailing NO_REPLY (H6/#2053) is suppressed', async () => {
+    const { calls, cardId } = await openThenClear({
+      replyCalled: false,
+      lastReplyText: '',
+      capturedText: ["Nothing actionable in today's digest.", 'NO_REPLY'],
+      finalAnswerEverDelivered: false,
+    })
+    expect(calls.filter((c) => c.method === 'deleteMessage' && c.message_id === cardId)).toHaveLength(1)
+    expect(calls.filter((c) => c.method === 'editMessageText' && c.message_id === cardId)).toHaveLength(0)
+  })
+
+  it('normal reply turn: still FINALIZES the card (edit, no delete)', async () => {
+    // The guarantee the fix must not break: a real answer keeps its record.
+    const { calls, cardId, turn } = await openThenClear({
+      replyCalled: true,
+      lastReplyText: 'The fix is deployed and the tests are green.',
+      finalAnswerEverDelivered: true,
+    })
+    expect(calls.filter((c) => c.method === 'editMessageText' && c.message_id === cardId).length)
+      .toBeGreaterThanOrEqual(1)
+    expect(calls.filter((c) => c.method === 'deleteMessage')).toHaveLength(0)
+    expect(turn.activityMessageId).toBeNull()
+  })
+
+  it('reply "prose\\nNO_REPLY" that WAS delivered (finalAnswerEverDelivered) keeps its card', async () => {
+    // The guard does NOT drop a reply with non-marker content, so its prose
+    // reached chat — endsWithSilentMarker must NOT suppress a delivered reply.
+    const { calls, cardId } = await openThenClear({
+      replyCalled: true,
+      lastReplyText: 'Here is the full answer to your question.\nNO_REPLY',
+      finalAnswerEverDelivered: true,
+    })
+    expect(calls.filter((c) => c.method === 'editMessageText' && c.message_id === cardId).length)
+      .toBeGreaterThanOrEqual(1)
+    expect(calls.filter((c) => c.method === 'deleteMessage')).toHaveLength(0)
+  })
+})
+
 // ── THREE-MODULE cross-surface dedup (Amendment 1) ────────────────────────
 // The REAL P4-A handleSessionEvent turn-flush, with the REAL P4-B lane wired
 // into its deps, records the delivered answer into ONE OutboundDedupCache;