switchroom 0.18.8 → 0.18.9

package/telegram-plugin/tests/outbound-send-chunks.test.ts

@@ -0,0 +1,304 @@
+/**
+ * Invocable send-loop harness (#2996 step 1).
+ *
+ * PR 3007 extracted the deterministic text/chunk CORE of the outbound path but
+ * noted the side-effecting send ORCHESTRATION could not be moved (or tested)
+ * without an "invocable-executeReply harness" — because gateway.ts is not
+ * importable in any test runner: it runs boot logic (acquires the PID lock,
+ * `process.exit(1)` when another gateway is live) and calls `Bun.listen` at
+ * import time, so `executeReply` can never be driven from vitest/bun in-place.
+ *
+ * This harness closes that gap for the highest-bug-density mechanic of the send
+ * path — the chunk-send loop with its THREAD_NOT_FOUND / oversize re-split /
+ * parse-reject fallback ladder and partial-failure contract (exactly where the
+ * recent oversize / wire-cap fixes landed). `sendReplyChunks` was relocated
+ * VERBATIM from executeReply and is now driven here against a FAKE bot API,
+ * asserting: multi-chunk send order, partial-failure contract (which chunks
+ * report sent), oversize re-send, HTML parse-reject plaintext fallback,
+ * THREAD_NOT_FOUND thread-drop + retry, keyboard-on-last-chunk passthrough,
+ * preview edit-in-place, and voice-only text suppression.
+ *
+ * The gateway keeps the raw `bot.api.*` calls as thin injected adapters; the
+ * module is bot-agnostic, so a fake is a plain record of function calls. The
+ * cross-surface `outboundDedup` singleton contract is covered by the sibling
+ * `outbound-send-path.test.ts` (a stream-path `record` suppresses a reply-path
+ * `check` on the same instance) — dedup lives in executeReply, not in this
+ * relocated loop, so it is intentionally out of scope here.
+ */
+import { describe, it, expect } from 'vitest'
+import { GrammyError } from 'grammy'
+import {
+  sendReplyChunks,
+  type ReplyChunkSendDeps,
+  type ReplyChunkSendState,
+} from '../gateway/outbound-send-path.js'
+
+// Build a GrammyError with a given 400 description (grammy 1.44 ctor shape).
+function grammy400(description: string, method = 'sendRichMessage'): GrammyError {
+  return new GrammyError(
+    `Call to '${method}' failed! (400: ${description})`,
+    { ok: false, error_code: 400, description },
+    method,
+    {},
+  )
+}
+
+interface RecordedCall {
+  kind: 'sendRich' | 'sendLiteral' | 'sendLiteralRaw' | 'sendRichRaw' | 'editPreview'
+  opts: Record<string, unknown>
+  body: unknown
+  threadId?: number | undefined
+  messageId?: number
+}
+
+/**
+ * Fake bot surface. `sendRich`/`sendLiteral` are the retry-wrapped adapters;
+ * `*Raw` are the unwrapped last-resort adapters; `editPreview` is the
+ * preview edit-in-place. Each records its call; per-kind `failers` inject
+ * one-shot errors (keyed by chunk-body identity or call index) so we can
+ * script the fallback ladder deterministically.
+ */
+function makeFake(opts?: {
+  failNext?: Partial<Record<RecordedCall['kind'], Array<unknown>>>
+  richMessage?: (s: string) => unknown
+}): {
+  deps: ReplyChunkSendDeps
+  calls: RecordedCall[]
+  stderr: string[]
+  logs: Array<{ id: number; chars: number; extra?: string }>
+  deleted: number[]
+} {
+  const calls: RecordedCall[] = []
+  const stderr: string[] = []
+  const logs: Array<{ id: number; chars: number; extra?: string }> = []
+  const deleted: number[] = []
+  let nextId = 1000
+  const queues = opts?.failNext ?? {}
+
+  const maybeFail = (kind: RecordedCall['kind']): void => {
+    const q = queues[kind]
+    if (q && q.length > 0) {
+      const e = q.shift()
+      if (e != null) throw e
+    }
+  }
+  const send = (
+    kind: RecordedCall['kind'],
+    o: Record<string, unknown>,
+    body: unknown,
+    threadId?: number | undefined,
+  ): Promise<{ message_id: number }> => {
+    // Evaluate the failure queue synchronously so a thrown GrammyError
+    // rejects the returned promise exactly as the real adapter would.
+    return (async () => {
+      maybeFail(kind)
+      const id = ++nextId
+      calls.push({ kind, opts: o, body, threadId, messageId: id })
+      return { message_id: id }
+    })()
+  }
+
+  const deps: ReplyChunkSendDeps = {
+    sendRich: (o, body, tid) => send('sendRich', o, body, tid),
+    sendLiteral: (o, txt, tid) => send('sendLiteral', o, txt, tid),
+    sendLiteralRaw: (o, txt) => send('sendLiteralRaw', o, txt),
+    sendRichRaw: (o, body) => send('sendRichRaw', o, body),
+    editPreview: async (mid, body, o, tid) => {
+      maybeFail('editPreview')
+      calls.push({ kind: 'editPreview', opts: o, body, threadId: tid, messageId: mid })
+      return {}
+    },
+    richMessage: opts?.richMessage ?? ((s: string) => ({ rich: s })),
+    logOutbound: (_path, _chat, id, chars, extra) => { logs.push({ id, chars, extra }) },
+    deleteStalePreview: async (id) => { deleted.push(id) },
+    stderr: (s) => { stderr.push(s) },
+  }
+  return { deps, calls, stderr, logs, deleted }
+}
+
+function baseState(over: Partial<ReplyChunkSendState> & { chunks: string[] }): ReplyChunkSendState {
+  return {
+    chatId: '555',
+    literalText: false,
+    suppressText: false,
+    threadId: undefined,
+    previewMessageId: null,
+    sentIds: [],
+    buildSendOpts: (i, isLastChunk, tid) => ({
+      ...(tid != null ? { message_thread_id: tid } : {}),
+      ...(isLastChunk ? { _last: true } : {}),
+      _chunkIndex: i,
+    }),
+    buildPreviewEditOpts: () => ({}),
+    ...over,
+  }
+}
+
+describe('sendReplyChunks — multi-chunk send order', () => {
+  it('sends every chunk in order and appends ids to the shared sentIds array', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({ chunks: ['a', 'b', 'c'] })
+    const res = await sendReplyChunks(deps, state)
+    expect(calls.map((c) => c.kind)).toEqual(['sendRich', 'sendRich', 'sendRich'])
+    expect(calls.map((c) => c.body)).toEqual([{ rich: 'a' }, { rich: 'b' }, { rich: 'c' }])
+    // ids appended in order, one per chunk
+    expect(state.sentIds).toHaveLength(3)
+    expect(state.sentIds).toEqual([...state.sentIds].sort((x, y) => x - y))
+    expect(res.threadId).toBeUndefined()
+  })
+
+  it('literal (format:text) chunks route through sendLiteral, never rich', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({ chunks: ['x', 'y'], literalText: true })
+    await sendReplyChunks(deps, state)
+    expect(calls.map((c) => c.kind)).toEqual(['sendLiteral', 'sendLiteral'])
+    expect(calls.map((c) => c.body)).toEqual(['x', 'y'])
+  })
+
+  it('voice-only suppressText sends NOTHING (voice note IS the reply)', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({ chunks: ['a', 'b'], suppressText: true })
+    await sendReplyChunks(deps, state)
+    expect(calls).toHaveLength(0)
+    expect(state.sentIds).toHaveLength(0)
+  })
+})
+
+describe('sendReplyChunks — keyboard/opts passthrough', () => {
+  it('reply_markup rides ONLY on the last chunk (isLastChunk gate)', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({
+      chunks: ['one', 'two', 'three'],
+      buildSendOpts: (i, isLastChunk, tid) => ({
+        ...(tid != null ? { message_thread_id: tid } : {}),
+        ...(isLastChunk ? { reply_markup: { inline_keyboard: [[{ text: 'Go', callback_data: 'x' }]] } } : {}),
+      }),
+    })
+    await sendReplyChunks(deps, state)
+    expect(calls[0].opts.reply_markup).toBeUndefined()
+    expect(calls[1].opts.reply_markup).toBeUndefined()
+    expect(calls[2].opts.reply_markup).toBeDefined()
+  })
+
+  it('rich path strips link_preview_options before sending (rich entity previews)', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({
+      chunks: ['only'],
+      buildSendOpts: () => ({ link_preview_options: { is_disabled: true }, keepme: 1 }),
+    })
+    await sendReplyChunks(deps, state)
+    expect(calls[0].opts.link_preview_options).toBeUndefined()
+    expect(calls[0].opts.keepme).toBe(1)
+  })
+})
+
+describe('sendReplyChunks — partial-failure contract', () => {
+  it('an unrecoverable error midway propagates, and sentIds holds ONLY the chunks already sent', async () => {
+    // chunk 0 ok, chunk 1 throws a non-400 (not length, not parse) → rethrow.
+    const boom = new Error('network exploded')
+    const { deps, calls } = makeFake({ failNext: { sendRich: [undefined, boom] } })
+    const state = baseState({ chunks: ['first', 'second', 'third'] })
+    await expect(sendReplyChunks(deps, state)).rejects.toThrow('network exploded')
+    // first chunk reported sent; second/third never appended.
+    expect(state.sentIds).toHaveLength(1)
+    // exactly one send succeeded (chunk 1 threw before being recorded).
+    expect(calls.filter((c) => c.kind === 'sendRich')).toHaveLength(1)
+  })
+})
+
+describe('sendReplyChunks — oversize re-send', () => {
+  it('a RICH_MESSAGE_TEXT_TOO_LONG on the wrapped send re-splits via the raw rich adapter', async () => {
+    // A chunk far past the wire cap so resplitOversizeChunk yields >1 piece.
+    const huge = 'x'.repeat(70_000)
+    const { deps, calls } = makeFake({ failNext: { sendRich: [grammy400('RICH_MESSAGE_TEXT_TOO_LONG')] } })
+    const state = baseState({ chunks: [huge] })
+    await sendReplyChunks(deps, state)
+    const raws = calls.filter((c) => c.kind === 'sendRichRaw')
+    expect(raws.length).toBeGreaterThan(1)
+    // every re-split piece landed a message id
+    expect(state.sentIds.length).toBe(raws.length)
+  })
+})
+
+describe('sendReplyChunks — parse-reject plaintext fallback', () => {
+  it("a can't-parse-entities 400 resends the chunk as plain text via sendLiteralRaw", async () => {
+    const { deps, calls } = makeFake({ failNext: { sendRich: [grammy400("can't parse entities: bad offset")] } })
+    const state = baseState({ chunks: ['**bad markdown'] })
+    await sendReplyChunks(deps, state)
+    expect(calls.map((c) => c.kind)).toEqual(['sendLiteralRaw'])
+    expect(calls[0].body).toBe('**bad markdown')
+    expect(state.sentIds).toHaveLength(1)
+  })
+
+  it('an empty chunk parse-reject falls back to the placeholder glyph', async () => {
+    const { deps, calls } = makeFake({ failNext: { sendRich: [grammy400("can't parse entities")] } })
+    const state = baseState({ chunks: [''] })
+    await sendReplyChunks(deps, state)
+    expect(calls[0].kind).toBe('sendLiteralRaw')
+    expect(String(calls[0].body)).toContain('could not be rendered')
+  })
+})
+
+describe('sendReplyChunks — THREAD_NOT_FOUND fallback', () => {
+  it('drops the thread and retries UNWRAPPED, and returns threadId undefined', async () => {
+    // wrapped send throws THREAD_NOT_FOUND; retry (raw) succeeds.
+    const tnf = new Error('THREAD_NOT_FOUND')
+    const { deps, calls } = makeFake({ failNext: { sendRich: [tnf] } })
+    const state = baseState({ chunks: ['hi'], threadId: 42 })
+    const res = await sendReplyChunks(deps, state)
+    // The first (wrapped) attempt threw before recording; the retry uses
+    // sendChunk(_, false) → the UNWRAPPED raw adapter, deliberately not
+    // re-entering the retry policy after a dropped thread.
+    expect(calls[0].kind).toBe('sendRichRaw')
+    // retry re-built opts WITHOUT the thread id.
+    expect(res.threadId).toBeUndefined()
+    expect(calls[0].opts.message_thread_id).toBeUndefined()
+    expect(state.sentIds).toHaveLength(1)
+  })
+
+  it('THREAD_NOT_FOUND then a length error on retry re-splits', async () => {
+    const tnf = new Error('THREAD_NOT_FOUND')
+    const huge = 'y'.repeat(70_000)
+    const { deps, calls } = makeFake({
+      failNext: { sendRich: [tnf], sendRichRaw: [grammy400('MESSAGE_TOO_LONG')] },
+    })
+    const state = baseState({ chunks: [huge], threadId: 7 })
+    await sendReplyChunks(deps, state)
+    // retry (raw) threw length → resplit sent multiple raw pieces
+    const raws = calls.filter((c) => c.kind === 'sendRichRaw')
+    expect(raws.length).toBeGreaterThan(1)
+  })
+})
+
+describe('sendReplyChunks — preview edit-in-place', () => {
+  it('edits the stale preview on the first chunk, consumes it, then sends the rest fresh', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({ chunks: ['a', 'b'], previewMessageId: 900 })
+    const res = await sendReplyChunks(deps, state)
+    expect(calls[0].kind).toBe('editPreview')
+    expect(calls[0].messageId).toBe(900)
+    // preview id consumed → subsequent chunk is a fresh send
+    expect(calls[1].kind).toBe('sendRich')
+    expect(res.previewMessageId).toBeNull()
+    // first sentId is the reused preview id
+    expect(state.sentIds[0]).toBe(900)
+  })
+
+  it('a failed preview edit deletes the stale preview and sends fresh', async () => {
+    const { deps, calls, deleted } = makeFake({ failNext: { editPreview: [new Error('message to edit not found')] } })
+    const state = baseState({ chunks: ['a'], previewMessageId: 901 })
+    const res = await sendReplyChunks(deps, state)
+    expect(deleted).toEqual([901])
+    expect(calls.some((c) => c.kind === 'sendRich')).toBe(true)
+    expect(res.previewMessageId).toBeNull()
+  })
+
+  it('a "not modified" preview edit is treated as success (id reused, no fresh send)', async () => {
+    const { deps, calls, deleted } = makeFake({ failNext: { editPreview: [new Error('Bad Request: message is not modified')] } })
+    const state = baseState({ chunks: ['a'], previewMessageId: 902 })
+    await sendReplyChunks(deps, state)
+    expect(deleted).toEqual([])
+    expect(state.sentIds).toEqual([902])
+    expect(calls.filter((c) => c.kind === 'sendRich')).toHaveLength(0)
+  })
+})

