switchroom 0.18.31 → 0.18.33

package/telegram-plugin/tests/boot-card-routing.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Boot-card "Routing" row (.routing-mode observability — 2026-07-17 boot-race
+ * incident: silent fable→opus demotion on one agent, silent fable→router-root
+ * divergence on another).
+ *
+ * Contract:
+ *   - `readRoutingMode` parses `<agentDir>/.routing-mode`, returns null on
+ *     absence/garbage (tolerant), and flags `prevBoot` when the file's mtime
+ *     predates this gateway boot (render-timing hazard: the gateway's outer
+ *     pass can render the card before the inner pass writes this boot's line).
+ *   - `renderBootCard` renders the row when `routing` is passed; stale values
+ *     are suffixed "(prev boot)" — never presented as current; divergence
+ *     (landed ≠ declared) gets the warning dot; absent file → no row at all.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync, utimesSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { readRoutingMode, renderRoutingRow, renderBootCard, containerBootStartMs } from '../gateway/boot-card.js'
+
+const LINE =
+  'mode=router-root base=http://litellm:4010 model=fable litellm_ok=1 declared=router-root ts=2026-07-17T02:00:00Z\n'
+
+describe('readRoutingMode', () => {
+  let dir: string
+  beforeEach(() => { dir = mkdtempSync(join(tmpdir(), 'routing-mode-')) })
+  afterEach(() => { rmSync(dir, { recursive: true, force: true }) })
+
+  it('parses a current-boot line', () => {
+    writeFileSync(join(dir, '.routing-mode'), LINE)
+    const r = readRoutingMode(dir, Date.now() - 60_000)
+    expect(r).not.toBeNull()
+    expect(r!.mode).toBe('router-root')
+    expect(r!.declared).toBe('router-root')
+    expect(r!.model).toBe('fable')
+    expect(r!.litellmOk).toBe('1')
+    expect(r!.prevBoot).toBe(false)
+  })
+
+  it('returns null when the file is absent (fleets pre-dating the state file)', () => {
+    expect(readRoutingMode(dir, Date.now())).toBeNull()
+  })
+
+  it('returns null on a garbage file with no mode= field', () => {
+    writeFileSync(join(dir, '.routing-mode'), 'not a routing line\n')
+    expect(readRoutingMode(dir, Date.now())).toBeNull()
+  })
+
+  it('flags prevBoot when the file mtime predates this gateway boot', () => {
+    writeFileSync(join(dir, '.routing-mode'), LINE)
+    const old = (Date.now() - 3_600_000) / 1000
+    utimesSync(join(dir, '.routing-mode'), old, old)
+    const r = readRoutingMode(dir, Date.now() - 1_000)
+    expect(r).not.toBeNull()
+    expect(r!.prevBoot).toBe(true)
+  })
+})
+
+describe('containerBootStartMs', () => {
+  it('derives PID-1 start epoch from /proc/stat btime + /proc/1/stat starttime', () => {
+    const btime = 1_700_000_000 // seconds since epoch
+    const startTicks = 500 // 5s after boot at 100 HZ
+    const fsImpl = {
+      readFileSync: ((p: unknown) => {
+        if (p === '/proc/stat') return `cpu 1 2 3\nbtime ${btime}\nprocesses 100\n`
+        if (p === '/proc/1/stat')
+          // pid (comm) state ... field22=starttime. comm has a space+paren to
+          // exercise the last-')' split.
+          return `1 (init a) S 0 1 1 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 ${startTicks} 0`
+        throw new Error('unexpected path')
+      }) as typeof readFileSync,
+    }
+    expect(containerBootStartMs(fsImpl)).toBe((btime + startTicks / 100) * 1000)
+  })
+
+  it('returns null when /proc is unavailable (fallback path for callers)', () => {
+    const fsImpl = {
+      readFileSync: (() => {
+        throw new Error('ENOENT')
+      }) as typeof readFileSync,
+    }
+    expect(containerBootStartMs(fsImpl)).toBeNull()
+  })
+
+  it('returns null when btime is missing', () => {
+    const fsImpl = {
+      readFileSync: ((p: unknown) =>
+        p === '/proc/stat' ? 'cpu 1 2 3\nprocesses 100\n' : '1 (init) S 0') as typeof readFileSync,
+    }
+    expect(containerBootStartMs(fsImpl)).toBeNull()
+  })
+})
+
+describe('renderRoutingRow / renderBootCard routing row', () => {
+  const base = { agentName: 'klanker', version: 'v1' }
+
+  it('renders a converged row with the routing dot and model', () => {
+    const row = renderRoutingRow({
+      mode: 'router-root', declared: 'router-root', model: 'fable', litellmOk: '1', prevBoot: false,
+    })
+    expect(row).toContain('**Routing**')
+    expect(row).toContain('router-root')
+    expect(row).toContain('`fable`')
+    expect(row).toContain('litellm ok')
+    expect(row).not.toContain('≠')
+    expect(row).not.toContain('prev boot')
+  })
+
+  it('marks divergence (landed ≠ declared) with the warning dot', () => {
+    const row = renderRoutingRow({
+      mode: 'passthrough', declared: 'router-root', model: 'opus', litellmOk: '0', prevBoot: false,
+    })
+    expect(row).toContain('🟡')
+    expect(row).toContain('≠ declared router-root')
+    expect(row).toContain('litellm unconfirmed')
+  })
+
+  it('labels a stale (previous-boot) value instead of presenting it as current', () => {
+    const row = renderRoutingRow({
+      mode: 'router-root', declared: 'router-root', prevBoot: true,
+    })
+    expect(row).toContain('(prev boot)')
+  })
+
+  it('renderBootCard includes the routing row when passed, omits it when routing is null/absent', () => {
+    const withRow = renderBootCard({
+      ...base,
+      routing: { mode: 'router-root', declared: 'passthrough', model: 'fable', litellmOk: '1', prevBoot: false },
+    })
+    expect(withRow).toContain('**Routing**')
+    expect(withRow).toContain('router-root')
+
+    const without = renderBootCard({ ...base })
+    expect(without).not.toContain('Routing')
+    const withNull = renderBootCard({ ...base, routing: null })
+    expect(withNull).toBe(without)
+  })
+})

package/telegram-plugin/tests/bot-commands-model-effort.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Outcome pins for the /model and /effort commands extracted from gateway.ts
+ * (switchroom#2996 P6 bot.command drain). Registers against a fake grammy Bot
+ * and drives the captured handlers with mock contexts: asserts the durable
+ * receipt-first contract (#3177 — log line + history row before any branch),
+ * the busy → ack+queue disposition (#3017/#3262), the menu path, and the
+ * direct-apply path for both commands.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  registerModelEffortCommands,
+  type ModelEffortCommandDeps,
+} from '../gateway/bot-commands-model-effort.js'
+
+type Handler = (ctx: any) => Promise<void>
+
+function fakeBot() {
+  const handlers = new Map<string, Handler>()
+  return {
+    bot: { command: (name: string, h: Handler) => void handlers.set(name, h) } as any,
+    handlers,
+  }
+}
+
+function makeDeps(over: Partial<ModelEffortCommandDeps> = {}) {
+  const log = vi.fn()
+  const recordInbound = vi.fn()
+  const enqueueSessionCommand = vi.fn()
+  const switchroomReply = vi.fn(async () => {})
+  const deps: ModelEffortCommandDeps = {
+    isAuthorizedSender: () => true,
+    getMyAgentName: () => 'klanker',
+    resolveThreadId: () => undefined,
+    resolveModelEffortBusy: () => ({ currentTurnActive: false, turnInFlight: false }),
+    historyEnabled: true,
+    recordInbound,
+    buildModelDeps: () => ({
+      discover: async () => ({ models: [], current: null }),
+      isBusy: () => false,
+      getAgentName: () => 'klanker',
+      getQuotaBrief: async () => null,
+      discoverSrModels: async () => [],
+      escapeHtml: (s: string) => s,
+      getConfiguredModel: () => 'opus',
+      preBlock: (s: string) => s,
+      scheduleRestart: async () => {},
+      scheduleModelRelaunch: async () => {},
+      scheduleModelDefaultRelaunch: async () => {},
+    }) as any,
+    buildEffortDeps: () => ({
+      applyEffort: vi.fn(async () => ({ ok: true })),
+      getAgentName: () => 'klanker',
+      getConfiguredEffort: () => 'high',
+      getSessionEffort: () => null,
+      escapeHtml: (s: string) => s,
+    }) as any,
+    modelMenuReplyMarkup: () => undefined,
+    effortMenuReplyMarkup: () => undefined,
+    enqueueSessionCommand,
+    switchroomReply,
+    modelMenuEnabled: () => true,
+    log,
+    ...over,
+  }
+  return { deps, log, recordInbound, enqueueSessionCommand, switchroomReply }
+}
+
+function makeCtx(text: string) {
+  return {
+    message: { text, message_id: 7, date: 1000 },
+    chat: { id: 42 },
+    from: { id: 11, username: 'ken' },
+    replyWithRichMessage: vi.fn(async () => ({ message_id: 900 })),
+  }
+}
+
+describe('/model', () => {
+  it('drops unauthorized senders silently', async () => {
+    const { bot, handlers } = fakeBot()
+    const { deps, log } = makeDeps({ isAuthorizedSender: () => false })
+    registerModelEffortCommands(bot, deps)
+    await handlers.get('model')!(makeCtx('/model'))
+    expect(log).not.toHaveBeenCalled()
+  })
+
+  it('writes the durable receipt (log + history row) BEFORE any branch (#3177)', async () => {
+    const { bot, handlers } = fakeBot()
+    const { deps, log, recordInbound } = makeDeps()
+    registerModelEffortCommands(bot, deps)
+    await handlers.get('model')!(makeCtx('/model'))
+    expect(log.mock.calls[0][0]).toContain('model')
+    expect(recordInbound).toHaveBeenCalledWith(
+      expect.objectContaining({ chat_id: '42', message_id: 7, user: 'ken', text: '/model' }),
+    )
+  })
+
+  it('bare /model on an idle session opens the menu via switchroomReply', async () => {
+    const { bot, handlers } = fakeBot()
+    const buildModelDeps = vi.fn(() => ({
+      // ModelMenuDeps shape — what buildModelMenu really reads.
+      discover: async () => ({ models: [], current: null }),
+      isBusy: () => false,
+      getAgentName: () => 'klanker',
+      getQuotaBrief: async () => null,
+      discoverSrModels: async () => [],
+      escapeHtml: (s: string) => s,
+      getConfiguredModel: () => 'opus',
+      preBlock: (s: string) => s,
+      scheduleRestart: async () => {},
+      scheduleModelRelaunch: async () => {},
+      scheduleModelDefaultRelaunch: async () => {},
+    }) as any)
+    const { deps, switchroomReply } = makeDeps({ buildModelDeps })
+    registerModelEffortCommands(bot, deps)
+    await handlers.get('model')!(makeCtx('/model'))
+    expect(switchroomReply).toHaveBeenCalledTimes(1)
+    expect(switchroomReply.mock.calls[0][2]).toMatchObject({ html: true })
+  })
+
+  it('typed /model <target> while BUSY acks and queues instead of applying (#3017)', async () => {
+    const { bot, handlers } = fakeBot()
+    const { deps, enqueueSessionCommand, switchroomReply } = makeDeps({
+      resolveModelEffortBusy: () => ({ currentTurnActive: true, turnInFlight: true }),
+    })
+    registerModelEffortCommands(bot, deps)
+    const ctx = makeCtx('/model opus')
+    await handlers.get('model')!(ctx)
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+    expect(enqueueSessionCommand).toHaveBeenCalledWith(
+      expect.objectContaining({
+        kind: 'model',
+        origin: 'typed',
+        arg: 'opus',
+        ackChatId: '42',
+        ackMessageId: 900,
+      }),
+    )
+    expect(switchroomReply).not.toHaveBeenCalled()
+  })
+})
+
+describe('/effort', () => {
+  it('shows the menu for bare /effort', async () => {
+    const { bot, handlers } = fakeBot()
+    const buildEffortDeps = vi.fn(() => ({
+      applyEffort: vi.fn(async () => ({ ok: true })),
+      getAgentName: () => 'klanker',
+      getConfiguredEffort: () => 'high',
+      getSessionEffort: () => null,
+      escapeHtml: (s: string) => s,
+    }) as any)
+    const { deps, switchroomReply } = makeDeps({ buildEffortDeps })
+    registerModelEffortCommands(bot, deps)
+    await handlers.get('effort')!(makeCtx('/effort'))
+    expect(switchroomReply).toHaveBeenCalledTimes(1)
+    expect(switchroomReply.mock.calls[0][2]).toMatchObject({ html: true })
+  })
+
+  it('set while busy: acks and queues with the requested level', async () => {
+    const { bot, handlers } = fakeBot()
+    const { deps, enqueueSessionCommand } = makeDeps({
+      resolveModelEffortBusy: () => ({ currentTurnActive: true, turnInFlight: false }),
+    })
+    registerModelEffortCommands(bot, deps)
+    const ctx = makeCtx('/effort low')
+    await handlers.get('effort')!(ctx)
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+    expect(enqueueSessionCommand).toHaveBeenCalledWith(
+      expect.objectContaining({ kind: 'effort', arg: 'low', targetLabel: 'low' }),
+    )
+  })
+
+  it('set while idle: applies via handleEffortCommand and replies', async () => {
+    const { bot, handlers } = fakeBot()
+    const buildEffortDeps = vi.fn(() => ({
+      applyEffort: vi.fn(async () => ({ ok: true })),
+      getAgentName: () => 'klanker',
+      getConfiguredEffort: () => 'high',
+      getSessionEffort: () => null,
+      escapeHtml: (s: string) => s,
+    }) as any)
+    const { deps, switchroomReply, enqueueSessionCommand } = makeDeps({ buildEffortDeps })
+    registerModelEffortCommands(bot, deps)
+    await handlers.get('effort')!(makeCtx('/effort low'))
+    expect(enqueueSessionCommand).not.toHaveBeenCalled()
+    expect(switchroomReply).toHaveBeenCalledTimes(1)
+  })
+})

package/telegram-plugin/tests/bot-commands-start-info.test.ts

@@ -0,0 +1,240 @@
+/**
+ * Outcome pins for the /start /help /status /agents commands extracted from
+ * gateway.ts (switchroom#2996 P6 bot.command drain). Registers against a fake
+ * grammy Bot, captures the handlers, and drives them with mock contexts:
+ * asserts the dmCommandGate silent-drop, the disabled-flag plumbing into the
+ * start text, the paired/pending/unpaired /status branches, and the /agents
+ * formatter output fed through runSwitchroomCommandFormatted.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  registerStartInfoCommands,
+  type StartInfoCommandDeps,
+} from '../gateway/bot-commands-start-info.js'
+
+type Handler = (ctx: any) => Promise<void>
+
+function fakeBot() {
+  const handlers = new Map<string, Handler>()
+  return {
+    bot: { command: (name: string, h: Handler) => void handlers.set(name, h) } as any,
+    handlers,
+  }
+}
+
+function makeDeps(over: Partial<StartInfoCommandDeps> = {}): StartInfoCommandDeps {
+  return {
+    dmCommandGate: () => ({
+      access: { dmPolicy: 'allowlist', allowFrom: ['42'], pending: {} } as any,
+      senderId: '42',
+    }),
+    isAuthorizedSender: () => true,
+    getMyAgentName: () => 'klanker',
+    getCommandArgs: () => '',
+    hasDemoFlag: () => false,
+    buildAgentMetadata: async () =>
+      ({
+        agentName: 'klanker',
+        model: 'opus',
+        extendsProfile: null,
+        topicName: null,
+        topicEmoji: null,
+        uptime: '2h',
+        status: 'running',
+        auth: null,
+      }) as any,
+    runSwitchroomCommandFormatted: vi.fn(async (_ctx, _args, _label, formatter) => {
+      formatter()
+    }),
+    switchroomExecJson: () => null,
+    statusIcon: () => '🟢',
+    ...over,
+  }
+}
+
+function makeCtx(over: Record<string, unknown> = {}) {
+  return {
+    from: { username: 'ken' },
+    reply: vi.fn(async () => {}),
+    replyWithRichMessage: vi.fn(async () => {}),
+    ...over,
+  }
+}
+
+describe('/start and /help', () => {
+  it('silently drops when dmCommandGate rejects', async () => {
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(bot, makeDeps({ dmCommandGate: () => null }))
+    const ctx = makeCtx()
+    await handlers.get('start')!(ctx)
+    await handlers.get('help')!(ctx)
+    expect(ctx.replyWithRichMessage).not.toHaveBeenCalled()
+    expect(ctx.reply).not.toHaveBeenCalled()
+  })
+
+  it('replies with the start text, carrying the disabled flag through', async () => {
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        dmCommandGate: () => ({
+          access: { dmPolicy: 'disabled', allowFrom: [], pending: {} } as any,
+          senderId: '42',
+        }),
+      }),
+    )
+    const ctx = makeCtx()
+    await handlers.get('start')!(ctx)
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+    // welcome-text startText(name, disabled=true) renders the disabled notice.
+    const arg = ctx.replyWithRichMessage.mock.calls[0][0]
+    expect(JSON.stringify(arg)).toContain("isn't accepting new connections")
+  })
+
+  it('replies with the help text for allowed senders', async () => {
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(bot, makeDeps())
+    const ctx = makeCtx()
+    await handlers.get('help')!(ctx)
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('/status branches', () => {
+  it('paired: builds agent metadata and replies rich', async () => {
+    const buildAgentMetadata = vi.fn(async () =>
+      ({
+        agentName: 'klanker',
+        model: 'opus',
+        extendsProfile: null,
+        topicName: null,
+        topicEmoji: null,
+        uptime: '2h',
+        status: 'running',
+        auth: null,
+      }) as any)
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(bot, makeDeps({ buildAgentMetadata }))
+    const ctx = makeCtx()
+    await handlers.get('status')!(ctx)
+    expect(buildAgentMetadata).toHaveBeenCalledWith('klanker')
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+    expect(ctx.reply).not.toHaveBeenCalled()
+  })
+
+  it('pending: replies with the pairing-code text', async () => {
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        dmCommandGate: () => ({
+          access: {
+            dmPolicy: 'pairing',
+            allowFrom: [],
+            pending: { ABC123: { senderId: '42' } },
+          } as any,
+          senderId: '42',
+        }),
+      }),
+    )
+    const ctx = makeCtx()
+    await handlers.get('status')!(ctx)
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+    expect(JSON.stringify(ctx.replyWithRichMessage.mock.calls[0][0])).toContain('ABC123')
+  })
+
+  it('unpaired: falls through to the plain unpaired reply', async () => {
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        dmCommandGate: () => ({
+          access: { dmPolicy: 'pairing', allowFrom: [], pending: {} } as any,
+          senderId: '42',
+        }),
+      }),
+    )
+    const ctx = makeCtx()
+    await handlers.get('status')!(ctx)
+    expect(ctx.reply).toHaveBeenCalledTimes(1)
+    expect(ctx.replyWithRichMessage).not.toHaveBeenCalled()
+  })
+})
+
+describe('/agents', () => {
+  it('drops unauthorized senders before running the CLI', async () => {
+    const runSwitchroomCommandFormatted = vi.fn(async () => {})
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({ isAuthorizedSender: () => false, runSwitchroomCommandFormatted }),
+    )
+    await handlers.get('agents')!(makeCtx())
+    expect(runSwitchroomCommandFormatted).not.toHaveBeenCalled()
+  })
+
+  it('formats the agent list exactly (icon, name, status, uptime, template line)', async () => {
+    let formatted: string | null = ''
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        runSwitchroomCommandFormatted: vi.fn(async (_c, args, label, formatter) => {
+          expect(args).toEqual(['agent', 'list'])
+          expect(label).toBe('agent list')
+          formatted = formatter()
+        }),
+        switchroomExecJson: <T,>() =>
+          ({
+            agents: [
+              {
+                name: 'klanker',
+                status: 'running',
+                uptime: '2h',
+                template: 'root-debug',
+                topic_name: 'DM',
+                topic_emoji: '🔧',
+              },
+            ],
+          }) as T,
+      }),
+    )
+    await handlers.get('agents')!(makeCtx())
+    expect(formatted).toBe(
+      '**Agents**\n🟢 **klanker** · running · 2h\n    _root-debug → DM 🔧_',
+    )
+  })
+
+  it('renders the empty-list placeholder', async () => {
+    let formatted: string | null = ''
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        runSwitchroomCommandFormatted: vi.fn(async (_c, _a, _l, formatter) => {
+          formatted = formatter()
+        }),
+        switchroomExecJson: <T,>() => ({ agents: [] }) as T,
+      }),
+    )
+    await handlers.get('agents')!(makeCtx())
+    expect(formatted).toBe('_No agents defined_')
+  })
+
+  it('returns null (CLI failure passthrough) when exec returns null', async () => {
+    let formatted: string | null = 'sentinel'
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        runSwitchroomCommandFormatted: vi.fn(async (_c, _a, _l, formatter) => {
+          formatted = formatter()
+        }),
+        switchroomExecJson: () => null,
+      }),
+    )
+    await handlers.get('agents')!(makeCtx())
+    expect(formatted).toBeNull()
+  })
+})

package/telegram-plugin/tests/buffer-gate-broadened.test.ts

@@ -36,6 +36,18 @@ const gatewaySrc = readFileSync(
   resolve(__dirname, '..', 'gateway', 'gateway.ts'),
   'utf-8',
 )
+// #2996 P2: executeReply's body moved verbatim to outbound-send-path.ts
+// (`sendReply`); the post-send block assertions read there. #2996 P8 PR-B: the
+// `releaseTurnBufferGate` helper body moved verbatim to turn-end.ts (gateway
+// keeps a thin delegating wrapper); the helper-body assertions read there.
+const sendPathSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'outbound-send-path.ts'),
+  'utf-8',
+)
+const turnEndSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'turn-end.ts'),
+  'utf-8',
+)
 
 describe('buffer-gate release decoupled from final-answer classification', () => {
   // Extract the helper's docstring (everything between the matching
@@ -43,7 +55,7 @@ describe('buffer-gate release decoupled from final-answer classification', () =>
   // function declaration). The body slice (used by other tests) is
   // separate — see fnBody().
   function fnDocstring(): string {
-    const beforeFn = gatewaySrc.split('function releaseTurnBufferGate')[0] ?? ''
+    const beforeFn = turnEndSrc.split('function releaseTurnBufferGate')[0] ?? ''
     const lastBlockOpen = beforeFn.lastIndexOf('/**')
     if (lastBlockOpen < 0) return ''
     return beforeFn.slice(lastBlockOpen)
@@ -52,7 +64,7 @@ describe('buffer-gate release decoupled from final-answer classification', () =>
     // The function body — everything between `function
     // releaseTurnBufferGate(...): void {` and its matching `}`. Use
     // a simple brace-balance over the slice from open-brace onward.
-    const afterDecl = gatewaySrc.split('function releaseTurnBufferGate')[1] ?? ''
+    const afterDecl = turnEndSrc.split('function releaseTurnBufferGate')[1] ?? ''
     const openIdx = afterDecl.indexOf('{')
     if (openIdx < 0) return ''
     let depth = 0
@@ -71,7 +83,7 @@ describe('buffer-gate release decoupled from final-answer classification', () =>
     // Multitopic component 1: the signature now also accepts an optional
     // `endingTurn` so the serialize-until-replied drain gate can read its
     // finalAnswerDelivered flag. The narrow-helper contract is unchanged.
-    expect(gatewaySrc).toMatch(
+    expect(turnEndSrc).toMatch(
       /function releaseTurnBufferGate\(key: string, endingTurn\?: CurrentTurn\): void/,
     )
     // The helper docstring must explain WHY split from
@@ -102,8 +114,8 @@ describe('buffer-gate release decoupled from final-answer classification', () =>
   it('executeReply calls releaseTurnBufferGate OUTSIDE the isFinalAnswerReply branch', () => {
     // Slice the executeReply post-send block (between the anchor
     // comments and the next exported function).
-    const post = gatewaySrc.split("fresh sendMessage from reply tool is a user-visible")[1] ?? ''
-    const slice = post.split('\nasync function ')[0] ?? ''
+    const post = sendPathSrc.split("fresh sendMessage from reply tool is a user-visible")[1] ?? ''
+    const slice = post.split('\nexport async function ')[0] ?? ''
     // The narrow `isFinalAnswerReply`-gated finalize MUST stay (it
     // emits the 👍 reaction on the final-answer happy path).
     expect(slice).toMatch(/isFinalAnswerReply\(/)
@@ -131,9 +143,12 @@ describe('buffer-gate release decoupled from final-answer classification', () =>
     // helper is narrow on purpose. If future code adds new
     // callsites that aren't turn-terminal, the steer-vs-queue
     // semantics could drift.
-    const callMatches = gatewaySrc.match(/releaseTurnBufferGate\(/g) ?? []
-    // Definition + 2 callsites = 3:
-    //   - executeReply's post-send block (reply-finalize, the original).
+    // #2996 P2: the reply-finalize callsite moved (verbatim) into
+    // outbound-send-path.ts `sendReply`; gateway.ts keeps the definition,
+    // the halt callsite, and the deps-injection reference.
+    const callMatches = (gatewaySrc + sendPathSrc).match(/releaseTurnBufferGate\(/g) ?? []
+    // Definition + deps-interface member + 2 callsites = 4:
+    //   - sendReply's post-send block (reply-finalize, the original).
     //   - executeHaltNow (#3020): an interrupt-cancelled turn never reaches
     //     reply-finalize (the C-c killed it and no replacement inbound
     //     follows), so the halt IS that turn's terminal — releasing there is
@@ -142,6 +157,10 @@ describe('buffer-gate release decoupled from final-answer classification', () =>
     //     with executeStreamReply.)
     // If this count grows the test catches it; reviewer must justify
     // any new callsite.
-    expect(callMatches.length).toBe(3)
+    // #2996 P8 PR-B adds exactly one more match in gateway.ts: the thin
+    // wrapper's delegate call (`turnEndFunnel().releaseTurnBufferGate(...)`)
+    // alongside the wrapper's own declaration. Still only TWO turn-terminal
+    // callsites (sendReply post-send + executeHaltNow).
+    expect(callMatches.length).toBe(5)
   })
 })

package/telegram-plugin/tests/busy-ack-wiring.test.ts

@@ -20,6 +20,11 @@ const gatewaySrc = readFileSync(
   resolve(__dirname, '..', 'gateway', 'gateway.ts'),
   'utf-8',
 )
+// #2996 P8 PR-B: purgeReactionTracking's body moved verbatim to turn-end.ts.
+const turnEndSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'turn-end.ts'),
+  'utf-8',
+)
 
 describe('#2995 mid-flight busy ack — gateway wiring', () => {
   it('the buffer-until-idle branch calls maybePostBusyAck for the inbound own chat/topic', () => {
@@ -97,7 +102,7 @@ describe('#2995 mid-flight busy ack — gateway wiring', () => {
   })
 
   it('turn-end cleanup is PER-KEY: dedupe entry deleted and re-check timer cancelled for the ending turn only', () => {
-    const purge = gatewaySrc.split('function purgeReactionTracking')[1]?.split('\nfunction ')[0] ?? ''
+    const purge = turnEndSrc.split('function purgeReactionTracking')[1]?.split('\nfunction ')[0] ?? ''
     // Per-key delete — a purge for topic A must not reset topic B's dedupe.
     expect(purge).toMatch(/busyAckPostedKeys\.delete\(key\)/)
     expect(purge).not.toMatch(/busyAckPostedKeys\.clear\(\)/)