switchroom 0.20.0 → 0.20.2

package/telegram-plugin/tests/buzz-mirror-correlation-store.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect } from 'vitest'
+import {
+  createCorrelationStore,
+  type CorrelationFsLike,
+} from '../gateway/buzz-mirror-correlation-store.js'
+
+/**
+ * In-memory fake filesystem implementing CorrelationFsLike. Shared across store
+ * instances to simulate a gateway restart against the SAME journal — the core
+ * of the #4222 fix (an edit_message correction must survive a restart).
+ */
+function makeFakeFs(): CorrelationFsLike & { files: Map<string, string>; dirs: Set<string> } {
+  const files = new Map<string, string>()
+  const dirs = new Set<string>()
+  const fdPaths = new Map<number, string>()
+  let nextFd = 3
+  return {
+    files,
+    dirs,
+    existsSync: (p) => files.has(p) || dirs.has(p),
+    mkdirSync: (p) => { dirs.add(p) },
+    readFileSync: (p) => {
+      if (!files.has(p)) throw new Error(`ENOENT ${p}`)
+      return files.get(p)!
+    },
+    writeFileSync: (p, data) => { files.set(p, data) },
+    renameSync: (from, to) => {
+      files.set(to, files.get(from) ?? '')
+      files.delete(from)
+    },
+    openSync: (p) => {
+      if (!files.has(p)) files.set(p, '')
+      const fd = nextFd++
+      fdPaths.set(fd, p)
+      return fd
+    },
+    writeSync: (fd, data) => {
+      const p = fdPaths.get(fd)!
+      files.set(p, (files.get(p) ?? '') + data)
+    },
+    fsyncSync: () => { /* no-op */ },
+    closeSync: (fd) => { fdPaths.delete(fd) },
+  }
+}
+
+const JP = '/state/buzz/mirror-correlation.jsonl'
+
+describe('createCorrelationStore — durable msg→Buzz correlation (#4222)', () => {
+  it('replays a persisted mapping into a NEW store instance (restart survival)', () => {
+    const fs = makeFakeFs()
+    const a = createCorrelationStore({ journalPath: JP, fs })
+    a.set('555:1001', { eventId: 'evt-A', channelId: 'chan-A' })
+    a.close()
+
+    // Fresh instance over the SAME journal — the mapping must reload.
+    const b = createCorrelationStore({ journalPath: JP, fs })
+    expect(b.get('555:1001')).toEqual({ eventId: 'evt-A', channelId: 'chan-A' })
+    expect(b.size()).toBe(1)
+  })
+
+  it('last-write-wins on a re-set key across a restart', () => {
+    const fs = makeFakeFs()
+    const a = createCorrelationStore({ journalPath: JP, fs })
+    a.set('555:1', { eventId: 'evt-old', channelId: 'chan-A' })
+    a.set('555:1', { eventId: 'evt-new', channelId: 'chan-A' })
+    a.close()
+
+    const b = createCorrelationStore({ journalPath: JP, fs })
+    expect(b.get('555:1')).toEqual({ eventId: 'evt-new', channelId: 'chan-A' })
+    expect(b.size()).toBe(1)
+  })
+
+  it('persists + replays the NIP-10 threadRoot (outbound thread continuity)', () => {
+    const fs = makeFakeFs()
+    const a = createCorrelationStore({ journalPath: JP, fs })
+    // A mirror that threaded under a deeper parent records a root distinct from
+    // its own event id — that root must survive a restart so a later reply can
+    // emit the correct NIP-10 `root` marker.
+    a.set('555:200', { eventId: 'evt-mid', channelId: 'chan-A', threadRoot: 'evt-root' })
+    a.close()
+
+    const b = createCorrelationStore({ journalPath: JP, fs })
+    expect(b.get('555:200')).toEqual({ eventId: 'evt-mid', channelId: 'chan-A', threadRoot: 'evt-root' })
+    // The record on disk actually carries the field (not just an in-memory echo).
+    expect(fs.files.get(JP) ?? '').toContain('"threadRoot":"evt-root"')
+  })
+
+  it('a pre-threadRoot journal record replays with threadRoot undefined (backward compat)', () => {
+    const fs = makeFakeFs()
+    fs.dirs.add('/state/buzz')
+    // A record written before threadRoot existed — no threadRoot key.
+    fs.files.set(JP, JSON.stringify({ key: '555:1', eventId: 'evt-A', channelId: 'chan-A' }) + '\n')
+    const s = createCorrelationStore({ journalPath: JP, fs })
+    const v = s.get('555:1')
+    expect(v?.eventId).toBe('evt-A')
+    expect(v?.channelId).toBe('chan-A')
+    expect(v?.threadRoot).toBeUndefined()
+  })
+
+  it('in-memory-only mode (no journalPath) never touches the fs but still bounds', () => {
+    const fs = makeFakeFs()
+    const s = createCorrelationStore({ capacity: 2, fs })
+    s.set('a', { eventId: 'e1', channelId: 'c' })
+    s.set('b', { eventId: 'e2', channelId: 'c' })
+    s.set('c', { eventId: 'e3', channelId: 'c' })
+    expect(s.get('a')).toBeUndefined() // evicted (FIFO, capacity 2)
+    expect(s.size()).toBe(2)
+    expect(fs.files.size).toBe(0) // no journal written
+  })
+
+  it('enforces the FIFO capacity bound in memory AND on disk after compaction', () => {
+    const fs = makeFakeFs()
+    const capacity = 4
+    const a = createCorrelationStore({ journalPath: JP, fs, capacity })
+    // Insert more than capacity — oldest keys evict.
+    for (let i = 0; i < 20; i++) a.set(`k:${i}`, { eventId: `e${i}`, channelId: 'c' })
+    expect(a.size()).toBe(capacity)
+    expect(a.get('k:0')).toBeUndefined()
+    expect(a.get('k:19')).toEqual({ eventId: 'e19', channelId: 'c' })
+    a.close()
+
+    // Restart: boot compaction must keep the on-disk journal bounded too — a new
+    // instance sees exactly `capacity` keys, and the compacted journal file has
+    // no more than `capacity` lines.
+    const b = createCorrelationStore({ journalPath: JP, fs, capacity })
+    expect(b.size()).toBe(capacity)
+    const lines = (fs.files.get(JP) ?? '').split('\n').filter((l) => l.trim())
+    expect(lines.length).toBeLessThanOrEqual(capacity)
+    expect(b.get('k:19')).toEqual({ eventId: 'e19', channelId: 'c' })
+  })
+
+  it('re-compacts in-session so the journal never grows unbounded', () => {
+    const fs = makeFakeFs()
+    const capacity = 4
+    const s = createCorrelationStore({ journalPath: JP, fs, capacity })
+    // Churn far more writes than capacity; the in-session compaction (at
+    // capacity * COMPACTION_FACTOR appends) must keep the file bounded.
+    for (let i = 0; i < 200; i++) s.set(`k:${i}`, { eventId: `e${i}`, channelId: 'c' })
+    const lines = (fs.files.get(JP) ?? '').split('\n').filter((l) => l.trim())
+    // Bounded by roughly capacity * COMPACTION_FACTOR (4*4=16) + the compacted
+    // baseline — assert it stays a small multiple of capacity, never 200.
+    expect(lines.length).toBeLessThan(capacity * 8)
+    expect(s.size()).toBe(capacity)
+    s.close()
+  })
+
+  it('tolerates a torn final journal line (crash mid-write)', () => {
+    const fs = makeFakeFs()
+    fs.dirs.add('/state/buzz')
+    fs.files.set(
+      JP,
+      JSON.stringify({ key: '1:1', eventId: 'e1', channelId: 'c' }) + '\n' + '{"key":"1:2","eventId', // truncated
+    )
+    const s = createCorrelationStore({ journalPath: JP, fs })
+    expect(s.get('1:1')).toEqual({ eventId: 'e1', channelId: 'c' })
+    expect(s.get('1:2')).toBeUndefined()
+  })
+
+  it('degrades to empty in-memory when the journal cannot be read', () => {
+    const fs = makeFakeFs()
+    fs.dirs.add('/state/buzz')
+    fs.files.set(JP, 'exists-but-unreadable')
+    const throwingFs: CorrelationFsLike = {
+      ...fs,
+      readFileSync: () => { throw new Error('EIO') },
+    }
+    const s = createCorrelationStore({ journalPath: JP, fs: throwingFs })
+    // No crash; store is empty and still usable.
+    expect(s.size()).toBe(0)
+    s.set('1:1', { eventId: 'e1', channelId: 'c' })
+    expect(s.get('1:1')).toEqual({ eventId: 'e1', channelId: 'c' })
+  })
+})

