switchroom 0.14.21 → 0.14.22

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/tool-activity-summary.test.ts

@@ -4,7 +4,9 @@ import {
   appendActivityLine,
   appendActivityLabel,
   renderActivityFeed,
+  renderActivityFeedWithNested,
   MIRROR_MAX_LINES,
+  NESTED_MAX_LINES,
 } from "../tool-activity-summary.js";
 
 describe("describeToolUse — friendly per-tool rendering (draft-mirror)", () => {
@@ -143,3 +145,45 @@ describe("appendActivityLabel — precomputed label feed (tool_label path)", ()
     expect(lines.length).toBe(2);
   });
 });
+
+describe("renderActivityFeedWithNested — foreground sub-agent nesting (Model A)", () => {
+  it("with no child lines, is identical to the flat feed", () => {
+    const lines = ["Searching memory", "Delegating: review the migration"];
+    expect(renderActivityFeedWithNested(lines, [])).toBe(renderActivityFeed(lines));
+    // whitespace-only children also collapse to the flat feed
+    expect(renderActivityFeedWithNested(lines, ["  ", ""])).toBe(renderActivityFeed(lines));
+  });
+
+  it("done-styles ALL parent lines and nests the child block (newest = bold →)", () => {
+    const parent = ["Searching memory", "Delegating: review the migration"];
+    const child = ["Reading schema.ts", "Looking for foreign keys"];
+    const out = renderActivityFeedWithNested(parent, child)!;
+    // Parent is blocked at the Task tool → none of its lines is the live step.
+    expect(out).toContain("<i>✓ Searching memory</i>");
+    expect(out).toContain("<i>✓ Delegating: review the migration</i>");
+    expect(out).not.toContain("<b>→ Delegating");
+    // The live → step is the newest nested child line; earlier child = italic.
+    expect(out).toContain("   ↳ <i>Reading schema.ts</i>");
+    expect(out).toContain("   ↳ <b>→ Looking for foreign keys</b>");
+  });
+
+  it("caps the nested block to NESTED_MAX_LINES with a '↳ +N earlier…' header", () => {
+    const child = Array.from({ length: NESTED_MAX_LINES + 3 }, (_, i) => `step ${i + 1}`);
+    const out = renderActivityFeedWithNested(["Delegating: x"], child)!;
+    expect(out).toContain("   ↳ <i>+3 earlier…</i>");
+    // newest nested line is the live → step
+    expect(out).toContain(`   ↳ <b>→ step ${NESTED_MAX_LINES + 3}</b>`);
+    // the oldest (collapsed) lines are not rendered verbatim
+    expect(out).not.toContain("step 1<");
+  });
+
+  it("renders the child block even when the parent feed is empty", () => {
+    const out = renderActivityFeedWithNested([], ["Reading a.ts"]);
+    expect(out).toBe("   ↳ <b>→ Reading a.ts</b>");
+  });
+
+  it("HTML-escapes nested child text", () => {
+    const out = renderActivityFeedWithNested(["Delegating: x"], ["touch <a> & <b>"])!;
+    expect(out).toContain("   ↳ <b>→ touch &lt;a&gt; &amp; &lt;b&gt;</b>");
+  });
+});

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

@@ -5,7 +5,7 @@
  *   1. Clean turn: insert + finalize → row has ended_via='stop', non-null
  *      ended_at, correct previews.
  *   2. Mid-turn restart: insert without finalize, simulate gateway boot via
- *      markOrphanedAsRestarted → row has ended_via='restart'.
+ *      markOrphanedWithTimeoutClassification → row has ended_via='restart'.
  *   3. Multiple concurrent turns same chat: each row has a unique turn_key,
  *      no cross-contamination.
  *   4. tool_call_count increments correctly for N tool_use events.
@@ -20,9 +20,19 @@ import {
   openTurnsDbInMemory,
   recordTurnStart,
   recordTurnEnd,
-  markOrphanedAsRestarted,
+  markOrphanedWithTimeoutClassification,
 } from '../registry/turns-schema.js'
 
+// The boot reaper as the gateway calls it between turns (no live hang
+// marker) — every open turn is a clean 'restart' interrupt.
+function reapAsRestart(db: Parameters<typeof recordTurnEnd>[0]) {
+  return markOrphanedWithTimeoutClassification(db, {
+    markerTurnKey: null,
+    markerAgeMs: null,
+    hangThresholdMs: 300_000,
+  })
+}
+
 // ---------------------------------------------------------------------------
 // 1. Clean turn
 // ---------------------------------------------------------------------------
@@ -110,7 +120,7 @@ describe('clean turn (Phase 1 #332)', () => {
 // ---------------------------------------------------------------------------
 
 describe('mid-turn restart (Phase 1 #332)', () => {
-  it('insert without finalize, then markOrphanedAsRestarted → ended_via=restart', () => {
+  it('insert without finalize, then reaper → ended_via=restart', () => {
     const db = openTurnsDbInMemory()
 
     recordTurnStart(db, {
@@ -120,8 +130,8 @@ describe('mid-turn restart (Phase 1 #332)', () => {
     })
 
     // Simulate gateway boot reaper (same path as the real gateway boot).
-    const swept = markOrphanedAsRestarted(db)
-    expect(swept).toBe(1)
+    const swept = reapAsRestart(db)
+    expect(swept.reaped).toBe(1)
 
     const row = db
       .prepare('SELECT ended_via, ended_at FROM turns WHERE turn_key = ?')
@@ -141,7 +151,7 @@ describe('mid-turn restart (Phase 1 #332)', () => {
     recordTurnEnd(db, { turnKey: 'chat2:_:2001', endedVia: 'stop' })
     recordTurnStart(db, { turnKey: 'chat2:_:2002', chatId: 'chat2' })
 
-    markOrphanedAsRestarted(db)
+    reapAsRestart(db)
 
     const clean = db
       .prepare('SELECT ended_via FROM turns WHERE turn_key = ?')