switchroom 0.12.19 → 0.12.21

package/telegram-plugin/gateway/turn-state-purge.ts

@@ -0,0 +1,71 @@
+/**
+ * turn-state-purge.ts — defense-in-depth cleanup for the silence-poke
+ * framework-fallback (gateway.ts).
+ *
+ * The fallback's `purgeReactionTracking(fbKey)` clears the canonical
+ * `statusKey(chatId, threadId)` for the exact chat+thread that armed
+ * the silence-poke. But `activeTurnStartedAt` (and its siblings) can
+ * legitimately hold MORE than one entry for the same chat — e.g.:
+ *
+ *   - a normal turn-end handler null'd `currentTurn` but skipped
+ *     `purgeReactionTracking` on a code-path that didn't reach it
+ *     (gateway.ts:5887/5921/6193 — purgeReactionTracking calls in
+ *     those handlers are conditional/not on every branch), so
+ *     `activeTurnStartedAt[oldKey]` is dangling when the fallback
+ *     fires for a NEW key
+ *   - a multi-thread chat (topic-based group, or a `null` vs
+ *     `undefined` thread variant) has entries under different keys of
+ *     the SAME chat
+ *
+ * In either case, the fallback purges `fbKey` but a sibling key for
+ * the same chat remains → `activeTurnStartedAt.size > 0` persists →
+ * `#1556`'s turn-gate holds every new inbound forever → user sees
+ * "not responding" while claude is actually idle (gymbro + klanker,
+ * 2026-05-20).
+ *
+ * This helper sweeps any sibling keys for the firing chat after the
+ * canonical `purgeReactionTracking(fbKey)`, via the same purger.
+ * Multi-chat safe: it only touches keys whose chatId matches — other
+ * chats' active turns are untouched, preserving the deliberate
+ * multi-chat safety #1546 kept.
+ *
+ * Key shape: `statusKey(chatId, threadId)` emits
+ * `${chatId}:${threadId ?? '_'}`. Chat ids are numeric strings (no
+ * `:` inside), so `indexOf(':')` is a safe prefix delimiter. A
+ * "prefix-without-separator" false positive (e.g. chatId `123` vs key
+ * `1234:_`) is structurally impossible because the helper splits on
+ * `:` and equates the prefix, NOT a string-startsWith.
+ *
+ * Pure / dependency-free so the multi-chat-safety and key-shape logic
+ * are unit-testable without standing up a gateway — mirrors the
+ * `#1544 / #1546 / #1549 / #1558` pure-seam idiom.
+ */
+
+export interface PurgeStaleTurnsResult {
+  /** Keys for `chatId` that the helper purged via the callback. */
+  purged: string[]
+}
+
+export function purgeStaleTurnsForChat(
+  chatId: string,
+  keys: Iterable<string>,
+  purger: (key: string) => void,
+): PurgeStaleTurnsResult {
+  if (!chatId) return { purged: [] }
+  const purged: string[] = []
+  // Snapshot first — `purger` typically deletes from the same Map the
+  // caller is iterating; mutating during iteration is correct on JS
+  // Maps but a snapshot makes the contract explicit and lets the
+  // helper accept any iterable.
+  const snapshot: string[] = []
+  for (const k of keys) snapshot.push(k)
+  for (const key of snapshot) {
+    const sep = key.indexOf(':')
+    if (sep < 0) continue // malformed / non-statusKey shape — skip
+    const keyChat = key.slice(0, sep)
+    if (keyChat !== chatId) continue
+    purger(key)
+    purged.push(key)
+  }
+  return { purged }
+}

package/telegram-plugin/pty-partial-handler.ts

