switchroom 0.19.30 → 0.19.32

package/telegram-plugin/tests/stream-render-golden.test.ts

@@ -19,10 +19,14 @@
  * the duplicate. This is the exact duplicate-reply class the shared-singleton
  * injection (never a re-`new`) exists to kill.
  */
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, beforeEach } from 'vitest'
 import { readFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
-import { handleSessionEvent, type StreamRenderDeps } from '../gateway/stream-render.js'
+import {
+  handleSessionEvent,
+  __resetParkedTurnStartsForTest,
+  type StreamRenderDeps,
+} from '../gateway/stream-render.js'
 import {
   sendReply,
   type SendReplyGatewayDeps,
@@ -612,6 +616,9 @@ describe('structural — the singleton lives once in gateway, never in the modul
 // the assertion is the OUTCOME the user sees — chat actions on the wire — not
 // the call.
 describe('#3544 — turn-start typing is unconditional at the enqueue seam', () => {
+  // #3927's parked turn-start store is module-scope (one CLI session, one
+  // queue), so reset it between cases for determinism.
+  beforeEach(() => { __resetParkedTurnStartsForTest() })
   interface TypingRig {
     h: StreamHarness
     sent: Array<{ chatId: string; threadId: number | null }>
@@ -669,15 +676,23 @@ describe('#3544 — turn-start typing is unconditional at the enqueue seam', ()
 
   it('FLOOD GUARD: N turns arming on ONE chat inside the floor cost at most ONE chat action', () => {
     const rig = makeTypingRig({ adopts: false })
+    // #3927: a repeated bare `enqueue` no longer mints a turn — while one is
+    // live it PARKS, and the CLI's `dequeue` is what starts the next turn. This
+    // guard is about N turn STARTS coalescing, so drive real starts: the first
+    // enqueue mints (idle) and each later enqueue+dequeue pair mints one more.
+    const startTurn = () => {
+      handleSessionEvent(rig.h.deps, enqueue())
+      handleSessionEvent(rig.h.deps, { kind: 'dequeue' })
+    }
     // 12 arms on one chat inside a single floor window: a real-inbound arm
-    // (turn-start-surfaces) plus repeated enqueue seams / restarts.
+    // (turn-start-surfaces) plus repeated turn-start seams / restarts.
     rig.loop.start(CHAT, null) // stand-in for the real-inbound path's arm
-    for (let i = 0; i < 11; i++) handleSessionEvent(rig.h.deps, enqueue())
+    for (let i = 0; i < 11; i++) startTurn()
     expect(rig.sent).toHaveLength(1) // the floor coalesced all 12
     expect(rig.loop.activeCount()).toBe(1) // restart-safe: no interval pile-up
     // Crossing the floor lets exactly one more through, then the floor holds again.
     rig.clock.t += TYPING_FLOOR_MS
-    for (let i = 0; i < 5; i++) handleSessionEvent(rig.h.deps, enqueue())
+    for (let i = 0; i < 5; i++) startTurn()
     expect(rig.sent).toHaveLength(2)
     rig.loop.stopAll()
     rig.emitter.reset()

package/telegram-plugin/tests/tg-post-logger-error-shape.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Wire-level outcome tests for the `tg-post` logger's error shape (#3927).
+ *
+ * The bug: grammY resolves its transformer chain with the raw `ApiResponse`
+ * and only converts `{ok:false}` into a thrown `GrammyError` AFTER the chain
+ * returns (grammy `out/core/client.js`, `callApi`). Every Telegram-level
+ * rejection — 429 flood-wait, 400, 403 — therefore reached
+ * `installTgPostLogger` as a RESOLVED value and was logged
+ * `status=ok err=- code=- desc=-`. Only transport `HttpError`s ever hit the
+ * `catch`. A rate-limited `unpinAllChatMessages` on clerk logged as SUCCESS
+ * 3ms before the retry policy logged `429 rate limited, waiting 3s`.
+ *
+ * These tests MUST go through a REAL grammy `Bot` with a stubbed transport
+ * (the same reason `rich-markdown-guard-transformer.test.ts` does): the
+ * mock-`api` harnesses sit ABOVE the transformer layer, so `api.config.use`
+ * transformers never run there and a test written through them would be a
+ * false guard. Stubbing `client.fetch` with an `ok:false` envelope is the
+ * only way to reproduce the exact resolved-rejection path.
+ */
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { Bot } from 'grammy'
+import { installTgPostLogger } from '../shared/bot-runtime.js'
+
+/**
+ * A real Bot whose transport always answers with the given Telegram
+ * envelope. HTTP status stays 200 — a Bot API rejection is a 200 response
+ * carrying `ok:false`, which is precisely why it resolves the chain.
+ */
+function makeBot(envelope: Record<string, unknown>): Bot {
+  const fakeFetch = (async () =>
+    ({
+      ok: true,
+      status: 200,
+      json: async () => envelope,
+    }) as unknown as Response) as unknown as typeof fetch
+
+  const bot = new Bot('123456:TEST_TOKEN', {
+    botInfo: {
+      id: 123456,
+      is_bot: true,
+      first_name: 'Test',
+      username: 'test_bot',
+      can_join_groups: false,
+      can_read_all_group_messages: false,
+      supports_inline_queries: false,
+      can_connect_to_business: false,
+      has_main_web_app: false,
+    },
+    client: { fetch: fakeFetch },
+  })
+  installTgPostLogger(bot)
+  return bot
+}
+
+/** Run one API call against the stub and return every tg-post line emitted. */
+async function tgPostLinesFor(envelope: Record<string, unknown>): Promise<string[]> {
+  const written: string[] = []
+  const spy = vi
+    .spyOn(process.stderr, 'write')
+    .mockImplementation(((chunk: unknown) => {
+      written.push(String(chunk))
+      return true
+    }) as unknown as typeof process.stderr.write)
+  try {
+    const bot = makeBot(envelope)
+    // grammy converts the ok:false envelope into a thrown GrammyError once
+    // the transformer chain has returned — expected, and not what we assert.
+    await bot.api.sendMessage(4242, 'hello').catch(() => undefined)
+  } finally {
+    spy.mockRestore()
+  }
+  return written.filter(l => l.startsWith('tg-post '))
+}
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+describe('tg-post logger — resolved ok:false responses (#3927)', () => {
+  it('logs a 429 flood-wait as status=err code=429 (FAILS before the fix: logged status=ok)', async () => {
+    const lines = await tgPostLinesFor({
+      ok: false,
+      error_code: 429,
+      description: 'Too Many Requests: retry after 3',
+      parameters: { retry_after: 3 },
+    })
+
+    expect(lines).toHaveLength(1)
+    const line = lines[0]
+    expect(line).toContain('status=err')
+    expect(line).toContain('code=429')
+    expect(line).toContain('err=telegram_429')
+    expect(line).toContain('desc=Too Many Requests: retry after 3')
+    // The precise regression: it must NOT claim success.
+    expect(line).not.toContain('status=ok')
+  })
+
+  it('logs a non-benign 400 as status=err carrying the rejection reason', async () => {
+    const lines = await tgPostLinesFor({
+      ok: false,
+      error_code: 400,
+      description: "Bad Request: can't parse entities: unsupported start tag",
+    })
+
+    expect(lines).toHaveLength(1)
+    expect(lines[0]).toContain('status=err')
+    expect(lines[0]).toContain('code=400')
+    expect(lines[0]).toContain("desc=Bad Request: can't parse entities")
+  })
+
+  it('logs a 403 as status=err', async () => {
+    const lines = await tgPostLinesFor({
+      ok: false,
+      error_code: 403,
+      description: 'Forbidden: bot was blocked by the user',
+    })
+
+    expect(lines).toHaveLength(1)
+    expect(lines[0]).toContain('status=err')
+    expect(lines[0]).toContain('code=403')
+  })
+})
+
+describe('tg-post logger — benign 400s do not become error noise (#3927)', () => {
+  // Promoting every ok:false to status=err would flood the log with the
+  // high-volume no-ops the retry policy already swallows, burying the signal
+  // this change exists to create. They get their own `benign` tier instead:
+  // still logged (same volume as the status=ok line they replace), never
+  // matched by `grep status=err`.
+  const benign: Array<[string, string]> = [
+    ['not modified', 'Bad Request: message is not modified'],
+    ['edit target gone', 'Bad Request: message to edit not found'],
+    ['delete target gone', 'Bad Request: message to delete not found'],
+  ]
+
+  for (const [label, description] of benign) {
+    it(`logs "${label}" as status=benign, never status=err`, async () => {
+      const lines = await tgPostLinesFor({ ok: false, error_code: 400, description })
+
+      expect(lines).toHaveLength(1)
+      expect(lines[0]).toContain('status=benign')
+      expect(lines[0]).not.toContain('status=err')
+      // Still honest about what happened — the reason is on the line.
+      expect(lines[0]).toContain('code=400')
+      expect(lines[0]).toContain('desc=Bad Request: message')
+    })
+  }
+})
+
+describe('tg-post logger — success is unchanged', () => {
+  it('still logs a genuine ok:true response as status=ok with empty error fields', async () => {
+    const lines = await tgPostLinesFor({
+      ok: true,
+      result: { message_id: 7, date: 0, chat: { id: 4242, type: 'private' } },
+    })
+
+    expect(lines).toHaveLength(1)
+    expect(lines[0]).toContain('status=ok')
+    expect(lines[0]).toContain('err=- code=- desc=-')
+  })
+})

package/telegram-plugin/tests/turn-mint-defers-until-dequeue.test.ts

@@ -0,0 +1,196 @@
+/**
+ * #3927 FIX A — a QUEUE event is not a TURN-START event.
+ *
+ * Pre-fix, `case 'enqueue'` in stream-render.ts unconditionally minted a fresh
+ * `CurrentTurn` and swapped it into the per-topic slot, even with a turn
+ * already live. The claude CLI writes `{"type":"queue-operation","operation":
+ * "enqueue"}` at QUEUE time, so a message the operator sent mid-turn produced
+ * a brand-new card (reset `startedAt` / `toolCallCount` / `mirrorLines`) that
+ * then streamed the STILL-RUNNING previous turn's tool labels into it, while
+ * the real turn's card froze on its last edit.
+ *
+ * Ground truth (60 real agent transcripts, 372 enqueues): every enqueue is
+ * terminated by exactly one of
+ *   • `dequeue` — queue drained into a NEW turn (199/200 dequeues are directly
+ *     preceded by their enqueue; median gap 6 ms idle, 2–14 s when queued
+ *     behind a running turn), or
+ *   • `remove`  — folded into the ALREADY-RUNNING turn as a `queued_command`
+ *     attachment, replaying the enqueue's `content` byte-for-byte.
+ *
+ * These drive the REAL `handleSessionEvent` (extracted-module golden-harness
+ * oracle, same standard as `stream-render-golden.test.ts`).
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  handleSessionEvent,
+  __resetParkedTurnStartsForTest,
+  __parkedTurnStartCountForTest,
+} from '../gateway/stream-render.js'
+import { projectTranscriptLine } from '../session-tail.js'
+import { CHAT, enqueue, inbound, makeHarness } from './turn-mint-harness.js'
+
+beforeEach(() => {
+  __resetParkedTurnStartsForTest()
+})
+
+describe('#3927 FIX A — a mid-turn enqueue parks; the turn mints on dequeue', () => {
+  it('a second enqueue while turn A is live opens NO card, does not steal the slot, ' +
+    'and later tool labels still land on A — then dequeue mints B', () => {
+    const h = makeHarness()
+
+    // ── message A arrives on an idle session: mints immediately (unchanged) ──
+    handleSessionEvent(h.deps, enqueue('501'))
+    handleSessionEvent(h.deps, { kind: 'dequeue' }) // the CLI's ms-later pair
+    const turnA = h.current()!
+    expect(turnA).not.toBeNull()
+    expect(turnA.sourceMessageId).toBe(501)
+    expect(h.cardsOpened).toHaveLength(1)
+    // The idle enqueue already minted, so the paired dequeue found nothing
+    // parked and was a no-op — NOT a second turn.
+    expect(h.cardsOpened[0]!.sourceMessageId).toBe(501)
+
+    // ── A does tool work ────────────────────────────────────────────────────
+    handleSessionEvent(h.deps, { kind: 'tool_label', toolName: 'Read', label: 'Reading config.ts' })
+    expect(turnA.labeledToolCount).toBe(1)
+
+    // ── the operator sends message B MID-TURN (no turn_end for A) ───────────
+    handleSessionEvent(h.deps, enqueue('502', 'also check the vault'))
+
+    // No second card. This is BUG 1: pre-fix a fresh card appeared here with
+    // reset stats while A's froze.
+    expect(h.cardsOpened).toHaveLength(1)
+    // The topic slot still points at A — object identity, not just shape.
+    expect(h.current()).toBe(turnA)
+    // This is BUG 2: pre-fix the slot pointed at B, whose card quoted B's
+    // message id while streaming A's still-running work.
+    expect(h.current()!.sourceMessageId).toBe(501)
+    expect(__parkedTurnStartCountForTest()).toBe(1)
+
+    // ── labels emitted AFTER B still belong to A's card ─────────────────────
+    handleSessionEvent(h.deps, { kind: 'tool_label', toolName: 'Bash', label: 'Running tests' })
+    expect(turnA.labeledToolCount).toBe(2)
+    expect(turnA.mirrorLines.join('\n')).toContain('Running tests')
+    expect(h.drains.every((d) => d.turnId === turnA.turnId)).toBe(true)
+
+    // ── A ends, the CLI drains the queue → B's turn mints NOW ───────────────
+    turnA.endedAt = Date.now()
+    handleSessionEvent(h.deps, { kind: 'dequeue' })
+    const turnB = h.current()!
+    expect(turnB).not.toBe(turnA)
+    expect(turnB.sourceMessageId).toBe(502)
+    expect(h.cardsOpened).toHaveLength(2)
+    expect(h.cardsOpened[1]!.sourceMessageId).toBe(502)
+    // Fresh stats belong to B and only B.
+    expect(turnB.labeledToolCount).toBe(0)
+    expect(turnB.mirrorLines).toEqual([])
+    expect(__parkedTurnStartCountForTest()).toBe(0)
+  })
+
+  it('a `remove` terminal discards the parked start, so a LATER dequeue cannot ' +
+    'mint a spurious turn for an already-folded message', () => {
+    const h = makeHarness()
+    handleSessionEvent(h.deps, enqueue('601'))
+    const turnA = h.current()!
+
+    // Queued mid-turn, then folded into A as a `queued_command` attachment.
+    const queued = enqueue('602', 'while you are in there…')
+    handleSessionEvent(h.deps, queued)
+    expect(__parkedTurnStartCountForTest()).toBe(1)
+    handleSessionEvent(h.deps, { kind: 'queue_remove', rawContent: queued.rawContent })
+    expect(__parkedTurnStartCountForTest()).toBe(0)
+
+    // A stray dequeue now must NOT resurrect 602 as its own turn.
+    handleSessionEvent(h.deps, { kind: 'dequeue' })
+    expect(h.current()).toBe(turnA)
+    expect(h.cardsOpened).toHaveLength(1)
+  })
+
+  it('dequeue pairs with the MOST RECENT parked start (evidence: max observed ' +
+    'gap to the newest enqueue is 14.2 s; to the oldest, hours)', () => {
+    const h = makeHarness()
+    handleSessionEvent(h.deps, enqueue('701'))
+    const turnA = h.current()!
+
+    handleSessionEvent(h.deps, enqueue('702'))
+    handleSessionEvent(h.deps, enqueue('703'))
+    expect(__parkedTurnStartCountForTest()).toBe(2)
+
+    turnA.endedAt = Date.now()
+    handleSessionEvent(h.deps, { kind: 'dequeue' })
+    expect(h.current()!.sourceMessageId).toBe(703)
+    expect(__parkedTurnStartCountForTest()).toBe(1)
+  })
+
+  it('a chat-less enqueue never parks (it can never mint a turn)', () => {
+    const h = makeHarness()
+    handleSessionEvent(h.deps, { kind: 'enqueue', chatId: null, messageId: null, threadId: null, rawContent: 'x' })
+    expect(__parkedTurnStartCountForTest()).toBe(0)
+    expect(h.current()).toBeNull()
+    expect(h.cardsOpened).toHaveLength(0)
+  })
+
+  it('a parked start expires after its TTL, so a dequeue that never arrives can ' +
+    'never mint a stale turn later', () => {
+    // RUNNER-AGNOSTIC CLOCK. This file dual-runs (vitest + `bun test`), and
+    // bun's vitest shim does NOT implement `vi.setSystemTime` — calling it
+    // threw `TypeError: vi.setSystemTime is not a function` and made bun-test
+    // deterministically red. The TTL is a pure elapsed-time comparison
+    // (`now - parkedAt > PARKED_TURN_START_TTL_MS`), so the absolute wall
+    // clock is irrelevant; only the 31-minute JUMP matters. `useFakeTimers()`
+    // + `advanceTimersByTime()` moves `Date.now()` by exactly that delta on
+    // BOTH runners (same insight as races.test.ts:275-281), so the assertion
+    // below really executes under bun instead of being guarded away.
+    vi.useFakeTimers()
+    try {
+      const h = makeHarness()
+      handleSessionEvent(h.deps, enqueue('1201'))
+      const turnA = h.current()!
+      handleSessionEvent(h.deps, enqueue('1202'))
+      expect(__parkedTurnStartCountForTest()).toBe(1)
+
+      // The CLI died mid-turn: neither `dequeue` nor `remove` ever arrives.
+      vi.advanceTimersByTime(31 * 60_000) // TTL is 30 min
+      turnA.endedAt = Date.now()
+      handleSessionEvent(h.deps, { kind: 'dequeue' })
+
+      // 1202 was pruned, not minted 31 minutes late.
+      expect(__parkedTurnStartCountForTest()).toBe(0)
+      expect(h.current()).toBe(turnA)
+      expect(h.cardsOpened).toHaveLength(1)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('the parked store is bounded — the 17th mid-turn enqueue evicts the oldest, ' +
+    'so a dequeue that never arrives cannot grow it without limit', () => {
+    const h = makeHarness()
+    handleSessionEvent(h.deps, enqueue('801'))
+    for (let i = 0; i < 40; i++) handleSessionEvent(h.deps, enqueue(String(900 + i)))
+    expect(__parkedTurnStartCountForTest()).toBe(16)
+    // The newest message — the one the user is actually waiting on — survived.
+    h.current()!.endedAt = Date.now()
+    handleSessionEvent(h.deps, { kind: 'dequeue' })
+    expect(h.current()!.sourceMessageId).toBe(939)
+  })
+})
+
+describe('#3927 — session-tail projects the `remove` queue operation', () => {
+  it('projects op=remove as queue_remove carrying the enqueue content verbatim', () => {
+    const content = inbound('901', 'queued while busy')
+    const evs = projectTranscriptLine(
+      JSON.stringify({ type: 'queue-operation', operation: 'remove', content }),
+    )
+    expect(evs).toEqual([{ kind: 'queue_remove', rawContent: content }])
+  })
+
+  it('still projects enqueue and dequeue unchanged', () => {
+    const content = inbound('902', 'hello')
+    expect(projectTranscriptLine(
+      JSON.stringify({ type: 'queue-operation', operation: 'enqueue', content }),
+    )).toEqual([{ kind: 'enqueue', chatId: CHAT, messageId: '902', threadId: null, rawContent: content }])
+    expect(projectTranscriptLine(
+      JSON.stringify({ type: 'queue-operation', operation: 'dequeue' }),
+    )).toEqual([{ kind: 'dequeue' }])
+  })
+})

package/telegram-plugin/tests/turn-mint-harness.ts

@@ -0,0 +1,155 @@
+/**
+ * Shared harness for the #3927 turn-mint tests (FIX A / FIX B). NOT a test file
+ * — it drives the REAL `handleSessionEvent` against fake gateway closures, the
+ * extracted-module golden-harness oracle used by `stream-render-golden.test.ts`.
+ */
+import { tmpdir } from 'node:os'
+import type { CurrentTurn, StreamRenderDeps } from '../gateway/gateway.js'
+
+export const CHAT = '1001'
+
+/** `<channel …>` envelope shaped like the real inbound wrapper the CLI queues. */
+export function inbound(messageId: string, text: string): string {
+  return (
+    `<channel source="switchroom-telegram" chat_id="${CHAT}" ` +
+    `message_id="${messageId}" user="tester">${text}</channel>`
+  )
+}
+
+export interface Harness {
+  deps: StreamRenderDeps
+  /** Every card the early-liveness open posted, in order (one per minted turn). */
+  cardsOpened: Array<{ turnId: string; sourceMessageId: number | null }>
+  /** Turns handed to `clearActivitySummary`, in order (FIX B's observable). */
+  finalized: CurrentTurn[]
+  /** `drainActivitySummary` calls: which turn's feed was drained, and its text. */
+  drains: Array<{ turnId: string; render: string | null }>
+  /** Ordered trace of surface effects: `finalize:<turnId>` / `open:<turnId>`. */
+  seq: string[]
+  current: () => CurrentTurn | null
+}
+
+export function makeHarness(): Harness {
+  let curTurn: CurrentTurn | null = null
+  const cardsOpened: Harness['cardsOpened'] = []
+  const finalized: CurrentTurn[] = []
+  const drains: Harness['drains'] = []
+  const seq: string[] = []
+  const noop = () => {}
+  const key = (c: string, t?: number | null) => `${c}:${t ?? 'main'}`
+
+  const deps = {
+    // config
+    ANSWER_LANE: { visibleEnabled: false },
+    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,
+    // state
+    activeDraftStreams: new Map(),
+    activeStatusReactions: new Map(),
+    activeTurnStartedAt: new Map(),
+    backstopDeliveryLedger: { has: () => false, record: noop },
+    bot: { api: {} },
+    deliveryQueue: {},
+    flushedTurnSupersede: { record: noop },
+    handbackPreturnSignal: { tryAdopt: () => null },
+    idleTracker: { noteEvent: noop },
+    lastPtyPreviewByChat: new Map(),
+    obligationLedger: { close: noop, noteTurnEnded: noop },
+    outboundDedup: { check: () => null, record: noop },
+    pendingCrossTurnGate: new Map(),
+    preambleSuppressor: { dropNow: noop, flushNow: noop, onText: noop, onTool: noop, reset: noop },
+    progressDriver: null,
+    reactionTransitionCounts: new Map(),
+    sessionModelSource: { noteTranscriptModel: noop },
+    suppressPtyPreview: new Set(),
+    toolFlightTracker: { inFlightCount: () => 0 },
+    typingWrapper: { drainAll: noop, onToolResult: noop, onToolUse: noop },
+    robustApiCall: (fn: () => Promise<unknown>) => fn(),
+    swallowingApiCall: async (fn: () => Promise<unknown>) => { try { return await fn() } catch { return undefined } },
+    // accessors
+    getCurrentTurn: () => curTurn,
+    setCurrentTurn: (t: CurrentTurn) => { curTurn = t },
+    getLastContextExhaustionWarningAt: () => 0,
+    setLastContextExhaustionWarningAt: noop,
+    getPendingPtyPartial: () => null,
+    setPendingPtyPartial: noop,
+    // closures we observe
+    clearActivitySummary: (t: CurrentTurn) => { finalized.push(t); seq.push(`finalize:${t.turnId}`) },
+    scheduleEarlyLivenessOpen: (t: CurrentTurn) => {
+      // Models the real early-open: ONE card per minted turn. Pre-fix this ran
+      // for every enqueue, which is exactly how the duplicate card appeared.
+      cardsOpened.push({ turnId: t.turnId, sourceMessageId: t.sourceMessageId })
+      seq.push(`open:${t.turnId}`)
+    },
+    drainActivitySummary: (t: CurrentTurn) => {
+      drains.push({ turnId: t.turnId, render: t.activityPendingRender })
+      return Promise.resolve()
+    },
+    // rest of the closure surface
+    cardDrainGate: (_t: unknown, _ea: unknown, run: () => void) => run(),
+    clearAnswerReadyFlushTimeout: noop,
+    closeActivityLane: noop,
+    closeProgressLane: noop,
+    completeProgressCardTurn: null,
+    composeTurnActivity: () => null,
+    confirmMemoryLegibility: noop,
+    deliverAnswer: async () => ({ sentIds: [], chunkCount: 0, delivered: false, exhausted: false }),
+    deliverCapturedProse: async () => {},
+    emissionAuthorityFor: () => ({
+      mayDrain: () => true,
+      openOrEditCard: (_p: string, run: () => void) => run(),
+      claimOrDowngradePing: (_i: unknown, _s: unknown, _a: unknown, disabled: () => void) => disabled(),
+      markSubstantiveFinalDelivered: (fn: () => void) => fn(),
+      finalizeCard: (fn: () => void) => fn(),
+    }),
+    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) => t,
+    rememberRecentTurn: noop,
+    resetAnswerReadyFlushTimeout: noop,
+    resetOrphanedReplyTimeout: noop,
+    resolvePendingNarrativeOnTool: noop,
+    stagePendingNarrative: noop,
+    startTurnTypingLoop: noop,
+    statusKey: key,
+    streamKey: key,
+    surfaceMemoryLegibility: noop,
+    turnLiveForItsTopic: () => true,
+    turnsDb: null,
+    unpinProgressCardForChat: null,
+  } as unknown as StreamRenderDeps
+
+  return { deps, cardsOpened, finalized, drains, seq, current: () => curTurn }
+}
+
+export function enqueue(messageId: string | null, text = 'hi', threadId: string | null = null) {
+  return {
+    kind: 'enqueue' as const,
+    chatId: CHAT,
+    messageId,
+    threadId,
+    rawContent: messageId == null ? text : inbound(messageId, text),
+  }
+}
+