switchroom 0.20.7 → 0.20.8

package/telegram-plugin/tests/queued-card-surface.test.ts

@@ -260,3 +260,69 @@ describe('Part B — handback-while-busy: exactly one card, never a frozen "Queu
     expect(rec.edits).toHaveLength(0)
   })
 })
+
+describe('Part B — synthetic (fabricated) message ids never 400 the queued card', () => {
+  /** Recording bot that enforces the REAL Telegram Bot API contract on
+   *  `reply_parameters.message_id`: anything non-integer or beyond signed int32
+   *  is hard-rejected with the exact 400 the live gateway hit
+   *  (gateway-supervisor.log 2026-08-04, msg=1785846295635) — BEFORE recording,
+   *  exactly like the wire call. `allow_sending_without_reply` does not bypass
+   *  the range check, only the message-not-found case. */
+  function withTelegramStrictBot(h: Harness) {
+    const sends: SendRec[] = []
+    let nextId = 9001
+    ;(h.deps as unknown as { bot: unknown }).bot = {
+      api: {
+        sendRichMessage: async (chatId: string, msg: { markdown: string }, opts: Record<string, unknown>) => {
+          const rp = opts.reply_parameters as { message_id?: unknown } | undefined
+          if (rp != null) {
+            const mid = rp.message_id
+            if (typeof mid !== 'number' || !Number.isInteger(mid) || mid <= 0 || mid >= 2 ** 31) {
+              throw new Error(
+                `Call to 'sendRichMessage' failed! (400: Bad Request: field "message_id" must be a valid Number)`,
+              )
+            }
+          }
+          const id = nextId++
+          sends.push({ chatId, markdown: msg.markdown, opts, id })
+          return { message_id: id }
+        },
+        editMessageText: async () => true,
+        deleteMessage: async () => true,
+      },
+    }
+    return { sends }
+  }
+
+  it('sends the queued card UNANCHORED (no 400) when the parked message id is a fabricated Date.now() timestamp', async () => {
+    const h = makeHarness()
+    const rec = withTelegramStrictBot(h)
+
+    // Turn A mints on an idle session.
+    handleSessionEvent(h.deps, enqueue('501'))
+    expect(rec.sends).toHaveLength(0)
+
+    // A synthetic enqueue (subagent handback / boot resume) parks mid-turn with
+    // a fabricated ms-timestamp message id — finite, but NOT a Telegram id.
+    handleSessionEvent(h.deps, enqueue('1785846295635', 'handback: worker done'))
+    await settle()
+    expect(__parkedTurnStartCountForTest()).toBe(1)
+
+    // The card SENT (no 400 — RED on the pre-fix guard, which forwarded the
+    // 13-digit id into reply_parameters and lost the whole card)…
+    expect(rec.sends).toHaveLength(1)
+    // …and it sent WITHOUT reply-linkage: no reply_parameters at all.
+    expect(rec.sends[0]!.opts.reply_parameters).toBeUndefined()
+  })
+
+  it('still reply-anchors when the parked message id is a real Telegram id', async () => {
+    const h = makeHarness()
+    const rec = withTelegramStrictBot(h)
+
+    handleSessionEvent(h.deps, enqueue('501'))
+    handleSessionEvent(h.deps, enqueue('502', 'real mid-turn message'))
+    await settle()
+    expect(rec.sends).toHaveLength(1)
+    expect((rec.sends[0]!.opts.reply_parameters as { message_id: number }).message_id).toBe(502)
+  })
+})

package/telegram-plugin/tests/represent-guard.test.ts

@@ -336,6 +336,51 @@ describe("makeSessionBusyDrainDeferral — F2 bounded busy-defer for the idle dr
     expect(off(true, 0)).toBe(false);
     expect(off(true, 10_000)).toBe(false);
   });
