switchroom 0.14.39 → 0.14.40

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.40";
+var COMMIT_SHA = "d2d69140";
 
 // 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.40",
   "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,30 @@ function decideInboundDelivery(input) {
   return "deliver";
 }
 
+// gateway/inbound-delivery-confirm.ts
+function createDeliveryQueue() {
+  return { pending: new Map };
+}
+function trackDelivery(q, key, inbound, now) {
+  q.pending.set(key, { key, inbound, lastAttemptAt: now });
+}
+function ackDelivery(q, key) {
+  return q.pending.delete(key);
+}
+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);
+}
+
 // gateway/pending-permission-decisions.ts
 var DEFAULT_PENDING_PERMISSION_CAP = 32;
 function createPendingPermissionBuffer(opts = {}) {
@@ -47411,12 +47467,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 +51850,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.40";
+var COMMIT_SHA = "d2d69140";
+var COMMIT_DATE = "2026-06-02T08:59:46Z";
+var LATEST_PR = 2090;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -52967,8 +53023,14 @@ 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 DELIVERY_CONFIRM_TIMEOUT_MS = Number(process.env.SWITCHROOM_INBOUND_DELIVERY_TIMEOUT_MS) || 15000;
+var DELIVERY_CONFIRM_SWEEP_MS = 5000;
+var deliveryQueue = createDeliveryQueue();
 function turnInFlightForGate() {
   return isDeliveryCutoverEnabled() ? isMachineInTurn() : claudeBusyKeys.size > 0;
 }
@@ -54088,6 +54150,29 @@ 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) {
+    pendingInboundBuffer.push(selfAgent, p.inbound);
+    forgetDelivery(deliveryQueue, p.key);
+  }
+}
+var _deliveryConfirmSweep = setInterval(() => {
+  if (!DELIVERY_CONFIRM_ENABLED)
+    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 +56563,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));
+        }
         shadowEmit({
           kind: "turnStart",
           key: statusKey(ev.chatId, ev.threadId != null ? Number(ev.threadId) : undefined),
@@ -57910,8 +57998,12 @@ ${preBlock(write.output)}`;
     }
   }
   const delivered = ipcServer.sendToAgent(selfAgent, inboundMsg);
-  if (delivered)
-    markClaudeBusyForInbound(inboundMsg);
+  if (delivered) {
+    const busyKey = markClaudeBusyForInbound(inboundMsg);
+    if (DELIVERY_CONFIRM_ENABLED) {
+      trackDelivery(deliveryQueue, busyKey, inboundMsg, Date.now());
+    }
+  }
   if (!delivered) {
     pendingInboundBuffer.push(selfAgent, inboundMsg);
     const threadOpts = messageThreadId != null ? { message_thread_id: messageThreadId } : {};

package/telegram-plugin/gateway/gateway.ts

@@ -280,6 +280,14 @@ 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,
+  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 +1317,35 @@ 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 DELIVERY_CONFIRM_TIMEOUT_MS = Number(process.env.SWITCHROOM_INBOUND_DELIVERY_TIMEOUT_MS) || 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 +4089,38 @@ 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) {
+    // 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
+  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 +7940,16 @@ 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) {
+          ackDelivery(
+            deliveryQueue,
+            chatKey(ev.chatId, ev.threadId != null ? Number(ev.threadId) : null),
+          )
+        }
         // 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,7 +10666,15 @@ 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. See inbound-delivery-confirm.ts.
+    if (DELIVERY_CONFIRM_ENABLED) {
+      trackDelivery(deliveryQueue, busyKey, inboundMsg, Date.now())
+    }
+  }
   if (!delivered) {
     pendingInboundBuffer.push(selfAgent, inboundMsg)
     const threadOpts = messageThreadId != null ? { message_thread_id: messageThreadId } : {}

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

@@ -0,0 +1,96 @@
+/**
+ * Reliable inbound delivery: deliver-until-acked (the marko drop-wedge).
+ *
+ * Delivering an inbound to claude is fire-and-forget: the gateway calls
+ * `sendToAgent`, the bridge turns it into an MCP channel notification, and
+ * the unmodified CLI appends the text into its composer and auto-submits
+ * ONLY when the composer is empty + idle. If the message lands while claude
+ * is still finalizing the prior turn, the auto-submit races turn-completion
+ * and the text strands unsubmitted — claude never starts the turn, so the
+ * gateway eventually drops the message at the 300s silence-poke. Observed
+ * recurring on `marko` (supergroup topic + DMs alike).
+ *
+ * This is the queue that makes delivery reliable. The contract is the whole
+ * idea, and it is deliberately small:
+ *
+ *   1. A delivered inbound is ACKED only when claude actually starts the
+ *      turn — the `enqueue` session-event (the one signal that claude truly
+ *      picked the message up). NOT when `sendToAgent` returns true.
+ *   2. Until acked, the message stays tracked. If it hasn't been acked
+ *      within `timeoutMs`, it stranded: re-deliver it (the gateway re-clears
+ *      the composer and re-sends).
+ *   3. Re-deliver as many times as it takes. We never drop the message and
+ *      never give up — a reliable queue keeps the message until it lands.
+ *
+ * Keyed per `chatKey(chatId, threadId)`, so DMs and supergroup forum topics
+ * are handled identically (the key is opaque here). The #1556 gate
+ * serialises delivery per key, so at most one delivery per key is in flight.
+ *
+ * Pure bookkeeping only — the gateway does the actual composer-clear and
+ * re-send for whatever `sweep` returns. Unit-tested in isolation.
+ */
+
+export interface PendingDelivery<M> {
+  /** chatKey(chatId, threadId) — opaque to this module. */
+  readonly key: string
+  /** The exact inbound to re-send until claude acks it. */
+  readonly inbound: M
+  /** When the latest delivery attempt was made (unix-ms). */
+  lastAttemptAt: number
+}
+
+export interface DeliveryQueue<M> {
+  readonly pending: Map<string, PendingDelivery<M>>
+}
+
+export function createDeliveryQueue<M>(): DeliveryQueue<M> {
+  return { pending: new Map() }
+}
+
+/**
+ * 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.
+ */
+export function trackDelivery<M>(
+  q: DeliveryQueue<M>,
+  key: string,
+  inbound: M,
+  now: number,
+): void {
+  q.pending.set(key, { key, inbound, 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.
+ */
+export function ackDelivery<M>(q: DeliveryQueue<M>, key: string): boolean {
+  return q.pending.delete(key)
+}
+
+/**
+ * Return the inbounds that stranded (no ack within `timeoutMs`) and should be
+ * re-delivered now. Resets each returned entry's clock so the next sweep
+ * waits another full `timeoutMs` — the gateway re-sends them. Entries still
+ * within the window are left untouched (claude may yet be picking them up).
+ */
+export function sweep<M>(
+  q: DeliveryQueue<M>,
+  now: number,
+  timeoutMs: number,
+): PendingDelivery<M>[] {
+  const redeliver: PendingDelivery<M>[] = []
+  for (const entry of q.pending.values()) {
+    if (now - entry.lastAttemptAt < timeoutMs) continue
+    entry.lastAttemptAt = now
+    redeliver.push(entry)
+  }
+  return redeliver
+}
+
+/** Forget a key without acking (e.g. the bridge went offline and the message
+ *  was handed back to the offline buffer, which owns it now). */
+export function forgetDelivery<M>(q: DeliveryQueue<M>, key: string): void {
+  q.pending.delete(key)
+}

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

@@ -0,0 +1,109 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  ackDelivery,
+  createDeliveryQueue,
+  forgetDelivery,
+  sweep,
+  trackDelivery,
+  type DeliveryQueue,
+} from '../gateway/inbound-delivery-confirm.js'
+
+/**
+ * Regression coverage for the marko drop-wedge.
+ *
+ * An inbound delivered to claude's TUI composer strands unsubmitted when the
+ * auto-submit races turn-completion. claude never emits `enqueue`, so the
+ * gateway used to sit "typing…" for 300s then DROP the message.
+ *
+ * The queue's contract: a delivered inbound is acked ONLY by `enqueue`; until
+ * then it is re-delivered every `timeoutMs`, forever, never dropped — and an
+ * acked delivery never re-fires (no duplicate turns).
+ */
+type Msg = { text: string }
+const TIMEOUT = 15_000
+
+function fresh(): DeliveryQueue<Msg> {
+  return createDeliveryQueue<Msg>()
+}
+
+describe('inbound-delivery-confirm (reliable deliver-until-acked queue)', () => {
+  it('an acked delivery is never re-delivered (happy path — no duplicate turns)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'hi' }, 1_000)
+    expect(ackDelivery(q, 'chat:_')).toBe(true) // enqueue arrived
+    expect(sweep(q, 1_000 + 999_999, TIMEOUT)).toHaveLength(0)
+    expect(q.pending.size).toBe(0)
+  })
+
+  it('within the timeout, an un-acked delivery is left alone (claude may still be picking it up)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'hi' }, 1_000)
+    expect(sweep(q, 1_000 + 14_999, TIMEOUT)).toHaveLength(0)
+    expect(q.pending.size).toBe(1)
+  })
+
+  it('a strand (no ack) is re-delivered after the timeout, and the clock resets', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'draft nurture email' }, 1_000)
+    const r = sweep(q, 1_000 + 15_000, TIMEOUT)
+    expect(r).toHaveLength(1)
+    expect(r[0]!.inbound.text).toBe('draft nurture email')
+    expect(r[0]!.lastAttemptAt).toBe(1_000 + 15_000) // clock reset
+    // not re-swept until another full timeout elapses
+    expect(sweep(q, 1_000 + 15_000 + 14_999, TIMEOUT)).toHaveLength(0)
+  })
+
+  it('keeps re-delivering forever until acked — never drops (the reliability invariant)', () => {
+    const q = fresh()
+    let t = 0
+    trackDelivery(q, 'chat:_', { text: 'x' }, t)
+    for (let i = 0; i < 50; i++) {
+      t += 15_000
+      expect(sweep(q, t, TIMEOUT)).toHaveLength(1) // still trying after 50 strands
+    }
+    expect(q.pending.size).toBe(1) // never dropped
+    // claude finally picks it up → acked → stops.
+    expect(ackDelivery(q, 'chat:_')).toBe(true)
+    expect(sweep(q, t + 999_999, TIMEOUT)).toHaveLength(0)
+  })
+
+  it('an ack that lands right after a re-delivery stops further re-delivery (no duplicate turns)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'x' }, 0)
+    sweep(q, 15_000, TIMEOUT) // strand → re-delivered
+    expect(ackDelivery(q, 'chat:_')).toBe(true) // the re-delivered copy landed
+    expect(sweep(q, 999_999, TIMEOUT)).toHaveLength(0)
+    expect(q.pending.size).toBe(0)
+  })
+
+  it('keys are independent — a strand on one topic does not affect another (DM + supergroup topics)', () => {
+    const q = fresh()
+    trackDelivery(q, '-100:4', { text: 'crm topic msg' }, 0) // supergroup CRM topic
+    trackDelivery(q, '555:_', { text: 'dm msg' }, 0) // a DM
+    ackDelivery(q, '555:_') // the DM submits fine
+    const r = sweep(q, 15_000, TIMEOUT)
+    expect(r).toHaveLength(1)
+    expect(r[0]!.key).toBe('-100:4') // only the stranded topic re-delivers
+  })
+
+  it('tracking the same key twice keeps only the latest inbound (gate serialises per key)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'first' }, 0)
+    trackDelivery(q, 'chat:_', { text: 'second' }, 100)
+    expect(q.pending.size).toBe(1)
+    expect(sweep(q, 100 + 15_000, TIMEOUT)[0]!.inbound.text).toBe('second')
+  })
+
+  it('ack on an unknown key is a harmless no-op', () => {
+    expect(ackDelivery(fresh(), 'never-tracked')).toBe(false)
+  })
+
+  it('forgetDelivery clears without acking or re-delivering (bridge went offline)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'x' }, 0)
+    forgetDelivery(q, 'chat:_')
+    expect(q.pending.size).toBe(0)
+    expect(sweep(q, 999_999, TIMEOUT)).toHaveLength(0)
+  })
+})