@@ -94,7 +94,10 @@ export interface PtyHandlerDeps {
 }
 
 function streamKey(chatId: string, threadId?: number): string {
-  return `${chatId}:${threadId ?? '_'}`
+  // Canonical chat-key derivation lives in gateway/chat-key.ts — keep this
+  // expression in lockstep (treats 0/null/undefined the same). See #1564.
+  const t = threadId == null || threadId === 0 ? '_' : String(threadId)
+  return `${chatId}:${t}`
 }
 
 /**

package/telegram-plugin/stream-reply-handler.ts

@@ -313,7 +313,12 @@ function streamKey(
   lane?: string,
   turnKey?: string,
 ): string {
-  const base = `${chatId}:${threadId ?? '_'}`
+  // Canonical chat-key derivation lives in gateway/chat-key.ts — keep this
+  // expression in lockstep with that helper (treats 0/null/undefined the
+  // same), but inline here so this file doesn't introduce a cross-package
+  // import for one expression. See #1564 for the sibling-key bug class.
+  const t = threadId == null || threadId === 0 ? '_' : String(threadId)
+  const base = `${chatId}:${t}`
   const withLane = lane != null && lane.length > 0 ? `${base}:${lane}` : base
   return turnKey != null && turnKey.length > 0 ? `${withLane}:${turnKey}` : withLane
 }

package/telegram-plugin/tests/e2e.test.ts

@@ -50,7 +50,11 @@ function statusKey(chatId: string, threadId?: number): string {
 }
 
 function streamKey(chatId: string, threadId?: number): string {
-  return `${chatId}:${threadId ?? 'default'}`
+  // Mirrors production's canonical chat-key derivation (gateway/chat-key.ts):
+  // 0/null/undefined thread IDs all collapse to '_'. Diverging sentinels
+  // here would let the harness pass with a key shape production rejects.
+  const t = threadId == null || threadId === 0 ? '_' : String(threadId)
+  return `${chatId}:${t}`
 }
 
 interface PluginState {

package/telegram-plugin/tests/races.test.ts

@@ -29,7 +29,11 @@ function statusKey(chatId: string, threadId?: number): string {
   return `${chatId}:${threadId ?? '_'}`
 }
 function streamKey(chatId: string, threadId?: number): string {
-  return `${chatId}:${threadId ?? 'default'}`
+  // Mirrors production's canonical chat-key derivation (gateway/chat-key.ts):
+  // 0/null/undefined thread IDs all collapse to '_'. Diverging sentinels
+  // here would let the harness pass with a key shape production rejects.
+  const t = threadId == null || threadId === 0 ? '_' : String(threadId)
+  return `${chatId}:${t}`
 }
 
 interface PluginState {

package/telegram-plugin/tests/turn-state-purge.test.ts

@@ -0,0 +1,109 @@
+/**
+ * turn-state-purge — the silence-poke fallback's defense-in-depth
+ * cleanup. Pins the multi-chat safety + key-shape correctness that
+ * the gymbro/klanker held-mid-turn fix (2026-05-20) depends on.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { purgeStaleTurnsForChat } from '../gateway/turn-state-purge.js'
+
+function statusKey(chatId: string, threadId?: number): string {
+  return `${chatId}:${threadId ?? '_'}`
+}
+
+describe('purgeStaleTurnsForChat', () => {
+  it('returns [] and calls nothing when keys is empty', () => {
+    let calls = 0
+    const r = purgeStaleTurnsForChat('123', [], () => calls++)
+    expect(r.purged).toEqual([])
+    expect(calls).toBe(0)
+  })
+
+  it('returns [] and calls nothing when chatId is empty (guard)', () => {
+    let calls = 0
+    const r = purgeStaleTurnsForChat('', [statusKey('123')], () => calls++)
+    expect(r.purged).toEqual([])
+    expect(calls).toBe(0)
+  })
+
+  it('purges the canonical DM key for the firing chat (typical case)', () => {
+    const purged: string[] = []
+    const r = purgeStaleTurnsForChat(
+      '12345',
+      [statusKey('12345')],
+      (k) => purged.push(k),
+    )
+    expect(r.purged).toEqual(['12345:_'])
+    expect(purged).toEqual(['12345:_'])
+  })
+
+  it('purges every sibling key for the same chat (multi-thread / dangling)', () => {
+    // This is the gymbro/klanker symptom: a stale activeTurnStartedAt
+    // entry under a different thread of the same chat survives the
+    // canonical purgeReactionTracking(fbKey).
+    const purged: string[] = []
+    const r = purgeStaleTurnsForChat(
+      '12345',
+      [
+        statusKey('12345'),       // DM, no thread
+        statusKey('12345', 42),    // thread 42
+        statusKey('12345', 99),    // thread 99
+      ],
+      (k) => purged.push(k),
+    )
+    expect(r.purged.sort()).toEqual(['12345:42', '12345:99', '12345:_'])
+    expect(purged).toHaveLength(3)
+  })
+
+  it('NEVER touches keys for OTHER chats (multi-chat safety — the #1546 guard)', () => {
+    const purged: string[] = []
+    const r = purgeStaleTurnsForChat(
+      '12345',
+      [
+        statusKey('12345'),       // target chat — purge
+        statusKey('-1001234567890'),       // different chat — must NOT touch
+        statusKey('-1001234567890', 7),    // different chat thread — must NOT touch
+      ],
+      (k) => purged.push(k),
+    )
+    expect(r.purged).toEqual(['12345:_'])
+    expect(purged).toEqual(['12345:_']) // ONLY the target chat
+  })
+
+  it('does not false-match on a chatId-prefix superstring (e.g. 123 vs 1234)', () => {
+    // If we used a naive startsWith on the WHOLE key, chatId "123"
+    // would falsely match key "1234:_". The helper splits on `:` and
+    // equates the chatId slice, which prevents that.
+    const purged: string[] = []
+    const r = purgeStaleTurnsForChat(
+      '123',
+      [statusKey('123'), statusKey('1234'), statusKey('12')],
+      (k) => purged.push(k),
+    )
+    expect(r.purged).toEqual(['123:_']) // ONLY the exact match
+  })
+
+  it('skips malformed keys (no `:`)', () => {
+    let calls = 0
+    const r = purgeStaleTurnsForChat(
+      '123',
+      ['malformed', '', 'no-colon-here', statusKey('123')],
+      () => calls++,
+    )
+    expect(r.purged).toEqual(['123:_'])
+    expect(calls).toBe(1)
+  })
+
+  it('accepts any iterable (snapshots before iteration — purger may delete)', () => {
+    // The real call site iterates `activeTurnStartedAt.keys()` and
+    // the purger deletes from that same Map. Snapshotting in the
+    // helper prevents iterator skew.
+    const map = new Map<string, number>()
+    map.set('123:_', 1)
+    map.set('123:7', 2)
+    map.set('999:_', 3)
+    const r = purgeStaleTurnsForChat('123', map.keys(), (k) => map.delete(k))
+    expect(r.purged.sort()).toEqual(['123:7', '123:_'])
+    expect([...map.keys()]).toEqual(['999:_']) // multi-chat safety preserved
+  })
+})