switchroom 0.18.31 → 0.18.33

package/telegram-plugin/tests/litellm-proxy-auth-misconfig.test.ts

@@ -227,39 +227,94 @@ describe('PendingUserNoticeGate — notice fires IFF the turn dies reply-less',
     }
   }
 
+  // The single-turn norm: the error surfaced while topic A's turn was live, so
+  // the notice is keyed to A and topic A's turn end resolves it. `TOPIC_A` is a
+  // `statusKey(chatId, threadId)`-shaped value.
+  const TOPIC_A = '5000000002'
+  const TOPIC_B = '5000000009:42'
+
   it('DROPS the notice when the turn recovered (delivered a reply)', () => {
     const gate = new PendingUserNoticeGate()
-    gate.schedule(makeNotice())
-    expect(gate.resolveTurnEnd(true, 1_001_000)).toEqual([])
+    gate.schedule(makeNotice({ key: TOPIC_A }))
+    expect(gate.resolveTurnEnd(TOPIC_A, true, 1_001_000)).toEqual([])
     // And it does not resurrect on a later failed turn end.
-    expect(gate.resolveTurnEnd(false, 1_002_000)).toEqual([])
+    expect(gate.resolveTurnEnd(TOPIC_A, false, 1_002_000)).toEqual([])
   })
 
   it('SENDS the notice exactly once when the turn ends without a reply', () => {
     const gate = new PendingUserNoticeGate()
-    const notice = makeNotice()
-    gate.schedule(notice)
-    const flushed = gate.resolveTurnEnd(false, 1_001_000)
+    gate.schedule(makeNotice({ key: TOPIC_A }))
+    const flushed = gate.resolveTurnEnd(TOPIC_A, false, 1_001_000)
     expect(flushed).toHaveLength(1)
     expect(flushed[0].chatIds).toEqual(['5000000002', '5000000003'])
     // Exactly once — a second turn end flushes nothing.
-    expect(gate.resolveTurnEnd(false, 1_002_000)).toEqual([])
+    expect(gate.resolveTurnEnd(TOPIC_A, false, 1_002_000)).toEqual([])
   })
 
