switchroom 0.5.0

package/telegram-plugin/tests/two-zone-card-html-balance.test.ts

@@ -0,0 +1,110 @@
+/**
+ * P1 of #662 — render-invariant property tests.
+ *
+ * For any input state with fleet 0..50 and any tool-arg shape:
+ *   1. Output passes a tag-balance validator (no <blockquote> 400s).
+ *   2. Output is < 4096 bytes.
+ *   3. Idempotent: same inputs → same output.
+ *
+ * Uses vitest `it.each` with ~30 hand-crafted shapes covering the
+ * property surface (per #662 P1 — replaces fast-check).
+ */
+
+import { describe, it, expect } from 'vitest'
+import { renderTwoZoneCard } from '../two-zone-card.js'
+import type { FleetMember, FleetStatus } from '../fleet-state.js'
+import type { ProgressCardState } from '../progress-card.js'
+import { isBalancedHtml } from './html-balanced.js'
+
+const baseState: ProgressCardState = {
+  turnStartedAt: 1,
+  items: [],
+  narratives: [],
+  stage: 'run',
+  thinking: false,
+  subAgents: new Map(),
+  pendingAgentSpawns: new Map(),
+  tasks: [],
+}
+
+function makeMember(i: number, status: FleetStatus, argShape: string): FleetMember {
+  return {
+    agentId: `agent-${i.toString().padStart(8, '0')}`,
+    role: i % 3 === 0 ? `worker-${i}` : i % 3 === 1 ? 'general-purpose' : 'investigate the auth bug',
+    startedAt: 0,
+    toolCount: i,
+    lastActivityAt: 100 + i,
+    lastTool: i === 0 ? null : { name: 'Read', sanitisedArg: argShape },
+    status,
+    terminalAt: ['done', 'failed', 'killed'].includes(status) ? 100 + i : null,
+    errorSeen: status === 'failed',
+    originatingTurnKey: 'k',
+  }
+}
+
+const ARG_SHAPES = [
+  '',
+  'simple.ts',
+  'foo.key',
+  'a/b/c/very-long-relative-path-that-should-not-explode-the-card.ts',
+  '<html-y-arg>',
+  '&amp;already-escaped',
+  'emoji 🚀 in arg',
+  'quotes "and" \'apostrophes\'',
+  '[redacted]',
+  '\nmultiline\nshould\nflatten',
+]
+
+const STATUSES: FleetStatus[] = ['running', 'background', 'done', 'failed', 'stuck', 'killed']
+
+const SIZES = [0, 1, 3, 5, 10, 50]
+
+const cases: Array<[string, number, string]> = []
+for (const size of SIZES) {
+  for (const arg of ARG_SHAPES.slice(0, 3)) {
+    cases.push([`size=${size} arg=${JSON.stringify(arg).slice(0, 20)}`, size, arg])
+  }
+}
+
+describe('two-zone-card render invariants', () => {
+  it.each(cases)('%s — balanced HTML, <4096 bytes, idempotent', (_name, size, arg) => {
+    const fleet = new Map<string, FleetMember>()
+    for (let i = 0; i < size; i++) {
+      const status = STATUSES[i % STATUSES.length]
+      fleet.set(`a${i}`, makeMember(i, status, arg))
+    }
+    const out1 = renderTwoZoneCard({ state: baseState, fleet, now: 5000 })
+    const out2 = renderTwoZoneCard({ state: baseState, fleet, now: 5000 })
+    const balance = isBalancedHtml(out1)
+    expect(balance.balanced, `unbalanced: open=${balance.openTags.join(',')} extra=${balance.extraCloses.join(',')}`).toBe(true)
+    expect(out1.length).toBeLessThan(4096)
+    expect(out1).toBe(out2)
+  })
+
+  it('handles arg shapes individually with size=5', () => {
+    for (const arg of ARG_SHAPES) {
+      const fleet = new Map<string, FleetMember>()
+      for (let i = 0; i < 5; i++) fleet.set(`a${i}`, makeMember(i, 'running', arg))
+      const out = renderTwoZoneCard({ state: baseState, fleet, now: 5000 })
+      const b = isBalancedHtml(out)
+      expect(b.balanced, `unbalanced for arg=${arg}: open=${b.openTags.join(',')}`).toBe(true)
+      expect(out.length).toBeLessThan(4096)
+    }
+  })
+})
+
+describe('html-balanced validator self-test', () => {
+  it('balanced cases', () => {
+    expect(isBalancedHtml('').balanced).toBe(true)
+    expect(isBalancedHtml('plain text').balanced).toBe(true)
+    expect(isBalancedHtml('<b>bold</b>').balanced).toBe(true)
+    expect(isBalancedHtml('<b>bold <i>italic</i></b>').balanced).toBe(true)
+    expect(isBalancedHtml('text with &lt;not a tag&gt;').balanced).toBe(true)
+    expect(isBalancedHtml('<blockquote>x</blockquote>').balanced).toBe(true)
+  })
+  it('unbalanced cases', () => {
+    expect(isBalancedHtml('<b>open').balanced).toBe(false)
+    expect(isBalancedHtml('close</b>').balanced).toBe(false)
+    expect(isBalancedHtml('<b><i>x</b></i>').balanced).toBe(false)
+  })
+})

