switchroom 0.7.15 → 0.10.0

package/telegram-plugin/tests/progress-card-pin-race-fast-turn.test.ts

@@ -1,66 +0,0 @@
-/**
- * PR-C2 — fast-turn race between considerPin's deferred timer and a
- * subsequent completeTurn.
- *
- * considerPin schedules a pendingPin timer with `pinDelayMs`. If the
- * turn completes BEFORE the timer fires, completeTurn must:
- *
- *   - Cancel the timer (no Telegram pin issued).
- *   - Drop the entry from pendingPins (no orphan).
- *
- * fails when: completeTurn's pending-pin cancellation branch is removed
- * or the entry isn't deleted from `pendingPins` after `timer.cancel()`
- * (which would let a follow-up considerPin for the same composite get
- * silently no-op'd by the `pendingPins.has(key)` guard).
- */
-import { describe, it, expect, vi } from 'vitest'
-import { createPinManager, type TimerHandle } from '../progress-card-pin-manager.js'
-
-interface T { fn: () => void; cancelled: boolean; fired: boolean }
-
-describe('PR-C2: fast-turn pin-race — completeTurn before timer fires', () => {
-  it('cancels the pending pin timer and clears pendingPins; no pin API call ever issued', async () => {
-    const timers: T[] = []
-    const pin = vi.fn(async () => true)
-    const unpin = vi.fn(async () => true)
-
-    const mgr = createPinManager({
-      pin, unpin,
-      log: () => {},
-      now: () => 1000,
-      pinDelayMs: 100, // non-zero so we have a race window
-      scheduleTimer: (fn): TimerHandle => {
-        const t: T = { fn, cancelled: false, fired: false }
-        timers.push(t)
-        return { cancel: () => { t.cancelled = true } }
-      },
-    })
-
-    mgr.considerPin({
-      chatId: 'c', threadId: '0', turnKey: 'c:0:1', messageId: 500, isFirstEmit: true,
-    })
-
-    // Timer scheduled but NOT fired.
-    expect(timers).toHaveLength(1)
-    expect(timers[0].cancelled).toBe(false)
-    expect(timers[0].fired).toBe(false)
-
-    // Fast turn completes before timer fires.
-    mgr.completeTurn({ chatId: 'c', turnKey: 'c:0:1' })
-    await mgr.drainInFlight()
-
-    expect(timers[0].cancelled).toBe(true)
-    expect(pin).not.toHaveBeenCalled()
-    expect(unpin).not.toHaveBeenCalled()
-    expect(mgr.pinnedTurnKeys()).toEqual([])
-
-    // No orphan: a fresh considerPin under the same composite must be
-    // able to schedule a new timer (would no-op if pendingPins still
-    // had the stale entry).
-    mgr.considerPin({
-      chatId: 'c', threadId: '0', turnKey: 'c:0:1', messageId: 500, isFirstEmit: true,
-    })
-    expect(timers).toHaveLength(2)
-    expect(timers[1].cancelled).toBe(false)
-  })
-})

package/telegram-plugin/tests/progress-card-pin-sidecar-partial-write.test.ts

