switchroom 0.18.11 → 0.18.12

package/telegram-plugin/tests/gateway-boot-marker-clear.test.ts

@@ -43,7 +43,7 @@ describe('gateway boot — clear stale turn-active marker', () => {
     // window to ~5KB so we don't pick up the unrelated
     // `removeTurnActiveMarker` call in the onTurnComplete handler
     // way down at the bottom of the file.
-    const setupWindow = GATEWAY_SRC.slice(setupBlockStart, setupBlockStart + 9000)
+    const setupWindow = GATEWAY_SRC.slice(setupBlockStart, setupBlockStart + 12000)
     const clearMatches = setupWindow.match(/removeTurnActiveMarker\s*\(\s*STATE_DIR\s*\)/g) ?? []
     expect(clearMatches.length).toBe(1)
   })
@@ -53,7 +53,7 @@ describe('gateway boot — clear stale turn-active marker', () => {
     // must not prevent the gateway from coming up. Pin the try-wrapping
     // to make sure a future refactor doesn't drop it.
     const setupBlockStart = GATEWAY_SRC.indexOf('if (!didOneTimeSetup)')
-    const setupWindow = GATEWAY_SRC.slice(setupBlockStart, setupBlockStart + 9000)
+    const setupWindow = GATEWAY_SRC.slice(setupBlockStart, setupBlockStart + 12000)
     expect(setupWindow).toMatch(/try\s*\{\s*removeTurnActiveMarker\(STATE_DIR\)\s*\}\s*catch/)
   })
 
