switchroom 0.5.0

package/telegram-plugin/tests/recent-outbound-dedup.test.ts

@@ -0,0 +1,192 @@
+/**
+ * Tests for the outbound dedup cache (#546).
+ *
+ * The bug pattern we're defending against:
+ *   - turn-flush sends a long reply rendered as HTML (`<b>foo</b>`).
+ *   - 9-11 seconds later, the agent's reply tool retries (after a
+ *     bridge reconnect) and ships the SAME content as raw markdown
+ *     (`**foo**`).
+ *   - User sees both. Trust leaks.
+ *
+ * The cache normalises both forms to the same key so `record(html)`
+ * is detected when `check(markdown)` arrives, and vice versa.
+ */
+
+import { describe, it, expect } from 'bun:test'
+import {
+  OutboundDedupCache,
+  normalizeForDedup,
+  DEFAULT_DEDUP_TTL_MS,
+  DEDUP_MIN_CONTENT_LEN,
+} from '../recent-outbound-dedup.js'
+
+const LONG_HTML = '<b>Heads up</b> — those blockers are now in <code>main</code>: rotate the password, fix the pipeline, verify env vars.'
+const LONG_MARKDOWN = '**Heads up** — those blockers are now in `main`: rotate the password, fix the pipeline, verify env vars.'
+const LONG_PLAIN = 'Heads up — those blockers are now in main: rotate the password, fix the pipeline, verify env vars.'
+
+describe('normalizeForDedup', () => {
+  it('hashes HTML and markdown forms of the same content equally', () => {
+    expect(normalizeForDedup(LONG_HTML)).toBe(normalizeForDedup(LONG_MARKDOWN))
+  })
+
+  it('hashes plain-text form equally too (no markup at all)', () => {
+    expect(normalizeForDedup(LONG_HTML)).toBe(normalizeForDedup(LONG_PLAIN))
+  })
+
+  it('strips HTML tags including attributes', () => {
+    const r = normalizeForDedup('<a href="https://x">link</a>')
+    expect(r).toBe('link')
+  })
+
+  it('strips markdown bold / italic / code markers', () => {
+    expect(normalizeForDedup('**bold**')).toBe('bold')
+    expect(normalizeForDedup('__bold__')).toBe('bold')
+    expect(normalizeForDedup('`code`')).toBe('code')
+  })
+
+  it('strips line-leading markdown markers', () => {
+    expect(normalizeForDedup('# heading\n- item\n> quote')).toBe('heading item quote')
+  })
+
+  it('collapses whitespace + lowercases for comparison', () => {
+    expect(normalizeForDedup('  Foo   Bar\n\n\nBaz  ')).toBe('foo bar baz')
+  })
+
+  it('expands HTML entities to spaces (defensive)', () => {
+    // The renderer emits &gt; for >; both forms should hash equally.
+    expect(normalizeForDedup('a &gt; b')).toBe('a   b'.replace(/\s+/g, ' ').trim())
+  })
+
+  it('different content produces different hashes', () => {
+    expect(normalizeForDedup('hello world')).not.toBe(normalizeForDedup('hello there'))
+  })
+})
+
+describe('OutboundDedupCache — happy path', () => {
+  it('records and detects same content within TTL', () => {
+    const cache = new OutboundDedupCache()
+    cache.record('123', undefined, LONG_HTML, 1000)
+    const r = cache.check('123', undefined, LONG_MARKDOWN, 5000)
+    expect(r).not.toBeNull()
+    expect(r!.matched).toBe(true)
+    expect(r!.ageMs).toBe(4000)
+    expect(r!.preview).toContain('Heads up')
+  })
+
+  it('returns null on cache miss', () => {
+    const cache = new OutboundDedupCache()
+    cache.record('123', undefined, LONG_HTML, 1000)
+    const r = cache.check('123', undefined, 'completely different content here', 2000)
+    expect(r).toBeNull()
+  })
+
+  it('matches across HTML / markdown / plain renderings (the actual bug)', () => {
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, LONG_HTML, 1000)
+    expect(cache.check('chat', undefined, LONG_MARKDOWN, 1500)).not.toBeNull()
+    expect(cache.check('chat', undefined, LONG_PLAIN, 1500)).not.toBeNull()
+  })
+})
+
+describe('OutboundDedupCache — TTL expiry', () => {
+  it('does not match an entry past TTL', () => {
+    const cache = new OutboundDedupCache({ ttlMs: 5000 })
+    cache.record('123', undefined, LONG_HTML, 1000)
+    // 6s later → past 5s TTL
+    expect(cache.check('123', undefined, LONG_MARKDOWN, 7000)).toBeNull()
+  })
+
+  it('uses default TTL of 60s when none provided', () => {
+    const cache = new OutboundDedupCache()
+    cache.record('123', undefined, LONG_HTML, 0)
+    expect(cache.check('123', undefined, LONG_HTML, DEFAULT_DEDUP_TTL_MS - 1)).not.toBeNull()
+    expect(cache.check('123', undefined, LONG_HTML, DEFAULT_DEDUP_TTL_MS + 1)).toBeNull()
+  })
+
+  it('evicts old entries on subsequent operations', () => {
+    const cache = new OutboundDedupCache({ ttlMs: 5000 })
+    cache.record('chat', undefined, LONG_HTML, 1000)
+    expect(cache.size(2000)).toBe(1)
+    expect(cache.size(10000)).toBe(0) // past TTL → evicted
+  })
+})
+
+describe('OutboundDedupCache — chat / thread isolation', () => {
+  it('does not match across different chat ids', () => {
+    const cache = new OutboundDedupCache()
+    cache.record('chat-A', undefined, LONG_HTML, 1000)
+    expect(cache.check('chat-B', undefined, LONG_HTML, 2000)).toBeNull()
+  })
+
+  it('does not match across different thread ids in the same chat', () => {
+    const cache = new OutboundDedupCache()
+    cache.record('chat', 1, LONG_HTML, 1000)
+    expect(cache.check('chat', 2, LONG_HTML, 2000)).toBeNull()
+  })
+
+  it('matches when threadId is undefined on both record + check', () => {
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, LONG_HTML, 1000)
+    expect(cache.check('chat', undefined, LONG_HTML, 2000)).not.toBeNull()
+  })
+
+  it('does NOT match record(undefined) against check(0) — distinct keys', () => {
+    // 0 is a valid threadId in some Telegram APIs; treat as distinct
+    // from undefined to avoid false positives.
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, LONG_HTML, 1000)
+    expect(cache.check('chat', 0, LONG_HTML, 2000)).toBeNull()
+  })
+})
+
+describe('OutboundDedupCache — short content is not deduped', () => {
+  it(`ignores content under ${DEDUP_MIN_CONTENT_LEN} chars on record`, () => {
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, 'short reply', 1000)
+    expect(cache.size(1500)).toBe(0)
+  })
+
+  it(`ignores short content on check (returns null even if hash would match)`, () => {
+    const cache = new OutboundDedupCache()
+    // Force-record by accessing internals would be a hack — instead, prove
+    // the check side filters too. Record a long entry; check a SHORT
+    // canonicalised query against it. Different lengths → different hashes
+    // anyway, so this test mostly documents the intent.
+    cache.record('chat', undefined, LONG_HTML, 1000)
+    expect(cache.check('chat', undefined, 'ok', 2000)).toBeNull()
+  })
+
+  it('legitimate short repeats do not get suppressed', () => {
+    // "ok" / "got it" / "✅ Done" are common in normal multi-turn
+    // conversation. Deduping them would suppress legitimate replies.
+    // Same reasoning as DEDUP_MIN_CONTENT_LEN's docstring.
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, 'ok', 1000)
+    cache.record('chat', undefined, 'ok', 5000)
+    cache.record('chat', undefined, 'ok', 9000)
+    expect(cache.size(10_000)).toBe(0) // none recorded
+    expect(cache.check('chat', undefined, 'ok', 10_000)).toBeNull()
+  })
+})
+
+describe('OutboundDedupCache — multiple entries per chat', () => {
+  it('matches the first hash that fits, even if more recent entries exist', () => {
+    const cache = new OutboundDedupCache()
+    const A = 'first long reply with enough characters to count as content'
+    const B = 'second long reply with enough characters to count as content too'
+    cache.record('chat', undefined, A, 1000)
+    cache.record('chat', undefined, B, 5000)
+    expect(cache.check('chat', undefined, A, 6000)).not.toBeNull()
+    expect(cache.check('chat', undefined, B, 6000)).not.toBeNull()
+  })
+
+  it('evicted entries no longer match', () => {
+    const cache = new OutboundDedupCache({ ttlMs: 3000 })
+    cache.record('chat', undefined, LONG_HTML, 1000)
+    // Wait past TTL.
+    expect(cache.check('chat', undefined, LONG_HTML, 5000)).toBeNull()
+    // Re-record after eviction; check works again.
+    cache.record('chat', undefined, LONG_HTML, 5000)
+    expect(cache.check('chat', undefined, LONG_HTML, 6000)).not.toBeNull()
+  })
+})