package/telegram-plugin/tests/outbound-send-path.test.ts

@@ -0,0 +1,222 @@
+import { describe, it, expect } from 'vitest'
+import {
+  repairEscapedWhitespace,
+  normalizeParagraphBreaks,
+  normalizePunctuation,
+  stripExcessBold,
+  addParagraphSpacers,
+  splitMarkdownChunks,
+  hardSliceToCap,
+  RICH_MESSAGE_MAX_CHARS,
+} from '../format.js'
+import { scrubVoice } from '../text-voice-scrub.js'
+import { redact } from '../secret-detect/redact.js'
+import { OutboundDedupCache } from '../recent-outbound-dedup.js'
+import {
+  normalizeOutboundBody,
+  computeEffectiveText,
+  computeReplyChunks,
+  resplitOversizeChunk,
+  chunkText,
+} from '../gateway/outbound-send-path.js'
+
+/**
+ * Golden-transcript harness for the outbound send-path extraction (#2996,
+ * plan §3B).
+ *
+ * `executeReply` is not exported (same constraint the sibling
+ * gateway-outbound-redact.test.ts documents), so the golden reference is a
+ * VERBATIM inline copy of the pre-extraction pipeline transforms (below).
+ * Every fixture is run through BOTH the inline reference and the extracted
+ * `outbound-send-path.ts` module; the test asserts byte-identical output.
+ * If the extraction ever drifts from the inline pipeline, these diverge.
+ *
+ * The reference below is copied line-for-line from the executeReply entry
+ * (normalize → redact → punctuation/bold → voice scrub), the effective-text
+ * spacing decision, the chunk decision, and the oversize re-split. The
+ * `redact` injected here is the same `redact()` the gateway's
+ * `redactOutboundText` wraps.
+ */
+
+// ── Verbatim inline reference (the code as it lived in gateway.ts) ──────────
+
+function referenceNormalize(rawText: string): { text: string; voiceReplaced: number } {
+  let text = normalizeParagraphBreaks(repairEscapedWhitespace(rawText))
+  // redactOutboundText(text, 'reply') → redact(text) (the stderr log is a
+  // side effect the pure module leaves to the injected redactor).
+  text = redact(text)
+  text = stripExcessBold(normalizePunctuation(text))
+  let voiceReplaced = 0
+  const scrub = scrubVoice(text)
+  if (scrub.replaced > 0) {
+    text = scrub.scrubbed
+    voiceReplaced = scrub.replaced
+  }
+  return { text, voiceReplaced }
+}
+
+function referenceEffectiveText(text: string, literalText: boolean): string {
+  return literalText ? text : addParagraphSpacers(text)
+}
+
+function referenceChunks(
+  effectiveText: string,
+  literalText: boolean,
+  limit: number,
+  chunkMode: 'length' | 'newline',
+): string[] {
+  return literalText
+    ? chunkText(effectiveText, limit, chunkMode)
+    : splitMarkdownChunks(effectiveText, limit)
+}
+
+function referenceResplit(chunk: string): string[] {
+  const subPieces = splitMarkdownChunks(chunk, RICH_MESSAGE_MAX_CHARS)
+  return subPieces.length > 1 ? subPieces : hardSliceToCap(chunk, RICH_MESSAGE_MAX_CHARS)
+}
+
+const injectedRedact = (text: string, _site: string): string => redact(text)
+
+// ── Representative outbound fixtures ────────────────────────────────────────
+
+const FIXTURES: Record<string, string> = {
+  plain: 'Hello there, this is a normal reply.',
+  multiParagraph: 'First paragraph here.\n\nSecond paragraph here.\n\nThird one.',
+  codeFence:
+    'Here is code:\n\n```ts\nconst x = 1 // a comment — with an em-dash\nconst y = 2\n```\n\nDone.',
+  emDashes: 'This — that — and the other thing. En–dash here too.',
+  excessBold: '**bold one** and **bold two** and **bold three** and **bold four**.',
+  // Assembled at runtime so the source holds no contiguous token literal
+  // (scripts/check-no-pii-secrets.mjs rejects contiguous sk-ant-… literals).
+  secretApiKey: `Your key is ${'sk-ant-' + 'api03-' + 'ABCD'.repeat(12)} and more text.`,
+  jsonEscaped: 'Line one\\nLine two\\n\\nParagraph two with a \\t tab.',
+  bullets: '- item one\n- item two\n- item three with a — dash',
+  oversize: 'x'.repeat(RICH_MESSAGE_MAX_CHARS + 5000),
+  multiChunkProse: Array.from({ length: 60 }, (_, i) => `Paragraph number ${i} with some filler text to grow length.`).join('\n\n'),
+}
+
+describe('outbound-send-path — normalizeOutboundBody parity with inline pipeline', () => {
+  for (const [name, raw] of Object.entries(FIXTURES)) {
+    it(`normalize byte-identical: ${name}`, () => {
+      const ref = referenceNormalize(raw)
+      const got = normalizeOutboundBody(raw, 'reply', injectedRedact)
+      expect(got.text).toBe(ref.text)
+      expect(got.voiceReplaced).toBe(ref.voiceReplaced)
+    })
+  }
+
+  it('secret fixture is actually redacted (mask fired)', () => {
+    const got = normalizeOutboundBody(FIXTURES.secretApiKey, 'reply', injectedRedact)
+    expect(got.text).not.toContain('sk-ant-' + 'api03-' + 'ABCD'.repeat(12))
+  })
+
+  it('em/en dashes are removed by the normalize pipeline', () => {
+    const got = normalizeOutboundBody(FIXTURES.emDashes, 'reply', injectedRedact)
+    // normalizePunctuation + scrubVoice between them strip em/en dashes from
+    // prose; the exact stage that fires is an implementation detail, but no
+    // raw em-dash survives the pipeline.
+    expect(got.text).not.toContain('—')
+  })
+})
+
+describe('outbound-send-path — effective text + chunk parity', () => {
+  for (const [name, raw] of Object.entries(FIXTURES)) {
+    for (const literalText of [true, false]) {
+      it(`effectiveText + chunks byte-identical: ${name} literal=${literalText}`, () => {
+        const { text } = normalizeOutboundBody(raw, 'reply', injectedRedact)
+        const refEff = referenceEffectiveText(text, literalText)
+        const gotEff = computeEffectiveText(text, literalText)
+        expect(gotEff).toBe(refEff)
+
+        const limit = RICH_MESSAGE_MAX_CHARS
+        const chunkMode: 'length' | 'newline' = 'length'
+        const refChunks = referenceChunks(refEff, literalText, limit, chunkMode)
+        const gotChunks = computeReplyChunks({ effectiveText: gotEff, literalText, limit, chunkMode })
+        expect(gotChunks).toEqual(refChunks)
+      })
+    }
+  }
+
+  it('literal newline-mode chunking parity on a large body', () => {
+    const body = FIXTURES.multiChunkProse
+    const limit = 400
+    expect(computeReplyChunks({ effectiveText: body, literalText: true, limit, chunkMode: 'newline' }))
+      .toEqual(chunkText(body, limit, 'newline'))
+  })
+
+  it('oversize chunk re-split parity + every piece under the wire cap', () => {
+    const oversize = FIXTURES.oversize
+    const ref = referenceResplit(oversize)
+    const got = resplitOversizeChunk(oversize)
+    expect(got).toEqual(ref)
+    for (const piece of got) expect(piece.length).toBeLessThanOrEqual(RICH_MESSAGE_MAX_CHARS)
+  })
+})
+
+describe('outbound-send-path — chunkText golden snapshots', () => {
+  it('length mode hard-cuts at the limit', () => {
+    expect(chunkText('abcdefghij', 4, 'length')).toEqual(['abcd', 'efgh', 'ij'])
+  })
+  it('newline mode prefers a paragraph break past halfway', () => {
+    expect(chunkText('aaaa\n\nbbbbbbbb', 8, 'newline')).toEqual(['aaaa\n', 'bbbbbbbb'])
+  })
+  it('short text is returned whole', () => {
+    expect(chunkText('short', 100, 'length')).toEqual(['short'])
+  })
+})
+
+// ── Cross-surface dedup suppression (the load-bearing singleton contract) ────
+//
+// The plan calls out that `outboundDedup` MUST be the SAME injected instance
+// across executeReply / answer-stream / turn-flush — a hoist-once bug (the
+// gateway landmine comment) broke all three. The dedup KEY on every surface is
+// the post-`normalizeOutboundBody` text, so a stream-path record must suppress
+// a reply-path check for the same normalized content on the same singleton.
+
+describe('outbound-send-path — cross-surface dedup suppression', () => {
+  it('stream-path record suppresses reply-path check on the shared singleton', () => {
+    const dedup = new OutboundDedupCache()
+    const chatId = '12345'
+    const threadId = undefined
+    const turnKey = 'turn-abc'
+    const t0 = 1_000_000
+
+    // Both surfaces normalize the same raw model text identically.
+    const rawFromModel = 'The answer is 42 — computed carefully across the whole set of inputs.'
+    const streamText = normalizeOutboundBody(rawFromModel, 'stream_reply', injectedRedact).text
+    const replyText = normalizeOutboundBody(rawFromModel, 'reply', injectedRedact).text
+    expect(replyText).toBe(streamText) // same key on every surface
+
+    // Miss before anything recorded.
+    expect(dedup.check(chatId, threadId, replyText, t0, turnKey)).toBeNull()
+
+    // Answer-stream records first (same singleton, same turnKey).
+    dedup.record(chatId, threadId, streamText, t0, turnKey)
+
+    // Reply path now sees the within-turn duplicate and is suppressed.
+    const hit = dedup.check(chatId, threadId, replyText, t0 + 500, turnKey)
+    expect(hit).not.toBeNull()
+    expect(hit!.matched).toBe(true)
+  })
+
+  it('a DISTINCT normalized reply is NOT suppressed (no false dedup)', () => {
+    const dedup = new OutboundDedupCache()
+    const chatId = '12345'
+    const turnKey = 'turn-abc'
+    const t0 = 2_000_000
+    const a = normalizeOutboundBody('First distinct answer with enough length to record.', 'stream_reply', injectedRedact).text
+    const b = normalizeOutboundBody('Second completely different answer, also long enough.', 'reply', injectedRedact).text
+    dedup.record(chatId, undefined, a, t0, turnKey)
+    expect(dedup.check(chatId, undefined, b, t0 + 500, turnKey)).toBeNull()
+  })
+
+  it('cross-turn identical content is NOT suppressed (distinct turnKeys)', () => {
+    const dedup = new OutboundDedupCache()
+    const chatId = '12345'
+    const t0 = 3_000_000
+    const text = normalizeOutboundBody('Same content typed twice across two turns, long enough to record.', 'reply', injectedRedact).text
+    dedup.record(chatId, undefined, text, t0, 'turn-1')
+    // A later, separate turn with the same content still delivers.
+    expect(dedup.check(chatId, undefined, text, t0 + 500, 'turn-2')).toBeNull()
+  })
+})

