switchroom 0.14.49 → 0.14.50

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.50";
+var COMMIT_SHA = "07e8b692";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.49",
+  "version": "0.14.50",
   "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.50";
+var COMMIT_SHA = "07e8b692";
+var COMMIT_DATE = "2026-06-03T10:08:18Z";
+var LATEST_PR = 2124;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -52673,15 +52676,18 @@ function promptClause(turn) {
 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,
@@ -52699,8 +52705,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 +52719,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 +54509,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

@@ -78,14 +78,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,
@@ -127,8 +146,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 +162,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

@@ -124,6 +124,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 +184,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', () => {