@@ -1,64 +0,0 @@
-/**
- * PR-C2 — sweepActivePins must recover gracefully from a malformed
- * sidecar file written by a prior crash mid-write.
- *
- * Two scenarios:
- *   (a) JSON-truncated file — readActivePins falls back to [] and the
- *       sweep is a no-op without throwing.
- *   (b) Mixed valid/invalid entries inside a parseable JSON array —
- *       readActivePins drops the invalid entries and processes the
- *       valid ones.
- *
- * fails when: readActivePins is changed to throw on malformed JSON,
- * OR the per-entry validator is loosened so a malformed object slips
- * through and crashes the unpin loop.
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { ACTIVE_PINS_FILENAME } from '../active-pins.js'
-import { sweepActivePins } from '../active-pins-sweep.js'
-
-describe('PR-C2: sweepActivePins recovers from a malformed sidecar', () => {
-  let dir: string
-  beforeEach(() => { dir = mkdtempSync(join(tmpdir(), 'pin-sidecar-partial-')) })
-  afterEach(() => { rmSync(dir, { recursive: true, force: true }) })
-
-  it('truncated JSON array: sweep is a clean no-op (no throw, no calls)', async () => {
-    // Simulate a crash mid-write: a JSON array prefix that never closed.
-    writeFileSync(
-      join(dir, ACTIVE_PINS_FILENAME),
-      '[{"chatId":"A","messageId":1,"turnKey":"A:0:1","pinnedAt":17',
-    )
-
-    const calls: Array<[string, number]> = []
-    const logs: string[] = []
-    const result = await sweepActivePins(
-      dir,
-      async (chatId, messageId) => { calls.push([chatId, messageId]) },
-      { log: (m) => logs.push(m) },
-    )
-    expect(calls).toEqual([])
-    expect(result.swept).toEqual([])
-    expect(result.timedOut).toBe(false)
-  })
-
-  it('mixed valid/invalid entries: valid ones still get processed', async () => {
-    const blob = JSON.stringify([
-      { chatId: 'A', messageId: 1, turnKey: 'A:0:1', pinnedAt: 1700000000000 }, // valid
-      { chatId: 42, messageId: 'oops', turnKey: 'B:0:1', pinnedAt: 0 },          // invalid (wrong types)
-      null,                                                                       // invalid
-      { chatId: 'C', messageId: 3, turnKey: 'C:0:1', pinnedAt: 1700000000001 }, // valid
-      'garbage',                                                                  // invalid
-    ])
-    writeFileSync(join(dir, ACTIVE_PINS_FILENAME), blob)
-
-    const calls: Array<[string, number]> = []
-    await sweepActivePins(dir, async (c, m) => { calls.push([c, m]) })
-    expect(calls.sort()).toEqual([
-      ['A', 1],
-      ['C', 3],
-    ])
-  })
-})

package/telegram-plugin/tests/progress-card-pin-watchdog.test.ts

@@ -1,190 +0,0 @@
-/**
- * Unit tests for the progress-card pin watchdog.
- *
- * The watchdog is called from the gateway on every progress-card
- * heartbeat emit. It verifies Telegram's pinned-message id matches
- * what we think is pinned; if not, it re-pins. This suite exercises
- * the rate-limiter, re-pin path, and error isolation.
- */
-
-import { describe, it, expect, vi } from 'vitest'
-import { createPinWatchdog, type PinWatchdogDeps } from '../progress-card-pin-watchdog.js'
-
-interface Harness {
-  wd: ReturnType<typeof createPinWatchdog>
-  deps: {
-    getCurrentPinned: ReturnType<typeof vi.fn>
-    pin: ReturnType<typeof vi.fn>
-    log: ReturnType<typeof vi.fn>
-  }
-  /** Mutable clock. Tests advance this to exercise the rate-limiter. */
-  clock: { t: number }
-}
-
-function mkHarness(overrides: Partial<PinWatchdogDeps> = {}): Harness {
-  const clock = { t: 1_000_000 }
-  const deps = {
-    getCurrentPinned: vi.fn(async () => 42),
-    pin: vi.fn(async () => true),
-    log: vi.fn(),
-  }
-  const wd = createPinWatchdog({
-    getCurrentPinned: deps.getCurrentPinned,
-    pin: deps.pin,
-    log: deps.log,
-    now: () => clock.t,
-    intervalMs: 30_000,
-    ...overrides,
-  })
-  return { wd, deps, clock }
-}
-
-describe('progress-card pin watchdog', () => {
-  it('is a no-op when Telegram already shows the expected pin', async () => {
-    const h = mkHarness()
-    h.deps.getCurrentPinned.mockResolvedValueOnce(42)
-
-    await h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-
-    expect(h.deps.getCurrentPinned).toHaveBeenCalledTimes(1)
-    expect(h.deps.pin).not.toHaveBeenCalled()
-    expect(h.deps.log).not.toHaveBeenCalled()
-  })
-
-  it('re-pins when Telegram shows a different message pinned', async () => {
-    const h = mkHarness()
-    h.deps.getCurrentPinned.mockResolvedValueOnce(999) // some other pin
-
-    await h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-
-    expect(h.deps.getCurrentPinned).toHaveBeenCalledWith('100')
-    expect(h.deps.pin).toHaveBeenCalledWith('100', 42, { disable_notification: true })
-  })
-
-  it('re-pins when Telegram reports nothing pinned', async () => {
-    const h = mkHarness()
-    h.deps.getCurrentPinned.mockResolvedValueOnce(undefined)
-
-    await h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-
-    expect(h.deps.pin).toHaveBeenCalledWith('100', 42, { disable_notification: true })
-  })
-
-  it('rate-limits probes per turnKey within intervalMs', async () => {
-    const h = mkHarness()
-    h.deps.getCurrentPinned.mockResolvedValue(42)
-
-    // Burst of 5 verify calls within 1s of each other.
-    for (let i = 0; i < 5; i++) {
-      await h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-      h.clock.t += 1_000
-    }
-
-    expect(h.deps.getCurrentPinned).toHaveBeenCalledTimes(1)
-  })
-
-  it('probes again after the rate-limit window elapses', async () => {
-    const h = mkHarness()
-    h.deps.getCurrentPinned.mockResolvedValue(42)
-
-    await h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-    h.clock.t += 31_000 // past 30s interval
-    await h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-
-    expect(h.deps.getCurrentPinned).toHaveBeenCalledTimes(2)
-  })
-
-  it('rate-limiter is keyed by turnKey — different keys don\'t share budget', async () => {
-    const h = mkHarness()
-    h.deps.getCurrentPinned.mockResolvedValue(42)
-
-    await h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-    await h.wd.verify({ chatId: '100', turnKey: '100:2', expectedMessageId: 43 })
-    await h.wd.verify({ chatId: '100', turnKey: '100:3', expectedMessageId: 44 })
-
-    expect(h.deps.getCurrentPinned).toHaveBeenCalledTimes(3)
-  })
-
-  it('swallows and logs getChat errors without throwing', async () => {
-    const h = mkHarness()
-    h.deps.getCurrentPinned.mockRejectedValueOnce(new Error('Bad Request: chat not found'))
-
-    await expect(
-      h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 }),
-    ).resolves.toBeUndefined()
-
-    expect(h.deps.pin).not.toHaveBeenCalled()
-    expect(h.deps.log).toHaveBeenCalledOnce()
-    expect(h.deps.log.mock.calls[0]![0]).toMatch(/watchdog failed.*chat not found/)
-  })
-
-  it('swallows and logs pin errors without throwing', async () => {
-    const h = mkHarness()
-    h.deps.getCurrentPinned.mockResolvedValueOnce(999) // mismatch → try to re-pin
-    h.deps.pin.mockRejectedValueOnce(new Error('Forbidden: not enough rights'))
-
-    await expect(
-      h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 }),
-    ).resolves.toBeUndefined()
-
-    expect(h.deps.log).toHaveBeenCalledOnce()
-    expect(h.deps.log.mock.calls[0]![0]).toMatch(/watchdog failed.*not enough rights/)
-  })
-
-  it('clear() resets the rate-limit so a subsequent verify probes immediately', async () => {
-    const h = mkHarness()
-    h.deps.getCurrentPinned.mockResolvedValue(42)
-
-    await h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-    expect(h.deps.getCurrentPinned).toHaveBeenCalledTimes(1)
-
-    h.wd.clear('100:1')
-    // No time advance — only the clear should unlock the next probe.
-    await h.wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-
-    expect(h.deps.getCurrentPinned).toHaveBeenCalledTimes(2)
-  })
-
-  it('clear() on an unknown turnKey is a safe no-op', () => {
-    const h = mkHarness()
-    expect(() => h.wd.clear('never-seen')).not.toThrow()
-  })
-
-  it('defaults intervalMs to 30_000 when not provided', async () => {
-    // Construct without an explicit intervalMs override.
-    const clock = { t: 0 }
-    const getCurrentPinned = vi.fn(async () => 42)
-    const pin = vi.fn(async () => true)
-    const wd = createPinWatchdog({
-      getCurrentPinned,
-      pin,
-      now: () => clock.t,
-    })
-
-    await wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-    // Just under 30s — should still be gated.
-    clock.t = 29_999
-    await wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-    expect(getCurrentPinned).toHaveBeenCalledTimes(1)
-    // Past 30s — should probe again.
-    clock.t = 30_001
-    await wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-    expect(getCurrentPinned).toHaveBeenCalledTimes(2)
-  })
-
-  it('first verify for a turnKey always probes, even at t=0', async () => {
-    const clock = { t: 0 }
-    const deps = {
-      getCurrentPinned: vi.fn(async () => 42),
-      pin: vi.fn(async () => true),
-    }
-    const wd = createPinWatchdog({
-      getCurrentPinned: deps.getCurrentPinned,
-      pin: deps.pin,
-      now: () => clock.t,
-    })
-
-    await wd.verify({ chatId: '100', turnKey: '100:1', expectedMessageId: 42 })
-    expect(deps.getCurrentPinned).toHaveBeenCalledTimes(1)
-  })
-})

