switchroom 0.18.14 → 0.18.17

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

@@ -20534,6 +20534,9 @@ var init_schema = __esm(() => {
       window_ms: exports_external.number().int().nonnegative().optional().describe("Sliding-window (ms) for merging consecutive inbound messages from " + "the same sender+topic into ONE Claude turn. Each new message resets " + "the timer; the turn starts once the sender pauses for this long. " + "Catches forwarded bursts, pasted text the Telegram client split " + "into several messages, and mixed text+media forwards. Default 500. " + "Set 0 to disable (every message becomes its own turn). Raise for " + "users who think in multiple short messages; the trade-off is the " + "single-message turn start is delayed by this much (the \uD83D\uDC40 ack still " + "fires immediately, so perceived latency is unchanged)."),
       max_attachments: exports_external.number().int().positive().optional().describe("Maximum number of media attachments carried into ONE coalesced " + "Claude turn. Default 10 \u2014 a full Telegram album (media_group caps " + "at 10) or a text+multi-image forwarded burst arrives as a single " + "turn; the agent sees numbered attachment fields (image_path, " + "image_path_2, \u2026). Set 1 to restore the historical " + "single-attachment-per-turn behaviour. Excess attachments beyond " + "the cap spill into the next turn. Each attachment is downloaded, " + "so a high cap on a slow link delays turn start.")
     }).optional().describe("Inbound coalescing \u2014 how the gateway groups rapid consecutive messages " + "into a single turn so a forwarded album or split paste doesn't fan out " + "into N separate turns. Cascades from defaults.channels.telegram.coalesce."),
+    litellm_notice: exports_external.object({
+      window_ms: exports_external.number().int().positive().optional().describe("Per-agent cooldown window (ms) for the litellm-local 429 notice. " + "When the agent trips the LiteLLM proxy's OWN tpm_limit/rpm_limit " + "cap (a `litellm-local` classified 429 \u2014 see docs/auth.md \u00a7 " + "LiteLLM-proxy-local 429s), the gateway posts ONE calm notice " + "naming the fleet token limiter, then counts further hits silently " + "for this long; the first notice after the window expires says " + "how many were absorbed. Default 900000 (15 min). Invalid values " + "fall back to the default.")
+    }).optional().describe("Debounce tuning for the litellm-local throttle notice \u2014 the calm " + "'fleet token limiter engaged' message posted when the LiteLLM " + "proxy's own rate cap trips (never an Anthropic account limit). " + "Cascades from defaults.channels.telegram.litellm_notice."),
     interrupt: exports_external.object({
       safe_boundary: exports_external.boolean().optional().describe("When true (the default), a `!`-prefix interrupt that arrives while " + "the agent is mid-tool-call is DEFERRED: the SIGINT and the " + "replacement turn wait until the in-flight tool call finishes (a " + "clean boundary) instead of C-c'ing the agent mid-write/mid-bash. If " + "no tool is in flight the interrupt still fires immediately. Bounded " + "by max_wait_ms so a long tool never strands the user. Set false to " + "fire synchronously the moment `!` is received (historical " + "behaviour). Rapid repeated `!` while one is pending coalesce into a " + "single deferred interrupt carrying the latest body."),
       max_wait_ms: exports_external.number().int().positive().optional().describe("Upper bound (ms) the gateway waits for a safe boundary before firing " + "a deferred `!` interrupt anyway. Only consulted when safe_boundary is " + "true. Default 8000. Keep it short \u2014 the user explicitly asked to " + "interrupt, so a long in-flight tool shouldn't ghost them; the cap " + "trades a tiny risk of a mid-tool C-c for a guaranteed response.")
@@ -40236,6 +40239,60 @@ function renderActivityFeedWithNested(lines, childLines, final = false, liveSuff
   });
 }
 
