switchroom 0.20.22 → 0.21.1

package/telegram-plugin/history.ts

@@ -25,8 +25,9 @@
  * chat exists in the DB.
  */
 
-import { chmodSync, existsSync, mkdirSync } from 'fs'
+import { chmodSync, existsSync } from 'fs'
 import { join } from 'path'
+import { adoptSqliteOwnership, mkdirStateSync } from '../src/util/state-owner.js'
 import { redact } from './secret-detect/redact.js'
 
 /**
@@ -81,7 +82,22 @@ function loadDatabaseClass(): SqliteDatabaseConstructor {
   }
 }
 
-export type MessageRole = 'user' | 'assistant'
+/**
+ * `system` is the CARD lane (#4571): a bot→user message the gateway posted as
+ * a UI surface rather than as an answer — the mid-turn activity card, the
+ * status pin, approval / boot / issues / worker-feed cards, restart notices,
+ * `progress_update` lines. Those consume real Telegram message ids, so the
+ * operator can (and does) quote-reply to one; before this lane existed the
+ * row simply did not exist and the reply resolved to nothing.
+ *
+ * They are deliberately NOT `assistant`: every delivery-accounting predicate
+ * in this file keys on `role = 'assistant'` meaning "the user was actually
+ * answered" (`getRecentOutboundCount`, `hasOutboundDeliveredSince`,
+ * `hasOutboundWithText`), and calling a card an answer would silently suppress
+ * the silence/over-ping/represent safety nets. A distinct value keeps every
+ * existing predicate byte-identical while making the id resolvable.
+ */
+export type MessageRole = 'user' | 'assistant' | 'system'
 
 export interface RecordedMessage {
   chat_id: string
@@ -127,6 +143,14 @@ export interface RecordedMessage {
   forwarded_from_id: string | null
   forwarded_date: string | null
   forwarded_message_id: number | null
+  /**
+   * Discriminator for a `system` (card) row: the send's `verb` tag as it was
+   * passed to the gateway's retry wrapper, normalised (`activity-summary.send`
+   * → `activity-summary`). Null for `user` / `assistant` rows and for an
+   * untagged send. Surfaced to the agent as `reply_to_kind` when a native
+   * reply points at one of these messages.
+   */
+  kind: string | null
 }
 
 export interface QueryOptions {
@@ -134,6 +158,14 @@ export interface QueryOptions {
   thread_id?: number | null
   limit?: number
   before_message_id?: number
+  /**
+   * Include `system` (card) rows in the result. DEFAULT FALSE, deliberately:
+   * cards are ephemeral UI, and `get_recent_messages` renders straight into
+   * the operator-visible model context — a wall of activity-card rows there
+   * would be a regression. Card rows stay RESOLVABLE by id (see
+   * {@link lookupMessageRoleAndText}) without being LISTED.
+   */
+  include_system?: boolean
 }
 
 const DEFAULT_LIMIT = 10
@@ -185,7 +217,7 @@ function isValidMessageId(id: unknown): id is number {
 export function initHistory(stateDir: string, retentionDays = 30): void {
   if (db != null) return
   const Database = loadDatabaseClass()
-  mkdirSync(stateDir, { recursive: true, mode: 0o700 })
+  mkdirStateSync(stateDir, { recursive: true, mode: 0o700 })
   const path = join(stateDir, 'history.db')
   dbPath = path
   db = new Database(path, { create: true })
@@ -212,6 +244,7 @@ export function initHistory(stateDir: string, retentionDays = 30): void {
       group_id       INTEGER,
       reply_to_message_id INTEGER,
       reply_to_text  TEXT,
+      kind           TEXT,
       PRIMARY KEY (chat_id, thread_id, message_id)
     )
   `)
@@ -232,6 +265,10 @@ export function initHistory(stateDir: string, retentionDays = 30): void {
     "forwarded_from_id TEXT",
     "forwarded_date TEXT",
     "forwarded_message_id INTEGER",
+    // #4571 — card/system-surface discriminator. Nullable with no default, so
+    // the ALTER is instant on a multi-thousand-row live DB and every existing
+    // row keeps its exact contents (SQLite backfills NULL without a rewrite).
+    "kind TEXT",
   ]) {
     try {
       db.exec(`ALTER TABLE messages ADD COLUMN ${column}`)
@@ -300,6 +337,12 @@ export function initHistory(stateDir: string, retentionDays = 30): void {
     const f = path + suffix
     if (existsSync(f)) { try { chmodSync(f, 0o644) } catch { /* ignore */ } }
   }
+  // Ownership rides the same hook as the mode, for the same reason. SQLite
+  // creates `-wal`/`-shm` itself, in C, so no `node:fs` write helper can ever
+  // see them — this is the only place we get to fix their owner. A root
+  // gateway would otherwise leave root:root DB files in an agent-owned state
+  // dir and EACCES every non-root reader. No-op off the root path.
+  adoptSqliteOwnership(path)
 
   if (retentionDays > 0) {
     const cutoff = Math.floor(Date.now() / 1000) - retentionDays * 86400
@@ -422,6 +465,9 @@ export function checkpointWal(): boolean {
         const f = dbPath + suffix
         if (existsSync(f)) { try { chmodSync(f, 0o644) } catch { /* ignore */ } }
       }
+      // …and ownership with it: a TRUNCATE checkpoint DELETES and RE-CREATES
+      // the sidecars, so the owner we set at init is gone by here.
+      adoptSqliteOwnership(dbPath)
     }
     return true
   } catch {
@@ -609,12 +655,29 @@ export function recordOutbound(args: RecordOutboundArgs): void {
       (chat_id, thread_id, message_id, role, user, user_id, ts, text, attachment_kind, group_id)
     VALUES (?, ?, ?, 'assistant', NULL, NULL, ?, ?, ?, ?)
   `)
+  // #4571 — a real reply ALWAYS wins over a provisional card row.
+  //
+  // The system-lane observer (gateway `robustApiCall`) records every sent
+  // message the moment the API resolves, which is BEFORE the caller reaches
+  // its own `recordOutbound`. `INSERT OR REPLACE` alone would not reliably
+  // overwrite that row: the unique key folds `thread_id`, and the observer
+  // derives the thread from the Telegram response (which sets
+  // `message_thread_id` on reply chains in plain supergroups) while this
+  // writer uses the gateway's own `threadId` — a mismatch would leave BOTH
+  // rows and let the card row shadow the answer for id lookups. Deleting on
+  // (chat_id, message_id) — unique within a chat regardless of thread, the
+  // same assumption `recordEdit` / `recordReaction` already make — makes the
+  // promotion exact and is a no-op when no observer row exists.
+  const dropSystem = requireDb().prepare(
+    `DELETE FROM messages WHERE chat_id = ? AND message_id = ? AND role = 'system'`,
+  )
   // bun:sqlite has a transaction() helper. Cheap insurance against partial
   // writes if the process dies mid-loop. The transaction signature is
   // typed as variadic-unknown for genericity; cast the typed callback
   // through the wider shape.
   const tx = requireDb().transaction(((rows: Array<{ id: number; text: string; attachKind: string | null }>) => {
     for (const r of rows) {
+      dropSystem.run(args.chat_id, r.id)
       stmt.run(args.chat_id, args.thread_id ?? null, r.id, ts, r.text, r.attachKind, groupId)
     }
   }) as (...args: unknown[]) => unknown)
@@ -634,6 +697,97 @@ export function recordOutbound(args: RecordOutboundArgs): void {
   }
 }
 
+export interface RecordSystemOutboundArgs {
+  chat_id: string
+  thread_id: number | null | undefined
+  message_id: number
+  /** Normalised send verb (`activity-summary`, `approval-card`, …) or null. */
+  kind: string | null | undefined
+  /** Rendered text as Telegram echoed it back. May be empty. */
+  text: string
+  /** Unix SECONDS. Defaults to now. */
+  ts?: number
+}
+
+/**
+ * Record a CARD / system-surface outbound (#4571).
+ *
+ * Conditional insert on (chat_id, message_id): if ANY row already exists for
+ * that id — a real `assistant` reply recorded by `recordOutbound`, an inbound,
+ * or a previously-recorded card — this is a no-op and returns false. That is
+ * what makes the call safe to fire from a blanket send observer that cannot
+ * distinguish a fresh send from an edit of a message it already knows: an edit
+ * returns the SAME `message_id`, hits the `NOT EXISTS` guard, and falls through
+ * to {@link updateSystemOutboundText} instead of duplicating a row per edit.
+ *
+ * Never throws — a card row is a nice-to-have, and a failure here must not
+ * break the send path it is observing. Failures are logged via `warnHistory`.
+ *
+ * Returns true iff a new row was inserted.
+ */
+export function recordSystemOutbound(args: RecordSystemOutboundArgs): boolean {
+  if (!isValidMessageId(args.message_id)) return false
+  // History disabled / not yet initialised: stay silent. This is called from a
+  // blanket send observer, so a warn here would be one stderr line per API call.
+  if (db == null) return false
+  try {
+    const res = requireDb()
+      .prepare(`
+        INSERT INTO messages
+          (chat_id, thread_id, message_id, role, user, user_id, ts, text, attachment_kind, group_id, kind)
+        SELECT ?, ?, ?, 'system', NULL, NULL, ?, ?, NULL, NULL, ?
+         WHERE NOT EXISTS (
+           SELECT 1 FROM messages WHERE chat_id = ? AND message_id = ?
+         )
+      `)
+      .run(
+        args.chat_id,
+        args.thread_id ?? null,
+        args.message_id,
+        args.ts ?? Math.floor(Date.now() / 1000),
+        // Same outbound redaction chokepoint as recordOutbound: a card body is
+        // rendered from live tool activity and can quote a secret.
+        redact(args.text),
+        args.kind ?? null,
+        args.chat_id,
+        args.message_id,
+      ) as { changes?: number }
+    return (res?.changes ?? 0) > 0
+  } catch (err) {
+    warnHistory(
+      `recordSystemOutbound: INSERT failed (chat=${args.chat_id} id=${args.message_id}): ` +
+        `${err instanceof Error ? err.message : String(err)} — a posted card will not be ` +
+        `resolvable if the operator quote-replies to it`,
+    )
+    return false
+  }
+}
+
+/**
+ * Refresh a card row's stored text in place (#4571). Only ever touches a
+ * `system` row, so an edit of a real reply can never be rewritten through this
+ * path (`recordEdit` owns that).
+ *
+ * `ts` is deliberately NOT bumped: it is the card's POST time, which is what
+ * retention prunes on. Never throws. Returns true iff a row was updated.
+ */
+export function updateSystemOutboundText(args: {
+  chat_id: string
+  message_id: number
+  text: string
+}): boolean {
+  try {
+    const res = requireDb()
+      .prepare(
+        `UPDATE messages SET text = ? WHERE chat_id = ? AND message_id = ? AND role = 'system'`,
+      )
+      .run(redact(args.text), args.chat_id, args.message_id) as { changes?: number }
+    return (res?.changes ?? 0) > 0
+  } catch {
+    return false
+  }
+}
+
 interface RecordEditArgs {
   chat_id: string
   message_id: number
@@ -781,16 +935,27 @@ export function getLatestInboundMessageId(
 export function lookupMessageRoleAndText(
   chatId: string,
   messageId: number,
-): { role: 'user' | 'assistant'; text: string } | null {
-  const row = requireDb()
-    .prepare(
-      `SELECT role, text FROM messages WHERE chat_id = ? AND message_id = ? LIMIT 1`,
-    )
-    .get(chatId, messageId) as
-    | { role: 'user' | 'assistant'; text: string | null }
+  opts?: {
+    /**
+     * Also resolve `system` (card) rows. DEFAULT FALSE so the two
+     * authorship-sensitive callers — the reaction trigger's
+     * `role === 'assistant'` bot-authored predicate and the
+     * `reaction_dispatch` preview — keep their exact pre-#4571 behaviour
+     * (a card was invisible to them, and still is). The reply-antecedent
+     * resolver opts IN: that is the whole point of the card lane.
+     */
+    includeSystem?: boolean
+  },
+): { role: MessageRole; text: string; kind: string | null } | null {
+  const sql =
+    `SELECT role, text, kind FROM messages WHERE chat_id = ? AND message_id = ?` +
+    (opts?.includeSystem === true ? '' : ` AND role <> 'system'`) +
+    ` LIMIT 1`
+  const row = requireDb().prepare(sql).get(chatId, messageId) as
+    | { role: MessageRole; text: string | null; kind: string | null }
     | undefined
   if (!row) return null
-  return { role: row.role, text: row.text ?? '' }
+  return { role: row.role, text: row.text ?? '', kind: row.kind ?? null }
 }
 
 export function getRecentOutboundCount(
@@ -1007,6 +1172,8 @@ export function query(opts: QueryOptions): RecordedMessage[] {
   const limit = Math.min(MAX_LIMIT, Math.max(1, opts.limit ?? DEFAULT_LIMIT))
   const params: unknown[] = [opts.chat_id]
   let sql = 'SELECT * FROM messages WHERE chat_id = ?'
+  // #4571 — card rows are resolvable, not listable. See QueryOptions.include_system.
+  if (opts.include_system !== true) sql += " AND role <> 'system'"
   if (opts.thread_id !== undefined) {
     if (opts.thread_id === null) {
       sql += ' AND thread_id IS NULL'

package/telegram-plugin/registry/turns-schema.ts

@@ -36,8 +36,9 @@
  *   otherwise; the gateway then resumes or reports accordingly.
  */
 
-import { chmodSync, mkdirSync } from 'fs'
+import { chmodSync } from 'fs'
 import { join } from 'path'
+import { adoptSqliteOwnership, mkdirStateSync } from '../../src/util/state-owner.js'
 
 // ---------------------------------------------------------------------------
 // bun:sqlite lazy-loader (same pattern as history.ts)
@@ -302,7 +303,7 @@ function applySchema(db: SqliteDatabase): void {
 export function openTurnsDb(agentDir: string): SqliteDatabase {
   const Database = loadDatabaseClass()
   const dir = join(agentDir, 'telegram')
-  mkdirSync(dir, { recursive: true, mode: 0o700 })
+  mkdirStateSync(dir, { recursive: true, mode: 0o700 })
   const path = join(dir, 'registry.db')
   const db = new Database(path, { create: true })
   applySchema(db)
@@ -318,6 +319,11 @@ export function openTurnsDb(agentDir: string): SqliteDatabase {
   } catch {
     /* ignore — chmod not supported on some FUSE mounts */
   }
+  // Same reasoning as the chmod above, for the owner rather than the mode:
+  // a root-running gateway must not leave root:root DB files in an
+  // agent-owned state dir. `-wal`/`-shm` are created by SQLite in C, so this
+  // hook is the only place we can reach them. No-op off the root path.
+  adoptSqliteOwnership(path)
   return db
 }
 

package/telegram-plugin/shared/sent-text-capture.ts

@@ -0,0 +1,191 @@
+/**
+ * sent-text-capture.ts — the card-body FALLBACK: stamp a send's REQUEST body
+ * onto the `Message` Telegram returned for it (#4571 / #4576 follow-up).
+ *
+ * Read this first: it is NOT the primary source of the stored card body.
+ * -----------------------------------------------------------------------
+ * `system-message-observer.ts` takes the body off the RESPONSE — `rich_message`
+ * (Telegram's own rendered block tree) first, then `text` / `caption`. That is
+ * the more faithful source, and it covers every send verb the gateway writes a
+ * history row for. This module supplies the LAST tier of that precedence
+ * chain, for responses that carry no renderable body at all: a rich send whose
+ * blocks flatten to nothing (a media-only card), or a future verb whose
+ * response omits the body.
+ *
+ * Deliberately last, because the body it captures is NOT the body as written.
+ * The dominant card path is `sendRichMessage(chat, richMessage(body))`, and
+ * `richMessage()` applies `guardAccidentalFormatting` in the CALLER
+ * (`rich-send.ts`), long before any transformer seam. So what this module sees
+ * on that path is already wire-escaped: `sent_text_capture.ts` arrives as
+ * `sent\_text\_capture.ts`, `$12.40` as `\$12.40`. Escaped-but-present beats
+ * empty, which is why the tier exists at all — but it must never win over a
+ * response that resolved those escapes.
+ *
+ * The bug this exists to backstop
+ * -------------------------------
+ * #4576 gave every gateway card a `role='system'` history row so a quote-reply
+ * to it resolves. The row carried the right `message_id`, chat, thread and
+ * `kind` — and an EMPTY `text`, on 100% of the rows, on every agent in the
+ * fleet. `resolveReplyToFromBuffer` only sets `reply_to_text` when the stored
+ * body is non-empty (`inbound-router.ts`), so the agent learned WHICH card was
+ * tapped and still could not see WHAT IT SAID. That was the entire point.
+ *
+ * Root cause: the observer read ONE body field off the response
+ * (`msg.text ?? msg.caption`), and every card goes out through Bot API 10.1
+ * `sendRichMessage`, whose response is a `Message.RichMessageMessage` — the
+ * body lives under `rich_message: { blocks }`, and `text` / `caption` are
+ * simply absent (`@grammyjs/types` `message.d.ts:94`, `:180`; Bot API
+ * `RichMessage.blocks` = "Content of the message"). So the extractor fell
+ * through to `''` every single time. Reading `rich_message` is the fix; this
+ * module is the belt to that pair of braces.
+ *
+ * The mechanism
+ * -------------
+ * Capture the body from the REQUEST at the one seam no outbound call can
+ * bypass: a grammY API transformer (`bot.api.config.use`) — the same seam
+ * `installRichMarkdownGuard` already uses, and the reason that guard is
+ * universal where `richMessage()` is not.
+ *
+ * The transformer sees the outbound payload AND the resolved response in one
+ * call, so it can pair them with zero bookkeeping: no id→text map, no eviction,
+ * no cross-call race. It stamps the body onto the returned `Message` under a
+ * non-enumerable, `Symbol.for`-keyed property, which:
+ *   - survives grammY's `callApi` unwrapping — the transformer chain resolves
+ *     with the raw `{ok, result}` envelope and `callApi` returns `data.result`
+ *     BY REFERENCE (grammy 1.44.0 `out/core/client.js:95-99`), so the object
+ *     the caller receives is the object we stamped;
+ *   - is invisible to `JSON.stringify`, `Object.keys`, spreads and structural
+ *     equality, so nothing that reads a `Message` today can observe it.
+ *
+ * Non-negotiable: this must never break the send it observes. Every step is
+ * defensive and the transformer's only unconditional act is `return prev(...)`.
+ */
+
+import type { Bot } from 'grammy'
+
+/**
+ * The stamp key. `Symbol.for` (not a module-local `Symbol()`) deliberately:
+ * the plugin is consumed both from source and from a bundle, and a duplicated
+ * module instance would otherwise mint a second, non-matching symbol and
+ * silently reopen the exact hole this file closes.
+ */
+export const SENT_TEXT = Symbol.for('switchroom.telegram.sentText')
+
+/** Depth cap for the rich-block walk — a hostile/odd payload cannot recurse us. */
+const MAX_BLOCK_DEPTH = 8
+
+/**
+ * Best-effort readable text out of an OUTBOUND `InputRichMessage.blocks` array.
+ *
+ * Nothing in this repo builds `{ blocks }` today (every rich send goes through
+ * `richMessage()` → `{ markdown }`), so this is purely the guard against a
+ * future adopter silently re-emptying the card lane. Bounded, allocation-shy,
+ * never throws.
+ */
+function flattenInputRichBlocks(blocks: unknown, depth: number): string {
+  if (!Array.isArray(blocks) || depth > MAX_BLOCK_DEPTH) return ''
+  const parts: string[] = []
+  for (const block of blocks) {
+    if (block == null || typeof block !== 'object') continue
+    const b = block as Record<string, unknown>
+    for (const key of ['markdown', 'html', 'text', 'caption'] as const) {
+      const v = b[key]
+      if (typeof v === 'string' && v.length > 0) parts.push(v)
+    }
+    const nested = flattenInputRichBlocks(b.blocks, depth + 1)
+    if (nested.length > 0) parts.push(nested)
+  }
+  return parts.join('\n')
+}
+
+/**
+ * The body a Telegram API request is about to POST, or null when the payload
+ * carries no user-visible text (pins, deletes, reactions, `getUpdates`, …).
+ *
+ * Shape verified against grammy 1.44.0 `out/core/api.js` and the payload notes
+ * in `installRichMarkdownGuard`: `sendRichMessage` / rich `editMessageText`
+ * put the body at `payload.rich_message.markdown`, plain sends at
+ * `payload.text`, media sends at `payload.caption`. Pure.
+ */
+export function outboundPayloadText(payload: unknown): string | null {
+  if (payload == null || typeof payload !== 'object') return null
+  const p = payload as Record<string, unknown>
+  const rich = p.rich_message
+  if (rich != null && typeof rich === 'object') {
+    const r = rich as Record<string, unknown>
+    if (typeof r.markdown === 'string') return r.markdown
+    if (typeof r.html === 'string') return r.html
+    const flat = flattenInputRichBlocks(r.blocks, 0)
+    if (flat.length > 0) return flat
+  }
+  if (typeof p.text === 'string') return p.text
+  if (typeof p.caption === 'string') return p.caption
+  return null
+}
+
+/**
+ * Stamp `text` onto a resolved API response envelope's `Message` result.
+ *
+ * Takes the raw `{ok, result}` envelope (what a transformer sees), not the
+ * unwrapped message, and no-ops on anything that isn't a single Message —
+ * `true` (pins / dropped edits / `editMessageText` on an inline message),
+ * arrays, `{ok:false}` rejections. Never throws.
+ */
+export function attachSentText(envelope: unknown, text: string): void {
+  try {
+    if (envelope == null || typeof envelope !== 'object') return
+    const env = envelope as { ok?: unknown; result?: unknown }
+    if (env.ok !== true) return
+    const result = env.result
+    if (result == null || typeof result !== 'object' || Array.isArray(result)) return
+    Object.defineProperty(result, SENT_TEXT, {
+      value: text,
+      enumerable: false,
+      configurable: true,
+      writable: true,
+    })
+  } catch {
+    /* stamping must never break the send */
+  }
+}
+
+/**
+ * Read the body stamped by {@link installSentTextCapture} off a `Message`, or
+ * null when the message did not transit a capture-installed bot (a test double,
+ * a second Bot instance, a hand-built fixture). Pure.
+ */
+export function readSentText(message: unknown): string | null {
+  if (message == null || typeof message !== 'object') return null
+  const v = (message as Record<symbol, unknown>)[SENT_TEXT]
+  return typeof v === 'string' ? v : null
+}
+
+/**
+ * Install the capture transformer on the production Bot.
+ *
+ * Install it AFTER `installRichMarkdownGuard` so it composes OUTSIDE the guard
+ * (grammY's last-installed transformer runs first) and therefore captures the
+ * payload before the guard's backslash escapes are applied.
+ *
+ * Be precise about what that does and does not buy. It only avoids the
+ * TRANSFORMER's escaping pass, which matters for the call sites that build a
+ * raw `{ markdown }` and go straight to `sendRichMessage` / `editMessageText`
+ * (banners, approval and folder-picker edits — see `richMessage()`'s docblock
+ * for the list). It does NOT recover a pre-escape body for the dominant path,
+ * because `richMessage()` escapes in the CALLER, upstream of every transformer.
+ * There is no seam that can. That is precisely why this capture is the LAST
+ * tier of the observer's precedence chain rather than the first.
+ */
+export function installSentTextCapture(bot: Bot): void {
+  bot.api.config.use(async (prev, method, payload, signal) => {
+    let text: string | null = null
+    try {
+      text = outboundPayloadText(payload)
+    } catch {
+      text = null
+    }
+    const res = await prev(method, payload, signal)
+    if (text != null) attachSentText(res, text)
+    return res
+  })
+}

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from 'vitest'
 import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -29,6 +29,17 @@ function mirrorWith(sender: (m: OutboundToBuzzMessage) => boolean, opts?: { defa
 
 const BUZZ_COORDS = { channelId: 'chan-A', eventId: 'evt-1', threadRoot: 'root-1' }
 
+// Cross-FILE isolation. `getBuzzMirror()` is a module-level singleton and the
+// last describe here boots one (`maybeBootBuzzMirror`) with no trailing reset —
+// every `beforeEach` in this file resets on the way IN, nothing resets on the
+// way OUT. `bun test` runs every file in ONE process with no guaranteed file
+// order, so a booted mirror leaks into whichever suite runs next: sendReply's
+// Buzz hook (outbound-send-path.ts:2658) then fires in suites that never wired
+// its deps and dies on `findLatestTurnForChat is not a function` (observed:
+// 43 failures in send-reply-golden.test.ts, purely from readdir order).
+// Unconditional teardown here is the only ordering-proof fix.
+afterAll(() => __resetBuzzMirrorForTests())
+
 describe('BuzzMirror.mirrorReplyDelivered — routing + S1 owner guard', () => {
   beforeEach(() => __resetBuzzMirrorForTests())