switchroom 0.5.0

package/telegram-plugin/tests/real-gateway-i6-turn-flush-replay-dedup.test.ts

@@ -0,0 +1,313 @@
+/**
+ * I6 — Turn-flush + replay duplicate-content suppression (#546).
+ *
+ * THIS FILE IS A REGRESSION-PREVENTION LAYER. See
+ * `real-gateway-ipc-lifecycle.test.ts` for the I1–I5 backstory.
+ *
+ * Bug #546 (resolved by 5bed5b7 — "outbound content-dedup window"):
+ * agent emits text → bridge disconnects mid-flight → gateway's
+ * turn-flush backstop sends the buffered text as HTML → bridge
+ * reconnects → claude-code replays the un-acked stream_reply tool_call
+ * with identical content but raw markdown → user sees the same content
+ * twice.
+ *
+ * The fix added `OutboundDedupCache` (telegram-plugin/recent-outbound-
+ * dedup.ts), which has 23 unit tests on the cache logic but ZERO
+ * integration tests reproducing the full sequence end-to-end. This file
+ * closes that gap. Without integration coverage the *bug class* (two
+ * paths emitting the same content within a TTL) is still latent
+ * anywhere the dedup cache isn't wired.
+ *
+ * Invariant pinned here:
+ *
+ *   I6 — When the same multi-line content is emitted twice for the
+ *        same chat within the dedup TTL, only ONE outbound lands.
+ *        Holds across: bridge cycle in between, format mismatch
+ *        (HTML vs markdown), and reactions still finalize correctly.
+ *
+ * Failure mode if the dedup wiring regresses (e.g. someone removes the
+ * cache wire-up in `streamReply` or rolls back recent-outbound-dedup.ts):
+ * `recorder.sentTexts(chat).length === 2` and the test fails on the
+ * "exactly one outbound" assertion.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createRealGatewayHarness } from './real-gateway-harness.js'
+
+const CHAT = '8248703757'
+const INBOUND_MSG = 100
+const REPLY_TEXT =
+  'Here is a reply with enough content to clear the 24-char dedup floor — this paragraph is intentionally long to mirror the multi-paragraph replies that bug #546 actually duplicated.'
+
+beforeEach(() => {
+  vi.useFakeTimers()
+})
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe('I6 — turn-flush + replay duplicate-content suppression (#546)', () => {
+  it('two identical send calls within TTL — second is suppressed by dedup (the #546 reproducer)', async () => {
+    // fails when: the dedup cache wire-up in real-gateway-harness's
+    // send/streamReply path is removed, or recent-outbound-dedup.ts's
+    // check() always returns null.
+    const h = createRealGatewayHarness({ gapMs: 0, withDedup: true })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'hello' })
+    h.feedSessionEvent({
+      kind: 'enqueue',
+      chatId: CHAT,
+      messageId: '1',
+      threadId: null,
+      rawContent: 'hello',
+    })
+    await h.clock.advance(20)
+
+    const result = await h.simulateRetryDup({ chat_id: CHAT, text: REPLY_TEXT })
+
+    expect(result.suppressedSecond).toBe(true)
+    // The bridge cycle uses a REGISTERED agent, so flushOnAgentDisconnect
+    // must have run. If this is false, the test is a tautology (the
+    // anonymous-skip path bypassed the production helper).
+    expect(result.flushRan, 'flushOnAgentDisconnect must run — otherwise the test is a tautology').toBe(true)
+    expect(h.recorder.sentTexts(CHAT).filter((t) => t === REPLY_TEXT).length).toBe(1)
+    expect(h.dedupSuppressedCount()).toBe(1)
+    h.finalize()
+  })
+
+  it('content-equal-but-format-differ still dedupes (HTML vs markdown)', async () => {
+    // The smoking-gun shape from #546: msg=5025 had `<b>...</b>`,
+    // msg=5027 had `**...**`, same content. Dedup must catch this via
+    // the `normalizeForDedup` strip step.
+    //
+    // fails when: normalizeForDedup loses its HTML-tag or markdown-
+    // marker stripping (e.g. someone simplifies it to a plain hash).
+    //
+    // We use `h.send()` (fresh sendMessage every time) rather than
+    // `h.streamReply()` (which edits the same message on repeat
+    // calls). The bug class is "two SEPARATE messages with the same
+    // content", not "two streaming edits of one message."
+    const h = createRealGatewayHarness({ gapMs: 0, withDedup: true })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'q' })
+    h.feedSessionEvent({
+      kind: 'enqueue',
+      chatId: CHAT,
+      messageId: '1',
+      threadId: null,
+      rawContent: 'q',
+    })
+
+    const htmlForm = `<b>Important update:</b> The config file has been regenerated with the new schema layout described in section 4.2 of the migration guide.`
+    const mdForm = `**Important update:** The config file has been regenerated with the new schema layout described in section 4.2 of the migration guide.`
+
+    const id1 = await h.send({ chat_id: CHAT, text: htmlForm })
+    const id2 = await h.send({ chat_id: CHAT, text: mdForm })
+    expect(id1).not.toBeNull()
+    expect(id2).toBeNull() // dedup suppressed
+    expect(h.recorder.sentTexts(CHAT).length).toBe(1)
+    expect(h.dedupSuppressedCount()).toBe(1)
+    h.finalize()
+  })
+
+  it('content shorter than DEDUP_MIN_CONTENT_LEN (24 chars) is NOT deduped', async () => {
+    // Conservative floor: short replies ("ok", "got it", "✅") legitimately
+    // recur. Dedup ignores them.
+    //
+    // fails when: someone tightens the floor below 24 chars without
+    // updating tests.
+    const h = createRealGatewayHarness({ gapMs: 0, withDedup: true })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'q' })
+    h.feedSessionEvent({
+      kind: 'enqueue',
+      chatId: CHAT,
+      messageId: '1',
+      threadId: null,
+      rawContent: 'q',
+    })
+    const id1 = await h.send({ chat_id: CHAT, text: 'ok' })
+    const id2 = await h.send({ chat_id: CHAT, text: 'ok' })
+    expect(id1).not.toBeNull()
+    expect(id2).not.toBeNull() // NOT deduped — content too short
+    expect(h.recorder.sentTexts(CHAT).filter((t) => t === 'ok').length).toBe(2)
+    expect(h.dedupSuppressedCount()).toBe(0)
+    h.finalize()
+  })
+
+  it('after TTL expires, the same content sends again (cache evicts)', async () => {
+    // The TTL is bounded — same content sent an hour later should NOT
+    // be suppressed. This pins the eviction semantics.
+    //
+    // fails when: TTL eviction breaks (entries linger forever) or the
+    // dedup cache's clock source ignores caller-supplied `now`.
+    const h = createRealGatewayHarness({ gapMs: 0, withDedup: true, dedupTtlMs: 1000 })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'q' })
+    h.feedSessionEvent({
+      kind: 'enqueue',
+      chatId: CHAT,
+      messageId: '1',
+      threadId: null,
+      rawContent: 'q',
+    })
+
+    const id1 = await h.send({ chat_id: CHAT, text: REPLY_TEXT })
+    expect(id1).not.toBeNull()
+    expect(h.recorder.sentTexts(CHAT).filter((t) => t === REPLY_TEXT).length).toBe(1)
+
+    // Advance past the TTL.
+    await h.clock.advance(2000)
+
+    const id2 = await h.send({ chat_id: CHAT, text: REPLY_TEXT })
+    expect(id2).not.toBeNull() // TTL expired → fresh send allowed
+    expect(h.recorder.sentTexts(CHAT).filter((t) => t === REPLY_TEXT).length).toBe(2)
+    h.finalize()
+  })
+
+  it('without withDedup, duplicate content lands twice (control case — confirms the harness default is back-compat)', async () => {
+    // Sanity check: F1–F4 tests don't pass withDedup, and they MUST
+    // continue to see every outbound landing as before. If a future
+    // change wires dedup unconditionally, this test catches it.
+    //
+    // fails when: someone makes withDedup default to true, breaking
+    // F1–F4 deadline assertions.
+    const h = createRealGatewayHarness({ gapMs: 0 })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'q' })
+    h.feedSessionEvent({
+      kind: 'enqueue',
+      chatId: CHAT,
+      messageId: '1',
+      threadId: null,
+      rawContent: 'q',
+    })
+    const id1 = await h.send({ chat_id: CHAT, text: REPLY_TEXT })
+    const id2 = await h.send({ chat_id: CHAT, text: REPLY_TEXT })
+    expect(id1).not.toBeNull()
+    expect(id2).not.toBeNull() // no dedup, no suppression
+    expect(h.recorder.sentTexts(CHAT).filter((t) => t === REPLY_TEXT).length).toBe(2)
+    expect(h.dedup).toBeNull()
+    h.finalize()
+  })
+})
+
+// ─── I5 (Bug C) defense-in-depth via dedup ─────────────────────────────
+//
+// Bug C lives in profiles/_base/start.sh.hbs (a shell script the gateway
+// can't run). The actual fix is in the wake-audit sentinel comparison
+// logic, not in the gateway. BUT the OBSERVABLE failure is "duplicate
+// reply lands in the gateway." If the wake-audit fix regresses, the
+// dedup cache should still suppress the duplicate outbound. Defense in
+// depth — testable here.
+//
+// I5 in real-gateway-ipc-lifecycle.test.ts is `.skip`'d pending the
+// profile fix; this test is its harness-level companion.
+describe('I5(b) — wake-audit respawn duplicate suppressed by dedup defense in depth (Bug C)', () => {
+  it('respawn-replay simulation produces only one user-visible reply', async () => {
+    // fails when: the dedup wire-up regresses, OR if a wake-audit-style
+    // duplicate reply path emerges that bypasses streamReply (e.g. uses
+    // raw bot.api.sendMessage). In that case this test still catches
+    // the regression by counting outbounds.
+    const h = createRealGatewayHarness({ gapMs: 0, withDedup: true })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'morning' })
+    h.feedSessionEvent({
+      kind: 'enqueue',
+      chatId: CHAT,
+      messageId: '1',
+      threadId: null,
+      rawContent: 'morning',
+    })
+
+    const greeting =
+      'Good morning! I noticed you mentioned the deploy yesterday — did the rollback succeed and are you ready to retry, or is there something I can help you investigate first?'
+
+    // First wake-audit fire (legitimate).
+    const id1 = await h.send({ chat_id: CHAT, text: greeting })
+    expect(id1).not.toBeNull()
+
+    // Simulate the --continue respawn: agent dies (registered disconnect),
+    // a fresh agent spawns and re-runs wake-audit, attempts to fire the
+    // same greeting again because the marker check was wrong.
+    const cid = h.bridgeConnect('agent-x')
+    h.bridgeDisconnect(cid)
+    await h.clock.advance(50)
+
+    const id2 = await h.send({ chat_id: CHAT, text: greeting })
+    expect(id2).toBeNull() // dedup suppressed
+
+    expect(h.recorder.sentTexts(CHAT).filter((t) => t === greeting).length).toBe(1)
+    expect(h.dedupSuppressedCount()).toBeGreaterThanOrEqual(1)
+    // I7 invariant: even across the wake-audit respawn, the chat
+    // sees exactly ONE anchor sendMessage. (#626 — duplicate status
+    // messages bug class.)
+    expect(h.anchorMessageCount(CHAT)).toBe(1)
+    h.finalize()
+  })
+})
+
+// ─── I7 — duplicate-status-message regression (issue #626) ──────────────
+//
+// The progress-card driver / stream-reply-handler interaction has a
+// failure mode where `done=true` finalizes + deletes the active draft
+// stream entry, and a subsequent emit on the same lane+turn creates
+// a fresh `sendMessage` instead of editing the pinned card. User sees
+// multiple separate status messages where one anchor message edited
+// in place was expected.
+//
+// The fix is the `lookupExistingMessageId` hook in
+// `stream-reply-handler.ts` (wired in `gateway.ts`'s progress-card
+// emit callback to consult `pinMgr.pinnedMessageId(turnKey, agentId)`).
+// Detailed unit-level coverage lives in
+// `stream-reply-handler.test.ts` and `draft-stream.test.ts`.
+//
+// At the harness layer, the invariant is:
+//
+//   I7 — For any (chatId, threadId, turnKey?), the recorder shows
+//        exactly one `sendMessage` call (the anchor). All subsequent
+//        renders for the same logical turn are `editMessageText` on
+//        that anchor's `message_id`.
+//
+// This test pins the invariant for the simplest happy-path scenario
+// (one inbound, one outbound). The full progress-card lifecycle
+// scenario (first emit → done=true → post-done emit) is exercised at
+// the unit level — wiring the production progress driver through the
+// real-gateway harness is its own followup. What we lock in here is
+// the assertion shape so future regressions in the OTHER 7 paths the
+// RCA identified are caught the moment a second anchor lands.
+describe('I7 — exactly-one-anchor-message invariant (#626)', () => {
+  it('happy-path single send — anchorMessageCount equals 1', async () => {
+    // fails when: any handler regression causes a single send() call
+    // to land as TWO sendMessage invocations (e.g. preamble dedup
+    // path and main reply path both firing).
+    const h = createRealGatewayHarness({ gapMs: 0, withDedup: true })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'q' })
+    h.feedSessionEvent({
+      kind: 'enqueue',
+      chatId: CHAT,
+      messageId: '1',
+      threadId: null,
+      rawContent: 'q',
+    })
+    const id1 = await h.send({ chat_id: CHAT, text: REPLY_TEXT })
+    expect(id1).not.toBeNull()
+    expect(h.anchorMessageCount(CHAT)).toBe(1)
+    h.finalize()
+  })
+
+  it('dedup-suppressed second send does NOT add a second anchor', async () => {
+    // The combo invariant: dedup catching a duplicate AND the anchor
+    // count staying at 1. Both must hold for #626 to be considered
+    // closed at the harness layer.
+    const h = createRealGatewayHarness({ gapMs: 0, withDedup: true })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'q' })
+    h.feedSessionEvent({
+      kind: 'enqueue',
+      chatId: CHAT,
+      messageId: '1',
+      threadId: null,
+      rawContent: 'q',
+    })
+    await h.send({ chat_id: CHAT, text: REPLY_TEXT })
+    const id2 = await h.send({ chat_id: CHAT, text: REPLY_TEXT }) // same content
+    expect(id2).toBeNull()
+    expect(h.anchorMessageCount(CHAT)).toBe(1)
+    expect(h.dedupSuppressedCount()).toBeGreaterThanOrEqual(1)
+    h.finalize()
+  })
+})

package/telegram-plugin/tests/real-gateway-ipc-lifecycle.test.ts

@@ -0,0 +1,299 @@
+/**
+ * IPC + bridge lifecycle invariants — real-gateway harness coverage.
+ *
+ * THIS FILE IS A REGRESSION-PREVENTION LAYER. Each test corresponds to a
+ * real production bug observed on a specific date. The point is to leave
+ * breadcrumbs so a future engineer who breaks an invariant sees WHY the
+ * test exists.
+ *
+ * Production observation (2026-05-03 evening): the existing real-gateway
+ * harness (PR #582) covered the user-perceived waiting UX (status
+ * reactions, progress card, coalescer, first-paint timing) but had ZERO
+ * coverage of the IPC layer below it — the bridge connect/register/
+ * disconnect lifecycle, the validator boundary that decides which
+ * messages are lethal vs tolerated, and the temporal contract between
+ * "answer text delivered" and "👍 fires." Multiple bugs slipped through
+ * because of that gap.
+ *
+ * The five invariants pinned here:
+ *
+ *   I1 — Anonymous IPC client lifecycle is observably invisible.
+ *        Bug A: an anonymous IPC client (recall.py one-shot) connecting
+ *        and disconnecting flushed the gateway's active status reactions
+ *        to setDone(), producing premature 👍 mid-turn. Fix: PR #600
+ *        gates the disconnect-flush on `client.agentName != null`.
+ *
+ *   I2 — Per-agent disconnect isolation. When agent X disconnects,
+ *        only X's reactions get flushed; Y's stay intact. Today
+ *        switchroom is single-agent-per-gateway, but pinning the right
+ *        semantics now means a future multi-agent gateway can't
+ *        regress silently.
+ *
+ *   I3 — 👍 fires AFTER real delivery, not after JSONL `turn_end`.
+ *        Bug D (and Z): on slow Telegram outbound, setDone() was
+ *        firing on the JSONL `turn_end` event before the final
+ *        sendMessage/editMessageText round-tripped, so the user saw
+ *        the 👍 for ~150ms before the actual reply text appeared.
+ *
+ *   I4 — Legacy IPC types are tolerated, not lethal. Bug B: a legacy
+ *        `update_placeholder` IPC message from recall.py crashed the
+ *        gateway after PR 5 of #553 removed the handler. Fix: the
+ *        validator already returns false for unknown types, and
+ *        `processBuffer` logs+continues — but the absence of a test
+ *        meant the regression went unnoticed until production.
+ *
+ *   I5 — Wake-audit dedup. Bug C: the `.wake-audit-pending` sentinel
+ *        re-fired mid-conversation under `--continue` respawn,
+ *        producing a duplicate reply. Fix lives in profiles, not in
+ *        the gateway, but the invariant test belongs here so a future
+ *        change can't reintroduce the dup.
+ *
+ * Bug-to-PR map:
+ *   Bug A  → PR switchroom/switchroom#600 (in flight, conflicting at time of write)
+ *   Bug B  → covered by the same PR #600 (soft-accept update_placeholder)
+ *   Bug C  → next PR (wake-audit profile fix); test here is .skip'd until then
+ *   Bug D  → /tmp/switchroom-bugdz-setdone-timing branch (in flight)
+ *
+ * State at time of write (2026-05-03):
+ *   - PR #600 NOT yet merged → I1 + I2 mirror the production semantics
+ *     INSIDE the harness's bridgeDisconnect helper. When #600 merges,
+ *     the harness should be re-pointed at the extracted
+ *     `disconnect-flush.ts` so the test exercises the production code
+ *     path directly. See TODO in real-gateway-harness.ts.
+ *   - I4 passes against current main (the validator already rejects
+ *     unknown types).
+ *   - I3 currently exercises the harness's streamReply → setDone
+ *     ordering. When the Bug D+Z fix lands, this test will continue to
+ *     pass (it only asserts the temporal invariant, not a specific
+ *     code path).
+ *   - I5 is .skip'd pending the Bug C profile fix.
+ */
+
+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() })
+
+// ─── I1 — anonymous IPC client lifecycle is invisible (Bug A) ──────────
+describe('I1 — anonymous IPC client lifecycle is observably invisible (Bug A → PR #600)', () => {
+  it('anonymous connect → legacy update_placeholder → disconnect MUST NOT fire 👍 mid-turn', async () => {
+    // Setup: a real turn is in flight. 👀 is on the user's message and
+    // the controller is sitting at queued/thinking — i.e. NOT terminal.
+    const h = createRealGatewayHarness({ gapMs: 0 })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'hello' })
+    h.feedSessionEvent({ kind: 'enqueue', chatId: CHAT, messageId: '1', threadId: null, rawContent: 'hello' })
+    await h.clock.advance(50)
+    h.feedSessionEvent({ kind: 'thinking' })
+    await h.clock.advance(50)
+    expect(h.recorder.firstReactionMs(CHAT)).not.toBeNull()
+    expect(h.recorder.lastReactionEmoji(CHAT)).toBe('👀')
+
+    const reactionsBefore = h.recorder.reactionSequence().length
+
+    // Act: an anonymous (recall.py-style) client connects, fires a
+    // legacy update_placeholder one-shot, then disconnects. This is
+    // EXACTLY Bug A's reproducer.
+    const clientId = h.bridgeConnect(null)
+    h.sendIpcMessage(clientId, {
+      type: 'update_placeholder',
+      chatId: CHAT,
+      text: '📚 recalling memories',
+    })
+    h.bridgeDisconnect(clientId)
+    await h.clock.advance(10)
+
+    // Assert: no new reactions emitted. 👍 NOT fired. Active state intact.
+    const reactionsAfter = h.recorder.reactionSequence().length
+    expect(reactionsAfter).toBe(reactionsBefore)
+    expect(h.recorder.lastReactionEmoji(CHAT)).not.toBe('👍')
+    // PRIMARY ASSERTION — direct introspection of the production helper's
+    // side-effect counts. If the `agentName == null` gate is bypassed,
+    // these counts jump to ≥1. The recorder-based assertions above can
+    // miss the bug if the per-agent controller's emit isn't recorder-
+    // wired; this assertion is unambiguous.
+    const sfx = h.flushSideEffects()
+    expect(sfx.disposeProgressDriverCalls, 'progress driver disposed for anonymous client — gate bypassed').toBe(0)
+    expect(sfx.clearActiveReactionsCalls, 'reactions cleared for anonymous client — gate bypassed').toBe(0)
+    h.finalize()
+  })
+
+  it('anonymous disconnect MUST NOT dispose progress driver or close draft streams', async () => {
+    // Class-C-shaped turn: card is rendering, draft stream is open.
+    // Anonymous disconnect during this state must be a complete no-op.
+    const h = createRealGatewayHarness({ gapMs: 0, driverInitialDelayMs: 0 })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'work' })
+    h.feedSessionEvent({ kind: 'enqueue', chatId: CHAT, messageId: '1', threadId: null, rawContent: 'work' })
+    await h.clock.advance(100)
+    h.feedSessionEvent({ kind: 'thinking' })
+    await h.clock.advance(50)
+
+    const editsBefore = h.recorder.edits(CHAT).length
+    const sendsBefore = h.recorder.sentTexts(CHAT).length
+
+    const clientId = h.bridgeConnect(null)
+    h.bridgeDisconnect(clientId)
+    await h.clock.advance(50)
+
+    // Driver/streams untouched: no spurious card finalize, no extra
+    // sendMessage flushes. The exact counts must match what they were
+    // before the anonymous client touched anything.
+    expect(h.recorder.edits(CHAT).length).toBe(editsBefore)
+    expect(h.recorder.sentTexts(CHAT).length).toBe(sendsBefore)
+    // Direct assertion on the production helper's side-effect counts.
+    const sfx = h.flushSideEffects()
+    expect(sfx.disposeProgressDriverCalls).toBe(0)
+    expect(sfx.clearActiveReactionsCalls).toBe(0)
+    h.finalize()
+  })
+})
+
+// ─── I2 — per-agent disconnect isolation ───────────────────────────────
+describe('I2 — per-agent disconnect isolation (single-agent today, multi-agent-safe semantics)', () => {
+  it("agent Y's disconnect MUST NOT mutate agent X's active status reaction", async () => {
+    const h = createRealGatewayHarness({ gapMs: 0 })
+    // Agent X owns the live turn (whichever agent the gateway hosts —
+    // in production today, exactly one). 👀 is up.
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'q' })
+    h.feedSessionEvent({ kind: 'enqueue', chatId: CHAT, messageId: '1', threadId: null, rawContent: 'q' })
+    await h.clock.advance(50)
+    h.feedSessionEvent({ kind: 'thinking' })
+    await h.clock.advance(50)
+
+    const xClientId = h.bridgeConnect('agent-x')
+    const yClientId = h.bridgeConnect('agent-y')
+
+    const reactionsBefore = h.recorder.reactionSequence().length
+    const lastBefore = h.recorder.lastReactionEmoji(CHAT)
+
+    // Disconnect ONLY agent y. Agent x's per-agent state — and the
+    // shared chat's active reaction (which logically belongs to x in
+    // single-agent setups) — must remain untouched.
+    const sfxBefore = h.flushSideEffects()
+    expect(sfxBefore.activeAgentCount).toBe(2) // both x and y registered
+
+    h.bridgeDisconnect(yClientId)
+    await h.clock.advance(10)
+
+    expect(h.recorder.reactionSequence().length).toBe(reactionsBefore)
+    expect(h.recorder.lastReactionEmoji(CHAT)).toBe(lastBefore)
+
+    // PRIMARY ASSERTION — y disconnected (registered agent), so the
+    // helper's flush DID run and cleared y's entry. But x's entry must
+    // remain. With the current per-agent-Map shape, the helper iterates
+    // the WHOLE map on any registered disconnect — meaning today both x
+    // and y get flushed when y disconnects. That's a TODO for the helper
+    // (it would need a per-agent disconnect filter). For now, we pin
+    // what the helper actually does: both agents get flushed when ANY
+    // registered agent disconnects. When the helper grows per-agent
+    // filtering, update this assertion.
+    const sfxAfter = h.flushSideEffects()
+    expect(sfxAfter.disposeProgressDriverCalls, 'helper ran on registered disconnect').toBe(1)
+
+    // And agent x's controller is still operable — no premature finish.
+    // (Subsequent disconnect of x is allowed to flush; the invariant
+    // here is only about y's disconnect not touching x.)
+    h.bridgeDisconnect(xClientId)
+    h.finalize()
+  })
+})
+
+// ─── I3 — 👍 fires AFTER real delivery (Bug D, Bug Z) ─────────────────
+describe('I3 — 👍 fires at-or-after final outbound delivery, not before (Bug D/Z)', () => {
+  it('Class A reply path: lastReactionEmojiAt(👍) >= lastAnswerTextDeliveredAt(chat)', async () => {
+    const h = createRealGatewayHarness({ gapMs: 0 })
+
+    // Full Class A turn: inbound → quick model text → turn_end. The
+    // streamReply path internally awaits sendMessage before calling
+    // setDone(), which is the production-correct ordering. If a future
+    // refactor inverts that — e.g. setDone fires from the JSONL
+    // turn_end handler before the outbound completes — this test
+    // catches it.
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'hi' })
+    h.feedSessionEvent({ kind: 'enqueue', chatId: CHAT, messageId: '1', threadId: null, rawContent: 'hi' })
+    await h.clock.advance(20)
+
+    await h.streamReply({ chat_id: CHAT, text: 'Hello back!', done: true })
+    await h.clock.advance(20)
+
+    const deliveredAt = h.lastAnswerTextDeliveredAt(CHAT)
+    const reactionAt = h.lastReactionEmojiAt(CHAT)
+    expect(deliveredAt).not.toBeNull()
+    expect(reactionAt).not.toBeNull()
+    // The terminal reaction should be 👍 (or at least the LAST reaction
+    // for the turn), and its timestamp must be >= the last answer text
+    // delivery. A negative delta means 👍 fired before the user could
+    // read the reply (Bug D/Z's symptom).
+    expect(reactionAt!).toBeGreaterThanOrEqual(deliveredAt!)
+    h.finalize()
+  })
+})
+
+// ─── I4 — legacy IPC types are tolerated, not lethal (Bug B) ───────────
+describe('I4 — legacy IPC message types are soft-accepted (Bug B → PR #600)', () => {
+  it('update_placeholder is logged-and-discarded; sendIpcMessage MUST NOT throw', () => {
+    const h = createRealGatewayHarness({ gapMs: 0 })
+    const clientId = h.bridgeConnect(null)
+    // The test passes by virtue of NOT throwing. The validator returns
+    // false for the unknown type; the harness's processBuffer mirror
+    // logs and continues. If a future change wires `update_placeholder`
+    // to a handler that throws on missing fields (regressing the PR 5
+    // removal), this test would throw and fail loudly.
+    expect(() => {
+      h.sendIpcMessage(clientId, {
+        type: 'update_placeholder',
+        chatId: CHAT,
+        text: '🔵 thinking',
+      })
+    }).not.toThrow()
+
+    // And the connection is still usable — the harness can disconnect
+    // it cleanly afterward.
+    expect(() => h.bridgeDisconnect(clientId)).not.toThrow()
+    h.finalize()
+  })
+
+  it('a register message with the legacy "default" agent name is rejected by the validator (#430 defence)', () => {
+    const h = createRealGatewayHarness({ gapMs: 0 })
+    const clientId = h.bridgeConnect(null)
+    // The production validator rejects agentName="default" outright —
+    // see ipc-server.ts:108-119 for the rationale (anonymous bridges
+    // crosstalk into the wrong agent). This is a separate axis from
+    // I1/I4 but lives in the same lethality-tolerance neighborhood.
+    expect(() => {
+      h.sendIpcMessage(clientId, { type: 'register', agentName: 'default' })
+    }).not.toThrow()
+    h.finalize()
+  })
+})
+
+// ─── I5 — wake-audit dedup (Bug C) ─────────────────────────────────────
+describe('I5 — wake-audit dedup under --continue respawn (Bug C → next PR)', () => {
+  // TODO(bug-C): un-skip when the wake-audit profile fix lands. The
+  // fix lives in profiles/<profile>/CLAUDE.md.hbs (the .wake-audit-
+  // pending sentinel logic), not in the gateway. This test belongs
+  // here because the FAILURE MODE is observable at the gateway level
+  // (a duplicate reply on the same turn after respawn) and the
+  // harness is the right place to pin "no duplicate outbound for the
+  // same logical turn."
+  it.skip('mid-conversation respawn under --continue MUST NOT produce a duplicate reply', async () => {
+    const h = createRealGatewayHarness({ gapMs: 0 })
+    h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'hi' })
+    h.feedSessionEvent({ kind: 'enqueue', chatId: CHAT, messageId: '1', threadId: null, rawContent: 'hi' })
+    await h.streamReply({ chat_id: CHAT, text: 'Hello!', done: true })
+
+    // Simulate the --continue respawn path: agent process restarts,
+    // wake-audit cycle re-runs, sentinel SHOULD prevent re-firing the
+    // greeting reply. Until the fix lands, this would emit a duplicate.
+    // The exact respawn shim is TBD by the Bug C fix — this test is a
+    // placeholder so the invariant has a home.
+    const replyCount = h.recorder
+      .sentTexts(CHAT)
+      .filter((t) => t.includes('Hello')).length
+    expect(replyCount).toBe(1)
+    h.finalize()
+  })
+})