switchroom 0.19.48 → 0.20.0

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

@@ -0,0 +1,242 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  initBuzzMirror,
+  getBuzzMirror,
+  maybeBootBuzzMirror,
+  __resetBuzzMirrorForTests,
+  CORRECTION_DEBOUNCE_MS,
+} from '../gateway/buzz-mirror.js'
+import type { OutboundToBuzzMessage } from '../gateway/ipc-protocol.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
+// spy the sender to assert WHETHER and WITH WHAT a publish is issued.
+
+function mirrorWith(sender: (m: OutboundToBuzzMessage) => boolean, opts?: { defaultChannelId?: string }) {
+  const m = initBuzzMirror({
+    mode: 'both',
+    agentName: 'klanker',
+    defaultChannelId: opts?.defaultChannelId ?? 'default-chan',
+  })
+  m.attachSender(sender)
+  return m
+}
+
+const BUZZ_COORDS = { channelId: 'chan-A', eventId: 'evt-1', threadRoot: 'root-1' }
+
+describe('BuzzMirror.mirrorReplyDelivered — routing + S1 owner guard', () => {
+  beforeEach(() => __resetBuzzMirrorForTests())
+
+  it('T-6b (hub): a live buzz owner + un-echoed reply + a recent different-origin turn ⇒ NO publish', () => {
+    const sender = vi.fn(() => true)
+    const m = mirrorWith(sender)
+    m.mirrorReplyDelivered({
+      scrubbedText: 'answer',
+      ownerOriginChannel: 'buzz',
+      ownerBuzzCoords: BUZZ_COORDS,
+      ownerEchoed: false, // the reply did NOT echo this buzz turn's id
+      hasRecentDifferentOriginTurn: true, // a prior Telegram DM turn is live/recent
+      telegramMessageKeys: ['555:1001'],
+    })
+    // The S1 guard must refuse the ambiguous threaded publish — Telegram-only.
+    expect(sender).not.toHaveBeenCalled()
+  })
+
+  it('publishes a THREADED reply when the buzz owner id was echoed', () => {
+    const sender = vi.fn(() => true)
+    const m = mirrorWith(sender)
+    m.mirrorReplyDelivered({
+      scrubbedText: 'answer',
+      ownerOriginChannel: 'buzz',
+      ownerBuzzCoords: BUZZ_COORDS,
+      ownerEchoed: true,
+      hasRecentDifferentOriginTurn: true, // irrelevant once echoed
+      telegramMessageKeys: ['555:1001'],
+    })
+    expect(sender).toHaveBeenCalledTimes(1)
+    const msg = sender.mock.calls[0][0]
+    expect(msg.type).toBe('outbound_to_buzz')
+    expect(msg.channelId).toBe(BUZZ_COORDS.channelId)
+    expect(msg.replyToEventId).toBe(BUZZ_COORDS.eventId)
+    expect(msg.threadRootId).toBe(BUZZ_COORDS.threadRoot)
+    expect(msg.payload).toEqual({ kind: 'message', text: 'answer' })
+    expect(msg.agentName).toBe('klanker')
+  })
+
+  it('publishes a buzz-origin threaded reply when un-echoed but NO different-origin turn exists', () => {
+    const sender = vi.fn(() => true)
+    const m = mirrorWith(sender)
+    m.mirrorReplyDelivered({
+      scrubbedText: 'answer',
+      ownerOriginChannel: 'buzz',
+      ownerBuzzCoords: BUZZ_COORDS,
+      ownerEchoed: false,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:1001'],
+    })
+    expect(sender).toHaveBeenCalledTimes(1)
+  })
+
+  it('mirrors a TELEGRAM-origin answer as a fresh top-level post to defaultChannelId', () => {
+    const sender = vi.fn(() => true)
+    const m = mirrorWith(sender, { defaultChannelId: 'grp-top' })
+    m.mirrorReplyDelivered({
+      scrubbedText: 'tele answer',
+      ownerOriginChannel: 'telegram',
+      ownerEchoed: false,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:2002'],
+    })
+    expect(sender).toHaveBeenCalledTimes(1)
+    const msg = sender.mock.calls[0][0]
+    expect(msg.channelId).toBe('grp-top')
+    expect(msg.replyToEventId).toBeUndefined() // top-level, not a thread reply
+    expect(msg.threadRootId).toBeUndefined()
+  })
+
+  it('drops a telegram-origin mirror when no default channel is configured', () => {
+    const sender = vi.fn(() => true)
+    const m = mirrorWith(sender, { defaultChannelId: '' })
+    m.mirrorReplyDelivered({
+      scrubbedText: 'x',
+      ownerOriginChannel: 'telegram',
+      ownerEchoed: false,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:3003'],
+    })
+    expect(sender).not.toHaveBeenCalled()
+  })
+
+  it('never throws even if the sender throws (the Telegram copy is already delivered)', () => {
+    const sender = vi.fn(() => { throw new Error('peer exploded') })
+    const m = mirrorWith(sender)
+    expect(() =>
+      m.mirrorReplyDelivered({
+        scrubbedText: 'x',
+        ownerOriginChannel: 'telegram',
+        ownerEchoed: false,
+        hasRecentDifferentOriginTurn: false,
+        telegramMessageKeys: ['555:4004'],
+      }),
+    ).not.toThrow()
+  })
+})
+
+describe('BuzzMirror.mirrorCorrection — debounced, only for mirrored messages', () => {
+  beforeEach(() => {
+    __resetBuzzMirrorForTests()
+    vi.useFakeTimers()
+  })
+  // restore real timers after each via afterEach-less pattern
+  it('no-ops for a Telegram message that was never mirrored to Buzz', () => {
+    const sender = vi.fn(() => true)
+    const m = mirrorWith(sender)
+    m.mirrorCorrection({ telegramMessageKey: '555:9999', scrubbedText: 'fixed' })
+    vi.advanceTimersByTime(CORRECTION_DEBOUNCE_MS + 1000)
+    expect(sender).not.toHaveBeenCalled()
+    vi.useRealTimers()
+  })
+
+  it('publishes a debounced correction for a message recorded via onPublishResult', () => {
+    const sender = vi.fn(() => true)
+    const m = mirrorWith(sender)
+    // First: a delivered buzz publish, then its OK result records the mapping.
+    m.mirrorReplyDelivered({
+      scrubbedText: 'answer',
+      ownerOriginChannel: 'buzz',
+      ownerBuzzCoords: BUZZ_COORDS,
+      ownerEchoed: true,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:1001'],
+    })
+    const correlationId = sender.mock.calls[0][0].correlationId
+    m.onPublishResult({ correlationId, ok: true, eventId: 'published-evt' })
+    sender.mockClear()
+
+    m.mirrorCorrection({ telegramMessageKey: '555:1001', scrubbedText: 'corrected' })
+    // Debounced: nothing before the window elapses.
+    vi.advanceTimersByTime(CORRECTION_DEBOUNCE_MS - 10)
+    expect(sender).not.toHaveBeenCalled()
+    vi.advanceTimersByTime(20)
+    expect(sender).toHaveBeenCalledTimes(1)
+    const corr = sender.mock.calls[0][0]
+    expect(corr.payload).toEqual({ kind: 'correction', text: 'corrected', targetEventId: 'published-evt' })
+    vi.useRealTimers()
+  })
+
+  it('S4/F6: two rapid edits COALESCE to a SINGLE published correction (last-write-wins)', () => {
+    const sender = vi.fn(() => true)
+    const m = mirrorWith(sender)
+    // Record a mirrored message so there is a Buzz event to correct.
+    m.mirrorReplyDelivered({
+      scrubbedText: 'answer',
+      ownerOriginChannel: 'buzz',
+      ownerBuzzCoords: BUZZ_COORDS,
+      ownerEchoed: true,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:1001'],
+    })
+    const correlationId = sender.mock.calls[0][0].correlationId
+    m.onPublishResult({ correlationId, ok: true, eventId: 'published-evt' })
+    sender.mockClear()
+
+    // Edit #1 at t=0 arms a timer for t=DEBOUNCE. Edit #2 arrives INSIDE the
+    // window and must CLEAR edit #1's timer (buzz-mirror.ts:192-193) so only the
+    // latest text is ever published, and only once.
+    m.mirrorCorrection({ telegramMessageKey: '555:1001', scrubbedText: 'first edit' })
+    vi.advanceTimersByTime(CORRECTION_DEBOUNCE_MS - 5_000) // still inside the window
+    m.mirrorCorrection({ telegramMessageKey: '555:1001', scrubbedText: 'second edit' })
+
+    // Step PAST edit #1's original deadline. If coalescing were broken, edit #1's
+    // timer would fire here — it must NOT (it was cleared).
+    vi.advanceTimersByTime(6_000)
+    expect(sender).not.toHaveBeenCalled()
+
+    // Reach edit #2's deadline: EXACTLY ONE correction, carrying the LATEST text.
+    vi.advanceTimersByTime(CORRECTION_DEBOUNCE_MS)
+    expect(sender).toHaveBeenCalledTimes(1)
+    expect(sender.mock.calls[0][0].payload).toEqual({
+      kind: 'correction',
+      text: 'second edit',
+      targetEventId: 'published-evt',
+    })
+    vi.useRealTimers()
+  })
+})
+
+describe('maybeBootBuzzMirror — dark by default (S2)', () => {
+  beforeEach(() => __resetBuzzMirrorForTests())
+
+  it('stays dark (returns null, getBuzzMirror null) when BUZZ_ENABLED is unset', () => {
+    const booted = maybeBootBuzzMirror(() => true, {})
+    expect(booted).toBeNull()
+    expect(getBuzzMirror()).toBeNull()
+  })
+
+  it('stays dark when enabled but mode is off/origin (S2 degrade)', () => {
+    expect(maybeBootBuzzMirror(() => true, { BUZZ_ENABLED: '1', BUZZ_MIRROR: 'off' })).toBeNull()
+    expect(maybeBootBuzzMirror(() => true, { BUZZ_ENABLED: '1', BUZZ_MIRROR: 'origin' })).toBeNull()
+    expect(getBuzzMirror()).toBeNull()
+  })
+
+  it('boots when enabled AND mode both, wiring the sender', () => {
+    const sender = vi.fn(() => true)
+    const booted = maybeBootBuzzMirror(sender, {
+      BUZZ_ENABLED: '1',
+      BUZZ_MIRROR: 'both',
+      SWITCHROOM_AGENT_NAME: 'klanker',
+      BUZZ_CHANNEL_IDS: 'grp-top',
+    })
+    expect(booted).not.toBeNull()
+    expect(getBuzzMirror()).toBe(booted)
+    // Sender is wired: a telegram-origin mirror flows to it.
+    booted!.mirrorReplyDelivered({
+      scrubbedText: 'x',
+      ownerOriginChannel: 'telegram',
+      ownerEchoed: false,
+      hasRecentDifferentOriginTurn: false,
+      telegramMessageKeys: ['555:1'],
+    })
+    expect(sender).toHaveBeenCalledTimes(1)
+  })
+})