@@ -62,7 +62,7 @@ describe('gateway boot — clear stale turn-active marker', () => {
     // Clearing the marker first means the watchdog sees a clean slate
     // immediately, even if pin sweep takes 30s+ to finish.
     const setupBlockStart = GATEWAY_SRC.indexOf('if (!didOneTimeSetup)')
-    const setupWindow = GATEWAY_SRC.slice(setupBlockStart, setupBlockStart + 9000)
+    const setupWindow = GATEWAY_SRC.slice(setupBlockStart, setupBlockStart + 12000)
     const clearIdx = setupWindow.indexOf('removeTurnActiveMarker(STATE_DIR)')
     const pinSweepIdx = setupWindow.indexOf('Boot-time pin sweep')
     expect(clearIdx).toBeGreaterThan(0)

package/telegram-plugin/tests/gateway-disconnect-flush.test.ts

@@ -36,6 +36,7 @@ function makeDeps(agentName: string | null) {
   const finalizeB = vi.fn(async () => {})
   const clearActiveReactions = vi.fn()
   const disposeProgressDriver = vi.fn()
+  const stopTurnTypingLoops = vi.fn()
   const log = vi.fn()
 
   const activeStatusReactions = new Map<string, FakeCtrl>([
@@ -72,7 +73,7 @@ function makeDeps(agentName: string | null) {
   // carry or clear it.
 
   return {
-    spies: { setDoneA, setDoneB, finalizeA, finalizeB, clearActiveReactions, disposeProgressDriver, log },
+    spies: { setDoneA, setDoneB, finalizeA, finalizeB, clearActiveReactions, disposeProgressDriver, stopTurnTypingLoops, log },
     deps: {
       agentName,
       activeStatusReactions,
@@ -83,6 +84,7 @@ function makeDeps(agentName: string | null) {
       activeDraftStreams,
       clearActiveReactions,
       disposeProgressDriver,
+      stopTurnTypingLoops,
       log,
     },
   }
@@ -121,6 +123,16 @@ describe('flushOnAgentDisconnect — anonymous clients (the regression scenario)
     expect(spies.setDoneA).toHaveBeenCalledTimes(0)
     expect(spies.setDoneB).toHaveBeenCalledTimes(0)
   })
+
+  it('#2650: does NOT sweep the turn-typing loops for anonymous disconnects', () => {
+    // An anonymous one-shot IPC client (recall.py, etc.) never owned a
+    // turn-typing loop. The sweep MUST be gated by the agentName-null
+    // early-return so a constant stream of anonymous disconnects can't
+    // kill a live agent's typing indicator.
+    const { spies, deps } = makeDeps(null)
+    flushOnAgentDisconnect(deps)
+    expect(spies.stopTurnTypingLoops).not.toHaveBeenCalled()
+  })
 })
 
 describe('flushOnAgentDisconnect — registered agent disconnects (existing behavior preserved)', () => {
@@ -144,6 +156,15 @@ describe('flushOnAgentDisconnect — registered agent disconnects (existing beha
     expect(spies.clearActiveReactions).toHaveBeenCalledTimes(1)
   })
 
+  it('#2650: sweeps the turn-typing loops on a real agent disconnect', () => {
+    // The bridge died mid-turn — the canonical turn-end that would stop the
+    // per-(chat,thread) `typing…` interval will never arrive, so the flush
+    // must sweep every live loop or a stale "typing…" shows until next turn.
+    const { spies, deps } = makeDeps('clerk')
+    flushOnAgentDisconnect(deps)
+    expect(spies.stopTurnTypingLoops).toHaveBeenCalledTimes(1)
+  })
+
   it('finalizes only non-final draft streams and clears the maps', () => {
     const { spies, deps } = makeDeps('clerk')
     flushOnAgentDisconnect(deps)
@@ -172,6 +193,7 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
     const onDanglingTurnsSwept = vi.fn()
     const clearActiveReactions = vi.fn()
     const disposeProgressDriver = vi.fn()
+    const stopTurnTypingLoops = vi.fn()
     const log = vi.fn()
     const deps = {
       agentName: 'clerk',
@@ -185,6 +207,7 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       activeDraftStreams: new Map<string, FakeStream>(),
       clearActiveReactions,
       disposeProgressDriver,
+      stopTurnTypingLoops,
       onDanglingTurnsSwept,
       log,
     }
@@ -243,6 +266,7 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       activeDraftStreams: new Map<string, FakeStream>(),
       clearActiveReactions: vi.fn(),
       disposeProgressDriver: vi.fn(),
+      stopTurnTypingLoops: vi.fn(),
       onDanglingTurnsSwept,
       log: vi.fn(),
     }
@@ -278,6 +302,7 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       activeDraftStreams: new Map<string, FakeStream>(),
       clearActiveReactions: vi.fn(),
       disposeProgressDriver: vi.fn(),
+      stopTurnTypingLoops: vi.fn(),
       onDanglingTurnsSwept,
       log,
     }
@@ -310,6 +335,7 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       activeDraftStreams: new Map<string, FakeStream>(),
       clearActiveReactions: vi.fn(),
       disposeProgressDriver: vi.fn(),
+      stopTurnTypingLoops: vi.fn(),
     }
     // Singular form.
     flushOnAgentDisconnect({
@@ -348,6 +374,7 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       activeDraftStreams: new Map<string, FakeStream>(),
       clearActiveReactions: vi.fn(),
       disposeProgressDriver: vi.fn(),
+      stopTurnTypingLoops: vi.fn(),
       log,
     })
     expect(log.mock.calls.some((c: unknown[]) =>
@@ -368,6 +395,7 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       activeDraftStreams: new Map<string, FakeStream>(),
       clearActiveReactions: vi.fn(),
       disposeProgressDriver: vi.fn(),
+      stopTurnTypingLoops: vi.fn(),
       // onDanglingTurnsSwept intentionally omitted.
       log: vi.fn(),
     }

package/telegram-plugin/tests/gateway-loopback-paste-redact.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+
+/**
+ * Structural integration test for the loopback-paste fail-safe redaction in
+ * the gateway's inbound handler (security audit #3084, F2/F3).
+ *
+ * Why structural: gateway/gateway.ts does not export its inbound handler, so a
+ * pure-functional invocation would require end-to-end harnessing of
+ * Bot/Grammy/Context. The decision predicate (shouldConsumeLoopbackPaste, incl.
+ * the malformed-paste fail-safe) is exhaustively unit-tested in
+ * `auth-loopback-relay.test.ts`, and the redaction primitive
+ * (redactAuthCodeMessage) in `auth-code-redact.test.ts`. What's left to assert
+ * here is that the gateway actually WIRES a fail-safe so a code-bearing paste
+ * that is malformed, or arrives just after the intercept TTL, or has no active
+ * flow, is redacted + dropped rather than forwarded to the agent.
+ *
+ * The invariants:
+ *   1. The stale (TTL-expired) loopback branch does NOT let the paste fall
+ *      through to the agent — it flows into the fail-safe below.
+ *   2. A fail-safe `if (shouldConsumeLoopbackPaste(text))` block exists that
+ *      redacts (redactAuthCodeMessage) and returns, sitting AFTER the
+ *      pending-flow branch but BEFORE the generic auth-code / agent-forward
+ *      handlers.
+ */
+describe('gateway loopback-paste fail-safe redaction — structural wiring', () => {
+  const src = readFileSync(
+    new URL('../gateway/gateway.ts', import.meta.url),
+    'utf8',
+  )
+
+  it('imports the consume predicate + redaction helper', () => {
+    expect(src).toMatch(/shouldConsumeLoopbackPaste/)
+    expect(src).toMatch(/redactAuthCodeMessage/)
+  })
+
+  it('has a fail-safe redact-and-return block guarded by shouldConsumeLoopbackPaste', () => {
+    // Isolate the fail-safe block: `if (shouldConsumeLoopbackPaste(text)) { ... }`
+    // that is NOT part of the `pendingLoop && ...` pending-flow branch.
+    const failSafe = src.match(
+      /if \(shouldConsumeLoopbackPaste\(text\)\) \{[\s\S]{0,600}?\n {2}\}/g,
+    )
+    expect(failSafe).not.toBeNull()
+    // The standalone fail-safe (the one NOT preceded by `pendingLoop &&`).
+    const standalone = (failSafe ?? []).find(
+      (b) => !b.startsWith('if (pendingLoop'),
+    )
+    expect(standalone).toBeDefined()
+    expect(standalone!).toMatch(/redactAuthCodeMessage/)
+    expect(standalone!).toMatch(/return/)
+  })
+
+  it('the stale loopback branch falls through to the fail-safe (does not forward)', () => {
+    // The stale-path comment must reference the fail-safe, and the fail-safe
+    // block must appear AFTER the pending-loop branch and BEFORE the generic
+    // auth-code intercept (`pendingReauthFlows`).
+    const failSafeIdx = src.indexOf(
+      'Fail-safe redaction (security audit #3084, F2/F3)',
+    )
+    const pendingLoopIdx = src.indexOf('const pendingLoop = pendingLoopbackFlows.get')
+    const reauthIdx = src.indexOf('const pendingReauth = pendingReauthFlows.get')
+    expect(failSafeIdx).toBeGreaterThan(-1)
+    expect(failSafeIdx).toBeGreaterThan(pendingLoopIdx)
+    expect(reauthIdx).toBeGreaterThan(failSafeIdx)
+  })
+})

package/telegram-plugin/tests/gw-trace-gate.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Pin the gateway trace verbosity gate (#3025): zero-signal per-poll
+ * heartbeats are suppressed by default and the full firehose is restored
+ * only when SWITCHROOM_GW_TRACE is truthy. Error lines and real
+ * (non-poll / non-idle-tick) activity ALWAYS emit regardless of the flag.
+ *
+ * DUAL-RUNNER NOTE (vitest + bun): this file runs under BOTH runners, and
+ * bun's vitest shim does not honor `vi.resetModules()` — a re-import
+ * returns the originally-cached module, so flag variants CANNOT be tested
+ * via env + fresh import. Instead the gate exposes pure paths: the env
+ * parse is `computeGwTraceVerbose(flag)` and both should-emit functions
+ * take an explicit `verbose` argument (defaulting to the module-init
+ * read). Tests pass verbosity explicitly.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  computeGwTraceVerbose,
+  shouldEmitTgPost,
+  shouldEmitShadowTrace,
+} from '../shared/gw-trace-gate.js'
+
+describe('computeGwTraceVerbose — env flag parsing', () => {
+  it('is OFF when unset', () => {
+    expect(computeGwTraceVerbose(undefined)).toBe(false)
+  })
+
+  it('opts IN on the truthy set, case-insensitively (1/true/yes/on)', () => {
+    for (const v of ['1', 'true', 'TRUE', 'True', 'yes', 'Yes', 'YES', 'on', 'ON', 'On', ' 1', 'true ']) {
+      expect(computeGwTraceVerbose(v)).toBe(true)
+    }
+  })
+
+  it('stays OFF for falsey / unrecognized values', () => {
+    for (const v of ['', '0', 'false', 'FALSE', 'off', 'No', 'x', 'enabled']) {
+      expect(computeGwTraceVerbose(v)).toBe(false)
+    }
+  })
+})
+
+describe('shouldEmitTgPost — default (verbose=false): suppress poll heartbeats', () => {
+  it('suppresses status=ok for getUpdates and getMe', () => {
+    expect(shouldEmitTgPost('getUpdates', 'ok', false)).toBe(false)
+    expect(shouldEmitTgPost('getMe', 'ok', false)).toBe(false)
+  })
+
+  it('ALWAYS emits error lines, even for the poll methods', () => {
+    expect(shouldEmitTgPost('getUpdates', 'err', false)).toBe(true)
+    expect(shouldEmitTgPost('getMe', 'err', false)).toBe(true)
+  })
+
+  it('keeps status=ok for real outbound methods', () => {
+    for (const m of ['sendMessage', 'editMessageText', 'sendChatAction', 'answerCallbackQuery']) {
+      expect(shouldEmitTgPost(m, 'ok', false)).toBe(true)
+    }
+  })
+})
+
+describe('shouldEmitShadowTrace — default (verbose=false): suppress idle no-op ticks', () => {
+  it('suppresses a tick with no effects in an idle global state', () => {
+    expect(shouldEmitShadowTrace('tick', 0, 'bridge_alive_idle', false)).toBe(false)
+    expect(shouldEmitShadowTrace('tick', 0, 'bridge_dead', false)).toBe(false)
+  })
+
+  it('emits a tick that produced effects (e.g. a TTL turn expiry)', () => {
+    expect(shouldEmitShadowTrace('tick', 1, 'bridge_alive_idle', false)).toBe(true)
+  })
+
+  it('emits a tick while a turn is in flight', () => {
+    expect(shouldEmitShadowTrace('tick', 0, 'bridge_alive_in_turn', false)).toBe(true)
+  })
+
+  it('ALWAYS emits non-tick events (real inbound/turn/bridge activity)', () => {
+    for (const ev of ['inbound', 'turnStart', 'turnEnd', 'bridgeUp', 'bridgeDown', 'permVerdict']) {
+      expect(shouldEmitShadowTrace(ev, 0, 'bridge_alive_idle', false)).toBe(true)
+    }
+  })
+})
+
+describe('verbose=true — full firehose restored', () => {
+  it('emits every line, including the two suppressed-by-default families', () => {
+    expect(shouldEmitTgPost('getUpdates', 'ok', true)).toBe(true)
+    expect(shouldEmitTgPost('getMe', 'ok', true)).toBe(true)
+    expect(shouldEmitShadowTrace('tick', 0, 'bridge_alive_idle', true)).toBe(true)
+    expect(shouldEmitShadowTrace('tick', 0, 'bridge_dead', true)).toBe(true)
+  })
+})
+
+describe('default verbose argument wiring', () => {
+  it('the defaulted call form works and matches the module-init env read', () => {
+    // Env-agnostic assertion: the defaulted form must agree with the
+    // explicit form using the parsed CURRENT env — proving the default
+    // parameter is wired to the module-init flag, whatever its value in
+    // the test process.
+    const envVerbose = computeGwTraceVerbose(process.env.SWITCHROOM_GW_TRACE)
+    expect(shouldEmitTgPost('getUpdates', 'ok')).toBe(
+      shouldEmitTgPost('getUpdates', 'ok', envVerbose),
+    )
+    expect(shouldEmitShadowTrace('tick', 0, 'bridge_alive_idle')).toBe(
+      shouldEmitShadowTrace('tick', 0, 'bridge_alive_idle', envVerbose),
+    )
+    // Regardless of the flag, an error line always emits via the default form.
+    expect(shouldEmitTgPost('getUpdates', 'err')).toBe(true)
+  })
+})

package/telegram-plugin/tests/idle-clear.test.ts

@@ -1,17 +1,231 @@
+/**
+ * Idle auto-clear — what "idle" MEANS.
+ *
+ * On 2026-07-11 `overlord` worked for three hours straight (sub-agents, ~25 PRs
+ * merged) and was `/clear`ed 12 s after the window elapsed — three hours of
+ * session context destroyed. Root cause: the idle window was measured from the
+ * last turn START, and nothing in a turn (tool calls, sub-agent work, the turn
+ * ENDING) counted as activity. The invariant was inverted: the longer and more
+ * productive the work, the more certain the wipe.
+ *
+ * These tests assert the OUTCOME: an agent that is doing things is not idle,
+ * and an agent that is doing nothing still gets cleared.
+ *
+ * Deterministic virtual clock only (`T + n * H`) — no fake timers, no
+ * `Date.now()`. Everything schedulable takes the clock as an argument, so the
+ * whole 3h window is exercised in microseconds and the suite stays portable if
+ * this file is ever moved to the bun runner. (It runs under vitest today: it is
+ * not in `package.json`'s `test:bun` list and not excluded in
+ * `vitest.config.ts`.)
+ */
+
 import { describe, it, expect } from 'vitest'
 import {
   decideIdleClear,
+  classifyIdleEvent,
   idleDurationToMs,
   DEFAULT_IDLE_CLEAR_MS,
   type IdleClearState,
 } from '../gateway/idle-clear.js'
 
 const H = 3_600_000
+const M = 60_000
+/** Gateway's IDLE_CLEAR_CHECK_MS default. */
+const TICK = 60_000
+
 function state(p: Partial<IdleClearState>): IdleClearState {
-  return { lastActivityAt: 0, idleClearMs: 3 * H, alreadyCleared: false, turnInFlight: false, ...p }
+  return {
+    lastActivityAt: 0,
+    lastTurnEndedAt: null,
+    idleClearMs: 3 * H,
+    alreadyCleared: false,
+    turnInFlight: false,
+    ...p,
+  }
+}
+
+/**
+ * A minimal model of the gateway's idle bookkeeping, driven by a virtual clock.
+ * Mirrors gateway.ts: `markIdleActivity()` on inbound / cron / ANY session
+ * event, `markIdleTurnEnd()` on a turn ending, `decideIdleClear()` on each
+ * IDLE_CLEAR_CHECK_MS tick, `alreadyCleared` latched on fire.
+ */
+class IdleModel {
+  lastActivityAt: number
+  lastTurnEndedAt: number | null = null
+  alreadyCleared = false
+  turnInFlight = false
+  clears: number[] = []
+
+  constructor(
+    startedAt: number,
+    readonly idleClearMs = 3 * H,
+  ) {
+    this.lastActivityAt = startedAt
+  }
+
+  /** A claude session-stream event (the gateway's handleSessionEvent stamp). */
+  sessionEvent(kind: string, now: number, durationMs?: number): void {
+    const signal = classifyIdleEvent(kind, durationMs)
+    if (signal.activity) {
+      this.lastActivityAt = now
+      this.alreadyCleared = false
+    }
+    if (signal.turnEnded) this.lastTurnEndedAt = now
+  }
+
+  /** Inbound / cron fire. */
+  activity(now: number): void {
+    this.lastActivityAt = now
+    this.alreadyCleared = false
+  }
+
+  tick(now: number): boolean {
+    const { clear } = decideIdleClear(
+      {
+        lastActivityAt: this.lastActivityAt,
+        lastTurnEndedAt: this.lastTurnEndedAt,
+        idleClearMs: this.idleClearMs,
+        alreadyCleared: this.alreadyCleared,
+        turnInFlight: this.turnInFlight,
+      },
+      now,
+    )
+    if (clear) {
+      this.alreadyCleared = true
+      this.clears.push(now)
+    }
+    return clear
+  }
+
+  /** Run the interval from `from` to `to` inclusive, one tick per TICK. */
+  ticksThrough(from: number, to: number): void {
+    for (let t = from; t <= to; t += TICK) this.tick(t)
+  }
 }
 
-describe('decideIdleClear', () => {
+describe('idle-clear: a working agent is not idle', () => {
+  it('HEADLINE — a turn that runs LONGER than the idle window is not cleared when it ends', () => {
+    // The overlord incident, replayed. Window 3h. Turn starts at T, runs 3h08m
+    // of real work (sub-agents, tool calls), ends at T+3h08m.
+    const T = 100 * H
+    const m = new IdleModel(T)
+
+    m.turnInFlight = true
+    m.sessionEvent('enqueue', T) // turn start
+
+    // ... 3h08m of work. The gate suppresses the clear while in flight.
+    m.ticksThrough(T, T + 3 * H + 8 * M)
+    expect(m.clears).toEqual([])
+
+    // Turn ends. `turnInFlight` flips false — the moment of truth.
+    const end = T + 3 * H + 8 * M
+    m.sessionEvent('turn_end', end, 11_314_000)
+    m.turnInFlight = false
+
+    // The very next tick (12 s later in production) must NOT clear...
+    expect(m.tick(end + 12_000)).toBe(false)
+    // ...nor the next several ticks, nor anything short of a full fresh window.
+    m.ticksThrough(end, end + 3 * H - TICK)
+    expect(m.clears).toEqual([])
+  })
+
+  it('in-turn work keeps the timer warm even when the gateway sees no turn boundary', () => {
+    // What ACTUALLY happened to overlord: the last turn ended at 07:05 and the
+    // agent then worked for ~3h under stop-hook continuations that opened no new
+    // turn. `turnInFlight` was false the whole time, so only the per-event stamp
+    // can save it.
+    const T = 100 * H
+    const m = new IdleModel(T)
+    m.sessionEvent('turn_end', T, 34_596) // last turn boundary
+    m.turnInFlight = false
+
+    // 3h30m of real work with no turn boundary: tool calls + sub-agent activity
+    // every ~10 min, and a tick between each.
+    for (let t = T; t <= T + 3 * H + 30 * M; t += 10 * M) {
+      m.sessionEvent('tool_use', t)
+      m.sessionEvent('sub_agent_tool_use', t + 60_000)
+      m.ticksThrough(t, t + 10 * M - TICK)
+    }
+    expect(m.clears).toEqual([])
+  })
+
+  it('every genuine session event counts as activity (sub-agents included)', () => {
+    for (const kind of [
+      'enqueue',
+      'thinking',
+      'model',
+      'tool_use',
+      'tool_result',
+      'text',
+      'sub_agent_started',
+      'sub_agent_tool_use',
+      'sub_agent_text',
+      'sub_agent_turn_end',
+    ]) {
+      expect(classifyIdleEvent(kind).activity).toBe(true)
+      expect(classifyIdleEvent(kind).turnEnded).toBe(false)
+    }
+    // A real turn_end is activity AND a turn boundary.
+    expect(classifyIdleEvent('turn_end', 5_000)).toEqual({ activity: true, turnEnded: true })
+    // The gateway's own synthetic turn_end (orphaned-reply backstop) is not the
+    // model doing something — but it still ends the turn.
+    expect(classifyIdleEvent('turn_end', -1)).toEqual({ activity: false, turnEnded: true })
+  })
+
+  it('a background sub-agent still emitting events after the main turn ends holds off the clear', () => {
+    const T = 100 * H
+    const m = new IdleModel(T)
+    m.sessionEvent('turn_end', T, 30_000)
+    m.turnInFlight = false
+    // Worker grinds for 4h past the main turn end.
+    for (let t = T; t <= T + 4 * H; t += 5 * M) {
+      m.sessionEvent('sub_agent_tool_use', t)
+      m.ticksThrough(t, t + 5 * M - TICK)
+    }
+    expect(m.clears).toEqual([])
+  })
+})
+
+describe('idle-clear: a genuinely idle agent is still cleared', () => {
+  it('no turn, no inbound, no session event for a full window → cleared exactly once', () => {
+    const T = 100 * H
+    const m = new IdleModel(T)
+    m.ticksThrough(T, T + 6 * H)
+    expect(m.clears).toEqual([T + 3 * H])
+  })
+
+  it('cleared once per idle period, and re-arms on the next inbound', () => {
+    const T = 100 * H
+    const m = new IdleModel(T)
+    m.ticksThrough(T, T + 5 * H)
+    expect(m.clears).toEqual([T + 3 * H])
+
+    const inbound = T + 5 * H
+    m.activity(inbound) // operator comes back
+    m.ticksThrough(inbound, inbound + 3 * H - TICK)
+    expect(m.clears).toEqual([T + 3 * H]) // not yet
+    m.ticksThrough(inbound, inbound + 3 * H)
+    expect(m.clears).toEqual([T + 3 * H, inbound + 3 * H])
+  })
+
+  it('a turn that ends is cleared one full window after it ended (not before)', () => {
+    const T = 100 * H
+    const m = new IdleModel(T)
+    m.turnInFlight = true
+    m.sessionEvent('enqueue', T)
+    const end = T + 3 * H + 8 * M
+    m.sessionEvent('turn_end', end, 11_314_000)
+    m.turnInFlight = false
+
+    m.ticksThrough(end, end + 3 * H - TICK)
+    expect(m.clears).toEqual([]) // still warm
+    m.ticksThrough(end, end + 3 * H + TICK)
+    expect(m.clears).toEqual([end + 3 * H]) // now genuinely idle → cleared
+  })
+})
+
+describe('decideIdleClear (pure gate)', () => {
   it('fires once the idle window has elapsed', () => {
     expect(decideIdleClear(state({ lastActivityAt: 0 }), 3 * H).clear).toBe(true)
     expect(decideIdleClear(state({ lastActivityAt: 0 }), 3 * H + 1).clear).toBe(true)
@@ -32,10 +246,26 @@ describe('decideIdleClear', () => {
   it('is disabled when idleClearMs <= 0', () => {
     expect(decideIdleClear(state({ lastActivityAt: 0, idleClearMs: 0 }), 10 * H).clear).toBe(false)
     expect(decideIdleClear(state({ lastActivityAt: 0, idleClearMs: -1 }), 10 * H).clear).toBe(false)
+    // ...even with a fresh turn end in play.
+    expect(
+      decideIdleClear(state({ lastActivityAt: 0, lastTurnEndedAt: 9 * H, idleClearMs: 0 }), 10 * H).clear,
+    ).toBe(false)
+  })
+
+  it('measures the window from max(lastActivityAt, lastTurnEndedAt)', () => {
+    // Turn started at 0 (lastActivityAt), ended at 5h. At 5h the window has long
+    // "elapsed" against the START — it must not be treated as idle.
+    const justEnded = state({ lastActivityAt: 0, lastTurnEndedAt: 5 * H })
+    expect(decideIdleClear(justEnded, 5 * H).clear).toBe(false)
+    expect(decideIdleClear(justEnded, 8 * H - 1).clear).toBe(false)
+    expect(decideIdleClear(justEnded, 8 * H).clear).toBe(true) // a full window after the END
+    // Symmetric: activity newer than the turn end wins.
+    const activeSince = state({ lastActivityAt: 6 * H, lastTurnEndedAt: 5 * H })
+    expect(decideIdleClear(activeSince, 8 * H).clear).toBe(false)
+    expect(decideIdleClear(activeSince, 9 * H).clear).toBe(true)
   })
 
   it('re-arms after activity (fresh lastActivityAt + alreadyCleared=false → waits again)', () => {
-    // Simulated: after a clear, activity resets lastActivityAt to `now` and the flag.
     const now = 100 * H
     const reArmed = state({ lastActivityAt: now, alreadyCleared: false })
     expect(decideIdleClear(reArmed, now + 3 * H - 1).clear).toBe(false) // not yet

package/telegram-plugin/tests/inbound-dedup.test.ts

@@ -0,0 +1,93 @@
+/**
+ * #2094 finding 4 — bridge-side messageId dedup.
+ *
+ * Outcome contract: a genuine user message re-delivered by the stranded-
+ * message sweep within one turn is forwarded to claude exactly ONCE; after
+ * the turn-complete clear (a successful reply for that chat) forwarding
+ * resumes. Synthetic / button / structured-event inbounds are never deduped,
+ * and per-chat memory is capped.
+ */
+import { describe, it, expect } from 'vitest'
+import {
+  InboundDedup,
+  shouldDedupInbound,
+  dedupChatKey,
+  INBOUND_DEDUP_MAX_PER_CHAT,
+  type DedupInboundLike,
+} from '../bridge/inbound-dedup.js'
+
+function userMsg(messageId: number, extra: Record<string, string> = {}): DedupInboundLike {
+  return { messageId, meta: { chat_id: '12345', message_id: String(messageId), ...extra } }
+}
+
+describe('shouldDedupInbound gate', () => {
+  it('dedups a plain user message', () => {
+    expect(shouldDedupInbound(userMsg(500))).toBe(true)
+  })
+  it('never dedups synthetic (meta.source), button, structured, or reaction inbounds', () => {
+    expect(shouldDedupInbound(userMsg(500, { source: 'cron' }))).toBe(false)
+    expect(shouldDedupInbound(userMsg(500, { button_callback: 'true' }))).toBe(false)
+    expect(shouldDedupInbound(userMsg(500, { kind: 'checklist_task_changed' }))).toBe(false)
+    expect(shouldDedupInbound(userMsg(500, { event: 'reaction' }))).toBe(false)
+  })
+  it('never dedups a non-positive messageId (no real Telegram id)', () => {
+    expect(shouldDedupInbound(userMsg(0))).toBe(false)
+    expect(shouldDedupInbound({ messageId: -1, meta: {} })).toBe(false)
+  })
+})
+
+describe('InboundDedup checkAndRecord + clearChat', () => {
+  it('processes a duplicate messageId within one turn exactly once', () => {
+    const d = new InboundDedup()
+    const key = dedupChatKey('12345')
+    expect(d.checkAndRecord(key, 500)).toBe('fresh')
+    // Sweep re-delivers the SAME messageId before the turn completes.
+    expect(d.checkAndRecord(key, 500)).toBe('duplicate')
+    expect(d.checkAndRecord(key, 500)).toBe('duplicate')
+    // A different message in the same turn is still forwarded.
+    expect(d.checkAndRecord(key, 501)).toBe('fresh')
+  })
+
+  it('resumes processing the same messageId after the turn-complete clear', () => {
+    const d = new InboundDedup()
+    const key = dedupChatKey('12345')
+    expect(d.checkAndRecord(key, 500)).toBe('fresh')
+    expect(d.checkAndRecord(key, 500)).toBe('duplicate')
+    // reply fired for the chat → turn-complete reset.
+    d.clearChat('12345')
+    expect(d.size(key)).toBe(0)
+    // A genuinely new turn may re-see the id (fresh again).
+    expect(d.checkAndRecord(key, 500)).toBe('fresh')
+  })
+
+  it('clearChat is thread-agnostic — clears every thread key for the chat', () => {
+    const d = new InboundDedup()
+    const dm = dedupChatKey('12345')
+    const topic = dedupChatKey('12345', 42)
+    d.checkAndRecord(dm, 500)
+    d.checkAndRecord(topic, 700)
+    d.checkAndRecord(dedupChatKey('999', 1), 800) // unrelated chat, untouched
+    d.clearChat('12345')
+    expect(d.size(dm)).toBe(0)
+    expect(d.size(topic)).toBe(0)
+    expect(d.size(dedupChatKey('999', 1))).toBe(1)
+  })
+
+  it('caps per-chat memory (FIFO-evicts the oldest id)', () => {
+    const d = new InboundDedup(3)
+    const key = dedupChatKey('12345')
+    d.checkAndRecord(key, 1)
+    d.checkAndRecord(key, 2)
+    d.checkAndRecord(key, 3)
+    d.checkAndRecord(key, 4) // evicts id 1
+    expect(d.size(key)).toBe(3)
+    // id 1 was evicted → treated as fresh again (bounded memory, accepted).
+    expect(d.checkAndRecord(key, 1)).toBe('fresh')
+    // ids still tracked are duplicates.
+    expect(d.checkAndRecord(key, 4)).toBe('duplicate')
+  })
+
+  it('default cap is a sane bound', () => {
+    expect(INBOUND_DEDUP_MAX_PER_CHAT).toBeGreaterThanOrEqual(128)
+  })
+})