switchroom 0.14.39 → 0.14.41

package/dist/cli/switchroom.js

@@ -25257,7 +25257,7 @@ function decodeResponse2(line) {
   }
   return ResponseSchema2.parse(parsed);
 }
-var MAX_FRAME_BYTES2, PROTOCOL_VERSION = 1, ProviderNameSchema, GetCredentialsRequestSchema, ListStateRequestSchema, SetActiveRequestSchema, MarkExhaustedRequestSchema, RefreshAccountRequestSchema, AnthropicCredentialsSchema, GoogleCredentialsSchema, MicrosoftCredentialsSchema, ProviderCredentialsSchema, AddAccountRequestSchema, RmAccountRequestSchema, SetOverrideRequestSchema, ListGoogleAccountsRequestSchema, ProbeQuotaRequestSchema, RequestSchema2, GetCredentialsDataSchema, AccountStateSchema, AgentStateSchema, ConsumerStateSchema, ListStateDataSchema, SetActiveDataSchema, MarkExhaustedDataSchema, RefreshAccountDataSchema, AddAccountDataSchema, RmAccountDataSchema, SetOverrideDataSchema, GoogleAccountStateSchema, ListGoogleAccountsDataSchema, ErrorBodySchema, SuccessResponseSchema, ErrorResponseSchema2, ResponseSchema2;
+var MAX_FRAME_BYTES2, PROTOCOL_VERSION = 1, ProviderNameSchema, GetCredentialsRequestSchema, ListStateRequestSchema, SetActiveRequestSchema, MarkExhaustedRequestSchema, RefreshAccountRequestSchema, AnthropicCredentialsSchema, GoogleCredentialsSchema, MicrosoftCredentialsSchema, ProviderCredentialsSchema, AddAccountRequestSchema, RmAccountRequestSchema, SetOverrideRequestSchema, ListGoogleAccountsRequestSchema, ListMicrosoftAccountsRequestSchema, ProbeQuotaRequestSchema, RequestSchema2, GetCredentialsDataSchema, AccountStateSchema, AgentStateSchema, ConsumerStateSchema, ListStateDataSchema, SetActiveDataSchema, MarkExhaustedDataSchema, RefreshAccountDataSchema, AddAccountDataSchema, RmAccountDataSchema, SetOverrideDataSchema, GoogleAccountStateSchema, ListGoogleAccountsDataSchema, MicrosoftAccountStateSchema, ListMicrosoftAccountsDataSchema, ErrorBodySchema, SuccessResponseSchema, ErrorResponseSchema2, ResponseSchema2;
 var init_protocol2 = __esm(() => {
   init_zod();
   MAX_FRAME_BYTES2 = 64 * 1024;
@@ -25361,6 +25361,11 @@ var init_protocol2 = __esm(() => {
     op: exports_external.literal("list-google-accounts"),
     id: exports_external.string().min(1)
   });
+  ListMicrosoftAccountsRequestSchema = exports_external.object({
+    v: exports_external.literal(PROTOCOL_VERSION),
+    op: exports_external.literal("list-microsoft-accounts"),
+    id: exports_external.string().min(1)
+  });
   ProbeQuotaRequestSchema = exports_external.object({
     v: exports_external.literal(PROTOCOL_VERSION),
     op: exports_external.literal("probe-quota"),
@@ -25378,6 +25383,7 @@ var init_protocol2 = __esm(() => {
     RmAccountRequestSchema,
     SetOverrideRequestSchema,
     ListGoogleAccountsRequestSchema,
+    ListMicrosoftAccountsRequestSchema,
     ProbeQuotaRequestSchema
   ]);
   GetCredentialsDataSchema = exports_external.object({
@@ -25442,6 +25448,16 @@ var init_protocol2 = __esm(() => {
   ListGoogleAccountsDataSchema = exports_external.object({
     accounts: exports_external.array(GoogleAccountStateSchema)
   });
+  MicrosoftAccountStateSchema = exports_external.object({
+    account: exports_external.string(),
+    expiresAt: exports_external.number(),
+    scope: exports_external.string(),
+    clientId: exports_external.string(),
+    accountType: exports_external.enum(["personal", "work"])
+  });
+  ListMicrosoftAccountsDataSchema = exports_external.object({
+    accounts: exports_external.array(MicrosoftAccountStateSchema)
+  });
   ErrorBodySchema = exports_external.object({
     code: exports_external.enum([
       "FORBIDDEN",
@@ -25565,6 +25581,14 @@ class AuthBrokerClient {
     });
     return data;
   }
+  async listMicrosoftAccounts() {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "list-microsoft-accounts"
+    });
+    return data;
+  }
   async probeQuota(accounts, timeoutMs) {
     const data = await this.send({
       v: PROTOCOL_VERSION,
@@ -49438,8 +49462,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.39";
-var COMMIT_SHA = "fb30b654";
+var VERSION = "0.14.41";
+var COMMIT_SHA = "747ab2f1";
 
 // src/cli/agent.ts
 init_source();
@@ -57992,13 +58016,46 @@ function registerAccountRemove2(accountParent) {
   }));
 }
 function registerAccountList2(accountParent) {
-  accountParent.command("list").description("List Microsoft accounts the broker holds credentials for. Distinct from `auth microsoft list` (YAML ACL matrix).").option("--json", "Emit raw JSON").action(withConfigError(async (_opts) => {
+  accountParent.command("list").description("List Microsoft accounts the broker holds credentials for. Distinct from `auth microsoft list` (YAML ACL matrix).").option("--json", "Emit raw JSON").action(withConfigError(async (opts) => {
+    const { brokerCall: brokerCall2 } = await Promise.resolve().then(() => (init_broker_call(), exports_broker_call));
+    const data = await brokerCall2(async (client) => client.listMicrosoftAccounts());
+    if (opts.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
     console.log();
-    console.log(source_default.yellow("  Broker-side listing for Microsoft accounts is a follow-up (needs a list-microsoft-accounts wire op)."));
-    console.log(`  For now, see the YAML matrix: ${source_default.bold("switchroom auth microsoft list")}`);
+    if (data.accounts.length === 0) {
+      console.log(source_default.gray("  No Microsoft accounts stored in broker."));
+      console.log(`  Add one: ${source_default.bold("switchroom auth microsoft account add <email>")}`);
+      console.log();
+      return;
+    }
+    const accountColWidth = Math.max(...data.accounts.map((a) => a.account.length), "ACCOUNT".length);
+    const typeColWidth = "TYPE".length + 4;
+    const expiresColWidth = "EXPIRES".length + 2;
+    console.log(`${pad2("ACCOUNT", accountColWidth)}  ${pad2("TYPE", typeColWidth)}  ${pad2("EXPIRES", expiresColWidth)}  SCOPE`);
+    console.log(`${pad2("-".repeat(7), accountColWidth)}  ${pad2("-".repeat(4), typeColWidth)}  ${pad2("-".repeat(7), expiresColWidth)}  ${"-".repeat(5)}`);
+    const now = Date.now();
+    for (const a of data.accounts) {
+      const expiresLabel = formatMicrosoftExpiry(a.expiresAt - now);
+      const scopes = a.scope.split(" ").filter((s) => s.length > 0 && !["openid", "profile", "email", "offline_access"].includes(s)).join(", ");
+      console.log(`${pad2(a.account, accountColWidth)}  ${pad2(a.accountType, typeColWidth)}  ${pad2(expiresLabel, expiresColWidth)}  ${scopes}`);
+    }
     console.log();
   }));
 }
+function formatMicrosoftExpiry(remainingMs) {
+  if (remainingMs <= 0)
+    return source_default.red("expired");
+  const minutes = Math.round(remainingMs / 60000);
+  if (minutes < 60)
+    return `${minutes}m`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 48)
+    return `${hours}h`;
+  const days = Math.round(hours / 24);
+  return `${days}d`;
+}
 function validateAndNormalizeAccountEmail2(account) {
   const normalized = account.trim().toLowerCase();
   if (!/^[^@\s:]+@[^@\s:]+\.[^@\s:]+$/.test(normalized)) {

package/package.json

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

@@ -16160,7 +16160,7 @@ function decodeResponse(line) {
   }
   return ResponseSchema.parse(parsed);
 }
-var MAX_FRAME_BYTES, PROTOCOL_VERSION = 1, ProviderNameSchema, GetCredentialsRequestSchema, ListStateRequestSchema, SetActiveRequestSchema, MarkExhaustedRequestSchema, RefreshAccountRequestSchema, AnthropicCredentialsSchema, GoogleCredentialsSchema, MicrosoftCredentialsSchema, ProviderCredentialsSchema, AddAccountRequestSchema, RmAccountRequestSchema, SetOverrideRequestSchema, ListGoogleAccountsRequestSchema, ProbeQuotaRequestSchema, RequestSchema, GetCredentialsDataSchema, AccountStateSchema, AgentStateSchema, ConsumerStateSchema, ListStateDataSchema, SetActiveDataSchema, MarkExhaustedDataSchema, RefreshAccountDataSchema, AddAccountDataSchema, RmAccountDataSchema, SetOverrideDataSchema, GoogleAccountStateSchema, ListGoogleAccountsDataSchema, ErrorBodySchema, SuccessResponseSchema, ErrorResponseSchema, ResponseSchema;
+var MAX_FRAME_BYTES, PROTOCOL_VERSION = 1, ProviderNameSchema, GetCredentialsRequestSchema, ListStateRequestSchema, SetActiveRequestSchema, MarkExhaustedRequestSchema, RefreshAccountRequestSchema, AnthropicCredentialsSchema, GoogleCredentialsSchema, MicrosoftCredentialsSchema, ProviderCredentialsSchema, AddAccountRequestSchema, RmAccountRequestSchema, SetOverrideRequestSchema, ListGoogleAccountsRequestSchema, ListMicrosoftAccountsRequestSchema, ProbeQuotaRequestSchema, RequestSchema, GetCredentialsDataSchema, AccountStateSchema, AgentStateSchema, ConsumerStateSchema, ListStateDataSchema, SetActiveDataSchema, MarkExhaustedDataSchema, RefreshAccountDataSchema, AddAccountDataSchema, RmAccountDataSchema, SetOverrideDataSchema, GoogleAccountStateSchema, ListGoogleAccountsDataSchema, MicrosoftAccountStateSchema, ListMicrosoftAccountsDataSchema, ErrorBodySchema, SuccessResponseSchema, ErrorResponseSchema, ResponseSchema;
 var init_protocol = __esm(() => {
   init_zod();
   MAX_FRAME_BYTES = 64 * 1024;
@@ -16264,6 +16264,11 @@ var init_protocol = __esm(() => {
     op: exports_external.literal("list-google-accounts"),
     id: exports_external.string().min(1)
   });
+  ListMicrosoftAccountsRequestSchema = exports_external.object({
+    v: exports_external.literal(PROTOCOL_VERSION),
+    op: exports_external.literal("list-microsoft-accounts"),
+    id: exports_external.string().min(1)
+  });
   ProbeQuotaRequestSchema = exports_external.object({
     v: exports_external.literal(PROTOCOL_VERSION),
     op: exports_external.literal("probe-quota"),
@@ -16281,6 +16286,7 @@ var init_protocol = __esm(() => {
     RmAccountRequestSchema,
     SetOverrideRequestSchema,
     ListGoogleAccountsRequestSchema,
+    ListMicrosoftAccountsRequestSchema,
     ProbeQuotaRequestSchema
   ]);
   GetCredentialsDataSchema = exports_external.object({
@@ -16345,6 +16351,16 @@ var init_protocol = __esm(() => {
   ListGoogleAccountsDataSchema = exports_external.object({
     accounts: exports_external.array(GoogleAccountStateSchema)
   });
+  MicrosoftAccountStateSchema = exports_external.object({
+    account: exports_external.string(),
+    expiresAt: exports_external.number(),
+    scope: exports_external.string(),
+    clientId: exports_external.string(),
+    accountType: exports_external.enum(["personal", "work"])
+  });
+  ListMicrosoftAccountsDataSchema = exports_external.object({
+    accounts: exports_external.array(MicrosoftAccountStateSchema)
+  });
   ErrorBodySchema = exports_external.object({
     code: exports_external.enum([
       "FORBIDDEN",
@@ -16468,6 +16484,14 @@ class AuthBrokerClient {
     });
     return data;
   }
+  async listMicrosoftAccounts() {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID3(),
+      op: "list-microsoft-accounts"
+    });
+    return data;
+  }
   async probeQuota(accounts, timeoutMs) {
     const data = await this.send({
       v: PROTOCOL_VERSION,
@@ -40682,6 +40706,14 @@ class AuthBrokerClient2 {
     });
     return data;
   }
+  async listMicrosoftAccounts() {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID4(),
+      op: "list-microsoft-accounts"
+    });
+    return data;
+  }
   async probeQuota(accounts, timeoutMs) {
     const data = await this.send({
       v: PROTOCOL_VERSION,
@@ -47227,6 +47259,45 @@ function decideInboundDelivery(input) {
   return "deliver";
 }
 
+// gateway/inbound-delivery-confirm.ts
+function createDeliveryQueue() {
+  return { pending: new Map };
+}
+function trackDelivery(q, key, inbound, now, messageId = null) {
+  q.pending.set(key, { key, inbound, messageId, lastAttemptAt: now });
+}
+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 = [];
+  for (const entry of q.pending.values()) {
+    if (now - entry.lastAttemptAt < timeoutMs)
+      continue;
+    entry.lastAttemptAt = now;
+    redeliver.push(entry);
+  }
+  return redeliver;
+}
+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;
 function createPendingPermissionBuffer(opts = {}) {
@@ -47411,12 +47482,12 @@ function transition(state3, event) {
         turnStartedAt: null,
         lastOutboundAt: event.outboundEmitted ? event.at : p.lastOutboundAt
       }));
-      const sweep = sweepSiblings(stateAfterClear, chatId, event.key);
+      const sweep2 = sweepSiblings(stateAfterClear, chatId, event.key);
       const wasActive = state3.global.kind === "bridge_alive_in_turn" && state3.global.activeTurn === event.key;
-      const next = wasActive ? { ...sweep.state, global: { kind: "bridge_alive_idle" } } : sweep.state;
+      const next = wasActive ? { ...sweep2.state, global: { kind: "bridge_alive_idle" } } : sweep2.state;
       const effects = [
         { kind: "clearTurnStarted", key: event.key },
-        ...sweep.effects
+        ...sweep2.effects
       ];
       if (event.outboundEmitted) {
         effects.push({ kind: "noteOutbound", key: event.key, at: event.at });
@@ -51794,10 +51865,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.39";
-var COMMIT_SHA = "fb30b654";
-var COMMIT_DATE = "2026-06-02T05:46:22Z";
-var LATEST_PR = 2086;
+var VERSION = "0.14.41";
+var COMMIT_SHA = "747ab2f1";
+var COMMIT_DATE = "2026-06-02T11:03:39Z";
+var LATEST_PR = 2095;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -52967,8 +53038,16 @@ function markClaudeBusyForInbound(m) {
     if (Number.isFinite(n))
       tid = n;
   }
-  claudeBusyKeys.add(chatKey2(m.chatId, tid));
+  const key = chatKey2(m.chatId, tid);
+  claudeBusyKeys.add(key);
+  return key;
 }
+var DELIVERY_CONFIRM_ENABLED = process.env.SWITCHROOM_INBOUND_DELIVERY_CONFIRM !== "0";
+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() {
   return isDeliveryCutoverEnabled() ? isMachineInTurn() : claudeBusyKeys.size > 0;
 }
@@ -54088,6 +54167,38 @@ var _deliveryMachineTick = setInterval(() => {
   shadowEmit({ kind: "tick", now: Date.now() });
 }, DELIVERY_MACHINE_TICK_MS);
 _deliveryMachineTick.unref?.();
+async function redeliverStrandedInbound(p) {
+  const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? "";
+  process.stderr.write(`telegram gateway: inbound strand (no enqueue ack) key=${p.key} \u2014 re-clearing composer + re-delivering
+`);
+  try {
+    const { clearAgentComposer: clearAgentComposer2 } = await Promise.resolve().then(() => (init_tmux(), exports_tmux));
+    if (selfAgent)
+      clearAgentComposer2({ agentName: selfAgent });
+  } catch {}
+  const ok = ipcServer.sendToAgent(selfAgent, p.inbound);
+  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);
+  }
+}
+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);
+  }
+}, DELIVERY_CONFIRM_SWEEP_MS);
+_deliveryConfirmSweep.unref?.();
 startTimer2({
   editMessage: async (ctx) => {
     const editOpts = ctx.parseMode != null ? { parse_mode: ctx.parseMode } : undefined;
@@ -56478,6 +56589,9 @@ function handleSessionEvent(ev) {
           isDm: isDmChatId(ev.chatId)
         };
         currentTurn = next;
+        if (DELIVERY_CONFIRM_ENABLED) {
+          ackDelivery(deliveryQueue, chatKey2(ev.chatId, ev.threadId != null ? Number(ev.threadId) : null), ev.messageId);
+        }
         shadowEmit({
           kind: "turnStart",
           key: statusKey(ev.chatId, ev.threadId != null ? Number(ev.threadId) : undefined),
@@ -57910,10 +58024,26 @@ ${preBlock(write.output)}`;
     }
   }
   const delivered = ipcServer.sendToAgent(selfAgent, inboundMsg);
-  if (delivered)
-    markClaudeBusyForInbound(inboundMsg);
+  if (delivered) {
+    const busyKey = markClaudeBusyForInbound(inboundMsg);
+    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,

package/telegram-plugin/gateway/gateway.ts

@@ -280,6 +280,15 @@ import { createPendingInboundBuffer, redeliverBufferedInbound, idleDrainTick } f
 import { createInboundSpool } from './inbound-spool.js'
 import { purgeStaleTurnsForChat } from './turn-state-purge.js'
 import { decideInboundDelivery } from './inbound-delivery-gate.js'
+import {
+  createDeliveryQueue,
+  trackDelivery,
+  ackDelivery,
+  sweep as sweepDeliveryQueue,
+  forgetDelivery,
+  shouldTrackDelivery,
+  type PendingDelivery,
+} from './inbound-delivery-confirm.js'
 import { createPendingPermissionBuffer } from './pending-permission-decisions.js'
 import { chatKey, chatKeyWithSuffix, chatIdOfChatKey } from './chat-key.js'
 // Phase 2b PR 2 — shadow mode. Each event-site below calls shadowEmit()
@@ -1309,15 +1318,43 @@ function markClaudeBusyForInbound(m: {
   chatId: string
   threadId?: number
   meta?: Record<string, string>
-}): void {
+}): string {
   let tid: number | null = m.threadId ?? null
   if (tid == null && m.meta?.message_thread_id != null) {
     const n = Number(m.meta.message_thread_id)
     if (Number.isFinite(n)) tid = n
   }
-  claudeBusyKeys.add(chatKey(m.chatId, tid))
+  const key = chatKey(m.chatId, tid)
+  claudeBusyKeys.add(key)
+  return key
 }
 
+// ─── Reliable inbound delivery: deliver-until-acked (the marko drop-wedge) ─
+// A delivered inbound is ACKED only by the `enqueue` session-event (claude
+// actually started the turn) — NOT by sendToAgent returning true. Until
+// acked, the message stays queued; if it didn't land within the timeout it
+// stranded in claude's composer, so we re-deliver it. Re-deliver forever
+// until acked — never drop (vs the old fire-and-forget that the 300s
+// silence-poke swallowed). Kill switch: SWITCHROOM_INBOUND_DELIVERY_CONFIRM=0
+// → legacy fire-and-forget. See inbound-delivery-confirm.ts.
+const DELIVERY_CONFIRM_ENABLED = process.env.SWITCHROOM_INBOUND_DELIVERY_CONFIRM !== '0'
+// How long to wait for claude's `enqueue` ack before treating a delivery as
+// stranded and re-delivering. Generous by default — claude acks within ~1s of
+// 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 _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>()
+
 /**
  * Authoritative "is a turn in flight?" for every gate that previously
  * read `claudeBusyKeys.size`. PR 3b cutover (extends PR 3a's bridgeUp
@@ -4061,6 +4098,57 @@ const _deliveryMachineTick = setInterval(() => {
 }, DELIVERY_MACHINE_TICK_MS)
 _deliveryMachineTick.unref?.()
 
+// Re-deliver stranded inbounds until claude acks (the marko drop-wedge).
+// Every few seconds, re-send any inbound that was handed to claude but never
+// acked by an `enqueue` — it stranded unsubmitted in the composer. Re-clear
+// the composer so the re-sent notification lands on a clean line, then
+// re-send. Reuses the same delivery primitives; the message is never dropped.
+// (Refs ipcServer / pendingInboundBuffer declared below — resolved at fire
+// time, after module init.) unref so the interval never holds the process.
+async function redeliverStrandedInbound(p: PendingDelivery<InboundMessage>): Promise<void> {
+  const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? ''
+  process.stderr.write(
+    `telegram gateway: inbound strand (no enqueue ack) key=${p.key} — re-clearing composer + re-delivering\n`,
+  )
+  try {
+    const { clearAgentComposer } = await import('../../src/agents/tmux.js')
+    if (selfAgent) clearAgentComposer({ agentName: selfAgent })
+  } catch { /* best-effort; re-deliver regardless */ }
+  const ok = ipcServer.sendToAgent(selfAgent, p.inbound)
+  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)
+    forgetDelivery(deliveryQueue, p.key)
+  }
+}
+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)
+  }
+}, DELIVERY_CONFIRM_SWEEP_MS)
+_deliveryConfirmSweep.unref?.()
+
 // #1445 cross-turn pending-async ambient. When a turn ends after the
 // model dispatched background async work (Agent / Task / Bash run-in-
 // background) and the model has stopped speaking, keep editing the
@@ -7880,6 +7968,21 @@ function handleSessionEvent(ev: SessionEvent): void {
           isDm: isDmChatId(ev.chatId),
         }
         currentTurn = next
+        // Ack inbound delivery (the marko drop-wedge): claude actually started
+        // this turn, so its delivered inbound landed — stop tracking it for
+        // 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
         // machine. `enqueue` fires for EVERY turn atom regardless of
         // source — inbound, cron, subagent-handback, vault-resume,
@@ -10596,9 +10699,44 @@ async function handleInbound(
   }
 
   const delivered = ipcServer.sendToAgent(selfAgent, inboundMsg)
-  if (delivered) markClaudeBusyForInbound(inboundMsg)
+  if (delivered) {
+    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. 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