package/telegram-plugin/tests/pending-card-durability-wiring.test.ts

@@ -20,6 +20,16 @@ import { dirname, resolve } from 'node:path'
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const read = (p: string) => readFileSync(resolve(__dirname, '..', p), 'utf8')
 const GATEWAY = read('gateway/gateway.ts')
+// #2996 Phase 3: the in-memory approval-card Maps + their TTL sweeps moved
+// behind approval-card-stores.ts. The gateway now delegates each family sweep
+// to `<store>.sweep(now)`; the per-entry sweepExpiredEntries guard lives in the
+// store module.
+const CARD_STORES = read('gateway/approval-card-stores.ts')
+// #2996 Phase 5: the callback-query handler families (vault access/save,
+// mental-model, deferred-secret, grant wizard, operator-event, auth dashboard)
+// moved verbatim behind callback-query-handlers.ts; handler-body pins read
+// that module while staging/boot/sweep wiring stays pinned on gateway.ts.
+const CB_HANDLERS = read('gateway/callback-query-handlers.ts')
 
 function slice(src: string, header: string, span = 3000): string {
   const start = src.indexOf(header)
@@ -90,7 +100,7 @@ describe('boot restore (Defect A)', () => {
   })
 
   it('a Save tap on a restored (valueless) card degrades gracefully instead of writing empty', () => {
-    const fn = slice(GATEWAY, 'async function handleVaultRequestSaveCallback', 9000)
+    const fn = slice(CB_HANDLERS, 'async function handleVaultRequestSaveCallback', 9000)
     expect(fn).toMatch(/pending\.restoredWithoutValue \|\| pending\.value\.length === 0/)
     expect(fn).toMatch(/lost to a gateway restart/)
     expect(fn).toMatch(/buildVaultSaveFailedInbound/)
@@ -102,15 +112,15 @@ describe('boot restore (Defect A)', () => {
 describe('resolution clears the durable store (Defect A)', () => {
   it('vault access approve/deny remove from the store', () => {
     // deny path
-    const deny = slice(GATEWAY, 'async function handleVaultRequestAccessCallback', 4000)
+    const deny = slice(CB_HANDLERS, 'async function handleVaultRequestAccessCallback', 4000)
     expect(deny).toMatch(/pendingCardStore\.remove\(stageId\)/)
     // approve path (performVaultAccessApproval) removes on every terminal branch
-    const approve = slice(GATEWAY, 'async function performVaultAccessApproval', 9000)
+    const approve = slice(CB_HANDLERS, 'async function performVaultAccessApproval', 9000)
     expect(approve).toMatch(/pendingCardStore\.remove\(stageId\)/)
   })
 
   it('vault save resolution paths remove from the store', () => {
-    const fn = slice(GATEWAY, 'async function handleVaultRequestSaveCallback', 12000)
+    const fn = slice(CB_HANDLERS, 'async function handleVaultRequestSaveCallback', 12000)
     // discard / write-fail / success / passphrase-missing all clear the store.
     const count = (fn.match(/pendingCardStore\.remove\(stageId\)/g) ?? []).length
     expect(count).toBeGreaterThanOrEqual(3)
@@ -124,7 +134,7 @@ describe('resolution clears the durable store (Defect A)', () => {
   })
 
   it('mental model resolve removes from the store', () => {
-    const fn = slice(GATEWAY, 'async function handleMentalModelProposeCallback', 4000)
+    const fn = slice(CB_HANDLERS, 'async function handleMentalModelProposeCallback', 4000)
     expect(fn).toMatch(/pendingCardStore\.remove\(stageId\)/)
   })
 })
@@ -141,10 +151,13 @@ describe('TTL expiry wakes the parked agent (Defect B)', () => {
   })
 
   it('sweepExpiredApprovalCards runs all four family sweeps', () => {
+    // #2996 Phase 3: three families now delegate to their store's `.sweep(now)`;
+    // request_secret still routes via sweepSecretRequests (which also sweeps the
+    // transient armedSecretCaptures) and that in turn calls the store sweep.
     const fn = slice(GATEWAY, 'function sweepExpiredApprovalCards', 600)
-    expect(fn).toMatch(/sweepPendingVaultRequestAccesses\(now\)/)
-    expect(fn).toMatch(/sweepPendingVaultRequestSaves\(now\)/)
-    expect(fn).toMatch(/sweepPendingMentalModelProposes\(now\)/)
+    expect(fn).toMatch(/pendingVaultRequestAccesses\.sweep\(now\)/)
+    expect(fn).toMatch(/pendingVaultRequestSaves\.sweep\(now\)/)
+    expect(fn).toMatch(/pendingMentalModelProposes\.sweep\(now\)/)
     expect(fn).toMatch(/sweepSecretRequests\(now\)/)
   })
 
@@ -173,14 +186,20 @@ describe('TTL expiry wakes the parked agent (Defect B)', () => {
   })
 
   it('each family sweep is per-entry guarded via sweepExpiredEntries', () => {
-    for (const fnName of [
-      'function sweepPendingVaultRequestAccesses',
-      'function sweepPendingVaultRequestSaves',
-      'function sweepPendingMentalModelProposes',
-      'function sweepSecretRequests',
+    // #2996 Phase 3: the per-entry guard moved into the store module's `.sweep`,
+    // which is a thin pass-through to the same pure sweepExpiredEntries core.
+    // The three vault/mental families delegate to that store method; the
+    // request_secret family's sweepSecretRequests delegates to it too.
+    expect(CARD_STORES).toMatch(/sweep:\s*\(now\)\s*=>\s*\n?\s*sweepExpiredEntries\(/)
+    const secretSweep = slice(GATEWAY, 'function sweepSecretRequests', 500)
+    expect(secretSweep).toMatch(/pendingSecretRequests\.sweep\(now\)/)
+    for (const store of [
+      'const pendingVaultRequestAccesses = createSweepableCardStore',
+      'const pendingVaultRequestSaves = createSweepableCardStore',
+      'const pendingMentalModelProposes = createSweepableCardStore',
+      'const pendingSecretRequests = createSweepableCardStore',
     ]) {
-      const fn = slice(GATEWAY, fnName, 500)
-      expect(fn, fnName).toMatch(/sweepExpiredEntries\(/)
+      expect(GATEWAY, store).toContain(store)
     }
   })