+// retry-api-call.ts
+var import_grammy = __toESM(require_mod2(), 1);
+var FLOOD_WAIT_ACTIVE = "FLOOD_WAIT_ACTIVE";
+function makeFloodWaitActiveError(retryAfterSec, untilTs, original) {
+  return Object.assign(new Error(FLOOD_WAIT_ACTIVE), {
+    retryAfterSec,
+    untilTs,
+    error_code: 429,
+    parameters: { retry_after: retryAfterSec },
+    original
+  });
+}
+function isFloodWaitActiveError(err) {
+  return err instanceof Error && err.message === FLOOD_WAIT_ACTIVE;
+}
+async function retryWithThreadFallback(retry, send, opts) {
+  try {
+    return await retry(() => send(opts.threadId), {
+      ...opts.threadId != null ? { threadId: opts.threadId } : {},
+      chat_id: opts.chat_id,
+      ...opts.verb != null ? { verb: opts.verb } : {}
+    });
+  } catch (err) {
+    if (err instanceof Error && err.message === "THREAD_NOT_FOUND") {
+      return await retry(() => send(undefined), {
+        chat_id: opts.chat_id,
+        ...opts.verb != null ? { verb: opts.verb } : {}
+      });
+    }
+    throw err;
+  }
+}
+function isHtmlParseRejectError(err) {
+  if (!(err instanceof import_grammy.GrammyError) || err.error_code !== 400)
+    return false;
+  if (isMessageTooLongError(err))
+    return false;
+  const d = (err.description || "").toLowerCase();
+  return d.includes("can't parse entities") || d.includes("can\u2019t parse entities") || d.includes("can't parse") || d.includes("can\u2019t parse") || d.includes("parse markdown") || d.includes("parse rich") || d.includes("unsupported start tag") || d.includes("unclosed start tag") || d.includes("can't find end of the entity") || d.includes("can\u2019t find end of the entity") || d.includes("expected end tag");
+}
+function isMessageTooLongError(err) {
+  if (!(err instanceof import_grammy.GrammyError) || err.error_code !== 400)
+    return false;
+  const d = (err.description || "").toLowerCase();
+  return d.includes("rich_message_text_too_long") || d.includes("message_too_long") || d.includes("text_too_long") || d.includes("message is too long") || d.includes("text is too long");
+}
+
+// send-gate.ts
+var SEND_GATE_SHED = Symbol.for("switchroom.send-gate.shed");
+function isSendGateShed(value) {
+  return value === SEND_GATE_SHED;
+}
+var GROUP_TYPES = new Set(["group", "supergroup"]);
+
 // worker-activity-feed.ts
 function isWorkerActivityFeedEnabled(envVal) {
   return envVal !== "0";
@@ -40310,6 +40367,7 @@ function classifyEditError(err) {
 function createWorkerActivityFeed(opts) {
   const log = opts.log ?? (() => {});
   const nowFn = opts.now ?? Date.now;
+  const floodWaitRemainingMs = opts.floodWaitRemainingMs ?? (() => 0);
   const minEditInterval = opts.minEditIntervalMs ?? 2500;
   const firstPaintMin = opts.firstPaintMinMs ?? 8000;
   const heartbeatTickMs = opts.heartbeatTickMs ?? 6000;
@@ -40347,6 +40405,15 @@ function createWorkerActivityFeed(opts) {
     h.cooldownUntil = nowFn() + retryAfter * 1000 + COOLDOWN_JITTER_MS;
     log(`worker-feed: ${label} 429 \u2014 backing off ${retryAfter}s`);
   }
+  function parkIfFloodWindowOpen(h) {
+    const remaining = floodWaitRemainingMs();
+    if (remaining <= 0)
+      return false;
+    const until = nowFn() + remaining + COOLDOWN_JITTER_MS;
+    if (until > h.cooldownUntil)
+      h.cooldownUntil = until;
+    return true;
+  }
   function accumulateNarrative(h, view) {
     const line = view.latestSummary.trim();
     if (line.length === 0)
@@ -40367,12 +40434,19 @@ function createWorkerActivityFeed(opts) {
       h.dispatchAtMs = nowFn() - view.elapsedMs;
     if (nowFn() < h.cooldownUntil)
       return;
+    if (parkIfFloodWindowOpen(h))
+      return;
     const body = renderWorkerActivity(merged, liveSuffix);
     if (h.messageId == null) {
       if (view.elapsedMs < firstPaintMin)
         return;
       try {
         const sent = await opts.bot.sendMessage(h.chatId, body, sendOptsFor(h));
+        if (sent == null || typeof sent.message_id !== "number") {
+          parkIfFloodWindowOpen(h);
+          log(`worker-feed: first paint shed by send gate agent=${h.agentId} \u2014 not delivered`);
+          return;
+        }
         h.messageId = sent.message_id;
         h.lastBody = body;
         h.lastEditAt = nowFn();
@@ -40388,7 +40462,11 @@ function createWorkerActivityFeed(opts) {
     if (nowFn() - h.lastEditAt < minEditInterval)
       return;
     try {
-      await opts.bot.editMessageText(h.chatId, h.messageId, body, sendOptsFor(h));
+      const res = await opts.bot.editMessageText(h.chatId, h.messageId, body, sendOptsFor(h));
+      if (isSendGateShed(res)) {
+        parkIfFloodWindowOpen(h);
+        return;
+      }
       h.lastBody = body;
       h.lastEditAt = nowFn();
       log(`worker-feed: edit agent=${h.agentId} chat=${h.chatId} ` + `thread=${h.threadId ?? "-"} msgId=${h.messageId} bytes=${body.length}`);
@@ -40418,7 +40496,7 @@ function createWorkerActivityFeed(opts) {
       h.pendingFinish = null;
       return;
     }
-    if (nowFn() < h.cooldownUntil) {
+    if (parkIfFloodWindowOpen(h) || nowFn() < h.cooldownUntil) {
       h.pendingFinish = view;
       return;
     }
@@ -40428,7 +40506,12 @@ function createWorkerActivityFeed(opts) {
       return;
     }
     try {
-      await opts.bot.editMessageText(h.chatId, h.messageId, body, sendOptsFor(h));
+      const res = await opts.bot.editMessageText(h.chatId, h.messageId, body, sendOptsFor(h));
+      if (isSendGateShed(res)) {
+        parkIfFloodWindowOpen(h);
+        h.pendingFinish = view;
+        return;
+      }
       h.lastBody = body;
       h.lastEditAt = nowFn();
       h.pendingFinish = null;
@@ -41022,55 +41105,6 @@ var STALE_TAP_NOTICE = "This request already resolved (timed out) \u2014 ask aga
 var import_grammy2 = __toESM(require_mod2(), 1);
 var import_runner = __toESM(require_mod4(), 1);
 import { AsyncLocalStorage } from "async_hooks";
-
-// retry-api-call.ts
-var import_grammy = __toESM(require_mod2(), 1);
-var FLOOD_WAIT_ACTIVE = "FLOOD_WAIT_ACTIVE";
-function makeFloodWaitActiveError(retryAfterSec, untilTs, original) {
-  return Object.assign(new Error(FLOOD_WAIT_ACTIVE), {
-    retryAfterSec,
-    untilTs,
-    error_code: 429,
-    parameters: { retry_after: retryAfterSec },
-    original
-  });
-}
-function isFloodWaitActiveError(err) {
-  return err instanceof Error && err.message === FLOOD_WAIT_ACTIVE;
-}
-async function retryWithThreadFallback(retry, send, opts) {
-  try {
-    return await retry(() => send(opts.threadId), {
-      ...opts.threadId != null ? { threadId: opts.threadId } : {},
-      chat_id: opts.chat_id,
-      ...opts.verb != null ? { verb: opts.verb } : {}
-    });
-  } catch (err) {
-    if (err instanceof Error && err.message === "THREAD_NOT_FOUND") {
-      return await retry(() => send(undefined), {
-        chat_id: opts.chat_id,
-        ...opts.verb != null ? { verb: opts.verb } : {}
-      });
-    }
-    throw err;
-  }
-}
-function isHtmlParseRejectError(err) {
-  if (!(err instanceof import_grammy.GrammyError) || err.error_code !== 400)
-    return false;
-  if (isMessageTooLongError(err))
-    return false;
-  const d = (err.description || "").toLowerCase();
-  return d.includes("can't parse entities") || d.includes("can\u2019t parse entities") || d.includes("can't parse") || d.includes("can\u2019t parse") || d.includes("parse markdown") || d.includes("parse rich") || d.includes("unsupported start tag") || d.includes("unclosed start tag") || d.includes("can't find end of the entity") || d.includes("can\u2019t find end of the entity") || d.includes("expected end tag");
-}
-function isMessageTooLongError(err) {
-  if (!(err instanceof import_grammy.GrammyError) || err.error_code !== 400)
-    return false;
-  const d = (err.description || "").toLowerCase();
-  return d.includes("rich_message_text_too_long") || d.includes("message_too_long") || d.includes("text_too_long") || d.includes("message is too long") || d.includes("text is too long");
-}
-
-// shared/bot-runtime.ts
 init_flood_circuit_breaker();
 
 // shared/gw-trace-gate.ts
@@ -45307,6 +45341,12 @@ function createTypingEmitter(deps) {
 
 // draft-stream.ts
 var TELEGRAM_MAX_CHARS = 32768;
+function makeDraftEditShedError(messageId) {
+  return Object.assign(new Error(`draft edit shed by send gate (id=${messageId ?? "unknown"}); snapshot preserved for re-flush`), { draftEditShed: true });
+}
+function isDraftEditShedError(err) {
+  return err instanceof Error && err.draftEditShed === true;
+}
 var DEFAULT_DM_THROTTLE_MS = 400;
 var DEFAULT_GROUP_THROTTLE_MS = 1000;
 var MIN_THROTTLE_MS = 250;
@@ -45325,6 +45365,7 @@ function createDraftStream(send, edit, config = {}) {
   let messageId = config.initialMessageId ?? null;
   let pendingText = null;
   let lastSentText = null;
+  let shedText = null;
   let lastSentAt = 0;
   let inFlight = null;
   const streamStartedAt = Date.now();
@@ -45368,11 +45409,16 @@ function createDraftStream(send, edit, config = {}) {
       await sendViaMessage(textToSend);
       lastSentText = textToSend;
       lastSentAt = Date.now();
+      shedText = null;
     } catch (err) {
       const msg = err.message ?? String(err);
-      if (/\bmessage is not modified\b/i.test(msg)) {
+      if (isDraftEditShedError(err)) {
+        shedText = textToSend;
+        log?.(`stream \u2192 shed by send gate (id: ${messageId}); snapshot preserved for re-flush`);
+      } else if (/\bmessage is not modified\b/i.test(msg)) {
         lastSentText = textToSend;
         lastSentAt = Date.now();
+        shedText = null;
         log?.(`stream \u2192 not modified (id: ${messageId})`);
       } else if (/\bmessage to edit not found\b/i.test(msg) || /\bMESSAGE_ID_INVALID\b/i.test(msg)) {
         log?.(`stream \u2192 message not found (id: ${messageId}), re-sending`);
@@ -45465,10 +45511,12 @@ function createDraftStream(send, edit, config = {}) {
       }
       return waitPromise;
     },
-    async finalize() {
+    async finalize(finalText) {
       if (final)
         return;
       final = true;
+      if (finalText != null && !stopped)
+        pendingText = finalText;
       if (scheduledTimer != null) {
         clearTimeout(scheduledTimer);
         scheduledTimer = null;
@@ -45476,6 +45524,10 @@ function createDraftStream(send, edit, config = {}) {
       if (inFlight) {
         await inFlight;
       }
+      if (pendingText == null && shedText != null && !stopped) {
+        pendingText = shedText;
+      }
+      shedText = null;
       if (pendingText != null && !stopped) {
         await flush();
       }
@@ -54912,28 +54964,41 @@ function createStreamController(cfg) {
       return bot.api.editMessageText(chatId, id, piece.text, opts);
     return bot.api.editMessageText(chatId, id, richMessage(piece.text), opts);
   };
+  let handleRef = null;
+  const editGateOpts = (id, payload) => ({
+    threadId,
+    chat_id: chatId,
+    messageId: id,
+    editPayload: payload,
+    priorityClass: handleRef?.isFinal() === true ? "critical" : "cosmetic"
+  });
+  const piecePayload = (piece) => piece.rich ? richMessage(piece.text) : piece.text;
   const tailIds = [];
   const tailLastText = [];
   const upsertTail = async (ti, piece) => {
     const existingId = tailIds[ti];
     if (existingId != null) {
       if (tailLastText[ti] === piece.text)
-        return;
+        return false;
       try {
-        await retry(() => editPiece(existingId, piece, baseOpts), { threadId, chat_id: chatId });
+        const res = await retry(() => editPiece(existingId, piece, baseOpts), editGateOpts(existingId, piecePayload(piece)));
+        if (isSendGateShed(res))
+          return true;
         tailLastText[ti] = piece.text;
         onEdit?.(existingId, piece.text.length);
       } catch (err) {
         if (!literalText && piece.rich && isParseEntitiesError(err)) {
           warn?.(`stream-controller: tail-piece #${ti + 1} edit parse-entities rejected \u2014 retrying same id=${existingId} as plain text (${err instanceof Error ? err.message : String(err)})`);
-          await retry(() => bot.api.editMessageText(chatId, existingId, piece.text, baseOpts), { threadId, chat_id: chatId });
+          const res = await retry(() => bot.api.editMessageText(chatId, existingId, piece.text, baseOpts), editGateOpts(existingId, piece.text));
+          if (isSendGateShed(res))
+            return true;
           tailLastText[ti] = piece.text;
           onEdit?.(existingId, piece.text.length);
         } else {
           warn?.(`stream-controller: tail-piece #${ti + 1} edit FAILED (id=${existingId}) \u2014 partial delivery, this piece may be stale (${err instanceof Error ? err.message : String(err)})`);
         }
       }
-      return;
+      return false;
     }
     try {
       const sent = await retry(() => sendPiece(piece, sendOpts), { threadId, chat_id: chatId });
@@ -54951,8 +55016,9 @@ function createStreamController(cfg) {
         warn?.(`stream-controller: tail-piece #${ti + 1} send FAILED \u2014 partial delivery, this and later pieces may be missing this flush (${err instanceof Error ? err.message : String(err)})`);
       }
     }
+    return false;
   };
-  return createDraftStream(async (text4) => {
+  const handle = createDraftStream(async (text4) => {
     const pieces = renderPieces(text4);
     const head = pieces[0];
     let anchorId;
@@ -54977,22 +55043,34 @@ function createStreamController(cfg) {
   }, async (id, text4) => {
     const pieces = renderPieces(text4);
     const head = pieces[0];
+    let anchorShed = false;
     try {
-      await retry(() => editPiece(id, head, baseOpts), { threadId, chat_id: chatId });
-      onEdit?.(id, head.text.length);
+      const res = await retry(() => editPiece(id, head, baseOpts), editGateOpts(id, piecePayload(head)));
+      if (isSendGateShed(res)) {
+        anchorShed = true;
+      } else {
+        onEdit?.(id, head.text.length);
+      }
     } catch (err) {
       if (!literalText && head.rich && isParseEntitiesError(err)) {
         warn?.(`stream-controller: edit parse-entities rejected \u2014 retrying same id=${id} as plain text (${err instanceof Error ? err.message : String(err)})`);
         const fallbackBody = pieces.length === 1 ? text4 : head.text;
-        await retry(() => bot.api.editMessageText(chatId, id, fallbackBody, baseOpts), { threadId, chat_id: chatId });
-        onEdit?.(id, head.text.length);
+        const res = await retry(() => bot.api.editMessageText(chatId, id, fallbackBody, baseOpts), editGateOpts(id, fallbackBody));
+        if (isSendGateShed(res))
+          anchorShed = true;
+        else
+          onEdit?.(id, head.text.length);
       } else {
         throw err;
       }
     }
+    let anyTailShed = false;
     for (let pi = 1;pi < pieces.length; pi++) {
-      await upsertTail(pi - 1, pieces[pi]);
+      if (await upsertTail(pi - 1, pieces[pi]))
+        anyTailShed = true;
     }
+    if (anchorShed || anyTailShed)
+      throw makeDraftEditShedError(id);
   }, {
     ...throttleMs != null ? { throttleMs } : {},
     ...idleMs != null ? { idleMs } : {},
@@ -55002,6 +55080,8 @@ function createStreamController(cfg) {
     ...initialMessageId != null ? { initialMessageId } : {},
     chatId
   });
+  handleRef = handle;
+  return handle;
 }
 
 // pty-partial-handler.ts
@@ -55285,7 +55365,7 @@ var systemClock = {
   sleep: (ms) => new Promise((r) => setTimeout(r, ms))
 };
 var UNTAGGED_SEND_CLASS = "critical";
-
+var SEND_GATE_SHED2 = Symbol.for("switchroom.send-gate.shed");
 class TokenBucket {
   capacity;
   refillPerMs;
@@ -55363,7 +55443,7 @@ function stableStringify(value) {
     return v;
   });
 }
-var GROUP_TYPES = new Set(["group", "supergroup"]);
+var GROUP_TYPES2 = new Set(["group", "supergroup"]);
 function createSendGate(config) {
   const enabled2 = config.enabled;
   const clock = config.clock ?? systemClock;
@@ -55439,7 +55519,7 @@ function createSendGate(config) {
     const buckets = [globalBucket];
     if (opts?.chat_id) {
       buckets.push(chatBucket(opts.chat_id));
-      if (opts.chatType && GROUP_TYPES.has(opts.chatType)) {
+      if (opts.chatType && GROUP_TYPES2.has(opts.chatType)) {
         buckets.push(groupBucket(opts.chat_id));
       }
     }
@@ -55454,7 +55534,7 @@ function createSendGate(config) {
     applyWindow("global", untilTs, true);
     if (opts?.chat_id) {
       applyWindow(`chat:${opts.chat_id}`, untilTs, true);
-      if (opts.chatType && GROUP_TYPES.has(opts.chatType)) {
+      if (opts.chatType && GROUP_TYPES2.has(opts.chatType)) {
         applyWindow(`group:${opts.chat_id}`, untilTs, true);
       }
     }
@@ -55668,7 +55748,7 @@ function createSendGate(config) {
       const msgWait = state.suppressedUntilMs > now ? state.suppressedUntilMs - now : 0;
       if (wait > 0 || msgWait > 0) {
         counters.shed++;
-        return Promise.resolve(undefined);
+        return Promise.resolve(SEND_GATE_SHED2);
       }
     }
     if (state.pending) {
@@ -55713,7 +55793,7 @@ function createSendGate(config) {
     const outcome = await admitPriority(bucketsFor(opts), priority);
     if (outcome.result === "shed") {
       counters.shed++;
-      return;
+      return SEND_GATE_SHED2;
     }
     if (outcome.result === "expired") {
       counters.expired++;
@@ -64640,6 +64720,26 @@ var transientUpstreamSignals = [
   "would exceed your account\u2019s rate limit",
   "would exceed your account's rate limit"
 ];
+var litellmProxyLocal429Signals = [
+  "deployment over user-defined ratelimit",
+  "model rate limit exceeded. tpm limit",
+  "model rate limit exceeded. rpm limit",
+  "deployment over defined rpm limit",
+  "no deployments available for selected model",
+  "litellm rate limit handler",
+  "crossed tpm / rpm",
+  "max parallel request limit reached"
+];
+var litellmV3LimiterSignalPair = ["rate limit exceeded for ", "limit type:"];
+function isLitellmProxyLocal429(text4) {
+  if (typeof text4 !== "string" || text4.length === 0)
+    return false;
+  const sample = text4.length > 16384 ? text4.slice(0, 16384) : text4;
+  const lower = sample.toLowerCase();
+  if (litellmProxyLocal429Signals.some((s) => lower.includes(s)))
+    return true;
+  return litellmV3LimiterSignalPair.every((s) => lower.includes(s));
+}
 function detectModelUnavailable(stderr) {
   if (typeof stderr !== "string" || stderr.length === 0)
     return null;
@@ -64649,6 +64749,10 @@ function detectModelUnavailable(stderr) {
     const resetAt = parseResetTime(sample);
     return resetAt !== undefined ? { kind: "overload", resetAt, raw: stderr } : { kind: "overload", raw: stderr };
   }
+  if (isLitellmProxyLocal429(sample)) {
+    const resetAt = parseResetTime(sample);
+    return resetAt !== undefined ? { kind: "overload", resetAt, raw: stderr } : { kind: "overload", raw: stderr };
+  }
   const quotaSignals = [
     "out of extra usage",
     "extra usage",
@@ -64898,6 +65002,76 @@ function isTransientUpstreamSignal(text4) {
   const lower = sample.toLowerCase();
   return transientUpstreamSignals2.some((s) => lower.includes(s));
 }
+var litellmProxyLocal429Signals2 = [
+  "deployment over user-defined ratelimit",
+  "model rate limit exceeded. tpm limit",
+  "model rate limit exceeded. rpm limit",
+  "deployment over defined rpm limit",
+  "no deployments available for selected model",
+  "litellm rate limit handler",
+  "crossed tpm / rpm",
+  "max parallel request limit reached"
+];
+var litellmV3LimiterSignalPair2 = ["rate limit exceeded for ", "limit type:"];
+function isLitellmProxyLocal4292(text4) {
+  if (typeof text4 !== "string" || text4.length === 0)
+    return false;
+  const sample = text4.length > 16384 ? text4.slice(0, 16384) : text4;
+  const lower = sample.toLowerCase();
+  if (litellmProxyLocal429Signals2.some((s) => lower.includes(s)))
+    return true;
+  return litellmV3LimiterSignalPair2.every((s) => lower.includes(s));
+}
+function parseLitellmLimitDetail(text4, parseTimeNow = new Date) {
+  const empty2 = { limitType: null, limit: null, currentUsage: null, resetAtMs: null };
+  if (typeof text4 !== "string" || text4.length === 0)
+    return empty2;
+  const sample = text4.length > 16384 ? text4.slice(0, 16384) : text4;
+  const lower = sample.toLowerCase();
+  let limitType = null;
+  let limit = null;
+  const eqLimit = lower.match(/\b([tr]pm)[ _]limit[=:]\s*(\d+)/);
+  if (eqLimit) {
+    limitType = eqLimit[1];
+    limit = Number(eqLimit[2]);
+  }
+  if (limitType == null) {
+    const v3Type = lower.match(/limit type:\s*(tokens|requests|max_parallel_requests)/);
+    if (v3Type)
+      limitType = v3Type[1];
+  }
+  if (limit == null) {
+    const v3Limit = lower.match(/current limit:\s*(\d+)/);
+    if (v3Limit)
+      limit = Number(v3Limit[1]);
+  }
+  let currentUsage = null;
+  const usage = lower.match(/current usage=(\d+)/);
+  if (usage)
+    currentUsage = Number(usage[1]);
+  let resetAtMs = null;
+  const resetsAt = sample.match(/limit resets at:\s*(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}) UTC/i);
+  if (resetsAt) {
+    const d = new Date(`${resetsAt[1]}T${resetsAt[2]}Z`);
+    if (!Number.isNaN(d.getTime()))
+      resetAtMs = d.getTime();
+  }
+  if (resetAtMs == null) {
+    const tryAgain = lower.match(/try again in\s+(\d+(?:\.\d+)?)\s*seconds/);
+    if (tryAgain) {
+      const secs = Number(tryAgain[1]);
+      if (Number.isFinite(secs) && secs > 0 && secs < 7 * 24 * 3600) {
+        resetAtMs = parseTimeNow.getTime() + Math.round(secs * 1000);
+      }
+    }
+  }
+  return {
+    limitType,
+    limit: limit != null && Number.isFinite(limit) ? limit : null,
+    currentUsage: currentUsage != null && Number.isFinite(currentUsage) ? currentUsage : null,
+    resetAtMs
+  };
+}
 function parseResetTime2(text4, parseTimeNow = new Date) {
   const lower = text4.toLowerCase();
   const retryAfter = lower.match(/retry[\s-]*after[:\s]+(\d+)\s*(seconds?|s\b|minutes?|m\b|hours?|h\b)?/);
@@ -65034,6 +65208,30 @@ function isAccountScopedThrottle(text4) {
   const lower = sample.toLowerCase();
   return accountScopedThrottleSignals.some((s) => lower.includes(s));
 }
+function classify429Detail(text4) {
+  if (isAccountScopedThrottle(text4))
+    return "account-scoped";
+  if (isLitellmProxyLocal4292(text4))
+    return "litellm-local";
+  return "generic-transient";
+}
+function build429ClassifiedMetric(opts) {
+  const detail = typeof opts.detail === "string" ? opts.detail : "";
+  const litellm = parseLitellmLimitDetail(detail, new Date(opts.now));
+  const anthropicResetMs = parseResetTime2(detail, new Date(opts.now))?.getTime() ?? null;
+  const resetAtMs = anthropicResetMs ?? litellm.resetAtMs;
+  return {
+    kind: "rate_limit_429_classified",
+    agent: opts.agent,
+    classification: opts.classification,
+    action: opts.action,
+    reset_at_ms: resetAtMs,
+    reset_in_ms: resetAtMs != null ? Math.max(0, resetAtMs - opts.now) : null,
+    limit_type: litellm.limitType,
+    limit: litellm.limit,
+    current_usage: litellm.currentUsage
+  };
+}
 var THROTTLE_RETRY_IN_PLACE_MAX_MS_DEFAULT = 5 * 60000;
 var THROTTLE_DEFAULT_WAIT_MS = 60000;
 function throttleRetryInPlaceMaxMs(env = process.env) {
@@ -65207,6 +65405,132 @@ function createThrottleTierRunner(deps) {
   };
 }
 
+// litellm-local-notice.ts
+init_card_format();
+var LITELLM_LOCAL_NOTICE_WINDOW_MS_DEFAULT = 15 * 60000;
+function parseLitellmNoticeWindowMs(raw) {
+  if (typeof raw !== "number")
+    return LITELLM_LOCAL_NOTICE_WINDOW_MS_DEFAULT;
+  if (!Number.isFinite(raw) || raw <= 0)
+    return LITELLM_LOCAL_NOTICE_WINDOW_MS_DEFAULT;
+  return raw;
+}
+
+// litellm-local-notice.ts
+init_card_format();
+var LITELLM_LOCAL_NOTICE_WINDOW_MS_DEFAULT2 = 15 * 60000;
+function initialLitellmLocalNoticeState() {
+  return { lastSentAtMsByAgent: {}, suppressedCountByAgent: {} };
+}
+function evaluateLitellmLocalNotice(prev, agent, now, windowMs = LITELLM_LOCAL_NOTICE_WINDOW_MS_DEFAULT2) {
+  const last = prev.lastSentAtMsByAgent[agent];
+  if (last == null || now - last >= windowMs) {
+    return {
+      send: true,
+      suppressedSinceLastNotice: prev.suppressedCountByAgent[agent] ?? 0,
+      next: {
+        lastSentAtMsByAgent: { ...prev.lastSentAtMsByAgent, [agent]: now },
+        suppressedCountByAgent: { ...prev.suppressedCountByAgent, [agent]: 0 }
+      }
+    };
+  }
+  return {
+    send: false,
+    suppressedSinceLastNotice: 0,
+    next: {
+      lastSentAtMsByAgent: prev.lastSentAtMsByAgent,
+      suppressedCountByAgent: {
+        ...prev.suppressedCountByAgent,
+        [agent]: (prev.suppressedCountByAgent[agent] ?? 0) + 1
+      }
+    }
+  };
+}
+function renderLitellmLocalNotice(opts) {
+  const agent = escapeMarkdown(opts.agent);
+  const n = opts.suppressedSinceLastNotice;
+  const lines = [
+    `\uD83D\uDEA6 **Fleet token limiter engaged** \u2014 **${agent}** hit the local LiteLLM proxy cap (\`tpm_limit\`/\`rpm_limit\`).`,
+    `This is switchroom's own fleet limiter smoothing a burst, not an Anthropic account limit \u2014 nothing is exhausted and no account was touched.`
+  ];
+  if (n > 0) {
+    lines.push(`Throttled ${n} more ${n === 1 ? "time" : "times"} since the last notice.`);
+  }
+  lines.push(`_The turn retries automatically \u2014 no action needed._`);
+  return lines.join(`
+`);
+}
+function buildLitellmLocalNoticeMetric(opts) {
+  return {
+    kind: "litellm_local_429_notice",
+    agent: opts.agent,
+    suppressed_count: opts.suppressedCount,
+    window_ms: opts.windowMs
+  };
+}
+function isLitellmLocalNoticeEligible(classification) {
+  return classification === "litellm-local";
+}
+
+// gateway/litellm-local-notice-wiring.ts
+function decideRateLimitedSurface(opts) {
+  if (isLitellmLocalNoticeEligible(opts.classification))
+    return "litellm-local-notice";
+  return opts.shouldEmitCard(opts.agent) ? "generic-card" : "cooldown-suppressed";
+}
+function createLitellmLocalNoticeRunner(deps) {
+  const now = deps.now ?? (() => Date.now());
+  let state3 = initialLitellmLocalNoticeState();
+  function onRateLimited(classification, agent) {
+    try {
+      if (!isLitellmLocalNoticeEligible(classification))
+        return "skipped";
+      const windowMs = deps.windowMs();
+      const verdict = evaluateLitellmLocalNotice(state3, agent, now(), windowMs);
+      if (!verdict.send) {
+        state3 = verdict.next;
+        deps.log(`[litellm-local-notice] suppressed (cooldown) agent=${agent} ` + `suppressedSoFar=${state3.suppressedCountByAgent[agent] ?? 0}`);
+        return "suppressed";
+      }
+      const chats = deps.listNoticeChats();
+      const markdown = renderLitellmLocalNotice({
+        agent,
+        suppressedSinceLastNotice: verdict.suppressedSinceLastNotice
+      });
+      let issued = 0;
+      for (const chatId of chats) {
+        try {
+          deps.sendNotice(chatId, markdown);
+          issued++;
+        } catch (err) {
+          deps.log(`[litellm-local-notice] send failed chat=${chatId} agent=${agent}: ` + `${err?.message ?? err}`);
+        }
+      }
+      if (issued === 0) {
+        deps.log(`[litellm-local-notice] no sends issued (chats=${chats.length}) agent=${agent} \u2014 ` + `window not armed, will retry on the next event`);
+        return "skipped";
+      }
+      state3 = verdict.next;
+      deps.emitMetric(buildLitellmLocalNoticeMetric({
+        agent,
+        suppressedCount: verdict.suppressedSinceLastNotice,
+        windowMs
+      }));
+      deps.log(`[litellm-local-notice] posted agent=${agent} chats=${issued} ` + `suppressedSinceLast=${verdict.suppressedSinceLastNotice} windowMs=${windowMs}`);
+      return "sent";
+    } catch (err) {
+      try {
+        deps.log(`[litellm-local-notice] error agent=${agent}: ${err?.message ?? err}`);
+      } catch {}
+      return "skipped";
+    }
+  }
+  return {
+    onRateLimited,
+    inspect: () => ({ state: state3 })
+  };
+}
+
 // auto-fallback-fleet.ts
 init_card_format();
 init_auth_snapshot_format();
@@ -68516,7 +68840,22 @@ function parseModelCommand(text4) {
   }
   return { kind: "set", model: arg };
 }
-var PERSIST_NOTE = "_Sticky \u2014 persists across restarts, deploys, and crashes until `/model default` clears it (or the configured `model:` in switchroom.yaml changes, which resets it and notifies you). To change the default, set `model:` in switchroom.yaml._";
+function isModelCommandBusy(ctx) {
+  return ctx.currentTurnActive || ctx.turnInFlight;
+}
+function planModelCommand(parsed, ctx) {
+  if (parsed.kind === "show" && ctx.menuEnabled)
+    return { kind: "menu" };
+  if (parsed.kind === "set" && isModelCommandBusy(ctx)) {
+    return { kind: "queue", target: expandSrAlias(parsed.model) };
+  }
+  return { kind: "apply", parsed };
+}
+function modelCommandReceiptLine(agent, parsed, busy) {
+  const arg = parsed.kind === "set" ? parsed.model : parsed.kind === "show" ? "(show)" : "(help)";
+  return `telegram gateway: gw /model received agent=${agent} kind=${parsed.kind} arg=${arg} busy=${busy}`;
+}
+var PERSIST_NOTE = "_Session-only \u2014 this override lasts until the agent\u2019s next restart, then reverts to the configured `model:`. `/model default` clears it now. To change the default permanently, set `model:` in switchroom.yaml._";
 function helpText2(deps, reason) {
   const srAliasExamples = Object.keys(SR_MODEL_ALIASES).map((a) => `\`${a}\``).join(" \u00b7 ");
   const lines = [];
@@ -69070,12 +69409,7 @@ function isValidModelArg2(arg) {
 
 // gateway/session-model-file.ts
 var SESSION_MODEL_FILE = ".session-model";
-var RELAUNCH_MODEL_INTENT_FILE = ".relaunch-model-intent";
 var CONFIGURED_DEFAULT_MODEL_FILE = ".configured-default-model";
-var SESSION_MODEL_BOOT_ATTEMPTS_FILE = ".session-model-boot-attempts";
-function intentForRestartReason(_reason) {
-  return "keep";
-}
 function atomicWrite(path2, content3) {
   const tmp = `${path2}.tmp-${process.pid}-${Date.now()}`;
   writeFileSync21(tmp, content3, "utf8");
@@ -69089,17 +69423,6 @@ function serializeSessionModel(rec) {
   })}
 `;
 }
-function parseSessionModel(text4) {
-  try {
-    const raw = JSON.parse(text4);
-    if (typeof raw.model !== "string" || typeof raw.configuredDefaultAtWrite !== "string" || typeof raw.ts !== "number" || !isValidModelArg2(raw.model)) {
-      return null;
-    }
-    return { model: raw.model, configuredDefaultAtWrite: raw.configuredDefaultAtWrite, ts: raw.ts };
-  } catch {
-    return null;
-  }
-}
 function writeSessionModelFile(agentDir, model, configuredDefaultAtWrite) {
   if (!isValidModelArg2(model)) {
     throw new Error(`refusing to persist non-canonical session model token: ${JSON.stringify(model)}`);
@@ -69113,20 +69436,9 @@ function readSessionModelFileRaw(agentDir) {
     return null;
   }
 }
-function readSessionModelFile(agentDir) {
-  const raw = readSessionModelFileRaw(agentDir);
-  return raw == null ? null : parseSessionModel(raw);
-}
 function clearSessionModelFile(agentDir) {
   try {
     rmSync4(join29(agentDir, SESSION_MODEL_FILE), { force: true });
-    rmSync4(join29(agentDir, ".session-model-kept-notified"), { force: true });
-    rmSync4(join29(agentDir, SESSION_MODEL_BOOT_ATTEMPTS_FILE), { force: true });
-  } catch {}
-}
-function clearSessionModelBootAttempts(agentDir) {
-  try {
-    rmSync4(join29(agentDir, SESSION_MODEL_BOOT_ATTEMPTS_FILE), { force: true });
   } catch {}
 }
 function restoreSessionModelFileRaw(agentDir, raw) {
@@ -69138,40 +69450,6 @@ function restoreSessionModelFileRaw(agentDir, raw) {
     atomicWrite(join29(agentDir, SESSION_MODEL_FILE), raw);
   } catch {}
 }
-function writeRelaunchModelIntent(agentDir, intent, reason) {
-  try {
-    atomicWrite(join29(agentDir, RELAUNCH_MODEL_INTENT_FILE), `${JSON.stringify({ intent, reason, ts: Date.now() })}
-`);
-  } catch (err) {
-    process.stderr.write(`telegram gateway: relaunch-model-intent write failed (boot will revert): ${err?.message ?? String(err)}
-`);
-  }
-}
-var GATEWAY_SHUTDOWN_INTENT_REASON_PREFIX = "gateway-shutdown:";
-function readRelaunchModelIntent(agentDir) {
-  try {
-    const raw = readFileSync25(join29(agentDir, RELAUNCH_MODEL_INTENT_FILE), "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.intent !== "keep" && parsed.intent !== "revert" || typeof parsed.reason !== "string" || typeof parsed.ts !== "number") {
-      return null;
-    }
-    return { intent: parsed.intent, reason: parsed.reason, ts: parsed.ts };
-  } catch {
-    return null;
-  }
-}
-function clearStaleGatewayShutdownIntent(agentDir) {
-  const rec = readRelaunchModelIntent(agentDir);
-  if (rec == null || !rec.reason.startsWith(GATEWAY_SHUTDOWN_INTENT_REASON_PREFIX))
-    return false;
-  clearRelaunchModelIntent(agentDir);
-  return true;
-}
-function clearRelaunchModelIntent(agentDir) {
-  try {
-    rmSync4(join29(agentDir, RELAUNCH_MODEL_INTENT_FILE), { force: true });
-  } catch {}
-}
 function readConfiguredDefaultModel(agentDir) {
   try {
     const v = readFileSync25(join29(agentDir, CONFIGURED_DEFAULT_MODEL_FILE), "utf8").trim();
@@ -69182,17 +69460,6 @@ function readConfiguredDefaultModel(agentDir) {
 }
 var SESSION_EFFORT_FILE = ".session-effort";
 var EFFORT_LEVEL_RE = /^(low|medium|high|xhigh|max)$/;
-function parseSessionEffort(text4) {
-  try {
-    const raw = JSON.parse(text4);
-    if (typeof raw.level !== "string" || typeof raw.configuredDefaultAtWrite !== "string" || typeof raw.ts !== "number" || !EFFORT_LEVEL_RE.test(raw.level)) {
-      return null;
-    }
-    return { level: raw.level, configuredDefaultAtWrite: raw.configuredDefaultAtWrite, ts: raw.ts };
-  } catch {
-    return null;
-  }
-}
 function writeSessionEffortFile(agentDir, level, configuredDefaultAtWrite) {
   if (!EFFORT_LEVEL_RE.test(level)) {
     throw new Error(`refusing to persist non-allowlisted effort level: ${JSON.stringify(level)}`);
@@ -69200,13 +69467,6 @@ function writeSessionEffortFile(agentDir, level, configuredDefaultAtWrite) {
   atomicWrite(join29(agentDir, SESSION_EFFORT_FILE), `${JSON.stringify({ level, configuredDefaultAtWrite: configuredDefaultAtWrite ?? "", ts: Date.now() })}
 `);
 }
-function readSessionEffortFile(agentDir) {
-  try {
-    return parseSessionEffort(readFileSync25(join29(agentDir, SESSION_EFFORT_FILE), "utf8"));
-  } catch {
-    return null;
-  }
-}
 function clearSessionEffortFile(agentDir) {
   try {
     rmSync4(join29(agentDir, SESSION_EFFORT_FILE), { force: true });
@@ -69426,6 +69686,11 @@ function extractConfirmation(pane) {
 // ../src/agents/scaffold.ts
 import { join as join32, resolve as resolve6 } from "node:path";
 init_atomic();
+
+// ../src/agents/agent-uid.ts
+init_peercred();
+
+// ../src/agents/scaffold.ts
 init_schema();
 
 // ../src/config/users.ts
@@ -69576,7 +69841,7 @@ function parseEffortCommand(text4) {
   }
   return { kind: "set", level: arg.toLowerCase() };
 }
-var PERSIST_NOTE2 = "_Sticky \u2014 persists across restarts and deploys until `/effort default` clears it. To change the configured default, set `thinking_effort:` in switchroom.yaml._";
+var PERSIST_NOTE2 = "_Session-only \u2014 this override lasts until the agent\u2019s next restart, then reverts to the configured `thinking_effort:`. `/effort default` clears it now. To change the default permanently, set `thinking_effort:` in switchroom.yaml._";
 var LEVELS_INLINE = EFFORT_LEVELS.map((l) => `\`${l}\``).join(" \u00b7 ");
 function helpText3(deps, reason) {
   const lines = [];
@@ -77097,6 +77362,7 @@ function detectErrorInTranscriptLine(line) {
     const errStr = typeof obj.error === "string" ? obj.error : "";
     const text4 = extractAssistantText(obj);
     const kind2 = status === 429 ? isTransientUpstreamSignal(`${text4}
+${errStr}`) || isLitellmProxyLocal4292(`${text4}
 ${errStr}`) ? "rate-limited" : "quota-exhausted" : classifyClaudeError({ type: errStr, status, message: text4 });
     return {
       kind: kind2,
@@ -80620,7 +80886,8 @@ function buildFleetRollMessage(roll, now) {
   const pctPart = typeof roll.pct === "number" ? ` at ${fmtPct(roll.pct)}` : "";
   const resetPart = typeof roll.exhausted_until === "number" && roll.exhausted_until > now ? ` (resets ${formatRelative(new Date(roll.exhausted_until), new Date(now))})` : "";
   const softAvoid = roll.reason === "soft-avoid";
-  const causeLine = softAvoid ? `Proactive switch \u2014 \`${codeSpanSafe(roll.from)}\` is approaching its limits (${winLabel}${pctPart})${resetPart}, so the fleet moved early instead of hitting the wall.` : `${winLabel}${pctPart} on \`${codeSpanSafe(roll.from)}\`${resetPart}.`;
+  const modelTierWall = roll.reason === "model-tier-wall";
+  const causeLine = softAvoid ? `Proactive switch \u2014 \`${codeSpanSafe(roll.from)}\` is approaching its limits (${winLabel}${pctPart})${resetPart}, so the fleet moved early instead of hitting the wall.` : modelTierWall ? `Flagship (premium) tier weekly limit reached on \`${codeSpanSafe(roll.from)}\`${resetPart} \u2014 opus/haiku on that account are unaffected.` : `${winLabel}${pctPart} on \`${codeSpanSafe(roll.from)}\`${resetPart}.`;
   return [
     `\uD83D\uDD01 **Switched fleet to \`${codeSpanSafe(roll.to)}\`**`,
     ``,
@@ -80957,10 +81224,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.18.14";
-var COMMIT_SHA = "b0db04aa";
-var COMMIT_DATE = "2026-07-12T12:40:07+10:00";
-var LATEST_PR = 3165;
+var VERSION = "0.18.17";
+var COMMIT_SHA = "372a4968";
+var COMMIT_DATE = "2026-07-12T09:18:05Z";
+var LATEST_PR = 3190;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -82845,11 +83112,6 @@ function triggerSelfRestart(targetAgent, reason, delayMs = 300) {
 `);
       return false;
     }
-    {
-      const smDir = resolveAgentDirFromEnv();
-      if (smDir)
-        writeRelaunchModelIntent(smDir, intentForRestartReason(reason), reason);
-    }
     process.stderr.write(`telegram gateway: restart-via-SIGTERM-PID1 agent=${targetAgent} reason=${reason} (docker)
 `);
     setTimeout(() => {
@@ -82862,11 +83124,6 @@ function triggerSelfRestart(targetAgent, reason, delayMs = 300) {
     }, delayMs).unref();
     return true;
   }
-  if (targetAgent === selfAgent) {
-    const smDir = resolveAgentDirFromEnv();
-    if (smDir)
-      writeRelaunchModelIntent(smDir, intentForRestartReason(reason), reason);
-  }
   process.stderr.write(`telegram gateway: restart-via-systemctl agent=${targetAgent} reason=${reason}
 `);
   try {
@@ -82881,13 +83138,6 @@ function triggerSelfRestart(targetAgent, reason, delayMs = 300) {
     return false;
   }
 }
-{
-  const bootSmDir = resolveAgentDirFromEnv();
-  if (bootSmDir != null && clearStaleGatewayShutdownIntent(bootSmDir)) {
-    process.stderr.write(`telegram gateway: cleared stale gateway-shutdown relaunch-model intent (previous bounce was gateway-only \u2014 container never restarted)
-`);
-  }
-}
 var cachedClaudeCliVersion = undefined;
 function getClaudeCliVersion() {
   if (cachedClaudeCliVersion !== undefined)
@@ -83091,6 +83341,7 @@ function readAccessFile() {
       parseMode: parsed.parseMode,
       disableLinkPreview: parsed.disableLinkPreview,
       coalescingGapMs: parsed.coalescingGapMs,
+      litellmNoticeWindowMs: parsed.litellmNoticeWindowMs,
       coalesceMaxAttachments: parsed.coalesceMaxAttachments,
       interruptSafeBoundary: parsed.interruptSafeBoundary,
       interruptMaxWaitMs: parsed.interruptMaxWaitMs,
@@ -85647,12 +85898,52 @@ function emitGatewayOperatorEvent(event) {
   const { agent, kind } = event;
   let throttleEscalation = null;
   let escalationFired = false;
-  if (kind === "rate-limited" && isAccountScopedThrottle(event.detail)) {
+  let rateLimitedCooldownConsulted = false;
+  const rateLimit429Classification = kind === "rate-limited" ? classify429Detail(event.detail) : null;
+  if (rateLimit429Classification != null && rateLimit429Classification !== "account-scoped") {
+    emitRuntimeMetric(build429ClassifiedMetric({
+      agent,
+      detail: event.detail,
+      classification: rateLimit429Classification,
+      action: "calm",
+      now: Date.now()
+    }));
+    const surface = decideRateLimitedSurface({
+      classification: rateLimit429Classification,
+      agent,
+      shouldEmitCard: (a) => shouldEmitOperatorEvent(a, "rate-limited")
+    });
+    if (surface === "litellm-local-notice") {
+      process.stderr.write(`telegram gateway: 429 classified litellm-proxy-local agent=${agent} \u2014 ` + `calm path, no account attribution, no failover
+`);
+      const outcome = litellmLocalNoticeRunner.onRateLimited("litellm-local", agent);
+      if (outcome === "sent") {
+        try {
+          recordOperatorEvent(event);
+        } catch {}
+      }
+      return;
+    }
+    if (surface === "cooldown-suppressed") {
+      process.stderr.write(`telegram gateway: operator-event suppressed (cooldown) agent=${agent} kind=${kind}
+`);
+      return;
+    }
+    rateLimitedCooldownConsulted = true;
+  }
+  if (rateLimit429Classification === "account-scoped") {
     const throttleDecision = decideThrottleTier({
       detail: event.detail,
       now: Date.now(),
       thresholdMs: throttleRetryInPlaceMaxMs()
     });
+    emitRuntimeMetric(build429ClassifiedMetric({
+      agent,
+      detail: event.detail,
+      classification: "account-scoped",
+      action: throttleDecision.action === "failover" ? "failover" : "throttle",
+      now: Date.now()
+    }));
     if (throttleDecision.action === "throttle") {
       process.stderr.write(`telegram gateway: throttle-tier staying-put agent=${agent} until=${new Date(throttleDecision.throttledUntilMs).toISOString()} parsedReset=${throttleDecision.resetParsed}
 `);
@@ -85671,7 +85962,7 @@ function emitGatewayOperatorEvent(event) {
       }
     }
   }
-  if (!shouldEmitOperatorEvent(agent, kind)) {
+  if (!rateLimitedCooldownConsulted && !shouldEmitOperatorEvent(agent, kind)) {
     process.stderr.write(`telegram gateway: operator-event suppressed (cooldown) agent=${agent} kind=${kind}
 `);
     return;
@@ -86769,11 +87060,6 @@ var ipcServer = createIpcServer({
     }
     const bridgeUpEffects = client3.agentName != null ? shadowEmit({ kind: "bridgeUp", at: Date.now() }) : [];
     bridgeDeadWatchdog.noteBridgeRegistered(client3.agentName);
-    if (client3.agentName != null) {
-      const smBootDir = resolveAgentDirFromEnv();
-      if (smBootDir != null)
-        clearSessionModelBootAttempts(smBootDir);
-    }
     client3.send({ type: "status", status: "agent_connected" });
     if (client3.agentName != null) {
       if (isDispatchEnabled()) {
@@ -92842,11 +93128,6 @@ function buildModelDeps(restartCtx) {
         });
       }
       stampUserRestartReason(reason);
-      {
-        const smDir = resolveAgentDirFromEnv();
-        if (smDir)
-          writeRelaunchModelIntent(smDir, "keep", reason);
-      }
       await sweepBeforeSelfRestart();
       const hostdResp = await tryHostdDispatch2(name, {
         v: 1,
@@ -92861,11 +93142,6 @@ function buildModelDeps(restartCtx) {
       }
       if (hostdResp.result !== "started" && hostdResp.result !== "completed") {
         clearRestartMarker();
-        {
-          const smDir = resolveAgentDirFromEnv();
-          if (smDir)
-            clearRelaunchModelIntent(smDir);
-        }
         throw new Error(`hostd restart failed (result=${hostdResp.result}): ${hostdResp.error ?? "(no details)"}`);
       }
     },
@@ -92883,7 +93159,6 @@ function buildModelDeps(restartCtx) {
         if (err?.code !== "restart_in_flight") {
           restoreSessionModelFileRaw(agentDir, prevFileRaw);
           sessionModelSource.setOverride(prevOverride);
-          clearRelaunchModelIntent(agentDir);
         }
         throw err;
       }
@@ -92902,12 +93177,12 @@ function modelMenuReplyMarkup(reply) {
   }
   return kb;
 }
-function recordTypedModelSwitch(reply, requestedModelArg, deps) {
+function recordTypedModelSwitch(reply, requestedModelArg, _deps) {
   const requested = requestedModelArg != null ? expandSrAlias(requestedModelArg) : null;
   if (requested?.toLowerCase() === "default") {
-    const smDir2 = resolveAgentDirFromEnv();
-    if (smDir2)
-      clearSessionModelFile(smDir2);
+    const smDir = resolveAgentDirFromEnv();
+    if (smDir)
+      clearSessionModelFile(smDir);
     if (reply.selectedModel)
       sessionModelSource.setOverride(null);
     return "";
@@ -92915,33 +93190,11 @@ function recordTypedModelSwitch(reply, requestedModelArg, deps) {
   if (!reply.selectedModel)
     return "";
   sessionModelSource.setOverride(reply.selectedModel);
-  const smDir = resolveAgentDirFromEnv();
-  if (smDir && requested && isValidModelArg(requested) && !isSrModel(requested)) {
-    try {
-      writeSessionModelFile(smDir, requested, readConfiguredDefaultModel(smDir) ?? resolveMainModel(deps.getConfiguredModel() ?? undefined));
-    } catch (err) {
-      process.stderr.write(`telegram gateway: session-model persist failed (typed /model): ${err?.message ?? String(err)}
-`);
-      return `
-\u26A0\uFE0F Couldn\u2019t persist the sticky override \u2014 the switch is live now but won\u2019t survive a relaunch.`;
-    }
-  }
   return "";
 }
 function recordModelMenuSideEffects(outcome, modelDeps, cbChatId, cbThreadId, prevSessionModel) {
   if (outcome.selectedModel) {
     sessionModelSource.setOverride(outcome.selectedModel);
-    const smDir = resolveAgentDirFromEnv();
-    if (smDir && outcome.selectedModelToken) {
-      try {
-        writeSessionModelFile(smDir, outcome.selectedModelToken, readConfiguredDefaultModel(smDir) ?? resolveMainModel(modelDeps.getConfiguredModel() ?? undefined));
-      } catch (err) {
-        outcome.reply.text += `
-\u26A0\uFE0F Couldn\u2019t persist the sticky override \u2014 the switch is live now but won\u2019t survive a relaunch.`;
-        process.stderr.write(`telegram gateway: session-model persist failed (menu): ${err?.message ?? String(err)}
-`);
-      }
-    }
   }
   if (outcome.clearedDefault) {
     const smDir = resolveAgentDirFromEnv();
@@ -93038,7 +93291,6 @@ function persistQueuedCommandForRestart(action) {
         }
         const configured = readConfiguredDefaultModel(agentDir) ?? resolveMainModel(undefined);
         writeSessionModelFile(agentDir, expandSrAlias(action.arg), configured);
-        writeRelaunchModelIntent(agentDir, "keep", "queued /model carried across restart");
         break;
       }
       case "clear-model":
@@ -93095,14 +93347,38 @@ bot.command("model", async (ctx) => {
   const parsed = parseModelCommand(text5) ?? { kind: "show" };
   const chatId = String(ctx.chat.id);
   const threadId = resolveThreadId(chatId, ctx.message?.message_thread_id);
+  const busyNow = currentTurn !== null || turnInFlightForGate();
+  process.stderr.write(modelCommandReceiptLine(getMyAgentName(), parsed, busyNow) + `
+`);
+  if (HISTORY_ENABLED && ctx.message?.message_id != null) {
+    try {
+      recordInbound({
+        chat_id: chatId,
+        thread_id: threadId ?? null,
+        message_id: ctx.message.message_id,
+        user: ctx.from?.username ?? (ctx.from?.id != null ? String(ctx.from.id) : null),
+        user_id: ctx.from?.id != null ? String(ctx.from.id) : null,
+        ts: ctx.message.date ?? Math.floor(Date.now() / 1000),
+        text: text5
+      });
+    } catch (err) {
+      process.stderr.write(`telegram gateway: /model recordInbound failed: ${err?.message ?? String(err)}
+`);
+    }
+  }
   const deps = buildModelDeps({ chatId, threadId });
-  if (parsed.kind === "show" && process.env.SWITCHROOM_MODEL_MENU !== "0") {
+  const disposition = planModelCommand(parsed, {
+    currentTurnActive: currentTurn !== null,
+    turnInFlight: turnInFlightForGate(),
+    menuEnabled: process.env.SWITCHROOM_MODEL_MENU !== "0"
+  });
+  if (disposition.kind === "menu") {
     const menu = await buildModelMenu(deps);
     await switchroomReply(ctx, menu.text, { html: true, reply_markup: modelMenuReplyMarkup(menu) });
     return;
   }
-  if (parsed.kind === "set" && deps.isBusy()) {
-    const target = expandSrAlias(parsed.model);
+  if (disposition.kind === "queue") {
+    const target = disposition.target;
     const sent = await ctx.replyWithRichMessage(richMessage2(hardenCardBreaks2(ackText("model", target, escapeHtmlForTg2))), threadId != null ? { message_thread_id: threadId } : {});
     enqueueSessionCommand({
       kind: "model",
@@ -93121,34 +93397,24 @@ bot.command("model", async (ctx) => {
   const persistWarning = recordTypedModelSwitch(reply, parsed.kind === "set" ? parsed.model : null, deps);
   await switchroomReply(ctx, reply.text + persistWarning, { html: reply.html });
 });
+var sessionEffortOverride = null;
 function buildEffortDeps() {
   return {
     applyEffort: async (agent, level) => {
       const result = await applyEffort(agent, level);
-      if (result.ok) {
-        const agentDir = resolveAgentDirFromEnv();
-        if (agentDir) {
-          try {
-            writeSessionEffortFile(agentDir, level, getConfiguredEffortForPersist());
-          } catch (err) {
-            process.stderr.write(`telegram gateway: session-effort persist failed level=${level}: ${err?.message ?? String(err)}
-`);
-          }
-        }
-      }
+      if (result.ok)
+        sessionEffortOverride = level;
       return result;
     },
     getAgentName: getMyAgentName,
     getConfiguredEffort: () => getConfiguredEffortForPersist(),
     clearSessionEffort: () => {
+      sessionEffortOverride = null;
       const agentDir = resolveAgentDirFromEnv();
       if (agentDir)
         clearSessionEffortFile(agentDir);
     },
-    getSessionEffort: () => {
-      const agentDir = resolveAgentDirFromEnv();
-      return agentDir ? readSessionEffortFile(agentDir)?.level ?? null : null;
-    },
+    getSessionEffort: () => sessionEffortOverride,
     escapeHtml: escapeHtmlForTg2
   };
 }
@@ -93270,11 +93536,6 @@ bot.command("restart", async (ctx) => {
     } catch {}
     writeRestartMarker({ chat_id: chatId, thread_id: threadId ?? null, ack_message_id: ackId, ts: Date.now() });
     stampUserRestartReason("user: /restart from chat");
-    {
-      const smDir = resolveAgentDirFromEnv();
-      if (smDir)
-        writeRelaunchModelIntent(smDir, "keep", "user: /restart from chat");
-    }
     await sweepBeforeSelfRestart();
     const hostdResp = await tryHostdDispatch2(getMyAgentName(), {
       v: 1,
@@ -93371,9 +93632,6 @@ async function handleNewCommand(ctx) {
     }
   }
   stampUserRestartReason(`user: /${kind} from chat`);
-  if (agentDir != null) {
-    writeRelaunchModelIntent(agentDir, "keep", `user: /${kind} from chat`);
-  }
   await sweepBeforeSelfRestart();
   const hostdResp = await tryHostdDispatch2(getMyAgentName(), {
     v: 1,
@@ -93795,6 +94053,26 @@ var throttleTierRunner = createThrottleTierRunner({
   log: (m) => process.stderr.write(`telegram gateway: ${m}
 `)
 });
+var litellmLocalNoticeRunner = createLitellmLocalNoticeRunner({
+  listNoticeChats: () => loadAccess().allowFrom,
+  sendNotice: (chat_id, markdown) => {
+    const noticeTopic = resolveAgentOutboundTopic({ kind: "compact-watchdog" });
+    const noticeSupergroup = resolveAgentSupergroupChatId();
+    const noticeThread = topicForRecipient({
+      recipientChatId: chat_id,
+      resolvedTopic: noticeTopic,
+      supergroupChatId: noticeSupergroup
+    });
+    swallowingApiCall(() => bot.api.sendRichMessage(chat_id, richMessage2(markdown), {
+      disable_notification: true,
+      ...noticeThread != null ? { message_thread_id: noticeThread } : {}
+    }), { chat_id: String(chat_id), verb: "litellm-local-notice:notify" });
+  },
+  windowMs: () => parseLitellmNoticeWindowMs(loadAccess().litellmNoticeWindowMs),
+  emitMetric: (event) => emitRuntimeMetric(event),
+  log: (m) => process.stderr.write(`telegram gateway: ${m}
+`)
+});
 var fallbackFailureNoticeState = { lastSentAtMs: 0 };
 var fallbackAllBlockedNoticeState = { lastSentAtMs: 0 };
 function broadcastFleetFallbackFailure(triggerAgent, reason) {
@@ -96494,21 +96772,6 @@ async function shutdown(signal) {
 `);
     } catch (err) {
       process.stderr.write(`telegram gateway: shutdown.clean_marker_write_failed err=${err.message}
-`);
-    }
-    try {
-      const smDir = resolveAgentDirFromEnv();
-      if (smDir != null) {
-        const hasOverride = readSessionModelFile(smDir) != null;
-        const intentAlreadyStamped = existsSync50(join54(smDir, RELAUNCH_MODEL_INTENT_FILE));
-        if (hasOverride && !intentAlreadyStamped) {
-          writeRelaunchModelIntent(smDir, "keep", `${GATEWAY_SHUTDOWN_INTENT_REASON_PREFIX} graceful ${signal} shutdown (deploy/rolling restart) \u2014 preserving user-chosen session model`);
-          process.stderr.write(`telegram gateway: shutdown.session_model_keep_stamped signal=${signal}
-`);
-        }
-      }
-    } catch (err) {
-      process.stderr.write(`telegram gateway: shutdown.session_model_keep_stamp_failed err=${err.message}
 `);
     }
   } else {
@@ -96964,6 +97227,14 @@ var didOneTimeSetup = false;
                 sessionModelSource.setOverride(launched.length > 0 && launched !== configured ? launched : null);
               } catch {}
             }
+            const activeEffortPath = join54(smAgentDir, ".active-session-effort");
+            if (existsSync50(activeEffortPath)) {
+              try {
+                const launchedEffort = readFileSync54(activeEffortPath, "utf8").trim();
+                const configuredEffort = getConfiguredEffortForPersist();
+                sessionEffortOverride = launchedEffort.length > 0 && launchedEffort !== configuredEffort ? launchedEffort : null;
+              } catch {}
+            }
             const alertPath = join54(smAgentDir, ".session-model-alert");
             if (existsSync50(alertPath)) {
               let alertText = null;
@@ -97082,6 +97353,7 @@ var didOneTimeSetup = false;
                   editPayload: text5
                 })
               },
+              floodWaitRemainingMs: probeFloodWaitRemainingMs,
               log: (msg) => process.stderr.write(`telegram gateway: ${msg}
 `)
             });