switchroom 0.14.40 → 0.14.42

package/dist/cli/switchroom.js

@@ -49462,8 +49462,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.40";
-var COMMIT_SHA = "d2d69140";
+var VERSION = "0.14.42";
+var COMMIT_SHA = "6da4313d";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.40",
+  "version": "0.14.42",
   "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

@@ -44777,6 +44777,12 @@ function resolveOutboundTopic(config, event) {
       return aliasToId(cfg, ADMIN_ALIAS) ?? cfg.default_topic_id;
   }
 }
+function topicForRecipient(args) {
+  const { recipientChatId, resolvedTopic, supergroupChatId } = args;
+  if (resolvedTopic == null || supergroupChatId == null)
+    return;
+  return String(recipientChatId) === String(supergroupChatId) ? resolvedTopic : undefined;
+}
 
 // ../src/agents/perf.ts
 import { existsSync as existsSync18, readFileSync as readFileSync14 } from "node:fs";
@@ -47263,11 +47269,17 @@ function decideInboundDelivery(input) {
 function createDeliveryQueue() {
   return { pending: new Map };
 }
-function trackDelivery(q, key, inbound, now) {
-  q.pending.set(key, { key, inbound, lastAttemptAt: now });
+function trackDelivery(q, key, inbound, now, messageId = null) {
+  q.pending.set(key, { key, inbound, messageId, lastAttemptAt: now });
 }
-function ackDelivery(q, key) {
-  return q.pending.delete(key);
+function ackDelivery(q, key, enqueueMessageId = null) {
+  const entry = q.pending.get(key);
+  if (!entry)
+    return false;
+  if (entry.messageId != null && entry.messageId !== enqueueMessageId)
+    return false;
+  q.pending.delete(key);
+  return true;
 }
 function sweep(q, now, timeoutMs) {
   const redeliver = [];
@@ -47282,6 +47294,15 @@ function sweep(q, now, timeoutMs) {
 function forgetDelivery(q, key) {
   q.pending.delete(key);
 }
+function shouldTrackDelivery(input) {
+  if (input.isSteering || input.isInterrupt)
+    return false;
+  if (input.hasSource)
+    return false;
+  if (input.effectiveText !== undefined && input.effectiveText.trim().length === 0)
+    return false;
+  return true;
+}
 
 // gateway/pending-permission-decisions.ts
 var DEFAULT_PENDING_PERMISSION_CAP = 32;
@@ -51850,10 +51871,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.40";
-var COMMIT_SHA = "d2d69140";
-var COMMIT_DATE = "2026-06-02T08:59:46Z";
-var LATEST_PR = 2090;
+var VERSION = "0.14.42";
+var COMMIT_SHA = "6da4313d";
+var COMMIT_DATE = "2026-06-02T22:14:58Z";
+var LATEST_PR = 2097;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -53028,7 +53049,9 @@ function markClaudeBusyForInbound(m) {
   return key;
 }
 var DELIVERY_CONFIRM_ENABLED = process.env.SWITCHROOM_INBOUND_DELIVERY_CONFIRM !== "0";
-var DELIVERY_CONFIRM_TIMEOUT_MS = Number(process.env.SWITCHROOM_INBOUND_DELIVERY_TIMEOUT_MS) || 15000;
+var _deliveryTimeoutRaw = process.env.SWITCHROOM_INBOUND_DELIVERY_TIMEOUT_MS;
+var _deliveryTimeoutParsed = _deliveryTimeoutRaw != null && _deliveryTimeoutRaw !== "" ? Number(_deliveryTimeoutRaw) : 15000;
+var DELIVERY_CONFIRM_TIMEOUT_MS = Number.isFinite(_deliveryTimeoutParsed) && _deliveryTimeoutParsed > 0 ? _deliveryTimeoutParsed : 15000;
 var DELIVERY_CONFIRM_SWEEP_MS = 5000;
 var deliveryQueue = createDeliveryQueue();
 function turnInFlightForGate() {
@@ -53344,14 +53367,18 @@ function postPermissionResumeMessage(opts) {
     timeoutMinutes: opts.timeoutMinutes
   });
   const turn = currentTurn;
-  const targets = turn != null ? [{ chatId: turn.sessionChatId, threadId: turn.sessionThreadId }] : loadAccess().allowFrom.map((chatId) => ({
-    chatId,
-    threadId: resolveAgentOutboundTopic({
+  const targets = turn != null ? [{ chatId: turn.sessionChatId, threadId: turn.sessionThreadId }] : (() => {
+    const sg = resolveAgentSupergroupChatId();
+    const topic = resolveAgentOutboundTopic({
       kind: "permission",
       turnInitiated: false,
       originThreadId: undefined
-    })
-  }));
+    });
+    return loadAccess().allowFrom.map((chatId) => ({
+      chatId,
+      threadId: topicForRecipient({ recipientChatId: chatId, resolvedTopic: topic, supergroupChatId: sg })
+    }));
+  })();
   for (const { chatId, threadId } of targets) {
     swallowingApiCall(() => bot.api.sendMessage(chatId, text, {
       parse_mode: "HTML",
@@ -54160,7 +54187,12 @@ async function redeliverStrandedInbound(p) {
       clearAgentComposer2({ agentName: selfAgent });
   } catch {}
   const ok = ipcServer.sendToAgent(selfAgent, p.inbound);
-  if (!ok) {
+  if (ok) {
+    markClaudeBusyForInbound(p.inbound);
+    if (!deliveryQueue.pending.has(p.key)) {
+      trackDelivery(deliveryQueue, p.key, p.inbound, Date.now(), p.messageId);
+    }
+  } else {
     pendingInboundBuffer.push(selfAgent, p.inbound);
     forgetDelivery(deliveryQueue, p.key);
   }
@@ -54168,6 +54200,10 @@ async function redeliverStrandedInbound(p) {
 var _deliveryConfirmSweep = setInterval(() => {
   if (!DELIVERY_CONFIRM_ENABLED)
     return;
+  if (currentTurn != null)
+    return;
+  if (pendingPermissions.size > 0 || pendingAskUser.size > 0)
+    return;
   for (const p of sweep(deliveryQueue, Date.now(), DELIVERY_CONFIRM_TIMEOUT_MS)) {
     redeliverStrandedInbound(p);
   }
@@ -54453,11 +54489,13 @@ var ipcServer = createIpcServer({
       turnInitiated: activeTurn != null,
       originThreadId: activeTurn?.sessionThreadId
     });
+    const permSupergroup = resolveAgentSupergroupChatId();
     for (const chat_id of access.allowFrom) {
+      const permThread = topicForRecipient({ recipientChatId: chat_id, resolvedTopic: permTopic, supergroupChatId: permSupergroup });
       bot.api.sendMessage(chat_id, text, {
         parse_mode: "HTML",
         reply_markup: keyboard,
-        ...permTopic != null ? { message_thread_id: permTopic } : {}
+        ...permThread != null ? { message_thread_id: permThread } : {}
       }).catch((e) => {
         process.stderr.write(`telegram gateway: permission_request send to ${chat_id} failed: ${e}
 `);
@@ -54521,9 +54559,13 @@ var ipcServer = createIpcServer({
         if (operator === undefined)
           return null;
         const activeTurn = currentTurn;
-        const driveTopic = resolveAgentOutboundTopic({
-          kind: "hostd-approval",
-          originThreadId: activeTurn?.sessionThreadId
+        const driveTopic = topicForRecipient({
+          recipientChatId: operator,
+          resolvedTopic: resolveAgentOutboundTopic({
+            kind: "hostd-approval",
+            originThreadId: activeTurn?.sessionThreadId
+          }),
+          supergroupChatId: resolveAgentSupergroupChatId()
         });
         return {
           chatId: operator,
@@ -54579,9 +54621,13 @@ var ipcServer = createIpcServer({
         if (operator === undefined)
           return null;
         const activeTurn = currentTurn;
-        const ms365Topic = resolveAgentOutboundTopic({
-          kind: "hostd-approval",
-          originThreadId: activeTurn?.sessionThreadId
+        const ms365Topic = topicForRecipient({
+          recipientChatId: operator,
+          resolvedTopic: resolveAgentOutboundTopic({
+            kind: "hostd-approval",
+            originThreadId: activeTurn?.sessionThreadId
+          }),
+          supergroupChatId: resolveAgentSupergroupChatId()
         });
         return {
           chatId: operator,
@@ -54636,9 +54682,13 @@ var ipcServer = createIpcServer({
         if (operator === undefined)
           return null;
         const activeTurn = currentTurn;
-        const cfgTopic = resolveAgentOutboundTopic({
-          kind: "hostd-approval",
-          originThreadId: activeTurn?.sessionThreadId
+        const cfgTopic = topicForRecipient({
+          recipientChatId: operator,
+          resolvedTopic: resolveAgentOutboundTopic({
+            kind: "hostd-approval",
+            originThreadId: activeTurn?.sessionThreadId
+          }),
+          supergroupChatId: resolveAgentSupergroupChatId()
         });
         return {
           chatId: operator,
@@ -56564,7 +56614,7 @@ function handleSessionEvent(ev) {
         };
         currentTurn = next;
         if (DELIVERY_CONFIRM_ENABLED) {
-          ackDelivery(deliveryQueue, chatKey2(ev.chatId, ev.threadId != null ? Number(ev.threadId) : null));
+          ackDelivery(deliveryQueue, chatKey2(ev.chatId, ev.threadId != null ? Number(ev.threadId) : null), ev.messageId);
         }
         shadowEmit({
           kind: "turnStart",
@@ -58000,12 +58050,24 @@ ${preBlock(write.output)}`;
   const delivered = ipcServer.sendToAgent(selfAgent, inboundMsg);
   if (delivered) {
     const busyKey = markClaudeBusyForInbound(inboundMsg);
-    if (DELIVERY_CONFIRM_ENABLED) {
-      trackDelivery(deliveryQueue, busyKey, inboundMsg, Date.now());
+    if (DELIVERY_CONFIRM_ENABLED && shouldTrackDelivery({
+      isSteering,
+      isInterrupt: interrupt.isInterrupt,
+      hasSource: inboundMsg.meta?.source != null,
+      effectiveText
+    })) {
+      trackDelivery(deliveryQueue, busyKey, inboundMsg, Date.now(), String(inboundMsg.messageId));
     }
   }
   if (!delivered) {
-    pendingInboundBuffer.push(selfAgent, inboundMsg);
+    if (shouldTrackDelivery({
+      isSteering,
+      isInterrupt: interrupt.isInterrupt,
+      hasSource: inboundMsg.meta?.source != null,
+      effectiveText
+    })) {
+      pendingInboundBuffer.push(selfAgent, inboundMsg);
+    }
     const threadOpts = messageThreadId != null ? { message_thread_id: messageThreadId } : {};
     swallowingApiCall(() => bot.api.sendMessage(chat_id, "\u23F3 Agent is restarting \u2014 your message is queued and will be processed when it reconnects.", { ...threadOpts }), {
       chat_id,
@@ -58191,6 +58253,22 @@ function resolveAgentOutboundTopic(event) {
     return;
   }
 }
+function resolveAgentSupergroupChatId() {
+  const agentName3 = process.env.SWITCHROOM_AGENT_NAME;
+  if (!agentName3)
+    return;
+  try {
+    const cfg = loadConfig2();
+    const rawAgent = cfg.agents?.[agentName3];
+    if (!rawAgent)
+      return;
+    const resolved = resolveAgentConfig2(cfg.defaults, cfg.profiles, rawAgent);
+    const tg = resolved.channels?.telegram;
+    return tg?.chat_id != null ? String(tg.chat_id) : undefined;
+  } catch {
+    return;
+  }
+}
 function stampUserRestartReason(reason) {
   try {
     writeCleanShutdownMarker(GATEWAY_CLEAN_SHUTDOWN_MARKER_PATH, {

package/telegram-plugin/gateway/gateway.ts

@@ -251,7 +251,7 @@ import { handleInjectCommand } from './inject-handler.js'
 import { type BannerState } from '../slot-banner.js'
 import { refreshBanner } from '../slot-banner-driver.js'
 import { loadConfig as loadSwitchroomConfig, findConfigFile as findSwitchroomConfigFile } from '../../src/config/loader.js'; import { resolveAgentConfig } from '../../src/config/merge.js'
-import { resolveOutboundTopic as resolveOutboundTopicHelper, type TopicRouterConfig as _OutboundRouterConfig } from '../../src/telegram/topic-router.js'
+import { resolveOutboundTopic as resolveOutboundTopicHelper, topicForRecipient, type TopicRouterConfig as _OutboundRouterConfig } from '../../src/telegram/topic-router.js'
 import { readTurnUsages } from '../../src/agents/perf.js'
 import { decideProactiveCompact, initialCompactState, type CompactState } from './proactive-compact.js'
 import { nextCompactNotify, idleCompactNotifyState, type CompactNotifyState } from './compact-notify.js'
@@ -286,6 +286,7 @@ import {
   ackDelivery,
   sweep as sweepDeliveryQueue,
   forgetDelivery,
+  shouldTrackDelivery,
   type PendingDelivery,
 } from './inbound-delivery-confirm.js'
 import { createPendingPermissionBuffer } from './pending-permission-decisions.js'
@@ -1342,7 +1343,15 @@ const DELIVERY_CONFIRM_ENABLED = process.env.SWITCHROOM_INBOUND_DELIVERY_CONFIRM
 // a clean delivery, so 15s won't false-positive on a healthy turn. Tunable
 // (env) for tests/forensics; a too-low value re-delivers healthy slow turns
 // (duplicate turn), which is why the default is comfortably above ack latency.
-const DELIVERY_CONFIRM_TIMEOUT_MS = Number(process.env.SWITCHROOM_INBOUND_DELIVERY_TIMEOUT_MS) || 15_000
+const _deliveryTimeoutRaw = process.env.SWITCHROOM_INBOUND_DELIVERY_TIMEOUT_MS
+const _deliveryTimeoutParsed =
+  _deliveryTimeoutRaw != null && _deliveryTimeoutRaw !== '' ? Number(_deliveryTimeoutRaw) : 15_000
+// Clamp to a positive, finite value: a negative / zero / NaN env override would
+// make the sweep treat every tracked entry as stranded and re-deliver every
+// cycle forever (a self-inflicted re-delivery loop). To disable the feature,
+// use SWITCHROOM_INBOUND_DELIVERY_CONFIRM=0, not a degenerate timeout.
+const DELIVERY_CONFIRM_TIMEOUT_MS =
+  Number.isFinite(_deliveryTimeoutParsed) && _deliveryTimeoutParsed > 0 ? _deliveryTimeoutParsed : 15_000
 const DELIVERY_CONFIRM_SWEEP_MS = 5_000
 const deliveryQueue = createDeliveryQueue<InboundMessage>()
 
@@ -2264,14 +2273,20 @@ function postPermissionResumeMessage(opts: {
   const targets: Array<{ chatId: string; threadId: number | undefined }> =
     turn != null
       ? [{ chatId: turn.sessionChatId, threadId: turn.sessionThreadId }]
-      : loadAccess().allowFrom.map(chatId => ({
-          chatId,
-          threadId: resolveAgentOutboundTopic({
+      : (() => {
+          const sg = resolveAgentSupergroupChatId()
+          const topic = resolveAgentOutboundTopic({
             kind: 'permission',
             turnInitiated: false,
             originThreadId: undefined,
-          }),
-        }))
+          })
+          // allowFrom is normally operator DMs — attach the topic only to a
+          // recipient that owns it (the supergroup), never a DM (marko wedge).
+          return loadAccess().allowFrom.map(chatId => ({
+            chatId,
+            threadId: topicForRecipient({ recipientChatId: chatId, resolvedTopic: topic, supergroupChatId: sg }),
+          }))
+        })()
   for (const { chatId, threadId } of targets) {
     // allow-raw-bot-api: wrapped in swallowingApiCall (retry policy); thread-aware send
     void swallowingApiCall(
@@ -4106,7 +4121,16 @@ async function redeliverStrandedInbound(p: PendingDelivery<InboundMessage>): Pro
     if (selfAgent) clearAgentComposer({ agentName: selfAgent })
   } catch { /* best-effort; re-deliver regardless */ }
   const ok = ipcServer.sendToAgent(selfAgent, p.inbound)
-  if (!ok) {
+  if (ok) {
+    // Keep the #1556 gate coherent with the re-sent delivery, and survive an
+    // ack that raced the `await import` above: only `enqueue` clears tracking,
+    // so if a concurrent ack removed the entry, re-affirm it — never drop.
+    // Both ops are idempotent.
+    markClaudeBusyForInbound(p.inbound)
+    if (!deliveryQueue.pending.has(p.key)) {
+      trackDelivery(deliveryQueue, p.key, p.inbound, Date.now(), p.messageId)
+    }
+  } else {
     // Bridge offline between attempts — hand off to the offline buffer
     // (bridgeUp drains it) and stop tracking here; the spool owns it now.
     pendingInboundBuffer.push(selfAgent, p.inbound)
@@ -4115,6 +4139,16 @@ async function redeliverStrandedInbound(p: PendingDelivery<InboundMessage>): Pro
 }
 const _deliveryConfirmSweep = setInterval(() => {
   if (!DELIVERY_CONFIRM_ENABLED) return
+  // Re-deliver ONLY when claude is genuinely idle. `currentTurn` is set solely
+  // by the enqueue session-event and nulled at turn-end, so `currentTurn != null`
+  // means a real turn is in flight — re-clearing the composer + re-sending now
+  // would clobber it (the exact mid-turn wedge this queue exists to prevent). A
+  // pending permission / ask_user prompt is likewise a live interaction. Defer:
+  // leave the entry pending (it isn't acked) so the next idle sweep retries.
+  // NB: claudeBusyKeys (turnInFlightForGate) is set EAGERLY at delivery and
+  // stays set through a strand, so it is NOT a usable "idle" signal here.
+  if (currentTurn != null) return
+  if (pendingPermissions.size > 0 || pendingAskUser.size > 0) return
   for (const p of sweepDeliveryQueue(deliveryQueue, Date.now(), DELIVERY_CONFIRM_TIMEOUT_MS)) {
     void redeliverStrandedInbound(p)
   }
@@ -4636,16 +4670,20 @@ const ipcServer: IpcServer = createIpcServer({
       turnInitiated: activeTurn != null,
       originThreadId: activeTurn?.sessionThreadId,
     })
+    const permSupergroup = resolveAgentSupergroupChatId()
     for (const chat_id of access.allowFrom) {
       // parse_mode=HTML pairs with formatPermissionCardBody (#1790)
       // so the <b>/<i> tags render as formatting.
-      // PR4b emitter sweep — opts now optionally carries
-      // message_thread_id when supergroup mode is on.
+      // The resolved topic is valid only in the agent's supergroup — attach
+      // it ONLY when this recipient IS that supergroup. allowFrom DMs get the
+      // card thread-less; attaching a topic to a DM yields 400 "message thread
+      // not found" → card never arrives → auto-deny → wedge (marko 2026-06-02).
+      const permThread = topicForRecipient({ recipientChatId: chat_id, resolvedTopic: permTopic, supergroupChatId: permSupergroup })
       // allow-raw-bot-api: permission-request keyboard fan-out; topic-aware opts
       void bot.api.sendMessage(chat_id, text, {
         parse_mode: 'HTML',
         reply_markup: keyboard,
-        ...(permTopic != null ? { message_thread_id: permTopic } : {}),
+        ...(permThread != null ? { message_thread_id: permThread } : {}),
       }).catch(e => {
         process.stderr.write(`telegram gateway: permission_request send to ${chat_id} failed: ${e}\n`)
       })
@@ -4783,9 +4821,15 @@ const ipcServer: IpcServer = createIpcServer({
         // topic. Drive approval cards follow the originating turn
         // (operator-initiated tool call), admin alias fallback.
         const activeTurn = currentTurn
-        const driveTopic = resolveAgentOutboundTopic({
-          kind: 'hostd-approval',
-          originThreadId: activeTurn?.sessionThreadId,
+        // Attach the topic only when `operator` IS the agent's supergroup —
+        // operator DMs have no topics (marko brevo wedge, 2026-06-02).
+        const driveTopic = topicForRecipient({
+          recipientChatId: operator,
+          resolvedTopic: resolveAgentOutboundTopic({
+            kind: 'hostd-approval',
+            originThreadId: activeTurn?.sessionThreadId,
+          }),
+          supergroupChatId: resolveAgentSupergroupChatId(),
         })
         return {
           chatId: operator,
@@ -4856,9 +4900,14 @@ const ipcServer: IpcServer = createIpcServer({
         // alias fallback for background cases. Same shape as hostd /
         // drive approvals below.
         const activeTurn = currentTurn
-        const ms365Topic = resolveAgentOutboundTopic({
-          kind: 'hostd-approval',
-          originThreadId: activeTurn?.sessionThreadId,
+        // Topic valid only in the agent's supergroup — never on the operator DM.
+        const ms365Topic = topicForRecipient({
+          recipientChatId: operator,
+          resolvedTopic: resolveAgentOutboundTopic({
+            kind: 'hostd-approval',
+            originThreadId: activeTurn?.sessionThreadId,
+          }),
+          supergroupChatId: resolveAgentSupergroupChatId(),
         })
         return {
           chatId: operator,
@@ -4935,9 +4984,14 @@ const ipcServer: IpcServer = createIpcServer({
         // returns undefined for non-supergroup agents → behavior
         // unchanged.
         const activeTurn = currentTurn
-        const cfgTopic = resolveAgentOutboundTopic({
-          kind: 'hostd-approval',
-          originThreadId: activeTurn?.sessionThreadId,
+        // Topic valid only in the agent's supergroup — never on the operator DM.
+        const cfgTopic = topicForRecipient({
+          recipientChatId: operator,
+          resolvedTopic: resolveAgentOutboundTopic({
+            kind: 'hostd-approval',
+            originThreadId: activeTurn?.sessionThreadId,
+          }),
+          supergroupChatId: resolveAgentSupergroupChatId(),
         })
         return {
           chatId: operator,
@@ -7945,9 +7999,14 @@ function handleSessionEvent(ev: SessionEvent): void {
         // re-delivery. `enqueue` carries the same chat/thread the inbound was
         // keyed on, so the key matches.
         if (DELIVERY_CONFIRM_ENABLED) {
+          // Match on the source message id: `enqueue` fires for EVERY turn
+          // start (cron / subagent-handback / vault-resume / restart-marker
+          // too — see comment below), so a key-only ack would let a synthetic
+          // turn clear a real user message still waiting under the same key.
           ackDelivery(
             deliveryQueue,
             chatKey(ev.chatId, ev.threadId != null ? Number(ev.threadId) : null),
+            ev.messageId,
           )
         }
         // PR3b-cutover: feed the authoritative turn-start to the delivery
@@ -10670,13 +10729,40 @@ async function handleInbound(
     const busyKey = markClaudeBusyForInbound(inboundMsg)
     // Track until claude acks via `enqueue` (the marko drop-wedge): if no ack
     // lands, the message stranded in the composer and the sweep re-delivers
-    // it. See inbound-delivery-confirm.ts.
-    if (DELIVERY_CONFIRM_ENABLED) {
-      trackDelivery(deliveryQueue, busyKey, inboundMsg, Date.now())
+    // it. Track ONLY messages that produce an `enqueue` to ack against —
+    // shouldTrackDelivery excludes steering / `!` interrupt (amend the running
+    // turn), synthetic (meta.source) inbounds, and empty bodies, all of which
+    // never enqueue and would re-deliver forever. The tracked messageId lets
+    // the ack match only THIS message's enqueue (not a synthetic turn sharing
+    // the key). See shouldTrackDelivery / ackDelivery (inbound-delivery-confirm.ts).
+    if (
+      DELIVERY_CONFIRM_ENABLED &&
+      shouldTrackDelivery({
+        isSteering,
+        isInterrupt: interrupt.isInterrupt,
+        hasSource: inboundMsg.meta?.source != null,
+        effectiveText,
+      })
+    ) {
+      trackDelivery(deliveryQueue, busyKey, inboundMsg, Date.now(), String(inboundMsg.messageId))
     }
   }
   if (!delivered) {
-    pendingInboundBuffer.push(selfAgent, inboundMsg)
+    // Only persist fresh user turns to the durable spool. Steering / `!`
+    // interrupt / empty bodies are mid-turn amendments or no-ops that would
+    // arrive orphaned if replayed as a fresh turn after a restart — drop them
+    // (the restart notice below tells the user to re-send). Mirrors the
+    // tracking + #1556-gate carve-outs.
+    if (
+      shouldTrackDelivery({
+        isSteering,
+        isInterrupt: interrupt.isInterrupt,
+        hasSource: inboundMsg.meta?.source != null,
+        effectiveText,
+      })
+    ) {
+      pendingInboundBuffer.push(selfAgent, inboundMsg)
+    }
     const threadOpts = messageThreadId != null ? { message_thread_id: messageThreadId } : {}
     // #1075: thread-id-bearing — swallow via robustApiCall so a deleted
     // topic doesn't crash the gateway. Fire-and-forget; the inbound is
@@ -11007,6 +11093,30 @@ function resolveAgentOutboundTopic(
   }
 }
 
+/**
+ * The agent's supergroup chat id (`channels.telegram.chat_id`) when it is in
+ * supergroup-owned mode, else undefined. A forum topic id resolved by
+ * {@link resolveAgentOutboundTopic} is valid ONLY in this chat — used by
+ * {@link topicForRecipient} to decide whether an approval/permission card sent
+ * to a given recipient (operator DMs vs the supergroup itself) may carry a
+ * `message_thread_id`. Attaching a topic to a DM is the marko brevo wedge
+ * (2026-06-02): the card fails with "message thread not found" and auto-denies.
+ */
+function resolveAgentSupergroupChatId(): string | undefined {
+  const agentName = process.env.SWITCHROOM_AGENT_NAME
+  if (!agentName) return undefined
+  try {
+    const cfg = loadSwitchroomConfig()
+    const rawAgent = cfg.agents?.[agentName]
+    if (!rawAgent) return undefined
+    const resolved = resolveAgentConfig(cfg.defaults, cfg.profiles, rawAgent)
+    const tg = resolved.channels?.telegram as { chat_id?: string | number } | undefined
+    return tg?.chat_id != null ? String(tg.chat_id) : undefined
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * Stamp a user-facing restart reason into the clean-shutdown marker
  * (same file the SIGTERM handler writes to and the next session greeting

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

@@ -35,6 +35,14 @@ export interface PendingDelivery<M> {
   readonly key: string
   /** The exact inbound to re-send until claude acks it. */
   readonly inbound: M
+  /**
+   * Source message id of the tracked inbound (stringified Telegram
+   * `message_id`), or null if unknown. The `enqueue` ack matches on THIS so a
+   * synthetic-source turn (cron / resume / vault / reaction) that shares the
+   * chatKey can't false-ack — and silently drop — a real user message still
+   * waiting to land. See ackDelivery.
+   */
+  readonly messageId: string | null
   /** When the latest delivery attempt was made (unix-ms). */
   lastAttemptAt: number
 }
@@ -51,22 +59,44 @@ export function createDeliveryQueue<M>(): DeliveryQueue<M> {
  * Track a freshly-delivered inbound, awaiting claude's `enqueue` ack.
  * Overwrites any prior pending for the key — the #1556 gate serialises per
  * key, so a later inbound supersedes an earlier un-acked one for that key.
+ * `messageId` (stringified Telegram message_id) lets the ack match only the
+ * enqueue that belongs to THIS message; pass null when unknown.
  */
 export function trackDelivery<M>(
   q: DeliveryQueue<M>,
   key: string,
   inbound: M,
   now: number,
+  messageId: string | null = null,
 ): void {
-  q.pending.set(key, { key, inbound, lastAttemptAt: now })
+  q.pending.set(key, { key, inbound, messageId, lastAttemptAt: now })
 }
 
 /**
- * Ack a delivery — call from the `enqueue` session-event (claude started the
- * turn, so the message landed). Returns true if a pending entry was cleared.
+ * Ack a delivery — call from the `enqueue` session-event (claude started a
+ * turn). `enqueue` fires for EVERY turn start regardless of source (user
+ * inbound, cron, subagent-handback, vault-resume, restart-marker), so acking
+ * purely by chatKey would let a synthetic-source turn clear — and thus
+ * silently drop — a real user message still waiting under the same key. So
+ * ack ONLY when the enqueue's source message id matches the tracked one.
+ *
+ * Matching rule: if we recorded a messageId for the pending entry, require the
+ * enqueue's `enqueueMessageId` to equal it. If we never recorded one (legacy /
+ * defensive null), fall back to key-only ack. Returns true if an entry was
+ * cleared.
  */
-export function ackDelivery<M>(q: DeliveryQueue<M>, key: string): boolean {
-  return q.pending.delete(key)
+export function ackDelivery<M>(
+  q: DeliveryQueue<M>,
+  key: string,
+  enqueueMessageId: string | null = null,
+): boolean {
+  const entry = q.pending.get(key)
+  if (!entry) return false
+  // A different message started this turn — don't ack ours (it may still be
+  // waiting to land; the sweep will re-deliver it if it stranded).
+  if (entry.messageId != null && entry.messageId !== enqueueMessageId) return false
+  q.pending.delete(key)
+  return true
 }
 
 /**
@@ -94,3 +124,37 @@ export function sweep<M>(
 export function forgetDelivery<M>(q: DeliveryQueue<M>, key: string): void {
   q.pending.delete(key)
 }
+
+/**
+ * Should this delivered inbound be tracked for ack/re-delivery?
+ *
+ * Track a delivery iff it is a fresh user turn that will produce exactly one
+ * `enqueue` to ack against. Everything that does NOT enqueue must be excluded,
+ * or the sweep re-delivers it forever (re-clearing the composer every cycle):
+ *
+ *   - `isSteering` / `isInterrupt` — the #1556 gate's carve-outs: delivered
+ *     mid-turn to AMEND the running turn, so they never start a fresh turn and
+ *     never emit `enqueue`.
+ *   - `hasSource` — synthetic inbounds (cron / vault-resume / subagent-handback
+ *     / reaction) carry a `meta.source`; they enqueue under their own semantics
+ *     and must never be tracked as if they were a queued user turn.
+ *   - empty `effectiveText` — an empty body (e.g. `/queue` with no text) is
+ *     silently dropped by claude's auto-submit and never enqueues, so tracking
+ *     it is a pure re-delivery loop (a self-inflicted DoS on the queue).
+ *
+ * Mirror the gate's carve-outs here so tracking is exactly the set of messages
+ * that produce an `enqueue`.
+ */
+export function shouldTrackDelivery(input: {
+  isSteering: boolean
+  isInterrupt: boolean
+  hasSource?: boolean
+  effectiveText?: string
+}): boolean {
+  if (input.isSteering || input.isInterrupt) return false
+  if (input.hasSource) return false
+  // Gate on empty text only when the caller actually provided it (undefined =
+  // "not supplied", left untracked-gated so existing callers keep their behaviour).
+  if (input.effectiveText !== undefined && input.effectiveText.trim().length === 0) return false
+  return true
+}

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

@@ -4,6 +4,7 @@ import {
   ackDelivery,
   createDeliveryQueue,
   forgetDelivery,
+  shouldTrackDelivery,
   sweep,
   trackDelivery,
   type DeliveryQueue,
@@ -107,3 +108,73 @@ describe('inbound-delivery-confirm (reliable deliver-until-acked queue)', () =>
     expect(sweep(q, 999_999, TIMEOUT)).toHaveLength(0)
   })
 })
+
+// Regression for the cross-source ACK collision (silent drop): `enqueue` fires
+// for EVERY turn start regardless of source. A synthetic-source turn (cron /
+// resume / vault / reaction) that shares the chatKey of a real user message
+// still waiting to land would, with a key-only ack, clear — and silently drop
+// — that user message. The ack must match on the tracked message id.
+describe('ackDelivery — message-id-matched (cross-source false-ack guard)', () => {
+  it('acks when the enqueue message id matches the tracked one', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'real user msg' }, 0, '5001')
+    expect(ackDelivery(q, 'chat:_', '5001')).toBe(true)
+    expect(q.pending.size).toBe(0)
+  })
+
+  it('does NOT ack when a different (synthetic-source) turn enqueues under the same key', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'real user msg' }, 0, '5001')
+    // a cron / resume turn for the same chat enqueues first, with its own id
+    expect(ackDelivery(q, 'chat:_', '1716123456789')).toBe(false)
+    // the user message is still tracked — it strands → gets re-delivered, not dropped
+    expect(q.pending.size).toBe(1)
+    expect(sweep(q, 15_000, TIMEOUT)).toHaveLength(1)
+    // and its own enqueue (matching id) later acks it cleanly
+    expect(ackDelivery(q, 'chat:_', '5001')).toBe(true)
+    expect(q.pending.size).toBe(0)
+  })
+
+  it('does NOT ack when the enqueue carries no message id but the tracked one has one', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'real user msg' }, 0, '5001')
+    expect(ackDelivery(q, 'chat:_', null)).toBe(false)
+    expect(q.pending.size).toBe(1)
+  })
+
+  it('falls back to key-only ack when no message id was recorded (legacy/defensive)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'x' }, 0) // no messageId
+    expect(ackDelivery(q, 'chat:_', '5001')).toBe(true)
+    expect(q.pending.size).toBe(0)
+  })
+})
+
+// Regression for the steer/interrupt re-delivery loop: steering and `!`
+// interrupt inbounds amend the running turn and never emit `enqueue`, so they
+// must NOT be tracked (else the sweep re-delivers them forever). Only
+// fresh-turn messages — which DO enqueue — are tracked.
+describe('shouldTrackDelivery — only fresh-turn messages are tracked', () => {
+  it('tracks a normal (non-steering, non-interrupt) message', () => {
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false })).toBe(true)
+  })
+  it('does NOT track a /steer message (amends the turn — never acks)', () => {
+    expect(shouldTrackDelivery({ isSteering: true, isInterrupt: false })).toBe(false)
+  })
+  it('does NOT track a ! interrupt message (amends the turn — never acks)', () => {
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: true })).toBe(false)
+  })
+  it('does NOT track when both flags set (defensive)', () => {
+    expect(shouldTrackDelivery({ isSteering: true, isInterrupt: true })).toBe(false)
+  })
+  it('does NOT track a synthetic (meta.source) inbound — cron/resume/vault/reaction enqueue under their own semantics', () => {
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false, hasSource: true })).toBe(false)
+  })
+  it('does NOT track an empty-body message (e.g. `/queue` with no text) — never enqueues, would re-deliver forever', () => {
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false, effectiveText: '' })).toBe(false)
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false, effectiveText: '   ' })).toBe(false)
+  })
+  it('tracks a normal message when effectiveText is provided and non-empty', () => {
+    expect(shouldTrackDelivery({ isSteering: false, isInterrupt: false, effectiveText: 'draft the email' })).toBe(true)
+  })
+})

package/telegram-plugin/uat/scenarios/jtbd-rapid-followup-dm.test.ts

@@ -55,8 +55,15 @@ describe("uat: rapid follow-ups — steering vs queued classification", () => {
           (m) => {
             const txt = m.text;
             const mentionsMd5 = /\bmd5\b/i.test(txt);
+            // Steer narration: the agent acknowledges amending the in-flight
+            // task. Accept the phrasings the model actually uses — including
+            // "Switched to MD5 per your update/follow-up" (the 2026-06-02
+            // canary reply that the old regex wrongly rejected). Anchored on
+            // "per your <qualifier>" / continuation language so it stays
+            // distinct from the QUEUED path (a fresh answer with no such
+            // course-correction narration).
             const narratesSteer =
-              /↪️|\bsteer(ing)?\b|continuing the (prior|original|in-flight) task|amendment|course[- ]correct/i.test(
+              /↪️|\bsteer(ing)?\b|switch(?:ed|ing)? to \w+ per your (?:update|follow-?up|guidance|request|steer)|continuing the (prior|original|in-flight) task|amendment|course[- ]correct/i.test(
                 txt,
               );
             return mentionsMd5 && narratesSteer;