+
+  it("starts a FRESH bound for a new deferral episode after a call gap — a buffer emptied by bridge re-register (no busy=false call) must not pin a stale t0 (#4341 follow-up)", () => {
+    const BOUND = 20_000; // small bound so a realistic 5s poll cadence spans it
+    const defer = makeSessionBusyDrainDeferral(BOUND); // default staleGap = 15s
+
+    // Episode A: a represent is buffered while the session is busy. The idle
+    // drain gate polls it every ~5s (< staleGap) and defers each time.
+    expect(defer(true, 0)).toBe(true); // t0 = 0
+    expect(defer(true, 5_000)).toBe(true);
+    expect(defer(true, 10_000)).toBe(true);
+
+    // The buffer is now emptied by a bridge re-register (onClientRegistered)
+    // while the session is STILL busy. That drain path does NOT consult this
+    // predicate, so there is no busy=false call — deferringSince stays at 0 on
+    // the buggy code. Time then advances well past the bound with the buffer
+    // empty (predicate not called).
+
+    // Episode B: a brand-new represent is buffered while the session is busy,
+    // long after t0. This is a NEW mid-answer session — the represent MUST stay
+    // deferred (its own bound has not elapsed), NOT be drained immediately.
+    // Buggy code: now - stalePinnedT0 (2_000_000 - 0) >= BOUND → false → the
+    // represent is drained into the mid-answer session, reopening the duplicate
+    // window. Fixed code: the >15s call gap starts a fresh episode clock at
+    // t=2_000_000, so it defers.
+    const B0 = 2_000_000;
+    expect(defer(true, B0)).toBe(true);
+    // ...and the fresh episode is still bounded from ITS OWN start, polled at the
+    // real ~5s cadence (each gap < staleGap, so no further reset).
+    expect(defer(true, B0 + 5_000)).toBe(true);
+    expect(defer(true, B0 + 10_000)).toBe(true);
+    expect(defer(true, B0 + 15_000)).toBe(true);
+    expect(defer(true, B0 + BOUND)).toBe(false); // fresh bound elapsed → drains
+  });
+
+  it("does NOT reset the clock on the normal poll cadence — a genuinely wedged busy session still drains at the bound (wedge budget preserved)", () => {
+    const BOUND = 20_000;
+    const defer = makeSessionBusyDrainDeferral(BOUND); // default staleGap = 15s
+    // Polls arrive every 5s (< staleGap) throughout one continuous episode, so
+    // the clock is never reset and the bound elapses on schedule.
+    expect(defer(true, 0)).toBe(true);
+    expect(defer(true, 5_000)).toBe(true);
+    expect(defer(true, 10_000)).toBe(true);
+    expect(defer(true, 15_000)).toBe(true);
+    expect(defer(true, 20_000)).toBe(false); // bound reached — drains, not silenced forever
+  });
 });
 
 describe("obligationSweep — F2 decision half: a poke-cleared-but-busy session defers, then re-asks (bounded)", () => {

package/telegram-plugin/tests/turn-flush-safety.test.ts

@@ -20,6 +20,7 @@ import {
   isSilentFlushMarker,
   isCompositeSilentNoise,
   endsWithSilentMarker,
+  isSilentSentinelCardOutcome,
   isTurnFlushSafetyEnabled,
   selectFlushDeliveryText,
   FLUSH_SUBSTANTIVE_MIN_CHARS,
@@ -893,3 +894,85 @@ describe('selectFlushDeliveryText — structural provenance (followedByToolUse)
     expect(out).not.toContain('Here are the figures')
   })
 })
