switchroom 0.20.6 → 0.20.8

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