switchroom 0.14.21 → 0.14.23

package/telegram-plugin/tests/races.test.ts

@@ -7,9 +7,6 @@
  * server.ts directly.
  */
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
 
 import {
   parseQueuePrefix,
@@ -17,11 +14,6 @@ import {
   formatPriorAssistantPreview,
   buildChannelMetaAttributes,
 } from '../steering.js'
-import {
-  consumeHandoffTopic,
-  formatHandoffLine,
-  HANDOFF_TOPIC_FILENAME,
-} from '../handoff-continuity.js'
 
 // ---- harness (copy of e2e.test.ts's — intentional; tests stay isolated) ----
 
@@ -213,24 +205,6 @@ describe('Race: reply tool claims PTY preview suppression gate', () => {
   })
 })
 
-describe('Race: handoff topic consumed once, second reply no-ops', () => {
-  let tmp: string
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'handoff-race-'))
-  })
-  afterEach(() => {
-    rmSync(tmp, { recursive: true, force: true })
-  })
-
-  it('topic consumed on first reply; second reply sees null', () => {
-    writeFileSync(join(tmp, HANDOFF_TOPIC_FILENAME), 'topic\n', 'utf8')
-    const first = consumeHandoffTopic(tmp)
-    expect(first).toBe('topic')
-    const second = consumeHandoffTopic(tmp)
-    expect(second).toBeNull()
-  })
-})
-
 describe('Race: activeTurnStartedAt cleanup on every exit path', () => {
   // Parameterized test — exercises every code path that deletes a
   // status controller in server.ts and asserts the Map is empty after.

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

@@ -17,10 +17,20 @@ import {
   recordTurnStart,
   recordTurnEnd,
   findOrphanedTurns,
-  markOrphanedAsRestarted,
-  findMostRecentInterruptedTurn,
+  markOrphanedWithTimeoutClassification,
+  findLatestTurnIfInterrupted,
 } from '../registry/turns-schema.js'
 
+// Convenience: the boot reaper with no live hang marker — every open turn
+// is a clean 'restart' interrupt. Mirrors the gateway's between-turns boot.
+function reapAsRestart(db: Parameters<typeof findOrphanedTurns>[0]) {
+  return markOrphanedWithTimeoutClassification(db, {
+    markerTurnKey: null,
+    markerAgeMs: null,
+    hangThresholdMs: 300_000,
+  })
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -280,17 +290,18 @@ describe('findOrphanedTurns', () => {
 })
 
 // ---------------------------------------------------------------------------
-// markOrphanedAsRestarted
+// markOrphanedWithTimeoutClassification — no-hang-marker (clean restart) path
 // ---------------------------------------------------------------------------
 
-describe('markOrphanedAsRestarted', () => {
+describe('markOrphanedWithTimeoutClassification (restart path)', () => {
   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 res = reapAsRestart(db)
+    expect(res.reaped).toBe(2)
+    expect(res.timeoutTurnKey).toBeNull()
 
     const rows = db.prepare(
       "SELECT * FROM turns WHERE ended_via = 'restart'",
@@ -309,7 +320,7 @@ describe('markOrphanedAsRestarted', () => {
     recordTurnEnd(db, { turnKey: '555:3', endedVia: 'stop' })
     recordTurnStart(db, { turnKey: '555:4', chatId: '555' })
 
-    markOrphanedAsRestarted(db)
+    reapAsRestart(db)
 
     const closed = db.prepare(
       "SELECT ended_via FROM turns WHERE turn_key = '555:3'",
@@ -323,41 +334,99 @@ describe('markOrphanedAsRestarted', () => {
     db.close()
   })
 
-  it('after markOrphanedAsRestarted, findOrphanedTurns returns empty', () => {
+  it('after reaping, findOrphanedTurns returns empty', () => {
     const db = openTurnsDbInMemory()
     recordTurnStart(db, { turnKey: '666:1', chatId: '666' })
     recordTurnStart(db, { turnKey: '666:2', chatId: '666' })
 
-    markOrphanedAsRestarted(db)
+    reapAsRestart(db)
 
     expect(findOrphanedTurns(db, '666')).toHaveLength(0)
     db.close()
   })
 
-  it('returns 0 when there are no open turns', () => {
+  it('reaps 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)
+    expect(reapAsRestart(db).reaped).toBe(0)
     db.close()
   })
 
-  it('is safe to call on an empty DB (returns 0, no error)', () => {
+  it('is safe to call on an empty DB (reaps 0, no error)', () => {
     const db = openTurnsDbInMemory()
-    expect(markOrphanedAsRestarted(db)).toBe(0)
+    expect(reapAsRestart(db).reaped).toBe(0)
     db.close()
   })
 })
 
 // ---------------------------------------------------------------------------
-// findMostRecentInterruptedTurn
+// markOrphanedWithTimeoutClassification — hang-marker (timeout) path
 // ---------------------------------------------------------------------------
 
-describe('findMostRecentInterruptedTurn', () => {
+describe('markOrphanedWithTimeoutClassification (timeout path)', () => {
+  it('stamps the marker turn timeout when its marker is older than the threshold', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'hang:1', chatId: 'h' })
+    recordTurnStart(db, { turnKey: 'live:2', chatId: 'h' })
+
+    const res = markOrphanedWithTimeoutClassification(db, {
+      markerTurnKey: 'hang:1',
+      markerAgeMs: 600_000, // 10 min > 5 min threshold
+      hangThresholdMs: 300_000,
+      reasonSnapshot: JSON.stringify({ idleMs: 600_000 }),
+    })
+
+    expect(res.timeoutTurnKey).toBe('hang:1')
+    expect(res.reaped).toBe(2)
+
+    const hang = db.prepare("SELECT * FROM turns WHERE turn_key = 'hang:1'").get() as Record<string, unknown>
+    expect(hang['ended_via']).toBe('timeout')
+    expect(hang['interrupt_reason']).toBe(JSON.stringify({ idleMs: 600_000 }))
+    // The other open turn is a clean restart.
+    const live = db.prepare("SELECT * FROM turns WHERE turn_key = 'live:2'").get() as Record<string, unknown>
+    expect(live['ended_via']).toBe('restart')
+    db.close()
+  })
+
+  it('classifies the marker turn as restart when its marker is younger than the threshold', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'fresh:1', chatId: 'h' })
+
+    const res = markOrphanedWithTimeoutClassification(db, {
+      markerTurnKey: 'fresh:1',
+      markerAgeMs: 5_000, // 5s — was making progress
+      hangThresholdMs: 300_000,
+    })
+
+    expect(res.timeoutTurnKey).toBeNull()
+    const row = db.prepare("SELECT ended_via FROM turns WHERE turn_key = 'fresh:1'").get() as Record<string, unknown>
+    expect(row['ended_via']).toBe('restart')
+    db.close()
+  })
+
+  it('does not classify timeout when no marker turn key is present (between-turns boot)', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'x:1', chatId: 'h' })
+    const res = markOrphanedWithTimeoutClassification(db, {
+      markerTurnKey: null,
+      markerAgeMs: 999_999,
+      hangThresholdMs: 300_000,
+    })
+    expect(res.timeoutTurnKey).toBeNull()
+    db.close()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// findLatestTurnIfInterrupted — keys on the LATEST turn only
+// ---------------------------------------------------------------------------
+
+describe('findLatestTurnIfInterrupted', () => {
   it('returns null when no turns exist', () => {
     const db = openTurnsDbInMemory()
-    expect(findMostRecentInterruptedTurn(db)).toBeNull()
+    expect(findLatestTurnIfInterrupted(db)).toBeNull()
     db.close()
   })
 
@@ -365,14 +434,14 @@ describe('findMostRecentInterruptedTurn', () => {
     const db = openTurnsDbInMemory()
     recordTurnStart(db, { turnKey: '888:1', chatId: '888' })
     recordTurnEnd(db, { turnKey: '888:1', endedVia: 'stop' })
-    expect(findMostRecentInterruptedTurn(db)).toBeNull()
+    expect(findLatestTurnIfInterrupted(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)
+    const t = findLatestTurnIfInterrupted(db)
     expect(t).not.toBeNull()
     expect(t!.turn_key).toBe('999:1')
     expect(t!.last_user_msg_id).toBe('msg-1')
@@ -383,7 +452,7 @@ describe('findMostRecentInterruptedTurn', () => {
     const db = openTurnsDbInMemory()
     recordTurnStart(db, { turnKey: 'aaa:1', chatId: 'aaa' })
     recordTurnEnd(db, { turnKey: 'aaa:1', endedVia: 'sigterm' })
-    const t = findMostRecentInterruptedTurn(db)
+    const t = findLatestTurnIfInterrupted(db)
     expect(t).not.toBeNull()
     expect(t!.ended_via).toBe('sigterm')
     db.close()
@@ -393,30 +462,40 @@ describe('findMostRecentInterruptedTurn', () => {
     const db = openTurnsDbInMemory()
     recordTurnStart(db, { turnKey: 'bbb:1', chatId: 'bbb' })
     recordTurnEnd(db, { turnKey: 'bbb:1', endedVia: 'restart' })
-    const t = findMostRecentInterruptedTurn(db)
+    const t = findLatestTurnIfInterrupted(db)
     expect(t).not.toBeNull()
     expect(t!.ended_via).toBe('restart')
     db.close()
   })
 
-  it('picks the most-recently-started across multiple interrupted turns', () => {
+  it('returns a timeout-stamped turn as interrupted', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'tmo:1', chatId: 'tmo' })
+    recordTurnEnd(db, { turnKey: 'tmo:1', endedVia: 'timeout' })
+    const t = findLatestTurnIfInterrupted(db)
+    expect(t).not.toBeNull()
+    expect(t!.ended_via).toBe('timeout')
+    db.close()
+  })
+
+  it('picks the most-recently-started turn (latest), not an older interrupted one', () => {
     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)
+    const t = findLatestTurnIfInterrupted(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', () => {
+  it('a clean latest turn SHADOWS an older interrupted one (returns null)', () => {
+    // This is the inverse of the old findMostRecentInterruptedTurn bug: a
+    // completed resume (latest turn 'stop') must not resurface the stale
+    // interrupted turn on the next restart.
     const db = openTurnsDbInMemory()
     recordTurnStart(db, { turnKey: 'ddd:1', chatId: 'ddd' })
     db.exec(`UPDATE turns SET started_at = 1000 WHERE turn_key = 'ddd:1'`)
@@ -424,9 +503,7 @@ describe('findMostRecentInterruptedTurn', () => {
     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')
+    expect(findLatestTurnIfInterrupted(db)).toBeNull()
     db.close()
   })
 })

package/telegram-plugin/tests/resume-inbound-builder.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Unit tests for telegram-plugin/gateway/resume-inbound-builder.ts
+ *
+ * Pure builders — no SQLite, no gateway. They run under bun test alongside
+ * the other telegram-plugin tests. The contract under test:
+ *
+ *   - humanizeElapsed bucketing (moments / min / h / days, plus the
+ *     negative/NaN guard).
+ *   - buildResumeInterruptedInbound  → source='resume_interrupted', resume
+ *     framing, dedup anchor meta.resume_turn_key, thread routing.
+ *   - buildResumeWatchdogReportInbound → source='resume_watchdog_timeout',
+ *     report (not resume) framing, idle_ms passthrough.
+ *   - selectResumeBuilder policy table.
+ */
+
+import { describe, it, expect } from 'bun:test'
+import {
+  humanizeElapsed,
+  buildResumeInterruptedInbound,
+  buildResumeWatchdogReportInbound,
+  selectResumeBuilder,
+} from '../gateway/resume-inbound-builder.js'
+import type { Turn, TurnEndedVia } from '../registry/turns-schema.js'
+
+function makeTurn(overrides: Partial<Turn> = {}): Turn {
+  return {
+    turn_key: '12345:11',
+    chat_id: '12345',
+    thread_id: null,
+    started_at: 1_000_000,
+    ended_at: null,
+    ended_via: 'restart',
+    last_assistant_msg_id: null,
+    last_assistant_done: null,
+    last_user_msg_id: null,
+    user_prompt_preview: null,
+    assistant_reply_preview: null,
+    tool_call_count: null,
+    interrupt_reason: null,
+    created_at: 1_000_000,
+    updated_at: 1_000_000,
+    ...overrides,
+  }
+}
+
+describe('humanizeElapsed', () => {
+  it('returns "moments" under 45s', () => {
+    expect(humanizeElapsed(0)).toBe('moments')
+    expect(humanizeElapsed(44_000)).toBe('moments')
+  })
+
+  it('buckets minutes under an hour', () => {
+    expect(humanizeElapsed(60_000)).toBe('~1 min')
+    expect(humanizeElapsed(5 * 60_000)).toBe('~5 min')
+    expect(humanizeElapsed(59 * 60_000)).toBe('~59 min')
+  })
+
+  it('buckets hours under a day', () => {
+    expect(humanizeElapsed(60 * 60_000)).toBe('~1h')
+    expect(humanizeElapsed(3 * 60 * 60_000)).toBe('~3h')
+  })
+
+  it('buckets days at/over 24h with singular/plural', () => {
+    expect(humanizeElapsed(24 * 60 * 60_000)).toBe('~1 day')
+    expect(humanizeElapsed(50 * 60 * 60_000)).toBe('~2 days')
+  })
+
+  it('guards against negative / non-finite input', () => {
+    expect(humanizeElapsed(-5)).toBe('an unknown amount of time')
+    expect(humanizeElapsed(NaN)).toBe('an unknown amount of time')
+    expect(humanizeElapsed(Infinity)).toBe('an unknown amount of time')
+  })
+})
+
+describe('buildResumeInterruptedInbound', () => {
+  it('sets the resume_interrupted source and dedup anchor', () => {
+    const turn = makeTurn({ turn_key: 'abc:7', ended_via: 'sigterm' })
+    const msg = buildResumeInterruptedInbound({ turn, nowMs: turn.started_at + 3 * 60 * 60_000 })
+    expect(msg.type).toBe('inbound')
+    expect(msg.meta.source).toBe('resume_interrupted')
+    expect(msg.meta.resume_turn_key).toBe('abc:7')
+    expect(msg.meta.interrupted_via).toBe('sigterm')
+    expect(msg.user).toBe('switchroom')
+    expect(msg.userId).toBe(0)
+  })
+
+  it('frames the elapsed time in the body and tells the model to resume, not ask', () => {
+    const turn = makeTurn()
+    const msg = buildResumeInterruptedInbound({ turn, nowMs: turn.started_at + 3 * 60 * 60_000 })
+    expect(msg.text).toContain('~3h')
+    expect(msg.text.toLowerCase()).toContain('interrupted')
+    expect(msg.text.toLowerCase()).toContain('do')
+    expect(msg.text).toContain('not ask whether to resume')
+  })
+
+  it('defaults interrupted_via to restart when ended_via is null', () => {
+    const turn = makeTurn({ ended_via: null })
+    const msg = buildResumeInterruptedInbound({ turn })
+    expect(msg.meta.interrupted_via).toBe('restart')
+  })
+
+  it('includes the prompt preview when present and carries original_prompt meta', () => {
+    const turn = makeTurn({ user_prompt_preview: 'refactor the auth module' })
+    const msg = buildResumeInterruptedInbound({ turn })
+    expect(msg.text).toContain('refactor the auth module')
+    expect(msg.meta.original_prompt).toBe('refactor the auth module')
+  })
+
+  it('truncates a long prompt preview in the body', () => {
+    const long = 'x'.repeat(300)
+    const turn = makeTurn({ user_prompt_preview: long })
+    const msg = buildResumeInterruptedInbound({ turn })
+    expect(msg.text).toContain('…')
+    expect(msg.text).not.toContain('x'.repeat(200))
+  })
+
+  it('routes to the forum thread when thread_id is numeric', () => {
+    const turn = makeTurn({ thread_id: '99' })
+    const msg = buildResumeInterruptedInbound({ turn })
+    expect(msg.threadId).toBe(99)
+  })
+
+  it('omits threadId for a non-forum (null thread_id) chat', () => {
+    const msg = buildResumeInterruptedInbound({ turn: makeTurn({ thread_id: null }) })
+    expect(msg.threadId).toBeUndefined()
+  })
+})
+
+describe('buildResumeWatchdogReportInbound', () => {
+  it('sets the resume_watchdog_timeout source and idle_ms passthrough', () => {
+    const turn = makeTurn({ ended_via: 'timeout' })
+    const msg = buildResumeWatchdogReportInbound({ turn, idleMs: 300_000 })
+    expect(msg.meta.source).toBe('resume_watchdog_timeout')
+    expect(msg.meta.interrupted_via).toBe('timeout')
+    expect(msg.meta.idle_ms).toBe('300000')
+  })
+
+  it('reports the hang honestly and asks rather than resuming', () => {
+    const turn = makeTurn({ ended_via: 'timeout' })
+    const msg = buildResumeWatchdogReportInbound({ turn, idleMs: 300_000 })
+    expect(msg.text.toLowerCase()).toContain('hang-watchdog')
+    expect(msg.text).toContain('no observable progress')
+    expect(msg.text).toContain('Do NOT silently resume')
+    expect(msg.text.toLowerCase()).toContain('take a different angle')
+  })
+
+  it('mentions tool-call count when the turn ran tools before stalling', () => {
+    const turn = makeTurn({ ended_via: 'timeout', tool_call_count: 4 })
+    const msg = buildResumeWatchdogReportInbound({ turn, idleMs: 300_000 })
+    expect(msg.text).toContain('4 tool calls')
+    expect(msg.meta.tool_call_count).toBe('4')
+  })
+
+  it('singularizes a single tool call', () => {
+    const turn = makeTurn({ ended_via: 'timeout', tool_call_count: 1 })
+    const msg = buildResumeWatchdogReportInbound({ turn, idleMs: 300_000 })
+    expect(msg.text).toContain('1 tool call')
+    expect(msg.text).not.toContain('1 tool calls')
+  })
+
+  it('omits the tool clause when no tools ran', () => {
+    const turn = makeTurn({ ended_via: 'timeout', tool_call_count: 0 })
+    const msg = buildResumeWatchdogReportInbound({ turn, idleMs: 300_000 })
+    expect(msg.text).not.toContain('tool call')
+  })
+})
+
+describe('selectResumeBuilder', () => {
+  const cases: Array<[TurnEndedVia | null, 'resume' | 'report' | null]> = [
+    ['timeout', 'report'],
+    ['restart', 'resume'],
+    ['sigterm', 'resume'],
+    ['unknown', 'resume'],
+    [null, 'resume'],
+    ['stop', null],
+  ]
+  for (const [endedVia, expected] of cases) {
+    it(`maps ended_via=${String(endedVia)} → ${String(expected)}`, () => {
+      expect(selectResumeBuilder(endedVia)).toBe(expected)
+    })
+  }
+})

package/telegram-plugin/tests/status-accent.test.ts

@@ -54,7 +54,6 @@ function makeDeps(
     markdownToHtml: (t) => `<b>${t}</b>`,
     escapeMarkdownV2: (t) => `\\${t}\\`,
     repairEscapedWhitespace: (t) => t,
-    takeHandoffPrefix: () => '',
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
     disableLinkPreview: true,

package/telegram-plugin/tests/stream-reply-error-paths.test.ts

@@ -40,7 +40,6 @@ function makeDeps(
     markdownToHtml: (t) => realMarkdownToHtml(t),
     escapeMarkdownV2: (t) => t,
     repairEscapedWhitespace: (t) => t,
-    takeHandoffPrefix: () => '',
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
     disableLinkPreview: true,

package/telegram-plugin/tests/stream-reply-handler.test.ts

@@ -35,7 +35,6 @@ function makeDeps(
     markdownToHtml: (t) => `<b>${t}</b>`,
     escapeMarkdownV2: (t) => `\\${t}\\`,
     repairEscapedWhitespace: (t) => t,
-    takeHandoffPrefix: () => '',
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
     disableLinkPreview: true,
@@ -104,29 +103,6 @@ describe('handleStreamReply', () => {
     expect(bot.api.sendMessage.mock.calls[0][2]?.parse_mode).toBeUndefined()
   })
 
-  it('prepends handoff prefix on first chunk only', async () => {
-    const state = makeState()
-    const deps = makeDeps(bot, {
-      takeHandoffPrefix: vi.fn<(fmt: string) => string>(() => '↩️ '),
-    })
-
-    // First call: prefix applied
-    const p1 = handleStreamReply({ chat_id: '1', text: 'first' }, state, deps)
-    await microtaskFlush()
-    await p1
-    // Prefix is prepended AFTER format rendering (it's already format-safe
-    // because takeHandoffPrefix takes the format tag).
-    expect(bot.api.sendMessage.mock.calls[0][1]).toBe('↩️ <b>first</b>')
-
-    // Second call: handoff not consumed again
-    vi.advanceTimersByTime(1000)
-    const p2 = handleStreamReply({ chat_id: '1', text: 'second' }, state, deps)
-    await microtaskFlush()
-    await p2
-    expect(bot.api.editMessageText.mock.calls[0][2]).toBe('<b>second</b>')
-    expect(deps.takeHandoffPrefix).toHaveBeenCalledTimes(1)
-  })
-
   it('throws when text exceeds 4096 (no silent id:pending)', async () => {
     // Pins the bug found in prod: a >4096-char text would hit draft-
     // stream's length guard, silently stop, and the handler would return

package/telegram-plugin/tests/streaming-e2e.test.ts

@@ -88,7 +88,6 @@ function setup(opts: { progressCardActive?: boolean } = {}): Fixture {
       markdownToHtml: (t) => `<b>${t}</b>`, // stream_reply: bold
       escapeMarkdownV2: (t) => t,
       repairEscapedWhitespace: (t) => t,
-      takeHandoffPrefix: () => '',
       assertAllowedChat: () => {},
       resolveThreadId: () => undefined,
       disableLinkPreview: true,

package/telegram-plugin/tests/streaming-orchestration.test.ts

@@ -407,7 +407,6 @@ function makeActivityDeps(
     markdownToHtml: (t) => t,
     escapeMarkdownV2: (t) => t,
     repairEscapedWhitespace: (t) => t,
-    takeHandoffPrefix: () => '',
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
     disableLinkPreview: true,

package/telegram-plugin/tests/subagent-registry-bugs.test.ts

@@ -624,13 +624,17 @@ describe('Bug 3 — stalled-row sweeper: watcher must call recordSubagentStall i
     h.watcher.stop()
   })
 
-  it('does not call stall for historical entries (pre-existing at boot)', () => {
+  it('does not call stall for historical (done-at-boot) entries', () => {
+    // A worker that already FINISHED before boot (turn_end present) stays
+    // historical and must not write stall rows. A still-RUNNING file at
+    // boot is a different case — Gap 1 promotes it to live so it DOES get
+    // the stall safety net (covered in subagent-watcher-handback-gaps).
     const agentDir = '/home/user/.switchroom/agents/myagent'
     const subagentsDir = `${agentDir}/.claude/projects/p1/session-abc/subagents`
     const jsonlStem = 'hist-agent'
     const toolUseId = 'toolu_hist001'
     const jsonlPath = `${subagentsDir}/agent-${jsonlStem}.jsonl`
-    const content = buildJSONL(subAgentUserMsg('Old task'))
+    const content = buildJSONL(subAgentUserMsg('Old task'), subAgentTurnDuration())
 
     const db = makeInMemoryDb({
       [toolUseId]: { id: toolUseId, jsonl_agent_id: jsonlStem, status: 'running' },
@@ -648,7 +652,7 @@ describe('Bug 3 — stalled-row sweeper: watcher must call recordSubagentStall i
       db,
     })
 
-    // Do NOT flip historical — entry is historical by default (file at boot)
+    // Done-at-boot → stays historical (not promoted); no stall write fires.
     h.advance(65_000)
 
     const stallDbCalls = db._calls.filter(