-  it('collapses an error burst within one turn to ONE pending notice per agent', () => {
+  it('collapses an error burst within one turn to ONE pending notice per topic', () => {
     const gate = new PendingUserNoticeGate()
-    gate.schedule(makeNotice({ atMs: 1_000_000 }))
-    gate.schedule(makeNotice({ atMs: 1_000_500 }))
-    gate.schedule(makeNotice({ atMs: 1_001_000 }))
-    expect(gate.resolveTurnEnd(false, 1_002_000)).toHaveLength(1)
+    gate.schedule(makeNotice({ atMs: 1_000_000, key: TOPIC_A }))
+    gate.schedule(makeNotice({ atMs: 1_000_500, key: TOPIC_A }))
+    gate.schedule(makeNotice({ atMs: 1_001_000, key: TOPIC_A }))
+    expect(gate.resolveTurnEnd(TOPIC_A, false, 1_002_000)).toHaveLength(1)
   })
 
   it('expires an unresolved notice after the TTL (bias to silence over false failure)', () => {
     const gate = new PendingUserNoticeGate()
-    gate.schedule(makeNotice({ atMs: 1_000_000 }))
+    gate.schedule(makeNotice({ atMs: 1_000_000, key: TOPIC_A }))
     const after = 1_000_000 + PENDING_USER_NOTICE_TTL_MS + 1
     expect(gate.hasPending(after)).toBe(false)
-    expect(gate.resolveTurnEnd(false, after)).toEqual([])
+    expect(gate.resolveTurnEnd(TOPIC_A, false, after)).toEqual([])
+  })
+
+  // ── #3294 — keyed by turn/topic so concurrent per-topic turns don't
+  //    cross-resolve each other's pending notices. ─────────────────────────────
+  it("does NOT flush topic A's notice when a DIFFERENT topic's turn ends reply-less", () => {
+    const gate = new PendingUserNoticeGate()
+    gate.schedule(makeNotice({ atMs: 1_000_000, key: TOPIC_A }))
+    // Topic B's turn ends WITHOUT a reply. Pre-#3294 this flushed A's notice
+    // (a false "couldn't complete" for a turn that may still recover). Now B's
+    // end resolves nothing keyed to A.
+    expect(gate.resolveTurnEnd(TOPIC_B, false, 1_000_500)).toEqual([])
+    // A's notice is still pending, and A's OWN reply-less end flushes it.
+    expect(gate.hasPending(1_000_600)).toBe(true)
+    const flushed = gate.resolveTurnEnd(TOPIC_A, false, 1_000_700)
+    expect(flushed).toHaveLength(1)
+    expect(flushed[0].key).toBe(TOPIC_A)
+  })
+
+  it("does NOT drop topic A's notice when a DIFFERENT topic's turn recovers", () => {
+    const gate = new PendingUserNoticeGate()
+    gate.schedule(makeNotice({ atMs: 1_000_000, key: TOPIC_A }))
+    // Topic B's turn recovered (delivered a reply). It must not drop A's notice.
+    expect(gate.resolveTurnEnd(TOPIC_B, true, 1_000_500)).toEqual([])
+    // A's notice survives and still flushes on A's reply-less end.
+    expect(gate.resolveTurnEnd(TOPIC_A, false, 1_000_700)).toHaveLength(1)
+  })
+
+  it('keeps a per-topic pending notice for each concurrent topic (no cross-collapse)', () => {
+    const gate = new PendingUserNoticeGate()
+    gate.schedule(makeNotice({ atMs: 1_000_000, key: TOPIC_A, chatIds: ['5000000002'] }))
+    gate.schedule(makeNotice({ atMs: 1_000_100, key: TOPIC_B, chatIds: ['5000000009'] }))
+    // A's end flushes only A.
+    const a = gate.resolveTurnEnd(TOPIC_A, false, 1_000_200)
+    expect(a).toHaveLength(1)
+    expect(a[0].chatIds).toEqual(['5000000002'])
+    // B is still pending and flushes on B's end.
+    const b = gate.resolveTurnEnd(TOPIC_B, false, 1_000_300)
+    expect(b).toHaveLength(1)
+    expect(b[0].chatIds).toEqual(['5000000009'])
+  })
+
+  it('an UNATTRIBUTED (undefined-key) notice resolves on any turn end (legacy single-turn behavior)', () => {
+    const gate = new PendingUserNoticeGate()
+    // No key — the error arrived with no live turn (between turns / post-poke).
+    gate.schedule(makeNotice({ atMs: 1_000_000 }))
+    // Any topic's reply-less end flushes it (preserves pre-#3294 behavior so a
+    // genuine death on a single-turn gateway still notifies the user).
+    const flushed = gate.resolveTurnEnd(TOPIC_B, false, 1_000_500)
+    expect(flushed).toHaveLength(1)
+    expect(flushed[0].key).toBeUndefined()
   })
 })
 

package/telegram-plugin/tests/media-message-handlers.test.ts