package/telegram-plugin/tests/two-zone-card-lifecycle.test.ts

@@ -0,0 +1,128 @@
+/**
+ * P1 of #662 — lifecycle integration. Drive the real driver with
+ * TWO_ZONE_CARD=1 set; assert the rendered HTML for a turn with 2
+ * fleet members contains expected substrings (header phase, parent
+ * bullets, fleet rows, fleet count).
+ *
+ * Uses the same lightweight harness pattern as
+ * progress-card-driver-fleet-shadow.test.ts — no Telegram bot, just
+ * record the emit calls and inspect their HTML payload.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { createProgressDriver } from '../progress-card-driver.js'
+import type { SessionEvent } from '../session-tail.js'
+
+function harness() {
+  let now = 1000
+  const timers: Array<{ fireAt: number; fn: () => void; ref: number; repeat?: number }> = []
+  let nextRef = 0
+  const emits: Array<{ chatId: string; payload: string }> = []
+  const driver = createProgressDriver({
+    emit: (args) => {
+      // Parent card emits only — sub-agent per-agent cards carry agentId.
+      if ((args as { agentId?: string }).agentId == null) {
+        emits.push({ chatId: args.chatId, payload: args.html })
+      }
+    },
+    minIntervalMs: 0,
+    coalesceMs: 0,
+    initialDelayMs: 0,
+    promoteAfterMs: 999_999,
+    now: () => now,
+    setTimeout: (fn, ms) => {
+      const ref = nextRef++
+      timers.push({ fireAt: now + ms, fn, ref })
+      return { ref }
+    },
+    clearTimeout: (h) => {
+      const ref = (h as { ref: number }).ref
+      const idx = timers.findIndex((t) => t.ref === ref)
+      if (idx !== -1) timers.splice(idx, 1)
+    },
+    setInterval: (fn, ms) => {
+      const ref = nextRef++
+      timers.push({ fireAt: now + ms, fn, ref, repeat: ms })
+      return { ref }
+    },
+    clearInterval: (h) => {
+      const ref = (h as { ref: number }).ref
+      const idx = timers.findIndex((t) => t.ref === ref)
+      if (idx !== -1) timers.splice(idx, 1)
+    },
+  })
+  return {
+    driver,
+    emits,
+    advance: (ms: number) => {
+      now += ms
+      const due = timers.filter((t) => t.fireAt <= now)
+      for (const t of due) {
+        t.fn()
+        if (t.repeat) {
+          t.fireAt = now + t.repeat
+        } else {
+          const i = timers.indexOf(t)
+          if (i >= 0) timers.splice(i, 1)
+        }
+      }
+    },
+    flush: () => {
+      // Pump any pending timers
+      const due = timers.filter((t) => t.fireAt <= now)
+      for (const t of due) t.fn()
+    },
+  }
+}
+
+const enqueue = (chatId: string): SessionEvent => ({
+  kind: 'enqueue',
+  chatId,
+  messageId: '1',
+  threadId: null,
+  rawContent: `<channel chat_id="${chatId}">go</channel>`,
+})
+
+describe('two-zone-card lifecycle (TWO_ZONE_CARD=1)', () => {
+  let prevFlag: string | undefined
+  beforeEach(() => {
+    prevFlag = process.env.TWO_ZONE_CARD
+    process.env.TWO_ZONE_CARD = '1'
+  })
+  afterEach(() => {
+    if (prevFlag === undefined) delete process.env.TWO_ZONE_CARD
+    else process.env.TWO_ZONE_CARD = prevFlag
+  })
+
+  it('renders two-zone card with fleet rows when flag is on', () => {
+    const { driver, emits, advance } = harness()
+    const CHAT = 'c1'
+    driver.ingest(enqueue(CHAT), null)
+
+    const events: SessionEvent[] = [
+      { kind: 'tool_use', toolUseId: 'p1', toolName: 'Read', input: { file_path: '/tmp/foo.ts' } },
+      { kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'do work', subagentType: 'worker' },
+      { kind: 'sub_agent_started', agentId: 'sa2', firstPromptText: 'review', subagentType: 'reviewer' },
+      { kind: 'sub_agent_tool_use', agentId: 'sa1', toolUseId: 't1', toolName: 'Grep', input: { pattern: 'TODO' } },
+    ]
+    for (const ev of events) driver.ingest(ev, CHAT)
+    // Drain the coalesce/min-interval setTimeout queue so deferred
+    // sub-agent emits flush. Each ingest schedules a 0-delay timer
+    // that is only invoked when fake time advances.
+    advance(0)
+
+    // Find the most recent emitted payload — it should be a two-zone card.
+    const last = emits[emits.length - 1]
+    expect(last).toBeDefined()
+    const html = last.payload
+    // Header substrings
+    expect(html).toMatch(/Working/)
+    // Fleet zone present with count
+    expect(html).toContain('FLEET (2)')
+    expect(html).toContain('worker')
+    expect(html).toContain('reviewer')
+    // Fleet ids (6 chars)
+    expect(html).toContain('sa1')
+    expect(html).toContain('sa2')
+  })
+})

package/telegram-plugin/tests/two-zone-card-sanitise.test.ts

@@ -0,0 +1,58 @@
+/**
+ * P1 of #662 — renderer output never reintroduces raw absolute paths
+ * or bearer-shaped tokens. Most coverage lives in fleet-state.test.ts;
+ * this asserts the *renderer* basenames/redacts via the FleetMember's
+ * sanitised values (i.e. it doesn't re-pull from raw input anywhere).
+ */
+
+import { describe, it, expect } from 'vitest'
+import { renderTwoZoneCard } from '../two-zone-card.js'
+import type { FleetMember } from '../fleet-state.js'
+import type { ProgressCardState } from '../progress-card.js'
+
+const baseState: ProgressCardState = {
+  turnStartedAt: 1,
+  items: [],
+  narratives: [],
+  stage: 'run',
+  thinking: false,
+  subAgents: new Map(),
+  pendingAgentSpawns: new Map(),
+  tasks: [],
+}
+
+function fm(over: Partial<FleetMember>): FleetMember {
+  return {
+    agentId: 'aaaaaaaaaaaa',
+    role: 'agent',
+    startedAt: 0,
+    toolCount: 1,
+    lastActivityAt: 1000,
+    lastTool: null,
+    status: 'running',
+    terminalAt: null,
+    errorSeen: false,
+    originatingTurnKey: 'k',
+    ...over,
+  }
+}
+
+describe('two-zone-card sanitise', () => {
+  it('does not contain raw absolute path under /etc/secrets', () => {
+    const fleet = new Map([['a', fm({
+      lastTool: { name: 'Read', sanitisedArg: 'foo.key' }, // already sanitised by fleet-state
+    })]])
+    const out = renderTwoZoneCard({ state: baseState, fleet, now: 2000 })
+    expect(out).not.toContain('/etc/secrets')
+    expect(out).toContain('foo.key')
+  })
+
+  it('does not contain bearer-shaped tokens (sanitised upstream)', () => {
+    const fleet = new Map([['a', fm({
+      lastTool: { name: 'Bash', sanitisedArg: 'curl -H "Authorization: [redacted]" https://api' },
+    })]])
+    const out = renderTwoZoneCard({ state: baseState, fleet, now: 2000 })
+    expect(out).toContain('[redacted]')
+    expect(out).not.toMatch(/Bearer\s+[A-Za-z0-9]{16,}/)
+  })
+})

