switchroom 0.18.32 → 0.19.0

package/telegram-plugin/tests/activity-ever-opened-sticky.test.ts

@@ -32,6 +32,21 @@ const gatewaySrc = readFileSync(
   resolve(__dirname, '..', 'gateway', 'gateway.ts'),
   'utf-8',
 )
+// #2996 P4-A: one sticky-latch set site + the per-turn object-literal init live
+// in handleSessionEvent (the tool-label/answer send-success + the `enqueue`
+// turn ctor), which moved VERBATIM to stream-render.ts. The population spans
+// gateway.ts + that module.
+const streamSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'stream-render.ts'),
+  'utf-8',
+)
+// #2996 P4-B: the drain-side set-TRUE site (drainActivitySummary) moved on
+// into narrative-lane.ts.
+const laneSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'narrative-lane.ts'),
+  'utf-8',
+)
+const gatewayAndStreamSrc = gatewaySrc + '\n' + streamSrc + '\n' + laneSrc
 
 describe('M-2: activityEverOpened sticky-true invariant', () => {
   it('activityEverOpened = true appears only at the two feed-OPEN signal sites', () => {
@@ -39,19 +54,19 @@ describe('M-2: activityEverOpened sticky-true invariant', () => {
     // handback pre-turn ADOPTION seed (an adopted turn only edits, so it stamps
     // the flag itself). Both are set-TRUE; the sticky invariant (no reset to
     // false) is enforced by the next test.
-    const setTrueMatches = [...gatewaySrc.matchAll(/activityEverOpened\s*=\s*true/g)]
+    const setTrueMatches = [...gatewayAndStreamSrc.matchAll(/activityEverOpened\s*=\s*true/g)]
     expect(setTrueMatches).toHaveLength(2)
   })
 
   it('turn.activityEverOpened = false never appears (no standalone reset)', () => {
     // The only `false` value must be in the object literal initialiser
     // (e.g. `activityEverOpened: false`), never a standalone reassignment.
-    const resetMatches = [...gatewaySrc.matchAll(/turn\.activityEverOpened\s*=\s*false/g)]
+    const resetMatches = [...gatewayAndStreamSrc.matchAll(/turn\.activityEverOpened\s*=\s*false/g)]
     expect(resetMatches).toHaveLength(0)
   })
 
   it('activityEverOpened is initialised false in the turn object literal (per-turn reset)', () => {
     // The object literal form `activityEverOpened: false` must exist (per-turn init).
-    expect(gatewaySrc).toMatch(/activityEverOpened:\s*false/)
+    expect(gatewayAndStreamSrc).toMatch(/activityEverOpened:\s*false/)
   })
 })

package/telegram-plugin/tests/agent-button-callback-handler.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Outcome pins for the agent-emitted inline-keyboard callback family
+ * (`agent:` prefix, #271) extracted from the gateway's callback_query
+ * dispatcher (switchroom#2996 P6). Drives handleAgentButtonCallback with a
+ * mock ctx + injected deps and asserts: fall-through for non-agent data, the
+ * allowFrom gate, the ack-toast-first contract (#710), the exact InboundMessage
+ * envelope routed through the injected turn-safe delivery, the restarting
+ * notice only on bridge-offline, and the single-use keyboard strip + meta
+ * cleanup.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  handleAgentButtonCallback,
+  type AgentButtonCallbackDeps,
+} from '../gateway/agent-button-callback-handler.js'
+
+const DATA = 'agent:approve_pr'
+
+function makeCtx(over: Record<string, unknown> = {}) {
+  return {
+    from: { id: 42, username: 'ken' },
+    chat: { id: 42 },
+    callbackQuery: {
+      message: {
+        message_id: 77,
+        text: 'Deploy?',
+        reply_markup: {
+          inline_keyboard: [[{ text: 'Approve', callback_data: DATA }]],
+        },
+      },
+    },
+    answerCallbackQuery: vi.fn(async () => {}),
+    editMessageText: vi.fn(async () => {}),
+    editMessageReplyMarkup: vi.fn(async () => {}),
+    ...over,
+  } as any
+}
+
+function makeDeps(over: Partial<AgentButtonCallbackDeps> = {}) {
+  const deliverButtonTapInbound = vi.fn(async () => 'delivered')
+  const sendRestartingNotice = vi.fn()
+  const metaDelete = vi.fn()
+  const deps: AgentButtonCallbackDeps = {
+    loadAccess: () => ({ allowFrom: ['42'] }),
+    agentButtonMeta: { get: () => undefined, delete: metaDelete },
+    deliverButtonTapInbound,
+    sendRestartingNotice,
+    buttonConfirmSingleUseWarned: new Set(),
+    buttonConfirmParseModeWarned: new Set(),
+    log: vi.fn(),
+    ...over,
+  }
+  return { deps, deliverButtonTapInbound, sendRestartingNotice, metaDelete }
+}
+
+describe('handleAgentButtonCallback — routing + gates', () => {
+  it('returns false for non-agent callback data', async () => {
+    const { deps } = makeDeps()
+    const ctx = makeCtx()
+    expect(await handleAgentButtonCallback(ctx, 'perm:allow:abcde', deps)).toBe(false)
+    expect(ctx.answerCallbackQuery).not.toHaveBeenCalled()
+  })
+
+  it('gates non-allowlisted senders before any delivery', async () => {
+    const { deps, deliverButtonTapInbound } = makeDeps()
+    const ctx = makeCtx({ from: { id: 666 } })
+    expect(await handleAgentButtonCallback(ctx, DATA, deps)).toBe(true)
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: 'Not authorized.' })
+    expect(deliverButtonTapInbound).not.toHaveBeenCalled()
+  })
+})
+
+describe('handleAgentButtonCallback — delivery envelope', () => {
+  it('acks FIRST with the default toast, then delivers the exact inbound (#710/#271)', async () => {
+    const { deps, deliverButtonTapInbound } = makeDeps()
+    const ctx = makeCtx()
+    process.env.SWITCHROOM_AGENT_NAME = 'klanker'
+    expect(await handleAgentButtonCallback(ctx, DATA, deps)).toBe(true)
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: '✓ received' })
+    // Ack precedes delivery.
+    expect(ctx.answerCallbackQuery.mock.invocationCallOrder[0]).toBeLessThan(
+      deliverButtonTapInbound.mock.invocationCallOrder[0],
+    )
+    const [agent, msg] = deliverButtonTapInbound.mock.calls[0] as unknown as [string, any]
+    expect(agent).toBe('klanker')
+    expect(msg).toMatchObject({
+      type: 'inbound',
+      chatId: '42',
+      messageId: 77,
+      user: 'ken',
+      userId: 42,
+      text: '[user tapped button: "Approve" → approve_pr]',
+      meta: expect.objectContaining({
+        button_callback: 'true',
+        button_callback_data: 'approve_pr',
+        button_text: 'Approve',
+      }),
+    })
+  })
+
+  it('uses the stashed per-button ack_text when present', async () => {
+    // meta is keyed by the RAW payload (prefix stripped).
+    const metaMap = new Map([['approve_pr', { ack_text: 'On it!' }]])
+    const { deps } = makeDeps({
+      agentButtonMeta: { get: () => metaMap as any, delete: vi.fn() },
+    })
+    const ctx = makeCtx()
+    await handleAgentButtonCallback(ctx, DATA, deps)
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: 'On it!' })
+  })
+
+  it('shows the restarting notice ONLY on bridge-offline', async () => {
+    const { deps, sendRestartingNotice } = makeDeps({
+      deliverButtonTapInbound: vi.fn(async () => 'buffered-bridge-offline'),
+    })
+    await handleAgentButtonCallback(makeCtx(), DATA, deps)
+    expect(sendRestartingNotice).toHaveBeenCalledWith('42', undefined)
+
+    const second = makeDeps({
+      deliverButtonTapInbound: vi.fn(async () => 'buffered-mid-turn'),
+    })
+    await handleAgentButtonCallback(makeCtx(), DATA, second.deps)
+    expect(second.sendRestartingNotice).not.toHaveBeenCalled()
+  })
+})
+
+describe('handleAgentButtonCallback — single-use strip', () => {
+  it('strips the keyboard by default (no stashed meta) after the tap', async () => {
+    const { deps } = makeDeps()
+    const ctx = makeCtx()
+    await handleAgentButtonCallback(ctx, DATA, deps)
+    expect(ctx.editMessageReplyMarkup).toHaveBeenCalledWith({
+      reply_markup: { inline_keyboard: [] },
+    })
+  })
+
+  it('preserves the keyboard when a button opts out via single_use:false', async () => {
+    const metaMap = new Map([['approve_pr', { single_use: false }]])
+    const metaDelete = vi.fn()
+    const { deps } = makeDeps({
+      agentButtonMeta: { get: () => metaMap as any, delete: metaDelete },
+    })
+    const ctx = makeCtx()
+    await handleAgentButtonCallback(ctx, DATA, deps)
+    expect(ctx.editMessageReplyMarkup).not.toHaveBeenCalled()
+    expect(metaDelete).not.toHaveBeenCalled()
+  })
+})