package/telegram-plugin/tests/buzz-mirror.test.ts

@@ -1,12 +1,17 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import {
   initBuzzMirror,
   getBuzzMirror,
   maybeBootBuzzMirror,
+  resolveCorrelationJournalPath,
   __resetBuzzMirrorForTests,
   CORRECTION_DEBOUNCE_MS,
 } from '../gateway/buzz-mirror.js'
 import type { OutboundToBuzzMessage } from '../gateway/ipc-protocol.js'
+import { buildThreadTags } from '../../src/buzz-gateway/transform.js'
 
 // Hub-side mirror behaviour (Phase 2b). The mirror is DOWNSTREAM of a delivered
 // Telegram copy; a publish is emitted via the attached peer sender. These tests
@@ -122,6 +127,193 @@ describe('BuzzMirror.mirrorReplyDelivered — routing + S1 owner guard', () => {
   })
 })
 
+describe('BuzzMirror.mirrorReplyDelivered — NIP-10 OUTBOUND thread continuity', () => {
+  beforeEach(() => __resetBuzzMirrorForTests())
+
+  // Helper: mirror a telegram-origin answer, complete its publish so the
+  // correlation store learns its event id, and return the published event id.
+  function mirrorTelegramAndComplete(
+    m: ReturnType<typeof mirrorWith>,
+    sender: ReturnType<typeof vi.fn>,
+    opts: { telegramKey: string; antecedentKey?: string; eventId: string },
+  ): OutboundToBuzzMessage {
+    m.mirrorReplyDelivered({
+      scrubbedText: 'answer',
+      ownerOriginChannel: 'telegram',
+      ownerEchoed: false,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: [opts.telegramKey],
+      antecedentTelegramMessageKey: opts.antecedentKey,
+    })
+    const call = sender.mock.calls[sender.mock.calls.length - 1][0] as OutboundToBuzzMessage
+    m.onPublishResult({ correlationId: call.correlationId, ok: true, eventId: opts.eventId })
+    return call
+  }
+
+  it('threads a telegram-origin reply UNDER its antecedent`s mirrored event (root === parent for a top-level antecedent)', () => {
+    const sender = vi.fn(() => true)
+    const m = mirrorWith(sender, { defaultChannelId: 'grp' })
+
+    // A1: a top-level telegram-origin answer, published as evt-A.
+    mirrorTelegramAndComplete(m, sender, { telegramKey: '555:100', eventId: 'evt-A' })
+    // A2: a telegram-origin answer that REPLIES to A1's Telegram message.
+    m.mirrorReplyDelivered({
+      scrubbedText: 'follow-up',
+      ownerOriginChannel: 'telegram',
+      ownerEchoed: false,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:200'],
+      antecedentTelegramMessageKey: '555:100',
+    })
+
+    const msg = sender.mock.calls[sender.mock.calls.length - 1][0] as OutboundToBuzzMessage
+    // The immediate parent is A1's event; A1 was top-level so IT is the root.
+    expect(msg.replyToEventId).toBe('evt-A')
+    expect(msg.threadRootId).toBe('evt-A')
+    // NIP-10: root === parent collapses to a single reply-to-root e-tag.
+    expect(buildThreadTags({ threadRootId: msg.threadRootId, replyToEventId: msg.replyToEventId })).toEqual([
+      ['e', 'evt-A', '', 'root'],
+    ])
+  })
+
+  it('emits DISTINCT root + reply markers for a reply into a DEEPER thread', () => {
+    const sender = vi.fn(() => true)
+    const m = mirrorWith(sender, { defaultChannelId: 'grp' })
+
+    // A0 top-level → evt-root.
+    mirrorTelegramAndComplete(m, sender, { telegramKey: '555:100', eventId: 'evt-root' })
+    // A1 replies to A0 → threads under evt-root; published as evt-mid. Its
+    // recorded threadRoot must stay evt-root (NOT evt-mid).
+    mirrorTelegramAndComplete(m, sender, {
+      telegramKey: '555:200',
+      antecedentKey: '555:100',
+      eventId: 'evt-mid',
+    })
+    // A2 replies to A1 → parent is evt-mid, but the thread root is still evt-root.
+    m.mirrorReplyDelivered({
+      scrubbedText: 'deep',
+      ownerOriginChannel: 'telegram',
+      ownerEchoed: false,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:300'],
+      antecedentTelegramMessageKey: '555:200',
+    })
+
+    const msg = sender.mock.calls[sender.mock.calls.length - 1][0] as OutboundToBuzzMessage
+    expect(msg.replyToEventId).toBe('evt-mid') // immediate parent
+    expect(msg.threadRootId).toBe('evt-root') // thread root, NOT the parent
+    expect(buildThreadTags({ threadRootId: msg.threadRootId, replyToEventId: msg.replyToEventId })).toEqual([
+      ['e', 'evt-root', '', 'root'],
+      ['e', 'evt-mid', '', 'reply'],
+    ])
+  })
+
+  it('a reply whose antecedent is a correlation-store MISS mirrors FLAT (no wrong/guessed tag)', () => {
+    const logs: string[] = []
+    __resetBuzzMirrorForTests()
+    const sender = vi.fn(() => true)
+    const m = initBuzzMirror({ mode: 'both', agentName: 'klanker', defaultChannelId: 'grp', log: (l) => logs.push(l) })
+    m.attachSender(sender)
+
+    // The antecedent key was NEVER mirrored (e.g. it is the user's own inbound
+    // message) — the lookup misses. The mirror must NOT invent a thread tag.
+    m.mirrorReplyDelivered({
+      scrubbedText: 'answer',
+      ownerOriginChannel: 'telegram',
+      ownerEchoed: false,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:200'],
+      antecedentTelegramMessageKey: '555:100', // not in the store
+    })
+
+    expect(sender).toHaveBeenCalledTimes(1)
+    const msg = sender.mock.calls[0][0] as OutboundToBuzzMessage
+    expect(msg.replyToEventId).toBeUndefined()
+    expect(msg.threadRootId).toBeUndefined()
+    // The flat fallback still PUBLISHES (top-level), just with no thread tags.
+    expect(buildThreadTags({ threadRootId: msg.threadRootId, replyToEventId: msg.replyToEventId })).toEqual([])
+    expect(logs.some((l) => /outbound thread MISS/.test(l))).toBe(true)
+  })
+
+  it('#4299: a FOREIGN-CHANNEL antecedent mirrors FLAT (no cross-group e-tag)', () => {
+    const logs: string[] = []
+    __resetBuzzMirrorForTests()
+    const sender = vi.fn(() => true)
+    // Telegram-origin mirrors post into 'grp'; the antecedent below was mirrored
+    // into a DIFFERENT (buzz-origin) channel 'chan-A'.
+    const m = initBuzzMirror({ mode: 'both', agentName: 'klanker', defaultChannelId: 'grp', log: (l) => logs.push(l) })
+    m.attachSender(sender)
+
+    // Record '555:100' → an event published into buzz channel 'chan-A' (its
+    // channelId comes from ownerBuzzCoords, NOT defaultChannelId). This is the
+    // exact shape #4299 warns about: a parent recorded via a buzz-origin
+    // threaded reply whose channelId came from the inbound event's own h-tag.
+    m.mirrorReplyDelivered({
+      scrubbedText: 'buzz answer',
+      ownerOriginChannel: 'buzz',
+      ownerBuzzCoords: { channelId: 'chan-A', eventId: 'evt-buzz', threadRoot: 'root-buzz' },
+      ownerEchoed: true,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:100'],
+    })
+    const buzzCall = sender.mock.calls[sender.mock.calls.length - 1][0] as OutboundToBuzzMessage
+    expect(buzzCall.channelId).toBe('chan-A')
+    m.onPublishResult({ correlationId: buzzCall.correlationId, ok: true, eventId: 'evt-buzz' })
+
+    // A later TELEGRAM-origin answer replies to '555:100'. Its target channel is
+    // 'grp' ≠ 'chan-A' — threading under evt-buzz would carry e-tags into the
+    // foreign 'chan-A' group. It MUST mirror flat instead.
+    m.mirrorReplyDelivered({
+      scrubbedText: 'tele follow-up',
+      ownerOriginChannel: 'telegram',
+      ownerEchoed: false,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:200'],
+      antecedentTelegramMessageKey: '555:100',
+    })
+
+    const msg = sender.mock.calls[sender.mock.calls.length - 1][0] as OutboundToBuzzMessage
+    expect(msg.channelId).toBe('grp')
+    // FLAT: no thread tags at all — crucially NOT evt-buzz / root-buzz.
+    expect(msg.replyToEventId).toBeUndefined()
+    expect(msg.threadRootId).toBeUndefined()
+    expect(buildThreadTags({ threadRootId: msg.threadRootId, replyToEventId: msg.replyToEventId })).toEqual([])
+    // Logged distinctly as a cross-channel guard, NOT as an eviction MISS.
+    expect(logs.some((l) => /outbound thread CROSS-CHANNEL/.test(l))).toBe(true)
+    expect(logs.some((l) => /outbound thread MISS/.test(l))).toBe(false)
+  })
+
+  it('#4301: a quote-opt-in DEFAULT antecedent miss is NOT logged as an eviction MISS', () => {
+    const logs: string[] = []
+    __resetBuzzMirrorForTests()
+    const sender = vi.fn(() => true)
+    const m = initBuzzMirror({ mode: 'both', agentName: 'klanker', defaultChannelId: 'grp', log: (l) => logs.push(l) })
+    m.attachSender(sender)
+
+    // The antecedent is the latest INBOUND user message (quote-opt-in default),
+    // which is never in the correlation store — an EXPECTED miss, not eviction.
+    m.mirrorReplyDelivered({
+      scrubbedText: 'answer',
+      ownerOriginChannel: 'telegram',
+      ownerEchoed: false,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:200'],
+      antecedentTelegramMessageKey: '555:100', // latest inbound, never mirrored
+      antecedentIsQuoteOptInDefault: true,
+    })
+
+    expect(sender).toHaveBeenCalledTimes(1)
+    const msg = sender.mock.calls[0][0] as OutboundToBuzzMessage
+    // Still a flat top-level post.
+    expect(msg.replyToEventId).toBeUndefined()
+    expect(msg.threadRootId).toBeUndefined()
+    // The expected default-quote miss must NOT masquerade as an eviction MISS,
+    // so a genuine eviction miss stays distinguishable in the logs.
+    expect(logs.some((l) => /outbound thread MISS/.test(l))).toBe(false)
+    expect(logs.some((l) => /default-quote/.test(l))).toBe(true)
+  })
+})
+
 describe('BuzzMirror.mirrorCorrection — debounced, only for mirrored messages', () => {
   beforeEach(() => {
     __resetBuzzMirrorForTests()
@@ -204,6 +396,110 @@ describe('BuzzMirror.mirrorCorrection — debounced, only for mirrored messages'
   })
 })
 
+describe('BuzzMirror correction correlation SURVIVES a gateway restart (#4222)', () => {
+  let dir: string
+  let journalPath: string
+
+  beforeEach(() => {
+    __resetBuzzMirrorForTests()
+    vi.useFakeTimers()
+    dir = mkdtempSync(join(tmpdir(), 'buzz-mirror-corr-'))
+    journalPath = join(dir, 'buzz', 'mirror-correlation.jsonl')
+  })
+  afterEach(() => {
+    __resetBuzzMirrorForTests()
+    vi.useRealTimers()
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  function bootMirror(sender: (m: OutboundToBuzzMessage) => boolean) {
+    const m = initBuzzMirror({
+      mode: 'both',
+      agentName: 'klanker',
+      defaultChannelId: 'default-chan',
+      correlationJournalPath: journalPath,
+    })
+    m.attachSender(sender)
+    return m
+  }
+
+  it('an edit_message on a pre-restart-mirrored answer STILL emits the superseding correction', () => {
+    // --- Session 1: mirror an answer and record its published Buzz event. ---
+    const sender1 = vi.fn(() => true)
+    const m1 = bootMirror(sender1)
+    m1.mirrorReplyDelivered({
+      scrubbedText: 'answer',
+      ownerOriginChannel: 'buzz',
+      ownerBuzzCoords: BUZZ_COORDS,
+      ownerEchoed: true,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:1001'],
+    })
+    const correlationId = sender1.mock.calls[0][0].correlationId
+    m1.onPublishResult({ correlationId, ok: true, eventId: 'published-evt' })
+
+    // --- Restart: a NEW BuzzMirror over the SAME journal (map reloads from disk).
+    __resetBuzzMirrorForTests() // closes m1's journal fd
+    const sender2 = vi.fn(() => true)
+    const m2 = bootMirror(sender2)
+
+    // An edit lands AFTER the restart on a message mirrored BEFORE it. On today's
+    // in-memory-only code the reloaded map is empty and this is silently skipped;
+    // with the durable journal the correction still fires.
+    m2.mirrorCorrection({ telegramMessageKey: '555:1001', scrubbedText: 'corrected' })
+    vi.advanceTimersByTime(CORRECTION_DEBOUNCE_MS + 1000)
+
+    expect(sender2).toHaveBeenCalledTimes(1)
+    const corr = sender2.mock.calls[0][0]
+    expect(corr.payload).toEqual({
+      kind: 'correction',
+      text: 'corrected',
+      targetEventId: 'published-evt',
+    })
+    expect(m2.getCorrectionMisses()).toBe(0)
+  })
+
+  it('a correction on a truly-unknown key logs a LOUD miss (never silent) and never publishes', () => {
+    const logs: string[] = []
+    __resetBuzzMirrorForTests()
+    const sender = vi.fn(() => true)
+    const m = initBuzzMirror({
+      mode: 'both',
+      agentName: 'klanker',
+      defaultChannelId: 'default-chan',
+      correlationJournalPath: journalPath,
+      log: (msg) => logs.push(msg),
+    })
+    m.attachSender(sender)
+
+    m.mirrorCorrection({ telegramMessageKey: '555:404', scrubbedText: 'fixed' })
+    vi.advanceTimersByTime(CORRECTION_DEBOUNCE_MS + 1000)
+
+    expect(sender).not.toHaveBeenCalled()
+    expect(m.getCorrectionMisses()).toBe(1)
+    expect(logs.some((l) => /CORRECTION MISS/.test(l))).toBe(true)
+  })
+})
+
+describe('resolveCorrelationJournalPath — distinct from the sidecar dedup journal', () => {
+  it('derives mirror-correlation.jsonl under $TELEGRAM_STATE_DIR/buzz (NOT journal.jsonl)', () => {
+    const p = resolveCorrelationJournalPath({ TELEGRAM_STATE_DIR: '/state/agent/telegram' })
+    expect(p).toBe('/state/agent/telegram/buzz/mirror-correlation.jsonl')
+    // Must not collide with the sidecar's journal.jsonl on the shared buzz dir.
+    expect(p).not.toContain('journal.jsonl')
+  })
+
+  it('honours the BUZZ_MIRROR_CORRELATION_PATH override', () => {
+    expect(
+      resolveCorrelationJournalPath({ BUZZ_MIRROR_CORRELATION_PATH: '/custom/corr.jsonl' }),
+    ).toBe('/custom/corr.jsonl')
+  })
+
+  it('returns undefined (in-memory only) when TELEGRAM_STATE_DIR is unset', () => {
+    expect(resolveCorrelationJournalPath({})).toBeUndefined()
+  })
+})
+
 describe('maybeBootBuzzMirror — dark by default (S2)', () => {
   beforeEach(() => __resetBuzzMirrorForTests())
 

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

@@ -18,6 +18,7 @@ import {
   computeReplyChunks,
   resplitOversizeChunk,
   chunkText,
+  resolveMirrorAntecedentKey,
 } from '../gateway/outbound-send-path.js'
 
 /**
@@ -413,3 +414,26 @@ describe('outbound-send-path — temporal pass wiring (#3501)', () => {
     expect(viaSeam).toBe(viaModule)
   })
 })
+
+// ── Buzz-mirror antecedent gating (#4300 / #4301) ──────────────────────────
+describe('resolveMirrorAntecedentKey — Buzz-mirror antecedent gating', () => {
+  it('#4300: replyMode "off" stamps NO antecedent → Buzz mirror stays flat', () => {
+    // With reply-mode off the Telegram copy renders no reply, so the Buzz copy
+    // must not thread either — otherwise the surfaces diverge.
+    expect(resolveMirrorAntecedentKey('555', 100, 'off')).toBeUndefined()
+  })
+
+  it('stamps the antecedent for reply-rendering modes (first / all)', () => {
+    expect(resolveMirrorAntecedentKey('555', 100, 'first')).toBe('555:100')
+    expect(resolveMirrorAntecedentKey('555', 100, 'all')).toBe('555:100')
+  })
+
+  it('#4301: a non-numeric reply_to (NaN) stamps NO antecedent (no chat:NaN key)', () => {
+    expect(resolveMirrorAntecedentKey('555', Number('not-a-number'), 'first')).toBeUndefined()
+    expect(resolveMirrorAntecedentKey('555', NaN, 'all')).toBeUndefined()
+  })
+
+  it('stamps NO antecedent when there is no reply_to', () => {
+    expect(resolveMirrorAntecedentKey('555', undefined, 'first')).toBeUndefined()
+  })
+})