+
+// #4348 — the pure gate that suppresses the per-turn activity/telemetry card
+// when the turn's whole user-facing outcome was an intentional silent sentinel.
+describe('isSilentSentinelCardOutcome (#4348)', () => {
+  const base = { replyCalled: false, lastReplyText: '', capturedText: [] as string[], finalAnswerEverDelivered: false }
+
+  it('reply("NO_REPLY") — the blocked sentinel-only reply is a silent outcome', () => {
+    expect(isSilentSentinelCardOutcome({ ...base, replyCalled: true, lastReplyText: 'NO_REPLY' })).toBe(true)
+  })
+
+  it('trailing punctuation and case variants still count as silent', () => {
+    for (const t of ['NO_REPLY.', 'no_reply', 'HEARTBEAT_OK', 'heartbeat_ok!', ' NO_REPLY ']) {
+      expect(isSilentSentinelCardOutcome({ ...base, replyCalled: true, lastReplyText: t })).toBe(true)
+    }
+  })
+
+  it('composite silent noise ("Sent.\\nNO_REPLY\\nNO_REPLY") via the reply payload is silent', () => {
+    expect(
+      isSilentSentinelCardOutcome({ ...base, replyCalled: true, lastReplyText: 'Sent.\nNO_REPLY\nNO_REPLY' }),
+    ).toBe(true)
+  })
+
+  it('flush path (no reply): prose + trailing NO_REPLY (H6/#2053) is silent', () => {
+    expect(
+      isSilentSentinelCardOutcome({
+        ...base,
+        replyCalled: false,
+        capturedText: ["Nothing actionable in today's digest.", 'NO_REPLY'],
+      }),
+    ).toBe(true)
+  })
+
+  it('a real reply is NOT silent — the card is a legitimate record', () => {
+    expect(
+      isSilentSentinelCardOutcome({
+        ...base,
+        replyCalled: true,
+        lastReplyText: 'The three services are all green.',
+        finalAnswerEverDelivered: true,
+      }),
+    ).toBe(false)
+  })
+
+  it('finalAnswerEverDelivered short-circuits even when a stray NO_REPLY is the last reply text', () => {
+    // An interim answer landed, then a trailing sentinel — the delivered answer wins.
+    expect(
+      isSilentSentinelCardOutcome({
+        ...base,
+        replyCalled: true,
+        lastReplyText: 'NO_REPLY',
+        finalAnswerEverDelivered: true,
+      }),
+    ).toBe(false)
+  })
+
+  it('a delivered reply that merely mentions the sentinel in prose is NOT silent', () => {
+    // Non-marker content ⇒ the sentinel-reply-guard would not drop it ⇒ delivered.
+    expect(
+      isSilentSentinelCardOutcome({
+        ...base,
+        replyCalled: true,
+        lastReplyText: 'Reply with exactly NO_REPLY if there is nothing to add.',
+      }),
+    ).toBe(false)
+  })
+
+  it('endsWithSilentMarker does NOT suppress a DELIVERED reply of "prose\\nNO_REPLY"', () => {
+    // The guard lets prose+trailing-NO_REPLY through the reply tool, so its
+    // prose reached chat; the card must stay even though it ends with a marker.
+    expect(
+      isSilentSentinelCardOutcome({
+        ...base,
+        replyCalled: true,
+        lastReplyText: 'Here is the full answer.\nNO_REPLY',
+      }),
+    ).toBe(false)
+  })
+
+  it('a genuinely empty dark turn (no reply, no text) is NOT a sentinel', () => {
+    expect(isSilentSentinelCardOutcome({ ...base })).toBe(false)
+  })
+})

package/telegram-plugin/turn-flush-safety.ts

@@ -135,6 +135,85 @@ export function endsWithSilentMarker(text: string | undefined): boolean {
   return isSilentFlushMarker(lines[lines.length - 1])
 }
 
