switchroom 0.19.45 → 0.19.47

package/telegram-plugin/gateway/handback-preturn-signal.ts

@@ -238,6 +238,18 @@ export interface HandbackPreturnSignalDeps {
    *  is the GLOBAL busy signal because the handback queues behind whatever turn
    *  is running, regardless of topic. Optional; defaults to "not busy". */
   isClaudeBusy?: () => boolean
+  /** True IFF the gateway observed the SESSION consume input after `sinceTs` —
+   *  a turn minting at the enqueue seam, or a main-session MCP tool call over
+   *  the IPC bridge (`session-consume-signal.ts`). Consulted at the moment the
+   *  reap would otherwise declare a genuine orphan: claude holds ONE FIFO input
+   *  queue, so post-delivery consumption evidence means the delivered handback
+   *  entered the model's context even though no adopting turn was ever minted
+   *  (the 2026-08-02 invisible-consumption incident — the session answered the
+   *  handback via a `reply` from idle with zero session-tail events, then the
+   *  reap re-injected the already-answered report twice). When true the reap
+   *  CLEANS UP (card + typing + entry) without re-injecting and without
+   *  escalating. Optional; defaults to "no evidence" (legacy re-inject). */
+  sessionActivitySince?: (sinceTs: number) => boolean
   now?: () => number
   /** Debounce before painting the pre-turn card (kills sub-second flicker). */
   debounceMs?: number
@@ -487,13 +499,27 @@ export function createHandbackPreturnSignal(
       entry.reapTimer = setTimer(() => reap(entry), adoptTimeoutMs)
       return
     }
+    // INVISIBLE-CONSUMPTION GATE (2026-08-02 klanker incident). We are at the
+    // point the reap would declare a genuine orphan: claude is idle, the
+    // delivered TTL elapsed, and no adopting turn ever minted. But "no adopting
+    // turn" is NOT proof the handback went un-consumed — the session can
+    // consume injected input WITHOUT the gateway minting a turn (zero
+    // session-tail events; the only trace was a `reply` tool call from idle).
+    // If the gateway observed the session consume input after this handback
+    // was delivered (a later turn minting, or a main-session tool call —
+    // claude's single FIFO queue means either proves the earlier delivery
+    // entered the model's context), the handback was already processed:
+    // re-injecting it re-runs an answered report (observed: the same worker
+    // report processed three times). Clean up WITHOUT re-injection.
+    const consumedElsewhere = deps.sessionActivitySince?.(entry.deliveredAt) === true
     entry.consumed = true
-    // GENUINE ORPHAN. Recover DETERMINISTICALLY — never ask the operator to
-    // nudge. Stop the forever-running typing loop, DELETE the frozen card (do
-    // not leave a stale "needs a nudge" message), then re-inject the handback so
-    // the machine re-processes it itself. Cap the re-injections; past the cap
-    // escalate to fleet-health telemetry (NOT a chat card).
-    stopTypingUnlessTurnLive(entry, 'orphan reap')
+    // GENUINE ORPHAN (or consumed-elsewhere cleanup). Recover DETERMINISTICALLY
+    // — never ask the operator to nudge. Stop the forever-running typing loop,
+    // DELETE the frozen card (do not leave a stale "needs a nudge" message),
+    // then — for a genuine orphan only — re-inject the handback so the machine
+    // re-processes it itself. Cap the re-injections; past the cap escalate to
+    // fleet-health telemetry (NOT a chat card).
+    stopTypingUnlessTurnLive(entry, consumedElsewhere ? 'consumed reap' : 'orphan reap')
     if (entry.activityMessageId != null) {
       const record: PreTurnCardRecord = {
         turnKey: entry.syntheticTurnKey,
@@ -518,6 +544,18 @@ export function createHandbackPreturnSignal(
     // synchronously) is not swallowed by the per-topic dedupe guard. The entry
     // object stays valid for the captured re-inject below.
     dropEntry(entry)
+    if (consumedElsewhere) {
+      // Distinct structured line so fleet-health can track how often the
+      // session consumes a handback without a gateway-visible adopting turn
+      // (the underlying session-tail anomaly stays observable even though the
+      // false re-injection is gone).
+      log(
+        `handback-preturn-signal: reap resolved key=${entry.statusKey} ` +
+          `turnId=${entry.adoptTurnId} — session consumed input after delivery ` +
+          `(no adopting turn observed); cleaned up without re-injection\n`,
+      )
+      return
+    }
     if (entry.reinjectCount < maxReinjects) {
       const nextCount = entry.reinjectCount + 1
       // Stamp the counter on the inbound so it survives the buffer round trip

package/telegram-plugin/gateway/session-consume-signal.ts

@@ -0,0 +1,72 @@
+/**
+ * session-consume-signal.ts — "did the claude session consume input after T?"
+ *
+ * Built for the 2026-08-02 klanker false-orphan incident (handback turnId
+ * `#1785628912223`). A background worker's `subagent_handback` was released and
+ * DELIVERED to the bridge at 00:01:53Z; the session consumed it and answered it
+ * (a `reply` tool call at 00:02:58Z, IPC-observed, while the gateway's shadow
+ * state was `bridge_alive_idle`) — but NO gateway turn ever minted for it: the
+ * session-tail produced no `enqueue`/stream events for that consumption, so
+ * `handback-preturn-signal`'s entry was never adopted. After the delivered TTL
+ * the reap declared a genuine orphan and RE-INJECTED the already-answered
+ * handback — twice — re-processing the same worker report three times.
+ *
+ * The orphan reap's existing gates (`isClaudeBusy`, the delivered TTL) key off
+ * gateway-minted TURN state, which is exactly the signal that was absent. This
+ * module tracks the two consumption proxies the gateway CAN always observe,
+ * independent of the session-tail:
+ *
+ *   - a TURN MINT (the `enqueue` seam in stream-render): claude holds a single
+ *     FIFO input queue, so a turn minting for an inbound delivered AFTER the
+ *     handback proves everything delivered before it entered the model's
+ *     context (2026-08-02: real turn `#25821` minted 00:04:13Z and completed,
+ *     while the reap still declared the 00:01:53Z handback orphaned);
+ *   - a MAIN-SESSION MCP TOOL CALL over the IPC bridge (reply, progress_update,
+ *     …): the session can only produce a tool call by processing input, so a
+ *     tool call arriving after the delivery is direct evidence the session is
+ *     alive and consuming — the 00:02:58Z reply was the ONLY observable trace
+ *     of the invisible consumption. Cron/foreign sessions are excluded at the
+ *     call site (their activity says nothing about the main session's queue).
+ *
+ * Consumers ask `activitySince(deliveredAt)`. The deliberate trade: when this
+ * returns true for a handback that was in fact DROPPED before reaching claude
+ * (bridge death in the release→write window) while unrelated session activity
+ * happened to occur, the reap now cleans up instead of re-injecting — a lost
+ * recovery for a rare double-fault, logged distinctly for fleet-health. The
+ * previous behaviour re-injected an already-answered handback on every
+ * invisible consumption, which is the incident that actually occurs.
+ *
+ * Pure state, no I/O; module singleton mirrors `subagentReplyAuthority`.
+ */
+
+export class SessionConsumeSignal {
+  private lastTurnMintAt = 0
+  private lastMainToolCallAt = 0
+
+  /** A gateway turn minted at the `enqueue` seam (stream-render). */
+  noteTurnMint(now: number = Date.now()): void {
+    if (now > this.lastTurnMintAt) this.lastTurnMintAt = now
+  }
+
+  /** A NON-CRON client's MCP tool call arrived over the IPC bridge. The call
+   *  site excludes cron identities — a Tier-1 cheap-cron session consuming its
+   *  own input proves nothing about the main session's queue. */
+  noteMainToolCall(now: number = Date.now()): void {
+    if (now > this.lastMainToolCallAt) this.lastMainToolCallAt = now
+  }
+
+  /** True IFF either consumption proxy was observed strictly after `sinceTs`. */
+  activitySince(sinceTs: number): boolean {
+    return this.lastTurnMintAt > sinceTs || this.lastMainToolCallAt > sinceTs
+  }
+
+  /** Test-only: forget all observations. */
+  reset(): void {
+    this.lastTurnMintAt = 0
+    this.lastMainToolCallAt = 0
+  }
+}
+
+/** The ONE live instance (one CLI session per gateway process — the same
+ *  module-singleton shape as `subagentReplyAuthority`). */
+export const sessionConsumeSignal = new SessionConsumeSignal()

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

@@ -75,6 +75,7 @@ import { isTelegramReplyTool, isTelegramSurfaceTool } from '../tool-names.js'
 import { decideTurnFlush } from '../turn-flush-safety.js'
 import { FlushCompletionTracker } from '../flushed-turn-supersede.js'
 import { subagentReplyAuthority } from './subagent-reply-authority.js'
+import { sessionConsumeSignal } from './session-consume-signal.js'
 import { decideTerminalReason, deriveTurnRole } from '../turn-liveness-floor.js'
 import { chatKey, chatKeyWithSuffix } from './chat-key.js'
 import { deriveTurnId } from './derive-turn-id.js'
@@ -747,6 +748,10 @@ function beginTurn(deps: StreamRenderDeps, ev: TurnStartEnvelope): void {
     process.stderr.write(
       `telegram gateway: ${formatTurnLifecycle('set', 'enqueue', next, startedAt)}\n`,
     )
+    // Consumption proxy for the handback orphan reap (session-consume-signal):
+    // claude holds ONE FIFO input queue, so this turn minting proves every
+    // inbound delivered before its own entered the model's context.
+    sessionConsumeSignal.noteTurnMint(startedAt)
     // Component 3 — retain in the bounded recently-ended registry so a
     // LATE reply (landing after currentTurn flips to a successor) can
     // still resolve THIS turn's origin thread by its turnId.

package/telegram-plugin/tests/answer-ready-flush.test.ts

@@ -30,11 +30,14 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import {
   shouldArmAnswerReadyFlush,
   resolveAnswerReadyFlushMs,
+  resolveAnswerStageMs,
   ANSWER_READY_FLUSH_MS,
+  ANSWER_STAGE_MS,
   AnswerReadyFlushController,
   type AnswerReadyArmInput,
   type FlushTimerHandle,
 } from '../answer-ready-flush.js'
+import { decideTurnFlush } from '../turn-flush-safety.js'
 import { ToolFlightTracker } from '../gateway/interrupt-defer.js'
 
 const CHAT = '12345'
@@ -174,9 +177,10 @@ class GatewayWorld {
   window = WINDOW
   readonly controller: AnswerReadyFlushController<FakeTurn>
 
-  constructor() {
+  constructor(stageMs = 0) {
     this.currentTurn = { capturedText: [], replyCalled: false, answerReadyFlushTimeoutId: null }
     this.controller = new AnswerReadyFlushController<FakeTurn>({
+      stageWindowMs: stageMs,
       getCurrentTurn: () => this.currentTurn,
       getArmInput: (turn) => ({
         flush: { chatId: CHAT, replyCalled: turn.replyCalled, capturedText: turn.capturedText, flushEnabled: true },
@@ -203,14 +207,32 @@ class GatewayWorld {
   }
 
   /** = handleSessionEvent({turn_end}). A null atom short-circuits (no second
-   *  send); otherwise deliver once and tear the turn down. */
+   *  send); otherwise the turn-flush branch runs the REAL `decideTurnFlush`
+   *  classifier (exactly as stream-render does at turn_end): a reply-served
+   *  turn tears down without a flush send; a captured-answer turn delivers
+   *  once. Then tear the turn down. */
   dispatchTurnEnd(): void {
     const turn = this.currentTurn
     if (turn == null) return // atom already gone → exactly-once
-    this.sends++
+    const d = decideTurnFlush({
+      chatId: CHAT,
+      replyCalled: turn.replyCalled,
+      capturedText: turn.capturedText,
+      flushEnabled: true,
+    })
+    if (d.kind === 'flush') this.sends++
     this.endCurrentTurnAtomic(turn)
   }
 
+  /** = the model's `reply` tool call landing on the live turn: the canonical
+   *  answer message is sent on the normal reply path and the turn is marked
+   *  reply-served (turn teardown waits for the real turn_end). */
+  onReply(): void {
+    if (this.currentTurn == null) return
+    this.currentTurn.replyCalled = true
+    this.sends++ // the ONE canonical user-visible message
+  }
+
   /** = case 'text': push the chunk, then (re)arm via the REAL controller. */
   onText(chunk: string): void {
     if (this.currentTurn != null) this.currentTurn.capturedText.push(chunk)
@@ -341,3 +363,125 @@ describe('answer-ready quiescence flush — real controller integration', () =>
     expect(vi.getTimerCount()).toBe(0)
   })
 })
+
+// ---------------------------------------------------------------------------
+// Stage-don't-send (2026-08-02 live repro — klanker DM, msgs 25843/25844).
+// The quiescence flush posted the composed answer at 00:22:02Z; the model's
+// `reply` tool call landed 4 s later (delivered 00:22:36Z as msg 25844, a
+// REWORDING — not containment-equal) while a background sub-agent was live, so
+// the #4176 content-gate hold shipped it FRESH: two near-identical messages.
+// With staging, the quiescence expiry HOLDS the answer on the live turn and
+// only promotes when the completion window closes with no reply — the
+// provisional send (and everything downstream that had to claw it back) never
+// happens. These timelines assert OUTCOMES: user-visible messages sent.
+// ---------------------------------------------------------------------------
+
+const STAGE = 30_000
+
+describe('answer-ready stage-don\'t-send — completion-window staging', () => {
+  beforeEach(() => vi.useFakeTimers())
+  afterEach(() => vi.useRealTimers())
+
+  it('LIVE REPRO (msgs 25843/25844): a reply landing inside the stage window → exactly ONE message', () => {
+    const w = new GatewayWorld(STAGE)
+    // 00:21:30–00:22:00 — the model streams its terminal narration.
+    w.onText('Yes, that one\'s done, not pending. …the composed terminal answer…')
+    // 00:22:01 — quiescence fires. Pre-fix this SENT msg 25843; staged, it must
+    // send NOTHING (the turn stays live — typing hold — awaiting completion).
+    vi.advanceTimersByTime(WINDOW)
+    expect(w.sends).toBe(0) // ← RED on the immediate-flush behaviour
+    expect(w.currentTurn).not.toBeNull() // turn NOT ended by a provisional flush
+    // 00:22:06 — the model's `reply` lands (the reworded canonical answer).
+    vi.advanceTimersByTime(5_000)
+    w.onReply()
+    expect(w.sends).toBe(1) // the one canonical message (msg 25844)
+    // The stage promotion timer expires → fire-time re-verify sees replyCalled
+    // and DISCARDS the staged text. No second message, ever.
+    vi.advanceTimersByTime(STAGE)
+    expect(w.sends).toBe(1)
+    // The real turn_end finally lands: reply-served → teardown, no flush.
+    w.dispatchTurnEnd()
+    expect(w.sends).toBe(1)
+    expect(w.records).toBe(1)
+    vi.advanceTimersByTime(BACKSTOP_MS)
+    expect(w.sends).toBe(1)
+    expect(vi.getTimerCount()).toBe(0)
+  })
+
+  it('promotes the staged answer when the completion window closes with NO reply (delivery preserved)', () => {
+    const w = new GatewayWorld(STAGE)
+    w.onText('The composed final answer.')
+    vi.advanceTimersByTime(WINDOW)
+    expect(w.sends).toBe(0) // staged, not sent
+    // No reply, no real turn_end (the KNOWN-UNRELIABLE turn_end case PR A was
+    // built for): the stage window closes → promote through the same flush path.
+    vi.advanceTimersByTime(STAGE - 1)
+    expect(w.sends).toBe(0)
+    vi.advanceTimersByTime(1)
+    expect(w.sends).toBe(1)
+    expect(w.records).toBe(1)
+    // Exactly once: a late real turn_end short-circuits on the null atom.
+    w.dispatchTurnEnd()
+    expect(w.sends).toBe(1)
+  })
+
+  it('a REAL turn_end during the stage window delivers via the turn-flush branch — no double-send', () => {
+    const w = new GatewayWorld(STAGE)
+    w.onText('The composed final answer.')
+    vi.advanceTimersByTime(WINDOW) // staged
+    expect(w.sends).toBe(0)
+    vi.advanceTimersByTime(5_000)
+    w.dispatchTurnEnd() // the true completion signal lands first
+    expect(w.sends).toBe(1) // delivered by the turn-flush branch at turn_end
+    // endCurrentTurnAtomic's clear() cancelled the pending promotion timer.
+    expect(vi.getTimerCount()).toBe(0)
+    vi.advanceTimersByTime(BACKSTOP_MS)
+    expect(w.sends).toBe(1)
+  })
+
+  it('new text during the stage window re-stages (model still composing) and promotes once', () => {
+    const w = new GatewayWorld(STAGE)
+    w.onText('First part of the answer. ')
+    vi.advanceTimersByTime(WINDOW) // staged
+    expect(w.sends).toBe(0)
+    vi.advanceTimersByTime(10_000)
+    w.onText('Second part — the model was still composing.') // re-arms the debounce
+    vi.advanceTimersByTime(WINDOW) // re-staged with a fresh window
+    expect(w.sends).toBe(0)
+    vi.advanceTimersByTime(STAGE)
+    expect(w.sends).toBe(1) // promoted exactly once, with the full text captured
+  })
+
+  it('a tool starting during the stage window discards the stage (model resumed work)', () => {
+    const w = new GatewayWorld(STAGE)
+    w.onText('Interim narration that looked terminal.')
+    vi.advanceTimersByTime(WINDOW) // staged
+    w.onToolUse('bash_1') // clear() → unstaged + promotion timer cancelled
+    vi.advanceTimersByTime(BACKSTOP_MS)
+    expect(w.sends).toBe(0)
+    expect(vi.getTimerCount()).toBe(0)
+  })
+
+  it('stageMs=0 keeps the legacy immediate flush at quiescence', () => {
+    const w = new GatewayWorld(0)
+    w.onText('The composed final answer.')
+    vi.advanceTimersByTime(WINDOW)
+    expect(w.sends).toBe(1) // legacy: delivered at the ~1 s debounce
+  })
+})
+
+describe('resolveAnswerStageMs', () => {
+  it('defaults to ANSWER_STAGE_MS when unset', () => {
+    expect(resolveAnswerStageMs({})).toBe(ANSWER_STAGE_MS)
+  })
+  it('parses a positive override', () => {
+    expect(resolveAnswerStageMs({ SWITCHROOM_ANSWER_STAGE_MS: '15000' })).toBe(15_000)
+  })
+  it('treats 0 (and negatives) as the legacy immediate flush (0)', () => {
+    expect(resolveAnswerStageMs({ SWITCHROOM_ANSWER_STAGE_MS: '0' })).toBe(0)
+    expect(resolveAnswerStageMs({ SWITCHROOM_ANSWER_STAGE_MS: '-5' })).toBe(0)
+  })
+  it('fails safe to the default on an unparseable value', () => {
+    expect(resolveAnswerStageMs({ SWITCHROOM_ANSWER_STAGE_MS: 'soon' })).toBe(ANSWER_STAGE_MS)
+  })
+})

package/telegram-plugin/tests/auth-loopback-relay.test.ts

@@ -22,6 +22,7 @@ import { describe, it, expect } from 'vitest'
 import { EventEmitter } from 'node:events'
 
 import {
+  buildRelayArgs,
   parseLoopbackRedirect,
   extractConsentUrl,
   parseConsentUrl,
@@ -492,6 +493,7 @@ describe('parseAuthCommand — provider verbs (#2582)', () => {
       email: 'user@example.com',
       replace: false,
       write: false,
+      calendar: false,
       orgMode: false,
     })
   })
@@ -501,6 +503,26 @@ describe('parseAuthCommand — provider verbs (#2582)', () => {
     expect(p).toMatchObject({ kind: 'provider-add', replace: true, write: true })
   })
 
+  it('parses google --calendar, and it does not imply --write', () => {
+    const p = parseAuthCommand('/auth google add user@example.com --replace --calendar')
+    expect(p).toMatchObject({
+      kind: 'provider-add',
+      replace: true,
+      calendar: true,
+      write: false,
+    })
+  })
+
+  it('parses --write and --calendar together', () => {
+    const p = parseAuthCommand('/auth google add user@example.com --write --calendar')
+    expect(p).toMatchObject({ kind: 'provider-add', write: true, calendar: true })
+  })
+
+  it('--calendar is google-only — microsoft rejects it as an unknown flag', () => {
+    const p = parseAuthCommand('/auth microsoft add user@corp.com --calendar')
+    expect(p).toMatchObject({ kind: 'help' })
+  })
+
   it('parses /auth microsoft add with --org-mode', () => {
     const p = parseAuthCommand('/auth microsoft add user@corp.com --org-mode')
     expect(p).toMatchObject({
@@ -531,3 +553,39 @@ describe('parseAuthCommand — provider verbs (#2582)', () => {
     expect(p).toMatchObject({ kind: 'help' })
   })
 })
+
+
+describe('buildRelayArgs — chat flags actually reach the CLI', () => {
+  it('bare google add: no opt-in flags', () => {
+    expect(buildRelayArgs('google', 'a@b.com', {})).toEqual([
+      'auth', 'google', 'account', 'add', 'a@b.com',
+    ])
+  })
+
+  it('forwards --calendar', () => {
+    expect(buildRelayArgs('google', 'a@b.com', { calendar: true })).toEqual([
+      'auth', 'google', 'account', 'add', 'a@b.com', '--calendar',
+    ])
+  })
+
+  it('forwards --replace --write --calendar together, in order', () => {
+    expect(
+      buildRelayArgs('google', 'a@b.com', {
+        replace: true,
+        write: true,
+        calendar: true,
+      }),
+    ).toEqual([
+      'auth', 'google', 'account', 'add', 'a@b.com',
+      '--replace', '--write', '--calendar',
+    ])
+  })
+
+  it('--calendar never leaks into the microsoft argv', () => {
+    expect(
+      buildRelayArgs('microsoft', 'a@corp.com', { calendar: true, orgMode: true }),
+    ).toEqual([
+      'auth', 'microsoft', 'account', 'add', 'a@corp.com', '--org-mode',
+    ])
+  })
+})

package/telegram-plugin/tests/handback-preturn-signal.test.ts

@@ -12,6 +12,7 @@ import {
   type PreTurnCardRecord,
 } from '../gateway/handback-preturn-signal.js'
 import { createTurnTypingLoop } from '../gateway/turn-typing-loop.js'
+import { SessionConsumeSignal } from '../gateway/session-consume-signal.js'
 import type { InboundMessage } from '../gateway/ipc-protocol.js'
 
 /**
@@ -471,6 +472,82 @@ describe('handback-preturn-signal — dead-air pre-turn emit→adopt→reap', ()
     expect(h.signal.pendingCount()).toBe(0)
   })
 
+  // ── 2026-08-02 LIVE REPRO REPLAY (klanker, turnId #1785628912223) ──
+  // A handback was released+delivered at T0; the session CONSUMED it and
+  // answered (a reply tool call from idle at T0+65s — the only observable
+  // trace; no adopting turn ever minted), a later real turn minted and
+  // completed — yet at T0+TTL the reap declared a genuine orphan and
+  // RE-INJECTED the already-answered report (attempt 1/2 at 00:06:53Z,
+  // 2/2 at 00:11:58Z, escalation 00:17:34Z). The invisible-consumption gate
+  // must clean up WITHOUT re-injection. This test is RED on the pre-fix seam
+  // (it re-injects) and GREEN with `sessionActivitySince` consulted.
+  it('does NOT re-inject a handback the session already consumed (reply-from-idle after delivery)', async () => {
+    const consume = new SessionConsumeSignal()
+    const h = makeHarness({
+      deliveredTtlMs: 300_000,
+      sessionActivitySince: (sinceTs) => consume.activitySince(sinceTs),
+    })
+    // T0: release (= delivery) — pre-turn entry armed, card painted at debounce.
+    h.signal.noteHandbackRelease(handbackInbound({ chatId: 'chatConsumed', messageId: 900 }))
+    await h.sched.advance(700)
+    const cardId = await h.openCard.mock.results[0]!.value
+    expect(h.records.size).toBe(1)
+
+    // T0+65s: the session answers the handback — a main-session reply tool
+    // call observed over IPC while the gateway shows no live turn (the
+    // 00:02:58Z reply). NO gateway turn ever mints, so tryAdopt never fires.
+    await h.sched.advance(65_000)
+    consume.noteMainToolCall(h.sched.now())
+
+    // T0+TTL and beyond: the reap fires (idle, delivered TTL elapsed). The
+    // consumption evidence must resolve the entry WITHOUT re-injection and
+    // WITHOUT escalation — the frozen card is deleted, typing stops, entry
+    // dropped. OUTCOME: zero re-injected inbounds ever reach the buffer.
+    await h.sched.advance(600_000)
+    expect(h.reinjected).toEqual([])
+    expect(h.escalations).toEqual([])
+    expect(h.deletedIds).toEqual([cardId])
+    expect(h.records.size).toBe(0)
+    expect(h.signal.pendingCount()).toBe(0)
+    expect(h.typing.activeCount()).toBe(0)
+  })
+
+  it('a later turn MINT after delivery also counts as consumption (coalesced-turn case)', async () => {
+    const consume = new SessionConsumeSignal()
+    const h = makeHarness({
+      deliveredTtlMs: 300_000,
+      sessionActivitySince: (sinceTs) => consume.activitySince(sinceTs),
+    })
+    h.signal.noteHandbackRelease(handbackInbound({ chatId: 'chatCoalesced', messageId: 901 }))
+    await h.sched.advance(700)
+    // A real user turn mints AFTER the delivery (the 00:04:13Z turn #25821):
+    // FIFO queue ⇒ the earlier-delivered handback entered the model context.
+    await h.sched.advance(140_000)
+    consume.noteTurnMint(h.sched.now())
+    await h.sched.advance(600_000)
+    expect(h.reinjected).toEqual([])
+    expect(h.escalations).toEqual([])
+    expect(h.signal.pendingCount()).toBe(0)
+  })
+
+  it('still re-injects a GENUINE orphan (no session activity since delivery)', async () => {
+    const consume = new SessionConsumeSignal()
+    const h = makeHarness({
+      deliveredTtlMs: 300_000,
+      sessionActivitySince: (sinceTs) => consume.activitySince(sinceTs),
+    })
+    // Activity BEFORE the delivery must not mask a genuine orphan.
+    consume.noteMainToolCall(h.sched.now())
+    await h.sched.advance(10)
+    h.signal.noteHandbackRelease(handbackInbound({ chatId: 'chatDead', messageId: 902 }))
+    await h.sched.advance(700)
+    // Nothing consumes anything; past the TTL the deterministic recovery must
+    // still fire exactly as before the gate (delete + re-inject, no nudge).
+    await h.sched.advance(600_000)
+    expect(h.reinjected).toHaveLength(1)
+    expect(h.deletedIds).toHaveLength(1)
+  })
+
   // ── deterministic-recovery retry cap: re-inject up to 2×, THEN escalate ──
   // A genuine orphan whose re-injections keep coming back orphaned must not loop
   // forever, and must NEVER fall back to a chat nudge. After `maxReinjects` it