switchroom 0.14.20 → 0.14.22

package/telegram-plugin/tests/inbound-spool.test.ts

@@ -106,6 +106,51 @@ describe('spoolId — stable dedup key', () => {
     // messageId > 0 → legacy m:<chat>:<msgId> still wins.
     expect(a).toBe('m:c1:555')
   })
+  // honest-restart-resume: a boot-resume inbound is minted with a fresh
+  // ts/messageId every boot, so without a turn-keyed id an operator who
+  // restarts twice before the agent drains the first resume would stack
+  // N resumes of the same turn. Keying on resume_turn_key collapses them.
+  it('resume_interrupted → s:resume:<turn_key>, stable across boots (fresh ts/messageId)', () => {
+    const a = spoolId(
+      msg({
+        messageId: 1700_000_000_000,
+        ts: 1700_000_000_000,
+        meta: { source: 'resume_interrupted', resume_turn_key: '12345:11' },
+      }),
+    )
+    const b = spoolId(
+      msg({
+        messageId: 1700_000_999_999,
+        ts: 1700_000_999_999,
+        meta: { source: 'resume_interrupted', resume_turn_key: '12345:11' },
+      }),
+    )
+    expect(a).toBe('s:resume:12345:11')
+    expect(b).toBe(a)
+  })
+  it('resume_watchdog_timeout shares the s:resume namespace (one turn is one or the other)', () => {
+    const interrupted = spoolId(
+      msg({ messageId: 0, meta: { source: 'resume_interrupted', resume_turn_key: 'k:1' } }),
+    )
+    const timeout = spoolId(
+      msg({ messageId: 0, meta: { source: 'resume_watchdog_timeout', resume_turn_key: 'k:1' } }),
+    )
+    expect(timeout).toBe('s:resume:k:1')
+    expect(timeout).toBe(interrupted)
+  })
+  it('resume inbounds for distinct turns stay distinct', () => {
+    const a = spoolId(
+      msg({ messageId: 0, meta: { source: 'resume_interrupted', resume_turn_key: 'k:1' } }),
+    )
+    const b = spoolId(
+      msg({ messageId: 0, meta: { source: 'resume_interrupted', resume_turn_key: 'k:2' } }),
+    )
+    expect(a).not.toBe(b)
+  })
+  it('resume source without a turn_key falls back to legacy id (no crash)', () => {
+    const a = spoolId(msg({ messageId: 777, meta: { source: 'resume_interrupted' }, ts: 100 }))
+    expect(a).toBe('m:c1:777')
+  })
 })
 
 describe('inbound-spool — subagent_handback dedup across restart re-build (#1719)', () => {

package/telegram-plugin/tests/interrupt-defer.test.ts

@@ -15,6 +15,7 @@ import {
   ToolFlightTracker,
   decideInterruptTiming,
   resolveInterruptMaxWaitMs,
+  resolveSafeBoundaryEnabled,
   DEFAULT_INTERRUPT_MAX_WAIT_MS,
 } from '../gateway/interrupt-defer.js'
 
@@ -119,6 +120,18 @@ describe('decideInterruptTiming', () => {
   })
 })
 
