switchroom 0.14.49 → 0.14.51

package/dist/cli/switchroom.js

@@ -49462,8 +49462,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.49";
-var COMMIT_SHA = "df84be56";
+var VERSION = "0.14.51";
+var COMMIT_SHA = "53373533";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.49",
+  "version": "0.14.51",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/dist/gateway/gateway.js

@@ -47376,6 +47376,9 @@ function shouldTrackDelivery(input) {
     return false;
   return true;
 }
+function isTrackableResumeSynthetic(meta) {
+  return meta?.source === "resume_interrupted" && meta.message_id != null && meta.message_id !== "";
+}
 
 // gateway/pending-permission-decisions.ts
 var DEFAULT_PENDING_PERMISSION_CAP = 32;
@@ -52155,10 +52158,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.49";
-var COMMIT_SHA = "df84be56";
-var COMMIT_DATE = "2026-06-03T09:45:46Z";
-var LATEST_PR = 2123;
+var VERSION = "0.14.51";
+var COMMIT_SHA = "53373533";
+var COMMIT_DATE = "2026-06-03T11:19:38Z";
+var LATEST_PR = 2127;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -52667,21 +52670,23 @@ function promptClause(turn) {
   const p = turn.user_prompt_preview?.trim();
   if (!p)
     return "";
-  const snippet = p.length > 160 ? p.slice(0, 160) + "\u2026" : p;
-  return ` The request was: "${snippet}".`;
+  return ` The start of the request was: "${p}".`;
 }
 function buildResumeInterruptedInbound(ctx) {
   const ts = ctx.nowMs ?? Date.now();
   const elapsed = humanizeElapsed(ts - ctx.turn.started_at);
+  const threadId = threadIdNum(ctx.turn);
   const meta = {
     source: "resume_interrupted",
+    chat_id: ctx.turn.chat_id,
+    ...threadId != null ? { message_thread_id: String(threadId) } : {},
+    message_id: String(ts),
     resume_turn_key: ctx.turn.turn_key,
     interrupted_via: ctx.turn.ended_via ?? "restart",
     started_at: String(ctx.turn.started_at)
   };
   if (ctx.turn.user_prompt_preview)
     meta.original_prompt = ctx.turn.user_prompt_preview;
-  const threadId = threadIdNum(ctx.turn);
   return {
     type: "inbound",
     chatId: ctx.turn.chat_id,
@@ -52690,7 +52695,7 @@ function buildResumeInterruptedInbound(ctx) {
     user: "switchroom",
     userId: 0,
     ts,
-    text: `You just restarted. Your previous turn was interrupted ${elapsed} ago, ` + `before it finished \u2014 it was cut off by a restart, not completed.` + promptClause(ctx.turn) + ` Pick that work back up now and continue it through to completion. ` + `In your first message, briefly let the user know you're resuming what ` + `was interrupted (mention roughly how long ago in plain language) so ` + `they're not left wondering \u2014 then carry on with the actual task. Do ` + `not ask whether to resume; just resume. If you genuinely can't tell ` + `what the work was, say so and ask.`,
+    text: `You just restarted. Your previous turn was interrupted ${elapsed} ago, ` + `before it finished \u2014 it was cut off by a restart, not completed.` + promptClause(ctx.turn) + ` That quoted text is only the first ~200 characters of the original ` + `request, and you've lost your in-memory context across the restart \u2014 so ` + `BEFORE you continue, call get_recent_messages for this chat to read your ` + `full original message and the surrounding conversation, so you resume the ` + `COMPLETE task (including any instructions in the tail of a long request), ` + `not just the truncated preview. Then pick that work back up and carry it ` + `through to completion. In your first message, briefly let the user know ` + `you're resuming what was interrupted (mention roughly how long ago in ` + `plain language) so they're not left wondering \u2014 then carry on with the ` + `actual task. Do not ask whether to resume; just resume. If even after ` + `reading the recent messages you genuinely can't tell what the work was, ` + `say so and ask.`,
     meta
   };
 }
@@ -52699,8 +52704,11 @@ function buildResumeWatchdogReportInbound(ctx) {
   const idle = humanizeElapsed(ctx.idleMs);
   const since = humanizeElapsed(ts - ctx.turn.started_at);
   const toolClause = ctx.turn.tool_call_count != null && ctx.turn.tool_call_count > 0 ? ` You'd run ${ctx.turn.tool_call_count} tool call${ctx.turn.tool_call_count === 1 ? "" : "s"} before it stalled.` : "";
+  const threadId = threadIdNum(ctx.turn);
   const meta = {
     source: "resume_watchdog_timeout",
+    chat_id: ctx.turn.chat_id,
+    ...threadId != null ? { message_thread_id: String(threadId) } : {},
     resume_turn_key: ctx.turn.turn_key,
     interrupted_via: "timeout",
     idle_ms: String(ctx.idleMs),
@@ -52710,7 +52718,6 @@ function buildResumeWatchdogReportInbound(ctx) {
     meta.tool_call_count = String(ctx.turn.tool_call_count);
   if (ctx.turn.user_prompt_preview)
     meta.original_prompt = ctx.turn.user_prompt_preview;
-  const threadId = threadIdNum(ctx.turn);
   return {
     type: "inbound",
     chatId: ctx.turn.chat_id,
@@ -54501,7 +54508,8 @@ _deliveryMachineTick.unref?.();
 function trackRedeliveredInbound(merged) {
   if (!DELIVERY_CONFIRM_ENABLED)
     return;
-  if (!shouldTrackDelivery({
+  const isTrackableResume = isTrackableResumeSynthetic(merged.meta);
+  if (!isTrackableResume && !shouldTrackDelivery({
     isSteering: false,
     isInterrupt: false,
     hasSource: merged.meta?.source != null,

package/telegram-plugin/gateway/gateway.ts

@@ -287,6 +287,7 @@ import {
   sweep as sweepDeliveryQueue,
   forgetDelivery,
   shouldTrackDelivery,
+  isTrackableResumeSynthetic,
   type PendingDelivery,
 } from './inbound-delivery-confirm.js'
 import { createPendingPermissionBuffer } from './pending-permission-decisions.js'
@@ -4212,15 +4213,17 @@ _deliveryMachineTick.unref?.()
 // re-deliver forever.
 function trackRedeliveredInbound(merged: InboundMessage): void {
   if (!DELIVERY_CONFIRM_ENABLED) return
+  // The boot-resume synthetic ('resume_interrupted') is the ONE synthetic we DO
+  // enrol: a restart can drop it into a not-ready session exactly like a user
+  // inbound, leaving the interrupted work silently un-resumed. Safe iff it
+  // carries the chat_id + message_id that make its enqueue ack-able — see
+  // isTrackableResumeSynthetic. Every other synthetic stays excluded below.
+  const isTrackableResume = isTrackableResumeSynthetic(merged.meta)
   if (
+    !isTrackableResume &&
     !shouldTrackDelivery({
       isSteering: false,
       isInterrupt: false,
-      // Synthetic inbounds (cron / vault / handback / resume) carry a source
-      // and are NOT tracked here — they enqueue under their own semantics, and
-      // (for the resume synthetics) tracking them safely first needs the
-      // resume builder to emit meta.message_id so the deliver-until-acked ack
-      // matches its enqueue. Tracked separately as a follow-up (see PR notes).
       hasSource: merged.meta?.source != null,
       effectiveText: merged.text,
     })

package/telegram-plugin/gateway/inbound-delivery-confirm.ts

@@ -158,3 +158,29 @@ export function shouldTrackDelivery(input: {
   if (input.effectiveText !== undefined && input.effectiveText.trim().length === 0) return false
   return true
 }
+
+/**
+ * The ONE synthetic-source inbound that IS safe to enrol in the
+ * deliver-until-acked queue: the boot-resume synthetic
+ * (`meta.source === 'resume_interrupted'`). A restart can drop it into a
+ * not-ready (slow MCP boot) session exactly like a user inbound, leaving the
+ * interrupted work silently un-resumed — so it needs the same re-delivery
+ * backstop. It is safe to track ONLY when it carries BOTH:
+ *   - `meta.chat_id` — so the gateway's enqueue handler (gated on `ev.chatId`)
+ *     builds a currentTurn AND fires `ackDelivery` for it; and
+ *   - `meta.message_id` — so the enqueue's id round-trips and `ackDelivery`
+ *     matches THIS synthetic, stopping the sweep (no re-deliver-forever storm).
+ * Every other synthetic (cron / vault / handback / the watchdog `report`) omits
+ * `meta.message_id` and stays excluded by `shouldTrackDelivery`'s `hasSource`
+ * gate. We require message_id here (chat_id is implied by the ack mechanics);
+ * without a round-trippable id, tracking would storm.
+ */
+export function isTrackableResumeSynthetic(
+  meta: Record<string, string> | undefined,
+): boolean {
+  return (
+    meta?.source === 'resume_interrupted' &&
+    meta.message_id != null &&
+    meta.message_id !== ''
+  )
+}

package/telegram-plugin/gateway/resume-inbound-builder.ts

@@ -66,9 +66,12 @@ function threadIdNum(turn: Turn): number | undefined {
 function promptClause(turn: Turn): string {
   const p = turn.user_prompt_preview?.trim()
   if (!p) return ''
-  // Quote-trim so a long preview doesn't bloat the channel body.
-  const snippet = p.length > 160 ? p.slice(0, 160) + '…' : p
-  return ` The request was: "${snippet}".`
+  // The stored preview is already capped at the first ~200 chars of the user
+  // message (TURN_PREVIEW_MAX). Include it verbatim as a hint — do NOT
+  // re-truncate (the old 160-char slice dropped instructions that lived in the
+  // tail of a longer request). The FULL original is recovered via
+  // get_recent_messages; the resume body tells the model to do that.
+  return ` The start of the request was: "${p}".`
 }
 
 /**
@@ -78,14 +81,33 @@ function promptClause(turn: Turn): string {
 export function buildResumeInterruptedInbound(ctx: ResumeInboundContext): InboundMessage {
   const ts = ctx.nowMs ?? Date.now()
   const elapsed = humanizeElapsed(ts - ctx.turn.started_at)
+  const threadId = threadIdNum(ctx.turn)
   const meta: Record<string, string> = {
     source: 'resume_interrupted',
+    // Carry the originating chat/topic as model-visible channel attributes
+    // (mirrors the real-inbound + subagent_handback shapes — see
+    // gateway.ts:10753 and subagent-handback-inbound-builder.ts:115-121).
+    // Without meta.chat_id the enqueue's channel XML has no chat_id, so the
+    // gateway's enqueue handler (gateway.ts `if (ev.chatId)`) never builds a
+    // currentTurn for the resume turn — meaning no progress card, no
+    // silence-poke protection, and the reply falling back to the agent's
+    // default chat instead of the topic the interrupted work lived in.
+    chat_id: ctx.turn.chat_id,
+    ...(threadId != null ? { message_thread_id: String(threadId) } : {}),
+    // message_id rounds-trips the fabricated `ts` through the enqueue's
+    // channel XML so the deliver-until-acked queue can ack THIS synthetic by
+    // its own enqueue id (gateway trackRedeliveredInbound carve-in). It is
+    // never used as a Telegram reply_to: the model's reply tool quotes the
+    // real prior user message via getLatestInboundMessageId (role='user',
+    // synthetics aren't in history), and the activity feed anchors with
+    // allow_sending_without_reply. Required so tracking the resume can ack and
+    // never re-delivers forever.
+    message_id: String(ts),
     resume_turn_key: ctx.turn.turn_key,
     interrupted_via: ctx.turn.ended_via ?? 'restart',
     started_at: String(ctx.turn.started_at),
   }
   if (ctx.turn.user_prompt_preview) meta.original_prompt = ctx.turn.user_prompt_preview
-  const threadId = threadIdNum(ctx.turn)
   return {
     type: 'inbound',
     chatId: ctx.turn.chat_id,
@@ -98,12 +120,18 @@ export function buildResumeInterruptedInbound(ctx: ResumeInboundContext): Inboun
       `You just restarted. Your previous turn was interrupted ${elapsed} ago, ` +
       `before it finished — it was cut off by a restart, not completed.` +
       promptClause(ctx.turn) +
-      ` Pick that work back up now and continue it through to completion. ` +
-      `In your first message, briefly let the user know you're resuming what ` +
-      `was interrupted (mention roughly how long ago in plain language) so ` +
-      `they're not left wondering — then carry on with the actual task. Do ` +
-      `not ask whether to resume; just resume. If you genuinely can't tell ` +
-      `what the work was, say so and ask.`,
+      ` That quoted text is only the first ~200 characters of the original ` +
+      `request, and you've lost your in-memory context across the restart — so ` +
+      `BEFORE you continue, call get_recent_messages for this chat to read your ` +
+      `full original message and the surrounding conversation, so you resume the ` +
+      `COMPLETE task (including any instructions in the tail of a long request), ` +
+      `not just the truncated preview. Then pick that work back up and carry it ` +
+      `through to completion. In your first message, briefly let the user know ` +
+      `you're resuming what was interrupted (mention roughly how long ago in ` +
+      `plain language) so they're not left wondering — then carry on with the ` +
+      `actual task. Do not ask whether to resume; just resume. If even after ` +
+      `reading the recent messages you genuinely can't tell what the work was, ` +
+      `say so and ask.`,
     meta,
   }
 }
@@ -127,8 +155,15 @@ export function buildResumeWatchdogReportInbound(
     ctx.turn.tool_call_count != null && ctx.turn.tool_call_count > 0
       ? ` You'd run ${ctx.turn.tool_call_count} tool call${ctx.turn.tool_call_count === 1 ? '' : 's'} before it stalled.`
       : ''
+  const threadId = threadIdNum(ctx.turn)
   const meta: Record<string, string> = {
     source: 'resume_watchdog_timeout',
+    // Origin chat/topic as channel attributes so the report turn gets a
+    // currentTurn (progress card + silence-poke) and the "your last turn was
+    // interrupted" notice lands in the topic the work lived in, not the
+    // agent's default chat. Same rationale as buildResumeInterruptedInbound.
+    chat_id: ctx.turn.chat_id,
+    ...(threadId != null ? { message_thread_id: String(threadId) } : {}),
     resume_turn_key: ctx.turn.turn_key,
     interrupted_via: 'timeout',
     idle_ms: String(ctx.idleMs),
@@ -136,7 +171,6 @@ export function buildResumeWatchdogReportInbound(
   }
   if (ctx.turn.tool_call_count != null) meta.tool_call_count = String(ctx.turn.tool_call_count)
   if (ctx.turn.user_prompt_preview) meta.original_prompt = ctx.turn.user_prompt_preview
-  const threadId = threadIdNum(ctx.turn)
   return {
     type: 'inbound',
     chatId: ctx.turn.chat_id,

package/telegram-plugin/tests/inbound-delivery-confirm.test.ts

@@ -4,6 +4,7 @@ import {
   ackDelivery,
   createDeliveryQueue,
   forgetDelivery,
+  isTrackableResumeSynthetic,
   shouldTrackDelivery,
   sweep,
   trackDelivery,
@@ -178,3 +179,63 @@ describe('shouldTrackDelivery — only fresh-turn messages are tracked', () => {
     expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false, effectiveText: 'draft the email' })).toBe(true)
   })
 })
+
+// The boot-resume synthetic is the one synthetic ENROLLED for re-delivery (so a
+// restart can't silently drop the "pick up your interrupted work" wake into a
+// not-ready session). It is safe ONLY because it carries a round-trippable
+// message_id that its own enqueue acks — without that it would re-deliver
+// forever (the storm the hasSource exclusion otherwise prevents).
+describe('isTrackableResumeSynthetic — resume carve-in to the deliver-until-acked queue', () => {
+  it('tracks a resume_interrupted synthetic that carries a message_id', () => {
+    expect(isTrackableResumeSynthetic({ source: 'resume_interrupted', message_id: '1700000000000' })).toBe(true)
+  })
+  it('does NOT track a resume_interrupted WITHOUT a message_id (would never ack → storm)', () => {
+    expect(isTrackableResumeSynthetic({ source: 'resume_interrupted' })).toBe(false)
+    expect(isTrackableResumeSynthetic({ source: 'resume_interrupted', message_id: '' })).toBe(false)
+  })
+  it('does NOT track the watchdog report (untracked by design) even though it carries chat_id', () => {
+    expect(isTrackableResumeSynthetic({ source: 'resume_watchdog_timeout', chat_id: '123' })).toBe(false)
+  })
+  it('does NOT track other synthetics (cron / vault / handback) even if they somehow had a message_id', () => {
+    expect(isTrackableResumeSynthetic({ source: 'cron', message_id: '1' })).toBe(false)
+    expect(isTrackableResumeSynthetic({ source: 'subagent_handback', message_id: '1' })).toBe(false)
+    expect(isTrackableResumeSynthetic({ source: 'vault_grant_approved', message_id: '1' })).toBe(false)
+  })
+  it('does NOT track a real (no source) inbound here — that path is shouldTrackDelivery', () => {
+    expect(isTrackableResumeSynthetic({ chat_id: '1', message_id: '2' })).toBe(false)
+    expect(isTrackableResumeSynthetic(undefined)).toBe(false)
+  })
+})
+
+// End-to-end queue contract for the resume synthetic: tracked by its fabricated
+// id, acked by its OWN enqueue (which round-trips the same id), and — crucially
+// — it can never re-deliver forever (the storm the original deferral feared).
+describe('resume synthetic: tracked, acked by own enqueue, never storms', () => {
+  const RESUME_ID = '1700000000000' // String(ts), the fabricated message_id
+  it('acks when its own enqueue arrives with the matching id (no storm)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'resume…' }, 1_000, RESUME_ID)
+    // The resume turn starts → enqueue fires carrying the round-tripped id.
+    expect(ackDelivery(q, 'chat:_', RESUME_ID)).toBe(true)
+    expect(q.pending.size).toBe(0)
+    // Never re-delivered after the ack — bounded, not a forever loop.
+    expect(sweep(q, 1_000 + 999_999, TIMEOUT)).toHaveLength(0)
+  })
+  it('strands then re-delivers until acked (rescues a drop into a not-ready session)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'resume…' }, 1_000, RESUME_ID)
+    // Dropped into a not-ready session: no enqueue within the timeout → re-deliver.
+    const stranded = sweep(q, 1_000 + TIMEOUT + 1, TIMEOUT)
+    expect(stranded).toHaveLength(1)
+    expect(stranded[0]!.messageId).toBe(RESUME_ID)
+    // Once claude is ready, its enqueue acks it and the loop stops.
+    expect(ackDelivery(q, 'chat:_', RESUME_ID)).toBe(true)
+    expect(sweep(q, 1_000 + TIMEOUT * 10, TIMEOUT)).toHaveLength(0)
+  })
+  it('a DIFFERENT enqueue id (e.g. a racing real user msg) does NOT false-ack the resume', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'resume…' }, 1_000, RESUME_ID)
+    expect(ackDelivery(q, 'chat:_', '999')).toBe(false) // not our id
+    expect(q.pending.size).toBe(1) // still pending, will re-deliver
+  })
+})

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

@@ -106,12 +106,22 @@ describe('buildResumeInterruptedInbound', () => {
     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('includes the FULL stored preview in the body (no double-truncation below the 200-char storage cap)', () => {
+    // The turns table already caps the preview at ~200 chars (TURN_PREVIEW_MAX);
+    // the builder must NOT slice it shorter (the old 160-char cut dropped detail
+    // from the tail of a longer request). A 180-char preview must appear in full.
+    const preview = "step 1 do X; step 2 do Y; step 3 do Z; " + "d".repeat(141) // 180 chars
+    expect(preview.length).toBe(180)
+    const msg = buildResumeInterruptedInbound({ turn: makeTurn({ user_prompt_preview: preview }) })
+    expect(msg.text).toContain(preview) // verbatim, not sliced to 160
+    expect(msg.meta.original_prompt).toBe(preview)
+  })
+
+  it('tells the resumed turn to recover the FULL original via get_recent_messages', () => {
+    const msg = buildResumeInterruptedInbound({ turn: makeTurn({ user_prompt_preview: 'short task' }) })
+    expect(msg.text).toContain('get_recent_messages')
+    // Frames the quoted preview as partial so the model knows to fetch the rest.
+    expect(msg.text).toMatch(/first ~200 characters|start of the request/i)
   })
 
   it('routes to the forum thread when thread_id is numeric', () => {
@@ -124,6 +134,27 @@ describe('buildResumeInterruptedInbound', () => {
     const msg = buildResumeInterruptedInbound({ turn: makeTurn({ thread_id: null }) })
     expect(msg.threadId).toBeUndefined()
   })
+
+  // Origin routing + ack-ability (the resume-deliver hardening). meta.chat_id
+  // makes the gateway build a currentTurn (progress card + silence-poke) and
+  // fire ackDelivery; meta.message_id round-trips so the deliver-until-acked
+  // queue can ack THIS synthetic by its own enqueue id (no re-deliver storm).
+  it('carries origin chat_id + message_id in meta (DM)', () => {
+    const turn = makeTurn({ chat_id: '12345', thread_id: null })
+    const msg = buildResumeInterruptedInbound({ turn, nowMs: 1_700_000_000_000 })
+    expect(msg.meta.chat_id).toBe('12345')
+    expect(msg.meta.message_id).toBe('1700000000000')
+    expect(msg.messageId).toBe(1_700_000_000_000)
+    expect(msg.meta.message_thread_id).toBeUndefined()
+  })
+
+  it('carries message_thread_id in meta for a forum topic (supergroup routing)', () => {
+    const turn = makeTurn({ chat_id: '-1001234567890', thread_id: '42' })
+    const msg = buildResumeInterruptedInbound({ turn })
+    expect(msg.meta.chat_id).toBe('-1001234567890')
+    expect(msg.meta.message_thread_id).toBe('42')
+    expect(msg.threadId).toBe(42)
+  })
 })
 
 describe('buildResumeWatchdogReportInbound', () => {
@@ -163,6 +194,18 @@ describe('buildResumeWatchdogReportInbound', () => {
     const msg = buildResumeWatchdogReportInbound({ turn, idleMs: 300_000 })
     expect(msg.text).not.toContain('tool call')
   })
+
+  // The report turn ALSO gets origin routing (currentTurn + topic) — a "your
+  // last turn was interrupted" notice should land in the topic the work lived
+  // in — but it is NOT deliver-until-acked tracked, so it carries NO
+  // message_id (only the 'resume_interrupted' builder does, gating tracking).
+  it('carries origin chat_id + message_thread_id but NO message_id (report is untracked)', () => {
+    const turn = makeTurn({ ended_via: 'timeout', chat_id: '-1001234567890', thread_id: '42' })
+    const msg = buildResumeWatchdogReportInbound({ turn, idleMs: 300_000 })
+    expect(msg.meta.chat_id).toBe('-1001234567890')
+    expect(msg.meta.message_thread_id).toBe('42')
+    expect(msg.meta.message_id).toBeUndefined()
+  })
 })
 
 describe('selectResumeBuilder', () => {

package/telegram-plugin/uat/scenarios/jtbd-interrupted-turn-resumes-dm.test.ts

@@ -0,0 +1,90 @@
+/**
+ * JTBD — always-on: a turn interrupted by a restart is RESUMED without
+ * re-prompting, and the resume turn runs to completion (it is not silently
+ * dropped into a not-ready session). Regression gate for v0.14.50 / #2122.
+ *
+ * Flow: send a long-running task, let it get in-flight, then restart the agent
+ * (--force, NOT --wait, so it interrupts rather than draining). On boot the
+ * gateway finds the orphaned turn and injects the `resume_interrupted`
+ * synthetic. With #2122 that synthetic carries meta.chat_id + message_id, so the
+ * resumed turn (a) builds a currentTurn (progress card + silence-poke), (b)
+ * routes its reply to the originating chat, and (c) re-enrols in
+ * deliver-until-acked so a drop into a still-booting session is rescued rather
+ * than lost.
+ *
+ * Assertion: a reply arrives after the interrupting restart whose FRAMING shows
+ * the agent is resuming ("picking this back up" / "interrupted" / "cut off by a
+ * restart"). We deliberately do NOT assert an end-token: the resume synthetic
+ * only carries the first ~160 chars of the original prompt (promptClause
+ * truncation), so instructions in the prompt's tail are not guaranteed to
+ * survive — the resume FRAMING is the stable, builder-guaranteed signal.
+ *
+ * Self-skips green without NOPASSWD sudo.
+ */
+
+import { describe, it, expect } from "vitest";
+import { execSync, spawn } from "node:child_process";
+import { spinUp } from "../harness.js";
+
+const AGENT = "test-harness";
+const MID_TURN_MS = 10_000;        // let the turn enqueue (become a recorded interrupted turn)
+const RESUME_BUDGET_MS = 180_000;  // boot + resume + reply
+
+// The resume builder tells the model to "briefly let the user know you're
+// resuming what was interrupted" — so the reply always opens with this framing.
+const RESUME_FRAMING = /resum|picking .*back|interrupted|cut off|just restarted/i;
+
+function canShellSudo(): boolean {
+  try {
+    execSync("sudo -n true", { stdio: "ignore", timeout: 2_000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function kickRestartDetached(name: string): void {
+  // --force WITHOUT --wait → recreate now, interrupting the in-flight turn.
+  const child = spawn(
+    "sudo",
+    ["-n", "env", `PATH=${process.env.PATH}`, `HOME=${process.env.HOME}`,
+      "switchroom", "agent", "restart", name, "--force"],
+    { detached: true, stdio: "ignore" },
+  );
+  child.unref();
+}
+
+const sudoOk = canShellSudo();
+
+(sudoOk ? describe : describe.skip)("uat: interrupted turn resumes after restart (DM)", () => {
+  it(
+    "a turn interrupted by a restart is resumed and the resume turn completes",
+    async () => {
+      const sc = await spinUp({ agent: AGENT, settleMs: 0 });
+      try {
+        // A task long enough that it's still in-flight at MID_TURN_MS.
+        await sc.sendDM(
+          `Please write a thorough, detailed ~300-word explanation of how a ` +
+          `mechanical typewriter's typebar mechanism works, step by step. Take ` +
+          `your time and be complete.`,
+        );
+
+        await new Promise((r) => setTimeout(r, MID_TURN_MS));
+        kickRestartDetached(AGENT);
+
+        // After boot, the resume synthetic should make the agent pick the work
+        // back up and say so. (The newest interrupted turn — this one — is the
+        // one findLatestTurnIfInterrupted resumes.)
+        const reply = await sc.expectMessage((m) => RESUME_FRAMING.test(m.text), {
+          from: "bot",
+          timeout: RESUME_BUDGET_MS,
+        });
+        expect(reply.text).toMatch(RESUME_FRAMING);
+        expect(reply.text.length).toBeGreaterThan(40); // a substantive resumed reply, not a stub
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    RESUME_BUDGET_MS + 60_000,
+  );
+});

package/telegram-plugin/uat/scenarios/jtbd-message-during-restart-channel.test.ts

@@ -0,0 +1,95 @@
+/**
+ * JTBD — always-on in a supergroup: a message sent into a forum topic WHILE the
+ * agent is restarting must still be answered IN the group (the channel twin of
+ * jtbd-message-during-restart-dm). Regression gate for v0.14.48 / #2117, proving
+ * the restart-redeliver rescue is keyed per (chat, thread) so DM and supergroup
+ * topics recover identically.
+ *
+ * Self-skips green when SWITCHROOM_UAT_CHAT_ID is unset or the chat isn't a
+ * resolvable forum supergroup the driver is in (uat/** is excluded from gating
+ * CI). mtcute caveat: no forum-topic create API, so this uses the supergroup's
+ * General topic — it proves DM-vs-channel routing, not "correct topic among
+ * many" (pinned by the gateway unit thread-assertions).
+ */
+
+import { describe, it, expect } from "vitest";
+import { execSync, spawn } from "node:child_process";
+import { spinUp } from "../harness.js";
+import { expectMessage } from "../assertions.js";
+
+const AGENT = "test-harness";
+const SUPERGROUP_ID = Number.parseInt(process.env.SWITCHROOM_UAT_CHAT_ID ?? "", 10);
+const BOOT_SEND_DELAY_MS = Number.parseInt(
+  process.env.SWITCHROOM_UAT_BOOT_SEND_DELAY_MS ?? "12000",
+  10,
+);
+const REPLY_BUDGET_MS = 180_000;
+
+function canShellSudo(): boolean {
+  try {
+    execSync("sudo -n true", { stdio: "ignore", timeout: 2_000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function kickRestartDetached(name: string): void {
+  const child = spawn(
+    "sudo",
+    ["-n", "env", `PATH=${process.env.PATH}`, `HOME=${process.env.HOME}`,
+      "switchroom", "agent", "restart", name, "--force"],
+    { detached: true, stdio: "ignore" },
+  );
+  child.unref();
+}
+
+const sudoOk = canShellSudo();
+
+(sudoOk ? describe : describe.skip)("uat: message sent during a restart (supergroup)", () => {
+  it(
+    "a supergroup-topic message sent DURING the restart boot window is still answered in the group",
+    async () => {
+      if (!Number.isFinite(SUPERGROUP_ID)) {
+        console.warn("[during-restart-channel] SWITCHROOM_UAT_CHAT_ID unset — skipping");
+        return;
+      }
+      const sc = await spinUp({ agent: AGENT, settleMs: 0 });
+      try {
+        await sc.driver.primeDialogs();
+        if (!(await sc.driver.canResolve(SUPERGROUP_ID))) {
+          console.warn(
+            `[during-restart-channel] supergroup ${SUPERGROUP_ID} not resolvable — skipping ` +
+              `(ensure forum supergroup with Topics + driver is a member)`,
+          );
+          return;
+        }
+
+        const nonce = `bootsg-${Date.now().toString(36)}`;
+        kickRestartDetached(AGENT);
+        await new Promise((r) => setTimeout(r, BOOT_SEND_DELAY_MS));
+
+        const sendStart = Date.now();
+        await sc.driver.sendText(
+          SUPERGROUP_ID,
+          `You are being restart-tested in this group. Reply in this group with exactly this token and nothing else: ${nonce}`,
+        );
+
+        const reply = await expectMessage(
+          sc.driver,
+          SUPERGROUP_ID,
+          (m) => m.text.includes(nonce),
+          { timeout: REPLY_BUDGET_MS, senderFilter: { notUserId: sc.driverUserId } },
+        );
+        const ttfo = Date.now() - sendStart;
+        console.warn(`[during-restart-channel] answered in ${ttfo}ms (nonce ${nonce})`);
+        expect(reply.chatId).toBe(SUPERGROUP_ID);
+        expect(reply.fromBot).toBe(true);
+        expect(reply.text).toContain(nonce);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    REPLY_BUDGET_MS + 60_000,
+  );
+});

package/telegram-plugin/uat/scenarios/jtbd-message-during-restart-dm.test.ts

@@ -0,0 +1,95 @@
+/**
+ * JTBD — always-on: a message sent WHILE the agent is restarting must still be
+ * answered (DM). Regression gate for the v0.14.48 / #2117 lost-message incident
+ * (clerk/KenGPT, 2026-06-03).
+ *
+ * The wedge this guards: an inbound that arrives during a restart is buffered +
+ * spool-persisted, then redelivered on bridge-up — but `bridge registered` is
+ * not the same as `claude` session-ready. If claude is slow to boot (e.g. a
+ * Hindsight MCP timeout) the redelivered inject hit a still-booting session and
+ * was silently dropped; the 300s silence-poke then ended a phantom turn
+ * (`drained_buffered=0/0`) and the message was gone. The fix re-enrols the
+ * redelivered inbound in the deliver-until-acked queue so it re-delivers every
+ * 5s until claude actually consumes it.
+ *
+ * Unlike `jtbd-always-on-after-restart-dm` (which sends ~5s AFTER the restart
+ * returns, exercising the live path), this sends DURING the boot window so the
+ * message goes through the restart-redeliver path the fix patches. The mtcute
+ * driver sends straight to Telegram — independent of the agent's bridge — so the
+ * message queues server-side and is delivered the moment the new gateway
+ * reconnects.
+ *
+ * Self-skips green without NOPASSWD sudo (can't restart the agent).
+ */
+
+import { describe, it, expect } from "vitest";
+import { execSync, spawn } from "node:child_process";
+import { spinUp } from "../harness.js";
+
+const AGENT = "test-harness";
+
+// After kicking the restart, wait this long before sending — long enough that
+// the reconcile + docker recreate have dropped the bridge, so the message
+// buffers and is drained on bridge-up (the restart-redeliver path). Override
+// for forensics (e.g. 6000 to land it deeper in the not-ready window so the
+// strand-rescue sweep fires).
+const BOOT_SEND_DELAY_MS = Number.parseInt(
+  process.env.SWITCHROOM_UAT_BOOT_SEND_DELAY_MS ?? "12000",
+  10,
+);
+
+// Generous: the fix re-delivers every 5s until claude is ready. The wedge
+// symptom is ≥300s (silence-poke floor) or never — both fail this.
+const REPLY_BUDGET_MS = 180_000;
+
+function canShellSudo(): boolean {
+  try {
+    execSync("sudo -n true", { stdio: "ignore", timeout: 2_000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Kick a marker-safe restart and return immediately (detached). */
+function kickRestartDetached(name: string): void {
+  const child = spawn(
+    "sudo",
+    ["-n", "env", `PATH=${process.env.PATH}`, `HOME=${process.env.HOME}`,
+      "switchroom", "agent", "restart", name, "--force"],
+    { detached: true, stdio: "ignore" },
+  );
+  child.unref();
+}
+
+const sudoOk = canShellSudo();
+
+(sudoOk ? describe : describe.skip)("uat: message sent during a restart (DM)", () => {
+  it(
+    "a DM sent DURING the restart boot window is still answered (not lost)",
+    async () => {
+      const sc = await spinUp({ agent: AGENT, settleMs: 0 });
+      try {
+        const nonce = `bootdm-${Date.now().toString(36)}`;
+        kickRestartDetached(AGENT);
+        await new Promise((r) => setTimeout(r, BOOT_SEND_DELAY_MS));
+
+        const sendStart = Date.now();
+        await sc.sendDM(
+          `You are being restart-tested. Reply with exactly this token and nothing else: ${nonce}`,
+        );
+
+        const reply = await sc.expectMessage((m) => m.text.includes(nonce), {
+          from: "bot",
+          timeout: REPLY_BUDGET_MS,
+        });
+        const ttfo = Date.now() - sendStart;
+        console.warn(`[during-restart-dm] answered in ${ttfo}ms (nonce ${nonce})`);
+        expect(reply.text).toContain(nonce);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    REPLY_BUDGET_MS + 60_000,
+  );
+});