package/telegram-plugin/tests/progress-card-sigterm-pin-flush.test.ts

@@ -1,146 +0,0 @@
-/**
- * Regression test for #689 — SIGTERM mid-turn must flush pinned progress
- * cards with a "Restart interrupted" banner and unpin them, instead of
- * leaving them frozen on "Working…" forever.
- *
- * The full SIGTERM flush logic in gateway.ts is built around a closure
- * that needs a complete grammY bot harness, so this test exercises the
- * pieces it composes: `pinManager.pinnedEntries()` (the new
- * shutdown-introspection API) and `pinManager.unpinForChat()` (the
- * synchronous unpin path). The gateway's shutdown closure is a trivial
- * map over `pinnedEntries()` calling `editMessageText` + `unpinForChat`
- * — covering those two primitives covers the regression.
- */
-import { describe, it, expect, vi } from 'vitest'
-import {
-  createPinManager,
-  type PinManagerDeps,
-  type TimerHandle,
-} from '../progress-card-pin-manager.js'
-
-interface PendingTimer { fn: () => void; cancelled: boolean; fired: boolean }
-
-function mkHarness(overrides: Partial<PinManagerDeps> = {}) {
-  const timers: PendingTimer[] = []
-  const deps = {
-    pin: vi.fn(async () => true),
-    unpin: vi.fn(async () => true),
-    deleteMessage: vi.fn(async () => true),
-    addPin: vi.fn(),
-    removePin: vi.fn(),
-    log: vi.fn(),
-  }
-  const scheduleTimer = (fn: () => void): TimerHandle => {
-    const entry: PendingTimer = { fn, cancelled: false, fired: false }
-    timers.push(entry)
-    return { cancel() { entry.cancelled = true } }
-  }
-  const mgr = createPinManager({ ...deps, now: () => 10_000, scheduleTimer, ...overrides })
-  const fireTimers = (): void => {
-    for (const t of [...timers]) {
-      if (t.cancelled || t.fired) continue
-      t.fired = true
-      t.fn()
-    }
-  }
-  return { mgr, deps, fireTimers }
-}
-
-describe('SIGTERM mid-turn progress-card flush (#689)', () => {
-  it('pinnedEntries() reports chatId + threadId + messageId for every live pin', async () => {
-    const h = mkHarness()
-    h.mgr.considerPin({
-      chatId: 'chat-A', threadId: '7', turnKey: 'chat-A:7:1',
-      messageId: 101, isFirstEmit: true,
-    })
-    h.mgr.considerPin({
-      chatId: 'chat-B', turnKey: 'chat-B:1',
-      messageId: 202, isFirstEmit: true,
-    })
-    h.fireTimers()
-    await h.mgr.drainInFlight()
-
-    const entries = h.mgr.pinnedEntries()
-    expect(entries).toHaveLength(2)
-    const sorted = [...entries].sort((a, b) => a.messageId - b.messageId)
-    expect(sorted[0]).toMatchObject({
-      chatId: 'chat-A', threadId: '7', turnKey: 'chat-A:7:1',
-      messageId: 101, agentId: '__parent__',
-    })
-    expect(sorted[1]).toMatchObject({
-      chatId: 'chat-B', turnKey: 'chat-B:1',
-      messageId: 202, agentId: '__parent__',
-    })
-    // Threadless pins must not invent a threadId field — the gateway
-    // shutdown closure skips passing message_thread_id when undefined.
-    expect(sorted[1].threadId).toBeUndefined()
-  })
-
-  it('simulated SIGTERM: edit-then-unpin every pinned card with the banner', async () => {
-    const h = mkHarness()
-    h.mgr.considerPin({
-      chatId: 'chat-A', threadId: '7', turnKey: 'chat-A:7:1',
-      messageId: 101, isFirstEmit: true,
-    })
-    h.mgr.considerPin({
-      chatId: 'chat-B', turnKey: 'chat-B:1',
-      messageId: 202, isFirstEmit: true,
-    })
-    h.fireTimers()
-    await h.mgr.drainInFlight()
-
-    // Stand-in for `lockedBot.api.editMessageText`.
-    const editMessageText = vi.fn(async () => true)
-    const banner = '⚠️ <b>Restart interrupted this work</b>\n<i>SIGTERM: update: pulled X</i>'
-
-    const entries = h.mgr.pinnedEntries()
-    const ops = entries.map(({ chatId, threadId, messageId }) =>
-      editMessageText(chatId, messageId, banner, { parse_mode: 'HTML' })
-        .finally(() => {
-          h.mgr.unpinForChat(chatId, threadId != null ? Number(threadId) : undefined)
-        }),
-    )
-    await Promise.allSettled(ops)
-    await h.mgr.drainInFlight()
-
-    // Both cards saw the interrupted-banner edit.
-    expect(editMessageText).toHaveBeenCalledTimes(2)
-    expect(editMessageText).toHaveBeenCalledWith('chat-A', 101, banner, { parse_mode: 'HTML' })
-    expect(editMessageText).toHaveBeenCalledWith('chat-B', 202, banner, { parse_mode: 'HTML' })
-
-    // And both cards were unpinned afterwards.
-    expect(h.deps.unpin).toHaveBeenCalledWith('chat-A', 101)
-    expect(h.deps.unpin).toHaveBeenCalledWith('chat-B', 202)
-    expect(h.mgr.pinnedEntries()).toEqual([])
-    expect(h.mgr.pinnedTurnKeys()).toEqual([])
-  })
-
-  it('unpins even when the banner edit fails (frozen card is worse than no card)', async () => {
-    const h = mkHarness()
-    h.mgr.considerPin({
-      chatId: 'chat-A', threadId: '7', turnKey: 'chat-A:7:1',
-      messageId: 101, isFirstEmit: true,
-    })
-    h.fireTimers()
-    await h.mgr.drainInFlight()
-
-    const editMessageText = vi.fn(async () => {
-      throw new Error('Bad Request: message to edit not found')
-    })
-    const banner = '⚠️ <b>Restart interrupted this work</b>\n<i>SIGTERM</i>'
-
-    const entries = h.mgr.pinnedEntries()
-    const ops = entries.map(({ chatId, threadId, messageId }) =>
-      editMessageText(chatId, messageId, banner, { parse_mode: 'HTML' })
-        .catch(() => {})
-        .finally(() => {
-          h.mgr.unpinForChat(chatId, threadId != null ? Number(threadId) : undefined)
-        }),
-    )
-    await Promise.allSettled(ops)
-    await h.mgr.drainInFlight()
-
-    expect(h.deps.unpin).toHaveBeenCalledWith('chat-A', 101)
-    expect(h.mgr.pinnedEntries()).toEqual([])
-  })
-})