package/telegram-plugin/tests/buzz-origin-stamp-gate.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect } from 'vitest'
+import { tmpdir } from 'node:os'
+import {
+  handleSessionEvent,
+  type StreamRenderDeps,
+} from '../gateway/stream-render.js'
+import { OutboundDedupCache } from '../recent-outbound-dedup.js'
+import { FlushedTurnSupersedeRegistry } from '../flushed-turn-supersede.js'
+import { BackstopDeliveryLedger } from '../gateway/backstop-delivery.js'
+import { redact } from '../secret-detect/redact.js'
+import type { CurrentTurn } from '../gateway/gateway.js'
+
+/**
+ * Buzz co-channel — Phase 2a MINOR-1 gate guard (behavioural, non-mocked).
+ *
+ * `stream-render.ts` computes `BUZZ_ORIGIN_STAMP_ACTIVE` at import time from
+ * `BUZZ_ENABLED` + the routing kill switch; when it is false the turn ctor
+ * stamps a plain Telegram origin WITHOUT calling `parseChannelOrigin`, so the
+ * Telegram-only hot path is byte-identical.
+ *
+ * This runs with `BUZZ_ENABLED` UNSET (the default for every Telegram-only
+ * agent), i.e. the gate is OFF. The OUTCOME it pins: a turn whose rawContent
+ * carries a REAL buzz `<channel source="buzz" …>` envelope is STILL stamped
+ * `telegram` with no coords — proving the parser was not consulted. If someone
+ * deleted the gate, the parser would run on this same input and stamp
+ * `originChannel: 'buzz'` with coords, and this test would fail. That makes it a
+ * true regression guard for the flag-off invariant, not a code-path assertion.
+ */
+
+// A real captured buzz double-wrap envelope (same fixture as channel-route T-1c).
+const CHAN = '6d18fdfe-601b-4e6c-82b5-aed8ac002dd4'
+const EVT = '5e472ba250c45ea6f609f71d05e979a6992670ab12fd07781096bdcee6458c6b'
+const PUB = 'fc97c126b783147458e8ea640cd714af5f2a2dd1dc39b27afc3b013df24faf1b'
+const BUZZ_RAW =
+  `<channel source="switchroom-telegram" source="buzz" buzz_channel_id="${CHAN}" ` +
+  `buzz_event_id="${EVT}" buzz_pubkey="${PUB}" buzz_thread_root="${EVT}" user="buzz:fc97…af1b">\n` +
+  `<channel source="buzz" buzz_channel_id="${CHAN}" buzz_event_id="${EVT}" buzz_pubkey="${PUB}" ` +
+  `buzz_thread_root="${EVT}" user="buzz:fc97…af1b">[canary] inbound-path test</channel>\n</channel>`
+
+const CHAT = '1001'
+
+function makeStreamDeps(): { deps: StreamRenderDeps; getTurn: () => CurrentTurn | null } {
+  let curTurn: CurrentTurn | null = null
+  const key = (c: string, t?: number | null) => `${c}:${t ?? 'main'}`
+  const noop = () => {}
+  const fakeEA = {
+    claimOrDowngradePing: (_i: unknown, _s: unknown, _a: unknown, disabled: () => void) => disabled(),
+    markSubstantiveFinalDelivered: (fn: () => void) => fn(),
+    finalizeCard: (fn: () => void) => fn(),
+  }
+  const deps = {
+    ANSWER_LANE: { visibleEnabled: false } as unknown,
+    CAPTURED_PROSE_DELIVERY_ENABLED: false,
+    CONTEXT_EXHAUSTION_COOLDOWN_MS: 600000,
+    DELIVERY_CONFIRM_ENABLED: false,
+    FEED_REOPEN_AFTER_ACK_ENABLED: false,
+    HANDBACK_PRETURN_ENABLED: false,
+    HISTORY_ENABLED: false,
+    LIVENESS_TERMINAL_HONESTY: true,
+    OBLIGATION_LEDGER_ENABLED: false,
+    ORPHANED_REPLY_STREAM_WINDOW_MS: 120000,
+    SILENCE_LIVENESS_PRODUCTION: false,
+    STATE_DIR: tmpdir(),
+    TURN_FLUSH_SAFETY_ENABLED: true,
+    TURN_PREVIEW_MAX: 200,
+    activeDraftStreams: new Map(),
+    activeStatusReactions: new Map(),
+    activeTurnStartedAt: new Map(),
+    backstopDeliveryLedger: new BackstopDeliveryLedger(),
+    bot: { api: {} },
+    flushedTurnSupersede: new FlushedTurnSupersedeRegistry(),
+    idleTracker: { noteEvent: noop },
+    lastPtyPreviewByChat: new Map(),
+    obligationLedger: { close: noop, noteTurnEnded: noop },
+    outboundDedup: new OutboundDedupCache(),
+    pendingCrossTurnGate: new Map(),
+    preambleSuppressor: { dropNow: noop, flushNow: noop, onText: noop, onTool: noop, reset: noop },
+    progressDriver: null,
+    reactionTransitionCounts: new Map(),
+    suppressPtyPreview: new Set(),
+    toolFlightTracker: { inFlightCount: () => 0 },
+    deliveryQueue: {},
+    handbackPreturnSignal: { tryAdopt: () => null },
+    sessionModelSource: { noteTranscriptModel: noop },
+    typingWrapper: { drainAll: noop, onToolResult: noop, onToolUse: noop },
+    robustApiCall: (fn: () => Promise<unknown>) => fn(),
+    swallowingApiCall: async (fn: () => Promise<unknown>) => { try { return await fn() } catch { return undefined } },
+    getCurrentTurn: () => curTurn,
+    getLastContextExhaustionWarningAt: () => 0,
+    setLastContextExhaustionWarningAt: noop,
+    getPendingPtyPartial: () => null,
+    setPendingPtyPartial: noop,
+    setCurrentTurn: (t: CurrentTurn) => { curTurn = t },
+    cardDrainGate: (_t: unknown, _ea: unknown, run: () => void) => run(),
+    clearActivitySummary: noop,
+    clearAnswerReadyFlushTimeout: noop,
+    closeActivityLane: noop,
+    closeProgressLane: noop,
+    completeProgressCardTurn: null,
+    composeTurnActivity: () => null,
+    confirmMemoryLegibility: noop,
+    deliverAnswer: async () => ({ sentIds: [4242], chunkCount: 1, delivered: true, exhausted: false }),
+    deliverCapturedProse: async () => {},
+    drainActivitySummary: async () => {},
+    emissionAuthorityFor: () => fakeEA,
+    emitTurnRecord: noop,
+    endCurrentTurnAtomic: () => null,
+    extractUserPromptPreview: () => null,
+    finalizeStatusReaction: noop,
+    flushPendingNarrativeAtTurnEnd: noop,
+    getPinnedProgressCardMessageId: null,
+    handlePtyPartial: noop,
+    isDmChatId: () => true,
+    isLegitimatelyWorking: () => false,
+    makeNarrativeGate: () => ({ show: noop, stage: noop, resolveOnTool: noop, flushAtTurnEnd: noop, teardown: noop }),
+    promoteQueuedStatus: noop,
+    purgeReactionTracking: noop,
+    redactOutboundText: (t: string) => redact(t),
+    rememberRecentTurn: noop,
+    resetAnswerReadyFlushTimeout: noop,
+    resetOrphanedReplyTimeout: noop,
+    resolvePendingNarrativeOnTool: noop,
+    scheduleEarlyLivenessOpen: noop,
+    stagePendingNarrative: noop,
+    startTurnTypingLoop: noop,
+    statusKey: key,
+    streamKey: key,
+    surfaceMemoryLegibility: noop,
+    turnLiveForItsTopic: () => true,
+    turnsDb: null,
+    unpinProgressCardForChat: null,
+  } as unknown as StreamRenderDeps
+  return { deps, getTurn: () => curTurn }
+}
+
+describe('MINOR-1 — origin stamp gate OFF (default): parser is not consulted', () => {
+  it('stamps a buzz-enveloped turn as TELEGRAM when BUZZ_ENABLED is unset', () => {
+    // Guard: the process must actually be on the flag-off path for this to mean
+    // what it claims. (Every Telegram-only agent runs exactly here.)
+    expect(process.env.BUZZ_ENABLED === '1' || process.env.BUZZ_ENABLED === 'true').toBe(false)
+
+    const { deps, getTurn } = makeStreamDeps()
+    handleSessionEvent(deps, {
+      kind: 'enqueue',
+      chatId: CHAT,
+      messageId: null,
+      threadId: null,
+      rawContent: BUZZ_RAW,
+    } as unknown as Parameters<typeof handleSessionEvent>[1])
+
+    const turn = getTurn()
+    expect(turn).not.toBeNull()
+    // The OUTCOME: despite a real buzz envelope, the gate-off ctor defaulted to
+    // telegram WITHOUT calling parseChannelOrigin. Removing the gate would make
+    // this 'buzz' with coords — the regression this test exists to catch.
+    expect(turn!.originChannel).toBe('telegram')
+    expect(turn!.buzzCoords).toBeUndefined()
+  })
+})