package/telegram-plugin/tests/registry-turns.test.ts

@@ -0,0 +1,432 @@
+/**
+ * Unit tests for telegram-plugin/registry/turns-schema.ts
+ *
+ * These tests use bun:sqlite directly and must run under Bun, not vitest/Node.
+ * They are excluded from vitest.config.ts and run via:
+ *   bun test telegram-plugin/tests/registry-turns.test.ts
+ * or as part of the `test:bun` script in the root package.json.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import { mkdtempSync, rmSync, existsSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import {
+  openTurnsDb,
+  openTurnsDbInMemory,
+  recordTurnStart,
+  recordTurnEnd,
+  findOrphanedTurns,
+  markOrphanedAsRestarted,
+  findMostRecentInterruptedTurn,
+} from '../registry/turns-schema.js'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let tempDir: string
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), 'turns-test-'))
+})
+
+afterEach(() => {
+  if (existsSync(tempDir)) {
+    rmSync(tempDir, { recursive: true, force: true })
+  }
+})
+
+// ---------------------------------------------------------------------------
+// openTurnsDb — filesystem
+// ---------------------------------------------------------------------------
+
+describe('openTurnsDb', () => {
+  it('creates registry.db at <agentDir>/telegram/registry.db', () => {
+    openTurnsDb(tempDir)
+    const expected = join(tempDir, 'telegram', 'registry.db')
+    expect(existsSync(expected)).toBe(true)
+  })
+
+  it('schema migration is idempotent — second open does not throw', () => {
+    const db1 = openTurnsDb(tempDir)
+    db1.close()
+    expect(() => openTurnsDb(tempDir)).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// openTurnsDbInMemory — schema sanity
+// ---------------------------------------------------------------------------
+
+describe('openTurnsDbInMemory', () => {
+  it('creates the turns table without touching the filesystem', () => {
+    const db = openTurnsDbInMemory()
+    // If the table does not exist this throws; if it exists we get 0 rows.
+    const rows = db.prepare('SELECT * FROM turns').all()
+    expect(Array.isArray(rows)).toBe(true)
+    expect(rows).toHaveLength(0)
+    db.close()
+  })
+
+  it('creates the idx_turns_chat_ended index', () => {
+    const db = openTurnsDbInMemory()
+    const row = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='index' AND name='idx_turns_chat_ended'",
+    ).get() as { name: string } | undefined
+    expect(row?.name).toBe('idx_turns_chat_ended')
+    db.close()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// recordTurnStart
+// ---------------------------------------------------------------------------
+
+describe('recordTurnStart', () => {
+  it('writes a row with ended_at NULL', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '111:1', chatId: '111' })
+    const row = db.prepare('SELECT * FROM turns WHERE turn_key = ?').get('111:1') as
+      | Record<string, unknown>
+      | undefined
+    expect(row).toBeDefined()
+    expect(row!['ended_at']).toBeNull()
+    expect(row!['chat_id']).toBe('111')
+    db.close()
+  })
+
+  it('stores thread_id and last_user_msg_id when provided', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, {
+      turnKey: '111:2',
+      chatId: '111',
+      threadId: '42',
+      lastUserMsgId: '99',
+    })
+    const row = db.prepare('SELECT * FROM turns WHERE turn_key = ?').get('111:2') as
+      | Record<string, unknown>
+      | undefined
+    expect(row!['thread_id']).toBe('42')
+    expect(row!['last_user_msg_id']).toBe('99')
+    db.close()
+  })
+
+  it('stores null thread_id when not provided', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '111:3', chatId: '111' })
+    const row = db.prepare('SELECT * FROM turns WHERE turn_key = ?').get('111:3') as
+      | Record<string, unknown>
+      | undefined
+    expect(row!['thread_id']).toBeNull()
+    db.close()
+  })
+
+  it('is idempotent — duplicate turn_key is silently ignored', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '111:4', chatId: '111' })
+    expect(() =>
+      recordTurnStart(db, { turnKey: '111:4', chatId: '111' }),
+    ).not.toThrow()
+    const count = (
+      db.prepare('SELECT COUNT(*) as n FROM turns WHERE turn_key = ?').get('111:4') as {
+        n: number
+      }
+    ).n
+    expect(count).toBe(1)
+    db.close()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// recordTurnEnd
+// ---------------------------------------------------------------------------
+
+describe('recordTurnEnd', () => {
+  it('sets ended_at and ended_via on an existing row', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '111:5', chatId: '111' })
+    recordTurnEnd(db, { turnKey: '111:5', endedVia: 'stop' })
+    const row = db.prepare('SELECT * FROM turns WHERE turn_key = ?').get('111:5') as
+      | Record<string, unknown>
+      | undefined
+    expect(row!['ended_at']).toBeTypeOf('number')
+    expect(row!['ended_via']).toBe('stop')
+    db.close()
+  })
+
+  it('sets last_assistant_msg_id and last_assistant_done', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '111:6', chatId: '111' })
+    recordTurnEnd(db, {
+      turnKey: '111:6',
+      endedVia: 'stop',
+      lastAssistantMsgId: '77',
+      lastAssistantDone: true,
+    })
+    const row = db.prepare('SELECT * FROM turns WHERE turn_key = ?').get('111:6') as
+      | Record<string, unknown>
+      | undefined
+    expect(row!['last_assistant_msg_id']).toBe('77')
+    // SQLite stores booleans as integers
+    expect(row!['last_assistant_done']).toBe(1)
+    db.close()
+  })
+
+  it('stores last_assistant_done=false as 0', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '111:7', chatId: '111' })
+    recordTurnEnd(db, {
+      turnKey: '111:7',
+      endedVia: 'stop',
+      lastAssistantDone: false,
+    })
+    const row = db.prepare('SELECT * FROM turns WHERE turn_key = ?').get('111:7') as
+      | Record<string, unknown>
+      | undefined
+    expect(row!['last_assistant_done']).toBe(0)
+    db.close()
+  })
+
+  it('is a no-op for a missing turn_key', () => {
+    const db = openTurnsDbInMemory()
+    expect(() =>
+      recordTurnEnd(db, { turnKey: 'nonexistent:99', endedVia: 'unknown' }),
+    ).not.toThrow()
+    db.close()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// start → end round-trip
+// ---------------------------------------------------------------------------
+
+describe('recordTurnStart + recordTurnEnd round-trip', () => {
+  it('starts open, ends closed', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '222:1', chatId: '222', lastUserMsgId: 'msg1' })
+
+    const before = db.prepare('SELECT ended_at FROM turns WHERE turn_key = ?').get('222:1') as
+      | Record<string, unknown>
+      | undefined
+    expect(before!['ended_at']).toBeNull()
+
+    recordTurnEnd(db, {
+      turnKey: '222:1',
+      endedVia: 'stop',
+      lastAssistantMsgId: 'msg2',
+      lastAssistantDone: true,
+    })
+
+    const after = db.prepare('SELECT * FROM turns WHERE turn_key = ?').get('222:1') as
+      | Record<string, unknown>
+      | undefined
+    expect(after!['ended_at']).toBeTypeOf('number')
+    expect(after!['ended_via']).toBe('stop')
+    expect(after!['last_assistant_msg_id']).toBe('msg2')
+    expect(after!['last_assistant_done']).toBe(1)
+    expect(after!['last_user_msg_id']).toBe('msg1')
+    db.close()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// findOrphanedTurns
+// ---------------------------------------------------------------------------
+
+describe('findOrphanedTurns', () => {
+  it('returns turns with ended_at NULL for the given chat', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '333:1', chatId: '333' })
+    recordTurnStart(db, { turnKey: '333:2', chatId: '333' })
+    // Close one turn
+    recordTurnEnd(db, { turnKey: '333:1', endedVia: 'stop' })
+
+    const orphans = findOrphanedTurns(db, '333')
+    expect(orphans).toHaveLength(1)
+    expect(orphans[0]!.turn_key).toBe('333:2')
+    db.close()
+  })
+
+  it('returns empty array when no orphaned turns exist', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '333:3', chatId: '333' })
+    recordTurnEnd(db, { turnKey: '333:3', endedVia: 'stop' })
+
+    expect(findOrphanedTurns(db, '333')).toHaveLength(0)
+    db.close()
+  })
+
+  it('isolates by chat_id', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'A:1', chatId: 'A' })
+    recordTurnStart(db, { turnKey: 'B:1', chatId: 'B' })
+
+    expect(findOrphanedTurns(db, 'A')).toHaveLength(1)
+    expect(findOrphanedTurns(db, 'B')).toHaveLength(1)
+    expect(findOrphanedTurns(db, 'C')).toHaveLength(0)
+    db.close()
+  })
+
+  it('maps last_assistant_done integer to boolean correctly', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '444:1', chatId: '444' })
+
+    const [turn] = findOrphanedTurns(db, '444')
+    // Not yet set — should be null
+    expect(turn!.last_assistant_done).toBeNull()
+    db.close()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// markOrphanedAsRestarted
+// ---------------------------------------------------------------------------
+
+describe('markOrphanedAsRestarted', () => {
+  it('stamps all open turns with ended_via=restart and non-null ended_at', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '555:1', chatId: '555' })
+    recordTurnStart(db, { turnKey: '555:2', chatId: '555' })
+
+    const count = markOrphanedAsRestarted(db)
+    expect(count).toBe(2)
+
+    const rows = db.prepare(
+      "SELECT * FROM turns WHERE ended_via = 'restart'",
+    ).all() as Record<string, unknown>[]
+    expect(rows).toHaveLength(2)
+    for (const row of rows) {
+      expect(row['ended_at']).toBeTypeOf('number')
+      expect(row['ended_via']).toBe('restart')
+    }
+    db.close()
+  })
+
+  it('does not touch already-closed turns', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '555:3', chatId: '555' })
+    recordTurnEnd(db, { turnKey: '555:3', endedVia: 'stop' })
+    recordTurnStart(db, { turnKey: '555:4', chatId: '555' })
+
+    markOrphanedAsRestarted(db)
+
+    const closed = db.prepare(
+      "SELECT ended_via FROM turns WHERE turn_key = '555:3'",
+    ).get() as Record<string, unknown>
+    expect(closed['ended_via']).toBe('stop')
+
+    const swept = db.prepare(
+      "SELECT ended_via FROM turns WHERE turn_key = '555:4'",
+    ).get() as Record<string, unknown>
+    expect(swept['ended_via']).toBe('restart')
+    db.close()
+  })
+
+  it('after markOrphanedAsRestarted, findOrphanedTurns returns empty', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '666:1', chatId: '666' })
+    recordTurnStart(db, { turnKey: '666:2', chatId: '666' })
+
+    markOrphanedAsRestarted(db)
+
+    expect(findOrphanedTurns(db, '666')).toHaveLength(0)
+    db.close()
+  })
+
+  it('returns 0 when there are no open turns', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '777:1', chatId: '777' })
+    recordTurnEnd(db, { turnKey: '777:1', endedVia: 'stop' })
+
+    expect(markOrphanedAsRestarted(db)).toBe(0)
+    db.close()
+  })
+
+  it('is safe to call on an empty DB (returns 0, no error)', () => {
+    const db = openTurnsDbInMemory()
+    expect(markOrphanedAsRestarted(db)).toBe(0)
+    db.close()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// findMostRecentInterruptedTurn
+// ---------------------------------------------------------------------------
+
+describe('findMostRecentInterruptedTurn', () => {
+  it('returns null when no turns exist', () => {
+    const db = openTurnsDbInMemory()
+    expect(findMostRecentInterruptedTurn(db)).toBeNull()
+    db.close()
+  })
+
+  it('returns null when the only turn ended cleanly via stop', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '888:1', chatId: '888' })
+    recordTurnEnd(db, { turnKey: '888:1', endedVia: 'stop' })
+    expect(findMostRecentInterruptedTurn(db)).toBeNull()
+    db.close()
+  })
+
+  it('returns an open turn (ended_at IS NULL) as interrupted', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: '999:1', chatId: '999', lastUserMsgId: 'msg-1' })
+    const t = findMostRecentInterruptedTurn(db)
+    expect(t).not.toBeNull()
+    expect(t!.turn_key).toBe('999:1')
+    expect(t!.last_user_msg_id).toBe('msg-1')
+    db.close()
+  })
+
+  it('returns a sigterm-stamped turn as interrupted', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'aaa:1', chatId: 'aaa' })
+    recordTurnEnd(db, { turnKey: 'aaa:1', endedVia: 'sigterm' })
+    const t = findMostRecentInterruptedTurn(db)
+    expect(t).not.toBeNull()
+    expect(t!.ended_via).toBe('sigterm')
+    db.close()
+  })
+
+  it('returns a restart-stamped turn as interrupted', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'bbb:1', chatId: 'bbb' })
+    recordTurnEnd(db, { turnKey: 'bbb:1', endedVia: 'restart' })
+    const t = findMostRecentInterruptedTurn(db)
+    expect(t).not.toBeNull()
+    expect(t!.ended_via).toBe('restart')
+    db.close()
+  })
+
+  it('picks the most-recently-started across multiple interrupted turns', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'ccc:1', chatId: 'ccc' })
+    // Different started_at by waiting one ms; bun:sqlite stores the
+    // recordTurnStart call's Date.now() so we use raw insert below to be
+    // deterministic.
+    db.exec(`UPDATE turns SET started_at = 1000 WHERE turn_key = 'ccc:1'`)
+    recordTurnStart(db, { turnKey: 'ccc:2', chatId: 'ccc' })
+    db.exec(`UPDATE turns SET started_at = 2000 WHERE turn_key = 'ccc:2'`)
+    recordTurnEnd(db, { turnKey: 'ccc:1', endedVia: 'restart' })
+    recordTurnEnd(db, { turnKey: 'ccc:2', endedVia: 'sigterm' })
+    const t = findMostRecentInterruptedTurn(db)
+    expect(t).not.toBeNull()
+    expect(t!.turn_key).toBe('ccc:2')
+    db.close()
+  })
+
+  it('skips a clean stop and picks an older interrupted turn', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'ddd:1', chatId: 'ddd' })
+    db.exec(`UPDATE turns SET started_at = 1000 WHERE turn_key = 'ddd:1'`)
+    recordTurnStart(db, { turnKey: 'ddd:2', chatId: 'ddd' })
+    db.exec(`UPDATE turns SET started_at = 2000 WHERE turn_key = 'ddd:2'`)
+    recordTurnEnd(db, { turnKey: 'ddd:1', endedVia: 'sigterm' })
+    recordTurnEnd(db, { turnKey: 'ddd:2', endedVia: 'stop' })
+    const t = findMostRecentInterruptedTurn(db)
+    expect(t).not.toBeNull()
+    expect(t!.turn_key).toBe('ddd:1')
+    db.close()
+  })
+})