package/telegram-plugin/tests/real-gateway-f1-ladder-integrity.test.ts

@@ -1,123 +0,0 @@
-/**
- * F1 — "ladder collapse" — regression test against real-gateway harness.
- *
- * Symptom from #545: on a Class B turn (1–3 tool calls, < ~15s), the
- * status reaction jumps straight from 👀 to 👍, skipping the
- * intermediate 🤔 (thinking) and 🔥 (tool work) states. User loses the
- * "agent is doing things" signal.
- *
- * Root cause: `StatusReactionController.scheduleState()` debounces
- * non-immediate transitions (default `debounceMs=700`). When a turn
- * completes faster than the debounce window, intermediate states never
- * cross the timer — `setDone()` calls `finishWithState()` which
- * `clearDebounceTimer()`s and emits 👍 directly, dropping the pending
- * 🤔/🔥.
- *
- * Spec contract from `waiting-ux-spec.md`:
- *
- *   F1: ladder integrity — for Class B turns, recorded reaction
- *       sequence MUST contain 👀 followed by at least one
- *       intermediate state (🤔 / 🔥 / a tool-specific reaction)
- *       BEFORE 👍. No straight-to-👍 collapse.
- *
- * The fix flushes any pending non-terminal reaction before the
- * terminal 👍 emits. Tracking: #545 (parent), #553 (Phase 3).
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { createRealGatewayHarness } from './real-gateway-harness.js'
-
-const CHAT = '8248703757'
-const INBOUND_MSG = 100
-
-beforeEach(() => { vi.useFakeTimers() })
-afterEach(() => { vi.useRealTimers() })
-
-/**
- * Dedupe consecutive duplicate reactions in the recorded sequence.
- * The post-F2 harness fires 👀 twice (early-ack + controller setQueued);
- * Telegram dedupes by emoji so consecutive duplicates are visually one
- * step. Tests asserting ladder integrity should ignore them.
- */
-function uniqueLadder(seq: string[]): string[] {
-  const out: string[] = []
-  for (const e of seq) {
-    if (out[out.length - 1] !== e) out.push(e)
-  }
-  return out
-}
-
-describe('F1 — ladder integrity (no straight-to-👍 collapse)', () => {
-  it('Class B sub-debounce turn (~500ms): pending tool reaction MUST emit before 👍', async () => {
-    // The exact failure case from the live demo: a turn that completes
-    // faster than the controller's 700ms debounce window. Pre-fix, the
-    // 🔥 reaction was scheduled but cancelled when setDone() cleared
-    // the debounce timer. User saw 👀 → 👍 with no intermediate state.
-    const h = createRealGatewayHarness({ gapMs: 0 })
-    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'quick task' })
-    h.feedSessionEvent({ kind: 'enqueue', chatId: CHAT, messageId: '1', threadId: null, rawContent: 'quick task' })
-    await h.clock.advance(50)
-    h.feedSessionEvent({ kind: 'thinking' })
-    await h.clock.advance(50)
-    h.feedSessionEvent({ kind: 'tool_use', toolName: 'Bash' })
-    await h.clock.advance(400) // tool runs ~400ms, total turn ~500ms — under 700ms debounce
-    h.feedSessionEvent({ kind: 'turn_end', durationMs: 500 })
-    await h.clock.advance(1500) // settle, well past debounce window
-
-    const ladder = uniqueLadder(h.recorder.reactionSequence())
-    expect(ladder[0]).toBe('👀')
-    expect(ladder[ladder.length - 1]).toBe('👍')
-    // Must contain at least one intermediate — no straight 👀 → 👍 collapse.
-    expect(ladder.length).toBeGreaterThanOrEqual(3)
-    h.finalize()
-  })
-
-  it('Class B medium turn (~2s, single tool): ladder shows 👀 → tool reaction → 👍', async () => {
-    // Slower turn (single 2s tool) — works correctly even pre-fix because
-    // 2000ms > 700ms debounce. Pin so the fix doesn't regress the working case.
-    const h = createRealGatewayHarness({ gapMs: 0 })
-    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'medium task' })
-    h.feedSessionEvent({ kind: 'enqueue', chatId: CHAT, messageId: '1', threadId: null, rawContent: 'medium task' })
-    await h.clock.advance(50)
-    h.feedSessionEvent({ kind: 'thinking' })
-    await h.clock.advance(200)
-    h.feedSessionEvent({ kind: 'tool_use', toolName: 'Bash' })
-    await h.clock.advance(2000)
-    h.feedSessionEvent({ kind: 'turn_end', durationMs: 2300 })
-    await h.clock.advance(1000)
-
-    const ladder = uniqueLadder(h.recorder.reactionSequence())
-    expect(ladder[0]).toBe('👀')
-    expect(ladder[ladder.length - 1]).toBe('👍')
-    expect(ladder.length).toBeGreaterThanOrEqual(3)
-    h.finalize()
-  })
-
-  it('Class B 3-tool series at sub-debounce intervals: each transition shows', async () => {
-    // Three rapid tool transitions inside a single debounce window.
-    // Pre-fix, only the LAST one would survive (the others got
-    // overwritten by the next setTool). We don't strictly require all
-    // three to appear (the controller can collapse same-emoji adjacent
-    // calls) — but the FINAL pending state before 👍 must emit.
-    const h = createRealGatewayHarness({ gapMs: 0 })
-    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'rapid tools' })
-    h.feedSessionEvent({ kind: 'enqueue', chatId: CHAT, messageId: '1', threadId: null, rawContent: 'rapid tools' })
-    await h.clock.advance(50)
-    h.feedSessionEvent({ kind: 'thinking' })
-    await h.clock.advance(50)
-    h.feedSessionEvent({ kind: 'tool_use', toolName: 'Read' })
-    await h.clock.advance(100)
-    h.feedSessionEvent({ kind: 'tool_use', toolName: 'Bash' })
-    await h.clock.advance(100)
-    h.feedSessionEvent({ kind: 'tool_use', toolName: 'Edit' })
-    await h.clock.advance(200)
-    h.feedSessionEvent({ kind: 'turn_end', durationMs: 500 })
-    await h.clock.advance(1500)
-
-    const ladder = uniqueLadder(h.recorder.reactionSequence())
-    expect(ladder[0]).toBe('👀')
-    expect(ladder[ladder.length - 1]).toBe('👍')
-    expect(ladder.length).toBeGreaterThanOrEqual(3)
-    h.finalize()
-  })
-})