+describe('resolveSafeBoundaryEnabled (default ON)', () => {
+  it('defaults to true when unset', () => {
+    expect(resolveSafeBoundaryEnabled(undefined)).toBe(true)
+  })
+  it('stays true when explicitly true', () => {
+    expect(resolveSafeBoundaryEnabled(true)).toBe(true)
+  })
+  it('only an explicit false opts out', () => {
+    expect(resolveSafeBoundaryEnabled(false)).toBe(false)
+  })
+})
+
 describe('resolveInterruptMaxWaitMs', () => {
   it('uses the configured value when positive', () => {
     expect(resolveInterruptMaxWaitMs(3000)).toBe(3000)

package/telegram-plugin/tests/multi-turn-continuity.test.ts

@@ -31,7 +31,6 @@ function makeDeps(bot: FakeBot, overrides?: Partial<StreamReplyDeps>): StreamRep
     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/outbound-ordering.test.ts

@@ -437,7 +437,6 @@ describe('wrapBot + handleStreamReply + reply ordering', () => {
       markdownToHtml: (t) => t,
       escapeMarkdownV2: (t) => t,
       repairEscapedWhitespace: (t) => t,
-      takeHandoffPrefix: () => '',
       assertAllowedChat: () => {},
       resolveThreadId: () => undefined,
       disableLinkPreview: true,

package/telegram-plugin/tests/parse-mode-rotation.test.ts

@@ -31,7 +31,6 @@ function makeDeps(bot: FakeBot, overrides?: Partial<StreamReplyDeps>): StreamRep
     markdownToHtml: (t) => realMarkdownToHtml(t),
     escapeMarkdownV2: (t) => `ESC(${t})`,
     repairEscapedWhitespace: (t) => t,
-    takeHandoffPrefix: () => '',
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
     disableLinkPreview: true,

package/telegram-plugin/tests/permission-verdict-resume-guard.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Structural pin for the permission-card resume beat.
+ *
+ * What broke (and the bug this guards against): when the operator
+ * answers a permission card, the suspended `claude` turn un-parks and
+ * resumes the SAME turn — the gateway must flip the awaiting glyph
+ * (🙏) back to a working glyph so the operator sees progress instead
+ * of a stuck card. That flip is `resumeReactionAfterVerdict()`.
+ *
+ * The verdict can arrive down several independent paths (button tap,
+ * always-allow, `/allow`·`/deny`, TTL auto-deny, free-text `y <id>`/
+ * `no <id>` reply, …). Every one of them calls
+ * `dispatchPermissionVerdict(...)` to un-park the turn — but the resume
+ * glyph flip is a *separate* call right next to it. The free-text-reply
+ * path shipped the dispatch WITHOUT the resume (fixed in v0.14.19), so
+ * answering via a text reply left the card frozen on 🙏 even though the
+ * turn was running. The controller-level behaviour is covered by
+ * `status-reactions.test.ts` ("setAwaiting" + watchdog re-arm); mtcute
+ * UAT cannot observe reactions at all, so this static pin is the only
+ * thing that catches a verdict path forgetting the resume.
+ *
+ * This guard fails loudly if any `dispatchPermissionVerdict(...)`
+ * callsite is not paired with a `resumeReactionAfterVerdict()` within a
+ * few lines — i.e. a new (or refactored) verdict path drops the resume.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const GATEWAY_SRC = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'gateway.ts'),
+  'utf8',
+)
+
+const LINES = GATEWAY_SRC.split('\n')
+
+// A `dispatchPermissionVerdict(` occurrence is a CALLSITE unless it's the
+// function definition itself.
+const isDefinition = (line: string) =>
+  /\bfunction\s+dispatchPermissionVerdict\b/.test(line)
+
+const dispatchCallsites = LINES.flatMap((line, i) =>
+  /\bdispatchPermissionVerdict\s*\(/.test(line) && !isDefinition(line)
+    ? [i]
+    : [],
+)
+
+// How far below the dispatch the resume call is allowed to live. The
+// widest real gap today is ~9 lines (the slash-command path); 15 gives
+// refactor headroom without letting an unrelated resume "cover" a
+// dispatch from a different block.
+const RESUME_WINDOW = 15
+
+describe('permission verdict → resume reaction wiring', () => {
+  it('there is at least one verdict-dispatch path to guard', () => {
+    expect(dispatchCallsites.length).toBeGreaterThan(0)
+  })
+
+  it('every dispatchPermissionVerdict() callsite flips the awaiting glyph back via resumeReactionAfterVerdict()', () => {
+    const unpaired: number[] = []
+    for (const idx of dispatchCallsites) {
+      const window = LINES.slice(idx, idx + RESUME_WINDOW + 1).join('\n')
+      if (!/\bresumeReactionAfterVerdict\s*\(\s*\)/.test(window)) {
+        // 1-based line number for a human-readable failure.
+        unpaired.push(idx + 1)
+      }
+    }
+    expect(
+      unpaired,
+      `dispatchPermissionVerdict() at gateway.ts line(s) ` +
+        `${unpaired.join(', ')} has no resumeReactionAfterVerdict() within ` +
+        `${RESUME_WINDOW} lines — that verdict path leaves the permission ` +
+        `card stuck on 🙏 after the operator answers. Add the resume call ` +
+        `(see the sibling paths and v0.14.19 / the free-text-reply fix).`,
+    ).toEqual([])
+  })
+
+  it('the resume helper still exists (the pairing is meaningless if it was deleted)', () => {
+    expect(/function\s+resumeReactionAfterVerdict\s*\(/.test(GATEWAY_SRC)).toBe(
+      true,
+    )
+  })
+})

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,