package/telegram-plugin/tests/two-zone-card-snapshot.test.ts

@@ -0,0 +1,133 @@
+/**
+ * P1 of #662 — golden output for 5 canonical card states.
+ *
+ * Uses explicit `toBe()` rather than `toMatchSnapshot()` so the same
+ * test file passes under both vitest (Core tests CI step) and bun
+ * (Plugin tests CI step) — the two snapshot formats are incompatible.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { renderTwoZoneCard } from '../two-zone-card.js'
+import type { FleetMember } from '../fleet-state.js'
+import type { ProgressCardState } from '../progress-card.js'
+
+function st(over: Partial<ProgressCardState> & { stage: ProgressCardState['stage'] }): ProgressCardState {
+  return {
+    turnStartedAt: 0,
+    items: [],
+    narratives: [],
+    stage: over.stage,
+    thinking: false,
+    subAgents: new Map(),
+    pendingAgentSpawns: new Map(),
+    tasks: [],
+    ...over,
+  }
+}
+
+function fm(over: Partial<FleetMember>): FleetMember {
+  return {
+    agentId: 'aaaaaa00',
+    role: 'agent',
+    startedAt: 0,
+    toolCount: 0,
+    lastActivityAt: 0,
+    lastTool: null,
+    status: 'running',
+    terminalAt: null,
+    errorSeen: false,
+    originatingTurnKey: 'k',
+    ...over,
+  }
+}
+
+const NOW = 60_000
+
+describe('two-zone-card snapshots', () => {
+  it('empty fleet — clean clerk-style card', () => {
+    const out = renderTwoZoneCard({
+      state: st({ stage: 'run', turnStartedAt: NOW - 5000 }),
+      fleet: new Map(),
+      now: NOW,
+    })
+    expect(out).toBe('⚙️ <b>Working…</b> · ⏱ 00:05 · 🔧 0')
+  })
+
+  it('3 members mixed', () => {
+    const fleet = new Map([
+      ['a', fm({ agentId: 'aaaaaa01', role: 'researcher', status: 'running', toolCount: 4, lastActivityAt: NOW - 2000, lastTool: { name: 'Grep', sanitisedArg: 'TODO' } })],
+      ['b', fm({ agentId: 'bbbbbb02', role: 'worker', status: 'done', toolCount: 8, lastActivityAt: NOW - 10_000, terminalAt: NOW - 10_000 })],
+      ['c', fm({ agentId: 'cccccc03', role: 'reviewer', status: 'stuck', toolCount: 2, lastActivityAt: NOW - 70_000, lastTool: { name: 'Read', sanitisedArg: 'big.ts' } })],
+    ])
+    const out = renderTwoZoneCard({
+      state: st({ stage: 'run', turnStartedAt: NOW - 30_000 }),
+      fleet,
+      now: NOW,
+    })
+    expect(out).toBe(
+      '⚙️ <b>Working…</b> · ⏱ 00:30 · 🔧 14 · 🤖 3\n' +
+      '\n' +
+      '<b>FLEET (3)</b>\n' +
+      '↻ researcher <code>aaaaaa</code> · 4t · Grep <code>TODO</code> (2s ago)\n' +
+      '✓ worker <code>bbbbbb</code> · 8t · done 10s ago\n' +
+      '⚠ reviewer <code>cccccc</code> · 2t · idle 1m10s ago',
+    )
+  })
+
+  it('all-done with completed receipts', () => {
+    const fleet = new Map([
+      ['a', fm({ agentId: 'aaaaaa01', role: 'worker', status: 'done', toolCount: 5, lastActivityAt: NOW - 10_000, terminalAt: NOW - 10_000 })],
+      ['b', fm({ agentId: 'bbbbbb02', role: 'reviewer', status: 'done', toolCount: 3, lastActivityAt: NOW - 5000, terminalAt: NOW - 5000 })],
+    ])
+    const out = renderTwoZoneCard({
+      state: st({ stage: 'done', turnStartedAt: NOW - 20_000 }),
+      fleet,
+      now: NOW,
+    })
+    expect(out).toBe(
+      '✅ <b>Done</b> · ⏱ 00:20 · 🔧 8 · 🤖 2\n' +
+      '\n' +
+      '<b>FLEET (2)</b>\n' +
+      '✓ reviewer <code>bbbbbb</code> · 3t · done 5s ago\n' +
+      '✓ worker <code>aaaaaa</code> · 5t · done 10s ago',
+    )
+  })
+
+  it('all-stuck', () => {
+    const fleet = new Map([
+      ['a', fm({ agentId: 'aaaaaa01', role: 'worker', status: 'stuck', toolCount: 1, lastActivityAt: NOW - 90_000, lastTool: { name: 'Bash', sanitisedArg: 'sleep 999' } })],
+      ['b', fm({ agentId: 'bbbbbb02', role: 'worker', status: 'stuck', toolCount: 1, lastActivityAt: NOW - 80_000, lastTool: { name: 'Bash', sanitisedArg: 'sleep 999' } })],
+    ])
+    const out = renderTwoZoneCard({
+      state: st({ stage: 'run', turnStartedAt: NOW - 95_000 }),
+      fleet,
+      now: NOW,
+    })
+    expect(out).toBe(
+      '⚠ <b>Stalled</b> · ⏱ 01:35 · 🔧 2 · 🤖 2\n' +
+      '\n' +
+      '<b>FLEET (2)</b>\n' +
+      '⚠ worker <code>bbbbbb</code> · 1t · idle 1m20s ago\n' +
+      '⚠ worker <code>aaaaaa</code> · 1t · idle 1m30s ago',
+    )
+  })
+
+  it('background — parent done, background sub still running', () => {
+    const fleet = new Map([
+      ['a', fm({ agentId: 'aaaaaa01', role: 'worker', status: 'done', toolCount: 5, lastActivityAt: NOW - 30_000, terminalAt: NOW - 30_000 })],
+      ['b', fm({ agentId: 'bbbbbb02', role: 'background', status: 'background', toolCount: 12, lastActivityAt: NOW - 1000, lastTool: { name: 'Bash', sanitisedArg: 'long-job.sh' } })],
+    ])
+    const out = renderTwoZoneCard({
+      state: st({ stage: 'done', turnStartedAt: NOW - 90_000 }),
+      fleet,
+      now: NOW,
+    })
+    expect(out).toBe(
+      '⏸ <b>Background</b> · ⏱ 01:30 · 🔧 17 · 🤖 2\n' +
+      '\n' +
+      '<b>FLEET (2)</b>\n' +
+      '⏸ background <code>bbbbbb</code> · 12t · Bash <code>long-job.sh</code> (1s ago)\n' +
+      '✓ worker <code>aaaaaa</code> · 5t · done 30s ago',
+    )
+  })
+})

package/telegram-plugin/tests/two-zone-concurrent-turns-isolation.test.ts

@@ -0,0 +1,155 @@
+/**
+ * P2 of #662 — concurrent-chat isolation. Two distinct chats each
+ * spawn a background sub-agent. Routing must keep their fleets
+ * completely independent: a tool_use event for chat A's bg sub-agent
+ * must never bleed into chat B's fleet, and vice versa.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { createProgressDriver } from '../progress-card-driver.js'
+import type { SessionEvent } from '../session-tail.js'
+
+function harness() {
+  let now = 1000
+  const timers: Array<{ fireAt: number; fn: () => void; ref: number; repeat?: number }> = []
+  let nextRef = 0
+  const driver = createProgressDriver({
+    emit: () => {},
+    minIntervalMs: 500,
+    coalesceMs: 400,
+    initialDelayMs: 0,
+    promoteAfterMs: 999_999,
+    now: () => now,
+    setTimeout: (fn, ms) => {
+      const ref = nextRef++
+      timers.push({ fireAt: now + ms, fn, ref })
+      return { ref }
+    },
+    clearTimeout: (h) => {
+      const ref = (h as { ref: number }).ref
+      const idx = timers.findIndex((t) => t.ref === ref)
+      if (idx !== -1) timers.splice(idx, 1)
+    },
+    setInterval: (fn, ms) => {
+      const ref = nextRef++
+      timers.push({ fireAt: now + ms, fn, ref, repeat: ms })
+      return { ref }
+    },
+    clearInterval: (h) => {
+      const ref = (h as { ref: number }).ref
+      const idx = timers.findIndex((t) => t.ref === ref)
+      if (idx !== -1) timers.splice(idx, 1)
+    },
+  })
+  return { driver, advance: (ms: number) => { now += ms } }
+}
+
+const enqueue = (chatId: string): SessionEvent => ({
+  kind: 'enqueue',
+  chatId,
+  messageId: '1',
+  threadId: null,
+  rawContent: `<channel chat_id="${chatId}">go</channel>`,
+})
+
+const enqueueWithThread = (chatId: string, threadId: string, msgId: string): SessionEvent => ({
+  kind: 'enqueue',
+  chatId,
+  messageId: msgId,
+  threadId,
+  rawContent: `<channel chat_id="${chatId}" thread_id="${threadId}">go</channel>`,
+})
+
+describe('P2: concurrent-chat fleet isolation', () => {
+  it('two chats with their own background sub-agents do not cross-pollinate', () => {
+    const { driver } = harness()
+
+    // Chat A
+    driver.ingest(enqueue('cA'), null)
+    driver.ingest(
+      {
+        kind: 'tool_use',
+        toolName: 'Agent',
+        toolUseId: 'tuA',
+        input: { prompt: 'pA', run_in_background: true },
+      },
+      'cA',
+    )
+    driver.ingest({ kind: 'sub_agent_started', agentId: 'saA', firstPromptText: 'pA' }, 'cA')
+
+    // Chat B
+    driver.ingest(enqueue('cB'), null)
+    driver.ingest(
+      {
+        kind: 'tool_use',
+        toolName: 'Agent',
+        toolUseId: 'tuB',
+        input: { prompt: 'pB', run_in_background: true },
+      },
+      'cB',
+    )
+    driver.ingest({ kind: 'sub_agent_started', agentId: 'saB', firstPromptText: 'pB' }, 'cB')
+
+    const fleetA = driver.peekFleet('cA')!
+    const fleetB = driver.peekFleet('cB')!
+    expect(fleetA.has('saA')).toBe(true)
+    expect(fleetA.has('saB')).toBe(false)
+    expect(fleetB.has('saB')).toBe(true)
+    expect(fleetB.has('saA')).toBe(false)
+    expect(fleetA.get('saA')!.status).toBe('background')
+    expect(fleetB.get('saB')!.status).toBe('background')
+  })
+
+  it('PR-C2: two threads in the SAME chat (different threadId, shared chatId) — no cross-talk in per-chat state maps', () => {
+    // Two forum-topic threads in the same Telegram chat. Same chatId,
+    // distinct threadId. The driver must key per-turn state on the
+    // composite (chatId, threadId) base — closing one thread's turn
+    // must not touch the other's, and bg sub-agents must not bleed
+    // between threads.
+    const { driver } = harness()
+
+    driver.ingest(enqueueWithThread('cShared', 'tA', '1'), null)
+    driver.ingest(
+      {
+        kind: 'tool_use', toolName: 'Agent', toolUseId: 'tuA',
+        input: { prompt: 'pA', run_in_background: true },
+      },
+      'cShared',
+    )
+    driver.ingest({ kind: 'sub_agent_started', agentId: 'saA', firstPromptText: 'pA' }, 'cShared')
+
+    driver.ingest(enqueueWithThread('cShared', 'tB', '2'), null)
+    driver.ingest(
+      {
+        kind: 'tool_use', toolName: 'Agent', toolUseId: 'tuB',
+        input: { prompt: 'pB', run_in_background: true },
+      },
+      'cShared',
+    )
+    driver.ingest({ kind: 'sub_agent_started', agentId: 'saB', firstPromptText: 'pB' }, 'cShared')
+
+    // peekFleet keys on (chatId, threadId).
+    const fleetA = driver.peekFleet('cShared', 'tA')!
+    const fleetB = driver.peekFleet('cShared', 'tB')!
+    expect(fleetA).toBeDefined()
+    expect(fleetB).toBeDefined()
+    expect(fleetA.has('saA')).toBe(true)
+    expect(fleetA.has('saB')).toBe(false)
+    expect(fleetB.has('saB')).toBe(true)
+    expect(fleetB.has('saA')).toBe(false)
+
+    // baseTurnSeqs must have distinct entries for the two threads.
+    const maps = (driver as unknown as {
+      _debugGetMaps?: () => { baseTurnSeqs: Map<string, number>; chats: Map<string, unknown> }
+    })._debugGetMaps!()
+    const baseKeys = [...maps.baseTurnSeqs.keys()]
+    // The two threads MUST resolve to distinct base keys (proves the
+    // composite (chatId, threadId) is honoured). The exact base-key
+    // format is (chatId:threadId) — assert distinctness without
+    // hard-coding the format.
+    expect(baseKeys.length).toBe(2)
+    expect(new Set(baseKeys).size).toBe(2)
+    // chats map: 2 in-flight turns.
+    expect(maps.chats.size).toBe(2)
+  })
+})