@@ -0,0 +1,276 @@
+/**
+ * Outcome pins for the media-envelope inbound handlers extracted from
+ * gateway.ts (switchroom#2996 P6 cluster A). Each handler is driven with a
+ * fake grammy ctx + mock dispatch deps; the assertions pin the EXACT text
+ * envelope forwarded to `handleInbound` (and the stderr log line, and the
+ * ack/refuse dispatch) — the behaviour the gateway previously produced inline.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import type { Context } from 'grammy'
+import {
+  safeName,
+  PASSPORT_REFUSAL_TEXT,
+  handleContactMessage,
+  handleLocationMessage,
+  handleVenueMessage,
+  handlePollMessage,
+  handleWebAppDataMessage,
+  handleUsersSharedMessage,
+  handleChatSharedMessage,
+  handleSuccessfulPaymentMessage,
+  handlePassportDataMessage,
+  handleDiceMessage,
+  handleGameMessage,
+  handleStoryMessage,
+  handlePaidMediaMessage,
+  type MediaEnvelopeDeps,
+} from '../gateway/media-message-handlers.js'
+
+function makeDeps() {
+  const handleInbound = vi.fn(async () => {})
+  const handleAckOnly = vi.fn(async () => {})
+  const handleRefusal = vi.fn(async () => {})
+  const logs: string[] = []
+  const deps: MediaEnvelopeDeps = {
+    handleInbound,
+    handleAckOnly,
+    handleRefusal,
+    log: line => logs.push(line),
+  }
+  return { deps, handleInbound, handleAckOnly, handleRefusal, logs }
+}
+
+// Build a fake ctx whose `message` carries the given content key + a chat id.
+function ctxWith(content: Record<string, unknown>, chatId: number | null = 42): any {
+  return {
+    message: content,
+    chat: chatId == null ? undefined : { id: chatId },
+  }
+}
+
+describe('safeName', () => {
+  it('strips framing/injection characters', () => {
+    expect(safeName('a<b>[c]\r\nd;e')).toBe('a_b__c___d_e')
+  })
+  it('passes undefined through', () => {
+    expect(safeName(undefined)).toBeUndefined()
+  })
+})
+
+describe('handleContactMessage', () => {
+  it('renders the contact envelope and forwards it', async () => {
+    const { deps, handleInbound, logs } = makeDeps()
+    const ctx = ctxWith({
+      contact: { phone_number: '+15551234', first_name: 'Ada', last_name: 'Love', user_id: 7 },
+    })
+    await handleContactMessage(ctx, deps)
+    expect(handleInbound).toHaveBeenCalledWith(
+      ctx,
+      '(contact: name="Ada Love" phone="+15551234" user_id=7)',
+      undefined,
+    )
+    expect(logs[0]).toBe('telegram gateway: inbound contact from chat=42\n')
+  })
+
+  it('falls back to ? for missing fields and omits user_id', async () => {
+    const { deps, handleInbound } = makeDeps()
+    const ctx = ctxWith({ contact: {} })
+    await handleContactMessage(ctx, deps)
+    expect(handleInbound).toHaveBeenCalledWith(ctx, '(contact: name="?" phone="?")', undefined)
+  })
+
+  it('logs and swallows a builder error without forwarding', async () => {
+    const { deps, handleInbound, logs } = makeDeps()
+    // ctx.message is null → property access throws inside try.
+    const ctx = { message: null, chat: { id: 42 } } as unknown as Context
+    await handleContactMessage(ctx as any, deps)
+    expect(handleInbound).not.toHaveBeenCalled()
+    expect(logs.some(l => l.startsWith('telegram gateway: contact handler error:'))).toBe(true)
+  })
+})
+
+describe('handleLocationMessage', () => {
+  it('renders lat/lon at 6dp with live_period', async () => {
+    const { deps, handleInbound } = makeDeps()
+    const ctx = ctxWith({ location: { latitude: 12.3, longitude: -45.6, live_period: 60 } })
+    await handleLocationMessage(ctx, deps)
+    expect(handleInbound).toHaveBeenCalledWith(
+      ctx,
+      '(location: lat=12.300000 lon=-45.600000 live_period=60s)',
+      undefined,
+    )
+  })
+  it('omits live_period when absent and ? for non-numeric coords', async () => {
+    const { deps, handleInbound } = makeDeps()
+    const ctx = ctxWith({ location: {} })
+    await handleLocationMessage(ctx, deps)
+    expect(handleInbound).toHaveBeenCalledWith(ctx, '(location: lat=? lon=?)', undefined)
+  })
+})
+
+describe('handleVenueMessage', () => {
+  it('renders the venue envelope', async () => {
+    const { deps, handleInbound } = makeDeps()
+    const ctx = ctxWith({
+      venue: { title: 'Cafe', address: '1 St', location: { latitude: 1, longitude: 2 } },
+    })
+    await handleVenueMessage(ctx, deps)
+    expect(handleInbound).toHaveBeenCalledWith(
+      ctx,
+      '(venue: title="Cafe" address="1 St" lat=1.000000 lon=2.000000)',
+      undefined,
+    )
+  })
+})
+
+describe('handlePollMessage', () => {
+  it('renders question, count, anonymity and first-10 choices', async () => {
+    const { deps, handleInbound } = makeDeps()
+    const ctx = ctxWith({
+      poll: {
+        question: 'Pick',
+        is_anonymous: true,
+        options: [{ text: 'A' }, { text: 'B' }],
+      },
+    })
+    await handlePollMessage(ctx, deps)
+    expect(handleInbound).toHaveBeenCalledWith(
+      ctx,
+      '(poll: question="Pick" options=2 anonymous choices=[A | B])',
+      undefined,
+    )
+  })
+})
+
+describe('handleWebAppDataMessage', () => {
+  it('renders JSON-encoded data and logs byte count', async () => {
+    const { deps, handleInbound, logs } = makeDeps()
+    const ctx = ctxWith({ web_app_data: { data: 'hi', button_text: 'Go' } })
+    await handleWebAppDataMessage(ctx, deps)
+    expect(handleInbound).toHaveBeenCalledWith(
+      ctx,
+      '(web_app_data: button="Go" data="hi")',
+      undefined,
+    )
+    expect(logs[0]).toContain('button="Go" bytes=2')
+  })
+  it('truncates oversized data at 4096 chars', async () => {
+    const { deps, handleInbound } = makeDeps()
+    const big = 'x'.repeat(5000)
+    const ctx = ctxWith({ web_app_data: { data: big, button_text: 'B' } })
+    await handleWebAppDataMessage(ctx, deps)
+    const arg = (handleInbound as any).mock.calls[0][1] as string
+    expect(arg).toContain('…(truncated)')
+    expect(arg).toContain(JSON.stringify('x'.repeat(4096) + '…(truncated)'))
+  })
+})
+
+describe('handleUsersSharedMessage', () => {
+  it('renders shared user ids and count', async () => {
+    const { deps, handleInbound } = makeDeps()
+    const ctx = ctxWith({ users_shared: { request_id: 9, users: [{ user_id: 1 }, { user_id: 2 }] } })
+    await handleUsersSharedMessage(ctx, deps)
+    expect(handleInbound).toHaveBeenCalledWith(
+      ctx,
+      '(users_shared: request_id=9 user_ids=[1,2] count=2)',
+      undefined,
+    )
+  })
+})
+
+describe('handleChatSharedMessage', () => {
+  it('renders shared chat with optional title', async () => {
+    const { deps, handleInbound } = makeDeps()
+    const ctx = ctxWith({ chat_shared: { request_id: 3, chat_id: -100, title: 'Grp' } })
+    await handleChatSharedMessage(ctx, deps)
+    expect(handleInbound).toHaveBeenCalledWith(
+      ctx,
+      '(chat_shared: request_id=3 chat_id=-100 title="Grp")',
+      undefined,
+    )
+  })
+  it('omits title when absent', async () => {
+    const { deps, handleInbound } = makeDeps()
+    const ctx = ctxWith({ chat_shared: { request_id: 3, chat_id: -100 } })
+    await handleChatSharedMessage(ctx, deps)
+    expect(handleInbound).toHaveBeenCalledWith(
+      ctx,
+      '(chat_shared: request_id=3 chat_id=-100)',
+      undefined,
+    )
+  })
+})
+
+describe('handleSuccessfulPaymentMessage', () => {
+  it('logs structured fields and ack-only-warns, never forwarding', async () => {
+    const { deps, handleInbound, handleAckOnly, logs } = makeDeps()
+    const ctx = ctxWith({
+      successful_payment: {
+        currency: 'USD',
+        total_amount: 500,
+        invoice_payload: 'order-1',
+        provider_payment_charge_id: 'pc',
+        telegram_payment_charge_id: 'tc',
+      },
+    })
+    await handleSuccessfulPaymentMessage(ctx, deps)
+    expect(handleInbound).not.toHaveBeenCalled()
+    expect(handleAckOnly).toHaveBeenCalledWith(ctx, 'successful_payment', { warn: true })
+    expect(logs[0]).toContain('currency=USD total_amount=500')
+    expect(logs[0]).toContain('payload="order-1"')
+  })
+})
+
+describe('ack-only leaves (dice/game/story/paid_media)', () => {
+  it('handleDiceMessage logs and reacts 🎲, never forwarding', async () => {
+    const { deps, handleInbound, handleAckOnly, logs } = makeDeps()
+    const ctx = ctxWith({ dice: { emoji: '🎲', value: 4 } })
+    await handleDiceMessage(ctx, deps)
+    expect(handleInbound).not.toHaveBeenCalled()
+    expect(handleAckOnly).toHaveBeenCalledWith(ctx, 'dice', { emoji: '🎲' })
+    expect(logs[0]).toBe('telegram gateway: inbound dice from chat=42\n')
+  })
+
+  it('handleGameMessage logs and acks with no options', async () => {
+    const { deps, handleAckOnly, logs } = makeDeps()
+    const ctx = ctxWith({ game: {} })
+    await handleGameMessage(ctx, deps)
+    expect(handleAckOnly).toHaveBeenCalledWith(ctx, 'game')
+    expect(logs[0]).toBe('telegram gateway: inbound game from chat=42\n')
+  })
+
+  it('handleStoryMessage logs and acks with no options', async () => {
+    const { deps, handleAckOnly, logs } = makeDeps()
+    const ctx = ctxWith({ story: {} })
+    await handleStoryMessage(ctx, deps)
+    expect(handleAckOnly).toHaveBeenCalledWith(ctx, 'story')
+    expect(logs[0]).toBe('telegram gateway: inbound story from chat=42\n')
+  })
+
+  it('handlePaidMediaMessage logs and acks warn:true', async () => {
+    const { deps, handleInbound, handleAckOnly, logs } = makeDeps()
+    const ctx = ctxWith({ paid_media: {} })
+    await handlePaidMediaMessage(ctx, deps)
+    expect(handleInbound).not.toHaveBeenCalled()
+    expect(handleAckOnly).toHaveBeenCalledWith(ctx, 'paid_media', { warn: true })
+    expect(logs[0]).toBe('telegram gateway: inbound paid_media from chat=42\n')
+  })
+
+  it('falls back to ? for a missing chat id', async () => {
+    const { deps, logs } = makeDeps()
+    const ctx = ctxWith({ dice: {} }, null)
+    await handleDiceMessage(ctx, deps)
+    expect(logs[0]).toBe('telegram gateway: inbound dice from chat=?\n')
+  })
+})
+
+describe('handlePassportDataMessage', () => {
+  it('refuses with the fixed message and never forwards', async () => {
+    const { deps, handleInbound, handleRefusal } = makeDeps()
+    const ctx = ctxWith({ passport_data: {} })
+    await handlePassportDataMessage(ctx, deps)
+    expect(handleInbound).not.toHaveBeenCalled()
+    expect(handleRefusal).toHaveBeenCalledWith(ctx, 'passport_data', PASSPORT_REFUSAL_TEXT)
+  })
+})

package/telegram-plugin/tests/mental-model-propose-callback-gate.test.ts

@@ -20,13 +20,17 @@ import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
 // #2996 Phase 5: the callback-query handler families moved verbatim to
-// gateway/callback-query-handlers.ts; these pins read the gateway source
-// COMBINED with that module so the wiring assertions keep covering the
-// same runtime source text.
+// gateway/callback-query-handlers.ts, and the executeMentalModelPropose tool
+// handler to gateway/card-tool-handlers.ts (P5-tail); these pins read the
+// gateway source COMBINED with those modules so the wiring assertions keep
+// covering the same runtime source text. (The MENTAL_MODEL_* cap constant
+// DEFINITIONS stay in gateway.ts and are injected.)
 const gatewaySrc =
   readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf-8') +
   '\n' +
-  readFileSync(resolve(__dirname, '..', 'gateway', 'callback-query-handlers.ts'), 'utf-8')
+  readFileSync(resolve(__dirname, '..', 'gateway', 'callback-query-handlers.ts'), 'utf-8') +
+  '\n' +
+  readFileSync(resolve(__dirname, '..', 'gateway', 'card-tool-handlers.ts'), 'utf-8')
 
 function proposeCallbackBlock(): string {
   return (

package/telegram-plugin/tests/model-command.test.ts

@@ -444,6 +444,36 @@ describe("SR_MODEL_ALIASES / expandSrAlias", () => {
   it("every alias target is a sr-* id", () => {
     for (const target of Object.values(SR_MODEL_ALIASES)) expect(isSrModel(target)).toBe(true);
   });
+  it("2026-07-19 grok/kimi/gpt flagship buttons expand to their sr-* ids", () => {
+    expect(expandSrAlias("grok")).toBe("sr-grok-4.5");
+    expect(expandSrAlias("kimi")).toBe("sr-kimi-k3");
+    expect(expandSrAlias("gpt")).toBe("sr-gpt-5.6-sol");
+  });
+  it("per-tier GPT-5.6 buttons sol/terra/luna expand to their sr-* ids", () => {
+    expect(expandSrAlias("sol")).toBe("sr-gpt-5.6-sol");
+    expect(expandSrAlias("terra")).toBe("sr-gpt-5.6-terra");
+    expect(expandSrAlias("luna")).toBe("sr-gpt-5.6-luna");
+    for (const a of ["sol", "terra", "luna"]) expect(isOfflineTrustedModelToken(a)).toBe(true);
+  });
+  it("new flagship buttons are offline-trustable carriers (#3042 gate)", () => {
+    for (const a of ["grok", "kimi", "gpt"]) expect(isOfflineTrustedModelToken(a)).toBe(true);
+    for (const id of ["sr-grok-4.5", "sr-kimi-k3", "sr-gpt-5.6-sol"])
+      expect(isOfflineTrustedModelToken(id)).toBe(true);
+  });
+  it("labels every new grok/kimi/gpt-5.6 sr-* id (typeable tiers included)", () => {
+    for (const id of [
+      "sr-grok-4.5",
+      "sr-grok-4.3",
+      "sr-kimi-k3",
+      "sr-kimi-k2.7-code",
+      "sr-gpt-5.6-sol",
+      "sr-gpt-5.6-terra",
+      "sr-gpt-5.6-luna",
+    ]) {
+      expect(SR_MODEL_LABELS[id]).toBeTypeOf("string");
+      expect(isValidModelArg(id)).toBe(true);
+    }
+  });
 });
 
 describe("classifyDiscoveredOptions", () => {

package/telegram-plugin/tests/multitopic-routing-wiring.test.ts

@@ -12,10 +12,33 @@ import { describe, it, expect } from 'vitest'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-const gatewaySrc = readFileSync(
-  resolve(__dirname, '..', 'gateway', 'gateway.ts'),
+// #2996 P2: executeReply's body moved VERBATIM to outbound-send-path.ts
+// (`sendReply`); the reply-path routing assertions read the window there.
+const sendPathSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'outbound-send-path.ts'),
   'utf-8',
 )
+const sendReplyFn = sendPathSrc.split('export async function sendReply(')[1]?.split('\nexport ')[0] ?? ''
+const gatewaySrc =
+  readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf-8') +
+  '\n' +
+  // P7 PR-10 (#2996): the InboundMessage envelope assembly (origin_turn_id,
+  // topic_scope, meta lane) moved verbatim into gateway/inbound-router.ts
+  // (buildInboundEnvelope) — include it in the scraped corpus.
+  readFileSync(resolve(__dirname, '..', 'gateway', 'inbound-router.ts'), 'utf-8')
+// #2996 P4-A: the enqueue handler (turn ctor: `const turnId = deriveTurnId`,
+// `rememberRecentTurn(next)`, `promoteQueuedStatus`) moved VERBATIM into
+// stream-render.ts with handleSessionEvent. Enqueue-seam assertions span both.
+// #2996 P8 PR-B: the turn-end funnel bodies moved verbatim to turn-end.ts.
+const turnEndSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'turn-end.ts'),
+  'utf-8',
+)
+const streamSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'stream-render.ts'),
+  'utf-8',
+)
+const gatewayAndStreamSrc = gatewaySrc + '\n' + streamSrc
 const bridgeSrc = readFileSync(
   resolve(__dirname, '..', 'bridge', 'bridge.ts'),
   'utf-8',
@@ -31,12 +54,12 @@ const deriveTurnIdSrc = readFileSync(
 describe('component 3 — turn-origin reply routing', () => {
   it('CurrentTurn carries a turnId, and the enqueue handler initialises it', () => {
     expect(gatewaySrc).toMatch(/turnId: string/)
-    expect(gatewaySrc).toMatch(/const turnId\s*=\s*\n?\s*deriveTurnId\(/)
-    expect(gatewaySrc).toMatch(/rememberRecentTurn\(next\)/)
+    expect(gatewayAndStreamSrc).toMatch(/const turnId\s*=\s*\n?\s*deriveTurnId\(/)
+    expect(gatewayAndStreamSrc).toMatch(/rememberRecentTurn\(next\)/)
   })
 
   it('the inbound meta stamps origin_turn_id derived from chat/thread/messageId', () => {
-    expect(gatewaySrc).toMatch(/const originTurnId = deriveTurnId\(chat_id, messageThreadId \?\? null, msgId\)/)
+    expect(gatewaySrc).toMatch(/const originTurnId = deriveTurnId\((?:p\.)?chat_id, (?:p\.)?messageThreadId \?\? null, (?:p\.)?msgId\)/)
     expect(gatewaySrc).toMatch(/origin_turn_id: originTurnId/)
   })
 
@@ -54,7 +77,7 @@ describe('component 3 — turn-origin reply routing', () => {
   })
 
   it('executeReply resolves the answer thread via the origin turn, not the live currentTurn', () => {
-    const fn = gatewaySrc.split('async function executeReply')[1]?.split('\nasync function ')[0] ?? ''
+    const fn = sendReplyFn
     expect(fn).toMatch(/TURN_ORIGIN_ROUTING_ENABLED/)
     expect(fn).toMatch(/findTurnByOriginId\(args\.origin_turn_id/)
     // The resolution + reply-route telemetry go through resolveAnswerThreadWithLog,
@@ -85,8 +108,7 @@ describe('framework-owned origin recovery (determinism residual, 2026-06-05)', (
   })
 
   it('the reply path recovers origin from the quoted message_id when the model omits the echo', () => {
-    for (const name of ['executeReply']) {
-      const fn = gatewaySrc.split(new RegExp(`async function ${name}`))[1]?.split('\nasync function ')[0] ?? ''
+    for (const fn of [sendReplyFn]) {
       // Echo first (authoritative), quoted message_id as the framework fallback.
       expect(fn).toMatch(/const echoedTurn = findTurnByOriginId\(args\.origin_turn_id/)
       // Quoted lookup is CHAT-SCOPED (cross-chat message-id collision guard).
@@ -123,7 +145,9 @@ describe('component 4 — per-turn topic framing', () => {
     expect(gatewaySrc).toMatch(/TOPIC_FRAMING_ENABLED/)
     expect(gatewaySrc).toMatch(/topic_scope: topicScope/)
     // Only for topic inbounds — DMs get nothing.
-    expect(gatewaySrc).toMatch(/TOPIC_FRAMING_ENABLED && messageThreadId != null/)
+    // P7 PR-10: the guard reads the injected constant + params inside
+    // buildInboundEnvelope (topicFramingEnabled / p.messageThreadId).
+    expect(gatewaySrc).toMatch(/(?:TOPIC_FRAMING_ENABLED|p\.topicFramingEnabled) && (?:p\.)?messageThreadId != null/)
   })
 
   it('the bridge instructions frame each channel message as the current topic', () => {
@@ -145,17 +169,17 @@ describe('component 5 — queued-status UX (delete-on-answer)', () => {
   })
 
   it('Hook B promotes the placeholder to "On it" when the buffered turn starts', () => {
-    expect(gatewaySrc).toMatch(/promoteQueuedStatus\(ev\.chatId, enqThreadIdNum\)/)
+    expect(gatewayAndStreamSrc).toMatch(/promoteQueuedStatus\(ev\.chatId, enqThreadIdNum\)/)
   })
 
   it('Hook C reaps the placeholder on the answer (executeReply / stream)', () => {
-    const reapCalls = gatewaySrc.match(/reapQueuedStatus\(/g) ?? []
+    const reapCalls = (gatewaySrc + turnEndSrc).match(/reapQueuedStatus\(/g) ?? []
     // definition + executeReply + purge cleanup (2 branches)
     expect(reapCalls.length).toBeGreaterThanOrEqual(4)
   })
 
   it('purgeReactionTracking reaps the placeholder on abnormal turn-end (defense-in-depth)', () => {
-    const fn = gatewaySrc.split('function purgeReactionTracking')[1]?.split('\nfunction ')[0] ?? ''
+    const fn = turnEndSrc.split('function purgeReactionTracking')[1]?.split('\nfunction ')[0] ?? ''
     expect(fn).toMatch(/reapQueuedStatus\(/)
     // Reap sits alongside the activeReactionMsgIds cleanup.
     expect(fn).toMatch(/activeReactionMsgIds\.delete\(key\)/)

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

@@ -3,6 +3,7 @@ import {
   normalizeNarrative,
   prefixSimilarity,
   isDraftOfReply,
+  isReplyTool,
   DRAFT_SUPPRESS_THRESHOLD,
   REPLY_TOOLS,
 } from '../narrative-dedup.js'
@@ -18,6 +19,37 @@ describe('narrative-dedup', () => {
     expect(REPLY_TOOLS.has('Bash')).toBe(false)
   })
 
+  describe('isReplyTool (#3231 prefix-aware matching)', () => {
+    it('matches the PREFIXED prod wire shape (what real jsonl actually carries)', () => {
+      // The whole point of #3231: production jsonl carries mcp__…__telegram__<tool>,
+      // so a bare REPLY_TOOLS.has(name) was always false in prod → suppression inert.
+      expect(isReplyTool('mcp__switchroom-telegram__stream_reply')).toBe(true)
+      expect(isReplyTool('mcp__switchroom-telegram__reply')).toBe(true)
+    })
+
+    it('matches under ANY registration key (clerk-telegram, forks)', () => {
+      expect(isReplyTool('mcp__clerk-telegram__stream_reply')).toBe(true)
+      expect(isReplyTool('mcp__my-fork-telegram__reply')).toBe(true)
+    })
+
+    it('still matches BARE names (non-MCP sources)', () => {
+      expect(isReplyTool('reply')).toBe(true)
+      expect(isReplyTool('stream_reply')).toBe(true)
+    })
+
+    it('rejects non-reply tools, prefixed or bare', () => {
+      expect(isReplyTool('Bash')).toBe(false)
+      expect(isReplyTool('mcp__switchroom-telegram__react')).toBe(false)
+      expect(isReplyTool('mcp__switchroom-telegram__edit_message')).toBe(false)
+      expect(isReplyTool('mcp__hindsight__retain')).toBe(false)
+    })
+
+    it('is null/undefined safe', () => {
+      expect(isReplyTool(null)).toBe(false)
+      expect(isReplyTool(undefined)).toBe(false)
+    })
+  })
+
   describe('normalizeNarrative', () => {
     it('strips markdown emphasis/heading/quote marks, collapses whitespace, lowercases', () => {
       expect(normalizeNarrative('**Bold**  _italic_   `code`')).toBe('bold italic code')

package/telegram-plugin/tests/narrative-flush.test.ts

@@ -101,7 +101,10 @@ describe('anti-double-print (deferred path) — a draft-then-send reply is suppr
     const answer = 'The build is green — all 412 tests pass.'
     ctrl.stage(answer) // the model drafting its answer just before reply()
 
-    ctrl.resolveOnTool('reply', { text: answer }) // draft-then-send → SUPPRESS
+    // #3231: feed the PREFIXED prod wire shape (mcp__…__reply). Before the
+    // isReplyTool fix a bare REPLY_TOOLS.has() missed this and the draft was
+    // WRONGLY shown — the suppression path was inert on the real wire shape.
+    ctrl.resolveOnTool('mcp__switchroom-telegram__reply', { text: answer }) // draft-then-send → SUPPRESS
     expect(show).not.toHaveBeenCalled()
     expect(retractShown).not.toHaveBeenCalled() // nothing was shown to retract
     expect(scheduler.isArmed).toBe(false)
@@ -128,7 +131,8 @@ describe('anti-double-print (TIMER path) — a timer-painted draft is retracted'
 
     // The reply finally lands and IS that block → must be retracted, not left
     // on the card to double-print against the canonical reply.
-    ctrl.resolveOnTool('stream_reply', { text: answer })
+    // #3231: prefixed prod wire shape.
+    ctrl.resolveOnTool('mcp__switchroom-telegram__stream_reply', { text: answer })
     expect(retractShown).toHaveBeenCalledTimes(1)
     expect(retractShown).toHaveBeenCalledWith(answer)
     expect(show).toHaveBeenCalledTimes(1) // not re-shown