package/telegram-plugin/tests/real-gateway-f2-instant-draft.test.ts

@@ -1,82 +0,0 @@
-/**
- * F2 — "no instant draft / typing signal" — regression test.
- *
- * Spec contract from `waiting-ux-spec.md`:
- *
- *   F2 deadline: firstReactionAt - inboundAt < 800ms for ALL turn classes.
- *
- * Pre-fix history: Phase 1's harness (#547) called `setQueued()` synchronously
- * inside its `inbound()` helper, so F2 passed trivially — the harness was
- * lying about the inbound flow. The Phase 3 real-gateway harness (#553 PR 1)
- * wired the production `InboundCoalescer` BEFORE first-paint, exposing that
- * 👀 only fired AFTER the coalesce window (default 1500ms) — ~700ms over deadline.
- *
- * Fix (#553 PR 2): `gateway.ts handleInboundCoalesced` now fires the 👀
- * reaction directly on raw arrival via `bot.api.setMessageReaction`,
- * BEFORE the coalesce buffer. Eligibility: paired DM users on a fresh
- * turn (mid-turn messages preserve the current 🔥/🤔 state). The
- * controller's later `setQueued()` runs as before; Telegram dedupes
- * the duplicate 👀 emit.
- *
- * These tests pin the post-fix contract so the gap can never re-open.
- *
- * Tracking: #545 (parent), #553 (Phase 3 harness + fixes).
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { createRealGatewayHarness } from './real-gateway-harness.js'
-
-const CHAT = '8248703757'
-const INBOUND_MSG = 100
-
-beforeEach(() => { vi.useFakeTimers() })
-afterEach(() => { vi.useRealTimers() })
-
-describe('F2 — first-paint deadline (👀 within 800ms of inbound)', () => {
-  it('Class A — instant reply: 👀 reaction within 800ms', async () => {
-    const h = createRealGatewayHarness({ gapMs: 1500 }) // production default
-    const inboundAt = h.clock.now()
-    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'hi' })
-    // Allow up to 800ms for the deadline; do NOT advance through the
-    // full coalesce window — the deadline says 👀 lands BEFORE the
-    // coalesce flush would.
-    await h.clock.advance(800)
-    const firstReactionMs = h.recorder.firstReactionMs(CHAT)
-    expect(firstReactionMs).not.toBeNull()
-    expect((firstReactionMs ?? Infinity) - inboundAt).toBeLessThan(800)
-    h.finalize()
-  })
-
-  it('Class B — short turn: 👀 reaction within 800ms even with later tool calls', async () => {
-    const h = createRealGatewayHarness({ gapMs: 1500 })
-    const inboundAt = h.clock.now()
-    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'do a thing' })
-    await h.clock.advance(800)
-    const firstReactionMs = h.recorder.firstReactionMs(CHAT)
-    expect(firstReactionMs).not.toBeNull()
-    expect((firstReactionMs ?? Infinity) - inboundAt).toBeLessThan(800)
-    h.finalize()
-  })
-
-  it('Class C — long / multi-agent: 👀 reaction within 800ms regardless of total turn duration', async () => {
-    const h = createRealGatewayHarness({ gapMs: 1500 })
-    const inboundAt = h.clock.now()
-    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'big task' })
-    await h.clock.advance(800)
-    const firstReactionMs = h.recorder.firstReactionMs(CHAT)
-    expect(firstReactionMs).not.toBeNull()
-    expect((firstReactionMs ?? Infinity) - inboundAt).toBeLessThan(800)
-    h.finalize()
-  })
-
-  it('still meets deadline when an operator tunes coalescingGapMs lower', async () => {
-    const h = createRealGatewayHarness({ gapMs: 500 })
-    const inboundAt = h.clock.now()
-    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'hi' })
-    await h.clock.advance(800)
-    const firstReactionMs = h.recorder.firstReactionMs(CHAT)
-    expect(firstReactionMs).not.toBeNull()
-    expect((firstReactionMs ?? Infinity) - inboundAt).toBeLessThan(800)
-    h.finalize()
-  })
-})