+/**
+ * Inputs for {@link isSilentSentinelCardOutcome} — the fields of the ending
+ * turn the card-suppression gate reads. All are already tracked on the
+ * gateway's `CurrentTurn`; passed as a plain struct so the decision is a pure,
+ * unit-testable core (`gateway.ts` / `narrative-lane.ts` are not importable in
+ * tests).
+ */
+export interface SilentSentinelCardInput {
+  /** True when the model called `reply` / `stream_reply` at least once. */
+  replyCalled: boolean
+  /**
+   * The most-recent `reply` / `stream_reply` `input.text` this turn — empty
+   * string when the reply tool was never called (`CurrentTurn.lastReplyText`).
+   */
+  lastReplyText: string
+  /**
+   * Raw assistant text blocks accumulated across the turn — the same source
+   * `decideTurnFlush` classifies (`CurrentTurn.capturedText`). Only consulted
+   * on the reply-never-called (flush) path.
+   */
+  capturedText: string[]
+  /**
+   * A SUBSTANTIVE final answer reached the user at some point this turn
+   * (`CurrentTurn.finalAnswerEverDelivered`). When true the card is a
+   * legitimate record beside a delivered answer and is NEVER suppressed.
+   */
+  finalAnswerEverDelivered: boolean
+}
+
+/**
+ * Decide whether an ending turn's user-facing outcome was an INTENTIONAL silent
+ * sentinel (NO_REPLY / HEARTBEAT_OK) — the deterministic gate that suppresses
+ * the per-turn activity/telemetry card for a turn that said nothing to the user.
+ *
+ * The symptom (#4348): a background sub-agent handback injects a forced-synthesis
+ * turn, the parent legitimately answers `NO_REPLY`, and the gateway still
+ * finalizes a `🤖 Agent · done · 0 tools · … · ✓ NO_REPLY` card in the chat.
+ * `sentinel-reply-guard-pretool.mjs` already drops the sentinel-only reply so
+ * nothing reaches chat, but the blocked `tool_use` still stamps `lastReplyText`,
+ * and the activity card finalizes as pure noise.
+ *
+ * This reuses the SAME silent-turn predicates the flush safety net and the Stop
+ * hook use — it invents no second notion of "silent":
+ *   - Reply path (`replyCalled`): the model called `reply` with a sentinel-ONLY
+ *     payload, which `sentinel-reply-guard-pretool.mjs` drops before chat, so the
+ *     card's whole outcome is a silence signal that never became a message. Only
+ *     `isSilentFlushMarker` / `isCompositeSilentNoise` count here — a
+ *     `prose\nNO_REPLY` reply is NOT dropped by that guard (it has non-marker
+ *     content), so its prose WAS delivered and its card must stay. `endsWithSilentMarker`
+ *     is deliberately NOT applied to a delivered reply.
+ *   - Flush path (reply never called): the turn's captured terminal text is its
+ *     outcome, so match every shape `decideTurnFlush` treats as `silent-marker` —
+ *     bare marker, composite noise, and prose+trailing-`NO_REPLY` (#2053 / H6).
+ *
+ * The `finalAnswerEverDelivered` short-circuit is the normal-case guarantee: a
+ * turn that actually delivered a substantive answer keeps its card, so a real
+ * reply (even one a later stray `NO_REPLY` follows) is never suppressed.
+ */
+export function isSilentSentinelCardOutcome(input: SilentSentinelCardInput): boolean {
+  // A substantive answer reached the user — the card is a legitimate record.
+  if (input.finalAnswerEverDelivered) return false
+  // Reply-tool outcome: a sentinel-ONLY payload the guard dropped before chat.
+  if (isSilentFlushMarker(input.lastReplyText) || isCompositeSilentNoise(input.lastReplyText)) {
+    return true
+  }
+  // Flush outcome: reply never called; classify the captured terminal text with
+  // the exact predicates decideTurnFlush's `silent-marker` skip uses.
+  if (!input.replyCalled) {
+    const joined = input.capturedText.join('\n\n').trim()
+    if (
+      joined.length > 0 &&
+      (isSilentFlushMarker(joined) || isCompositeSilentNoise(joined) || endsWithSilentMarker(joined))
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
 /**
  * Substantive-answer floor (chars, trimmed). Mirrors
  * `final-answer-detect.ts` `FINAL_ANSWER_MIN_CHARS` and