package/telegram-plugin/tests/ask-callback-handler.test.ts

@@ -0,0 +1,118 @@
+/**
+ * Outcome pins for the ask_user option-callback family (`aq:<idx>:<askId>`,
+ * #574) extracted from the gateway's callback_query dispatcher
+ * (switchroom#2996 P6). Uses the REAL encode/decode from ask-user.ts and
+ * asserts: non-ask data falls through (returns false), the allowFrom gate,
+ * stale-tap and out-of-bounds acks, and the full resolve path (timer cleared,
+ * store entry deleted, promise resolved with the choice, message edited with
+ * the checkmark, toast acked).
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  handleAskCallback,
+  type AskCallbackDeps,
+  type PendingAskUserEntry,
+} from '../gateway/ask-callback-handler.js'
+import { encodeAskCallback } from '../ask-user.js'
+
+function makeCtx(over: Record<string, unknown> = {}) {
+  return {
+    from: { id: 42 },
+    callbackQuery: { message: { text: 'Pick one <a&b>' } },
+    answerCallbackQuery: vi.fn(async () => {}),
+    editMessageText: vi.fn(async () => {}),
+    ...over,
+  } as any
+}
+
+function makeDeps(entries: Record<string, PendingAskUserEntry> = {}) {
+  const store = new Map(Object.entries(entries))
+  const deps: AskCallbackDeps = {
+    loadAccess: () => ({ allowFrom: ['42'] }),
+    pendingAskUser: store,
+  }
+  return { deps, store }
+}
+
+function entryWith(options: string[]) {
+  let resolved: unknown = null
+  const entry: PendingAskUserEntry = {
+    options,
+    resolve: (o: unknown) => {
+      resolved = o
+    },
+    timer: setTimeout(() => {}, 60_000),
+  }
+  return { entry, getResolved: () => resolved }
+}
+
+describe('handleAskCallback — routing', () => {
+  it('returns false for non-ask callback data (dispatcher falls through)', async () => {
+    const { deps } = makeDeps()
+    const ctx = makeCtx()
+    expect(await handleAskCallback(ctx, 'apv:whatever', deps)).toBe(false)
+    expect(ctx.answerCallbackQuery).not.toHaveBeenCalled()
+  })
+
+  it('gates non-allowlisted senders with a Not authorized toast', async () => {
+    const { entry } = entryWith(['a'])
+    const { deps } = makeDeps({ aaaa1111: entry })
+    const ctx = makeCtx({ from: { id: 666 } })
+    expect(await handleAskCallback(ctx, encodeAskCallback('aaaa1111', 0), deps)).toBe(true)
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: 'Not authorized.' })
+    clearTimeout(entry.timer)
+  })
+
+  it('acks a stale tap (entry gone) with the expired toast', async () => {
+    const { deps } = makeDeps()
+    const ctx = makeCtx()
+    expect(await handleAskCallback(ctx, encodeAskCallback('deadbeef', 0), deps)).toBe(true)
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: 'This question expired.' })
+  })
+
+  it('rejects an out-of-bounds index (hostile callback) without resolving', async () => {
+    const { entry, getResolved } = entryWith(['only'])
+    const { deps, store } = makeDeps({ aaaa1111: entry })
+    const ctx = makeCtx()
+    await handleAskCallback(ctx, encodeAskCallback('aaaa1111', 3), deps)
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: 'Invalid option.' })
+    expect(getResolved()).toBeNull()
+    expect(store.has('aaaa1111')).toBe(true)
+    clearTimeout(entry.timer)
+  })
+})
+
+describe('handleAskCallback — resolve path', () => {
+  it('resolves the deferred, deletes the entry, edits the message, acks the toast', async () => {
+    const { entry, getResolved } = entryWith(['yes', 'no'])
+    const { deps, store } = makeDeps({ aaaa1111: entry })
+    const ctx = makeCtx()
+    expect(await handleAskCallback(ctx, encodeAskCallback('aaaa1111', 1), deps)).toBe(true)
+    expect(getResolved()).toEqual({ kind: 'answered', choice: 'no', idx: 1 })
+    expect(store.has('aaaa1111')).toBe(false)
+    // Edited body: escaped source text + checkmarked choice.
+    const edited = JSON.stringify(ctx.editMessageText.mock.calls[0][0])
+    expect(edited).toContain('✅')
+    expect(edited).toContain('no')
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: '✅ no' })
+  })
+
+  it('still resolves + acks when the source message has no text (no edit attempted)', async () => {
+    const { entry, getResolved } = entryWith(['ok'])
+    const { deps } = makeDeps({ aaaa1111: entry })
+    const ctx = makeCtx({ callbackQuery: { message: {} } })
+    await handleAskCallback(ctx, encodeAskCallback('aaaa1111', 0), deps)
+    expect(getResolved()).toEqual({ kind: 'answered', choice: 'ok', idx: 0 })
+    expect(ctx.editMessageText).not.toHaveBeenCalled()
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: '✅ ok' })
+  })
+
+  it('a failing editMessageText is swallowed — the ack toast still fires', async () => {
+    const { entry } = entryWith(['ok'])
+    const { deps } = makeDeps({ aaaa1111: entry })
+    const ctx = makeCtx({ editMessageText: vi.fn(async () => { throw new Error('too old') }) })
+    await handleAskCallback(ctx, encodeAskCallback('aaaa1111', 0), deps)
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: '✅ ok' })
+  })
+})

package/telegram-plugin/tests/attachment-message-handlers.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Outcome pins for the metadata-only attachment inbound handlers extracted
+ * from gateway.ts (switchroom#2996 P6 cluster C). Each handler is driven with
+ * a fake grammy ctx + a mock coalescing dispatch dep; the assertions pin the
+ * EXACT text envelope and AttachmentMeta slot forwarded to
+ * handleInboundCoalesced — the behaviour the gateway previously produced inline.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  handleDocumentMessage,
+  handleAudioMessage,
+  handleVideoMessage,
+  handleVideoNoteMessage,
+  handleStickerMessage,
+  handleAnimationMessage,
+  type AttachmentHandlerDeps,
+} from '../gateway/attachment-message-handlers.js'
+
+function makeDeps() {
+  const handleInboundCoalesced = vi.fn(async () => {})
+  const deps: AttachmentHandlerDeps = { handleInboundCoalesced }
+  return { deps, handleInboundCoalesced }
+}
+
+// Build a fake ctx whose `message` carries the given content key (+ caption).
+function ctxWith(content: Record<string, unknown>): any {
+  return { message: content, chat: { id: 42 } }
+}
+
+describe('handleDocumentMessage', () => {
+  it('renders the document envelope with a sanitized name', async () => {
+    const { deps, handleInboundCoalesced } = makeDeps()
+    const ctx = ctxWith({ document: { file_id: 'd1', file_name: 'a<b>.pdf', file_size: 10, mime_type: 'application/pdf' } })
+    await handleDocumentMessage(ctx, deps)
+    expect(handleInboundCoalesced).toHaveBeenCalledWith(
+      ctx,
+      '(document: a_b_.pdf)',
+      undefined,
+      { kind: 'document', file_id: 'd1', size: 10, mime: 'application/pdf', name: 'a_b_.pdf' },
+    )
+  })
+  it('prefers the caption and falls back to "file" when unnamed', async () => {
+    const { deps, handleInboundCoalesced } = makeDeps()
+    const ctx = ctxWith({ document: { file_id: 'd2' }, caption: 'see this' })
+    await handleDocumentMessage(ctx, deps)
+    const [, text, , meta] = (handleInboundCoalesced as any).mock.calls[0]
+    expect(text).toBe('see this')
+    expect(meta).toEqual({ kind: 'document', file_id: 'd2', size: undefined, mime: undefined, name: undefined })
+  })
+})
+
+describe('handleAudioMessage', () => {
+  it('renders title, then name, then "audio" fallback', async () => {
+    const { deps, handleInboundCoalesced } = makeDeps()
+    const ctx = ctxWith({ audio: { file_id: 'a1', title: 'Song', file_name: 'x.mp3', file_size: 5, mime_type: 'audio/mpeg' } })
+    await handleAudioMessage(ctx, deps)
+    expect(handleInboundCoalesced).toHaveBeenCalledWith(
+      ctx,
+      '(audio: Song)',
+      undefined,
+      { kind: 'audio', file_id: 'a1', size: 5, mime: 'audio/mpeg', name: 'x.mp3' },
+    )
+  })
+})
+
+describe('handleVideoMessage', () => {
+  it('renders the video envelope, caption-or-fallback', async () => {
+    const { deps, handleInboundCoalesced } = makeDeps()
+    const ctx = ctxWith({ video: { file_id: 'v1', file_size: 9, mime_type: 'video/mp4', file_name: 'clip.mp4' } })
+    await handleVideoMessage(ctx, deps)
+    expect(handleInboundCoalesced).toHaveBeenCalledWith(
+      ctx,
+      '(video)',
+      undefined,
+      { kind: 'video', file_id: 'v1', size: 9, mime: 'video/mp4', name: 'clip.mp4' },
+    )
+  })
+})
+
+describe('handleVideoNoteMessage', () => {
+  it('renders the fixed video-note envelope', async () => {
+    const { deps, handleInboundCoalesced } = makeDeps()
+    const ctx = ctxWith({ video_note: { file_id: 'vn1', file_size: 3 } })
+    await handleVideoNoteMessage(ctx, deps)
+    expect(handleInboundCoalesced).toHaveBeenCalledWith(
+      ctx,
+      '(video note)',
+      undefined,
+      { kind: 'video_note', file_id: 'vn1', size: 3 },
+    )
+  })
+})
+
+describe('handleStickerMessage', () => {
+  it('includes emoji and set name when present', async () => {
+    const { deps, handleInboundCoalesced } = makeDeps()
+    const ctx = ctxWith({ sticker: { file_id: 's1', emoji: '🎉', set_name: 'Party', file_size: 2 } })
+    await handleStickerMessage(ctx, deps)
+    expect(handleInboundCoalesced).toHaveBeenCalledWith(
+      ctx,
+      '(sticker — 🎉 from "Party")',
+      undefined,
+      { kind: 'sticker', file_id: 's1', size: 2 },
+    )
+  })
+  it('falls back to bare "(sticker)" with no emoji/set', async () => {
+    const { deps, handleInboundCoalesced } = makeDeps()
+    const ctx = ctxWith({ sticker: { file_id: 's2' } })
+    await handleStickerMessage(ctx, deps)
+    const [, text] = (handleInboundCoalesced as any).mock.calls[0]
+    expect(text).toBe('(sticker)')
+  })
+})
+
+describe('handleAnimationMessage', () => {
+  it('prefixes the caption to the gif envelope', async () => {
+    const { deps, handleInboundCoalesced } = makeDeps()
+    const ctx = ctxWith({ animation: { file_id: 'g1', file_size: 7, mime_type: 'video/mp4', file_name: 'a.gif' }, caption: 'perfect' })
+    await handleAnimationMessage(ctx, deps)
+    expect(handleInboundCoalesced).toHaveBeenCalledWith(
+      ctx,
+      '(gif) perfect',
+      undefined,
+      { kind: 'animation', file_id: 'g1', size: 7, mime: 'video/mp4', name: 'a.gif' },
+    )
+  })
+  it('renders bare "(gif)" when uncaptioned', async () => {
+    const { deps, handleInboundCoalesced } = makeDeps()
+    const ctx = ctxWith({ animation: { file_id: 'g2' } })
+    await handleAnimationMessage(ctx, deps)
+    const [, text] = (handleInboundCoalesced as any).mock.calls[0]
+    expect(text).toBe('(gif)')
+  })
+})

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)
+  })
+})