switchroom 0.18.15 → 0.18.18

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

@@ -20509,6 +20509,19 @@ var init_schema = __esm(() => {
     approval_timeout_minutes: exports_external.number().int().nonnegative().optional().describe("Operator approval-card lifetime (minutes) for the tool-use 'Allow " + "once' card and the vault grant decision wait. After this long with " + "no operator tap, the card auto-denies (a TIMEOUT, not a denial \u2014 the " + "agent is told not to retry). Default 60. hostd-gated verbs " + "(mcp__hostd__*) keep their own longer window; the hostd " + "config-propose card is not governed by this key."),
     sub_agent_tick_interval_ms: exports_external.number().int().nonnegative().optional().describe("Heartbeat tick interval (ms) for sub-agent rendering. Forces a " + "re-render of the elapsed-time counter while sub-agents are running, " + "even during silent stretches between tool calls. Default 10000 (10 s). " + "Set to 0 to disable the elapsed-ticker path."),
     edit_budget_threshold: exports_external.number().int().nonnegative().optional().describe("Telegram API edit budget per minute before the progress-card driver " + "falls back to a slower coalesce window. When a chat accumulates more " + "than this many card edits in the trailing 60 s, the driver switches " + "to a wider coalesce interval until the rate drops back. Default 18. " + "Increase if your gateway frequently bumps the Telegram edit-rate ceiling " + "with many parallel sub-agents; decrease for a more conservative buffer."),
+    send_gate: exports_external.object({
+      enabled: exports_external.boolean().optional().describe("Master switch for the deterministic outbound send gate " + "(telegram-plugin/send-gate.ts) \u2014 the token-bucket scheduler every " + "Bot API call transits so per-surface throttles can't add up past a " + "flood ceiling. ON by default. Precedence: the operator break-glass " + "env var SWITCHROOM_TELEGRAM_SEND_GATE (0/false/off/no) ALWAYS wins " + "when explicitly set; this key only decides when that env var is " + "unset. Omit to keep the gate on."),
+      global_per_sec: exports_external.number().positive().optional().describe("Global bucket sustained rate (Bot API calls/sec across ALL chats). " + "Default 25 (headroom under Telegram's ~30/s). Must be > 0 \u2014 a zero " + "or negative rate would wedge all outbound sends. Omit to keep 25."),
+      global_burst: exports_external.number().int().positive().describe("Global bucket burst capacity. Default 4; worst-case 1s window " + "admits global_burst + global_per_sec = 29 < 30, a real margin under " + "the ceiling. Must be an integer >= 1 (a 0 capacity never admits a " + "token and wedges sends). Omit to keep 4.").optional(),
+      per_chat_per_sec: exports_external.number().positive().optional().describe("Per-chat sustained rate (calls/sec to a single chat). Default 1. " + "Must be > 0 (zero/negative wedges that chat). Omit to keep 1."),
+      per_chat_burst: exports_external.number().int().positive().optional().describe("Per-chat burst capacity. Default 3. Must be an integer >= 1 " + "(0 wedges the chat's bucket). Omit to keep 3."),
+      per_group_per_min: exports_external.number().positive().optional().describe("Per-group sustained rate (calls/min to a single group/supergroup). " + "Default 18 (headroom under Telegram's ~20/min group ceiling). Must " + "be > 0. Omit to keep 18."),
+      per_group_burst: exports_external.number().int().positive().optional().describe("Per-group burst capacity. Default 2. Must be an integer >= 1 " + "(0 wedges the group's bucket). Omit to keep 2."),
+      edit_floor_ms: exports_external.number().int().nonnegative().optional().describe("Minimum ms between successive edits of the SAME message_id " + "(last-write-wins coalescing enforces this floor). Default 1500 " + "(Telegram's ~1 edit/sec/message practical ceiling). 0 disables the " + "floor. Must be an integer >= 0. Omit to keep 1500.")
+    }).optional().describe("Tunable rate limits for the deterministic outbound send gate " + "(telegram-plugin/send-gate.ts). Every key is optional and defaults to " + "the send gate's built-in value, so omitting the whole block reproduces " + "today's exact behaviour \u2014 this is pure operator tuning, no default is " + "changed. Cascades from defaults.channels.telegram.send_gate."),
+    worker_feed: exports_external.object({
+      max_rows: exports_external.number().int().positive().optional().describe("Max live-worker rows rendered in the COMBINED worker-activity feed " + "(2+ background workers in one chat/thread coalesce into ONE message; " + "telegram-plugin/worker-activity-feed.ts) before a compact " + "'+M more working\u2026' spill line \u2014 keeps the coalesced body compact and " + "legible (and under the rich-message wire ceiling). Default 8. A " + "single-worker chat renders the full \uD83D\uDEE0 Worker card and ignores this. " + "Must be an integer >= 1. Omit to keep 8.")
+    }).optional().describe("Tuning for the coalesced worker-activity feed " + "(telegram-plugin/worker-activity-feed.ts). Cascades from " + "defaults.channels.telegram.worker_feed."),
     stickers: exports_external.record(exports_external.string(), exports_external.string()).optional().describe("Sticker aliases for the `send_sticker` MCP tool (#576). Maps a " + "short alias name (e.g. 'happy', 'thinking') to a Telegram file_id. " + "Operator-curated \u2014 capture file_ids from inbound stickers the user " + "sends and add them here. The agent calls send_sticker(chat_id, " + "alias='happy') and the gateway resolves to the file_id at send " + "time. Aliases enable persona-flavored expressiveness without " + "exposing raw file_ids in the agent prompt. Personal-assistant / " + "health-coach personas benefit; coding agents typically don't " + "configure any."),
     voice_in: exports_external.object({
       enabled: exports_external.boolean().optional().describe("Master switch for voice-message transcription."),
@@ -20534,6 +20547,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.")
@@ -40235,6 +40251,96 @@ function renderActivityFeedWithNested(lines, childLines, final = false, liveSuff
     stepCount
   });
 }
+var COMBINED_ROW_DESC_MAX = 72;
+function renderCombinedWorkerFeed(rows, opts) {
+  if (rows.length === 0)
+    return null;
+  const maxRows = Math.max(1, Math.floor(opts.maxRows));
+  const rowLines = (r) => {
+    const desc = escapeMarkdown(truncate(stripMarkdown(r.description).replace(/\s+/g, " ").trim() || "background task", COMBINED_ROW_DESC_MAX));
+    const toolWord = r.toolCount === 1 ? "tool" : "tools";
+    const modelLabel = formatModelLabel(r.model);
+    const modelPart = modelLabel != null ? ` \u00b7 ${escapeMarkdown(modelLabel)}` : "";
+    const header = `**${desc}** _\u00b7 ${formatFeedElapsed(r.elapsedMs)} \u00b7 ${r.toolCount} ${toolWord}${modelPart}_`;
+    const stepClean = stripMarkdown(r.currentStep).replace(/\s+/g, " ").trim();
+    const step = stepClean.length > 0 ? `\u2192 _${escapeMarkdown(truncate(stepClean, STATUS_LINE_MAX))}_` : `\u2192 _starting\u2026_`;
+    return [header, step];
+  };
+  const compose = (visibleCount) => {
+    const shown = rows.slice(0, visibleCount);
+    const hidden = rows.length - shown.length;
+    const out = [`\uD83D\uDEE0 **Workers** \u00b7 _${rows.length} running_`];
+    for (const r of shown) {
+      const [h, s] = rowLines(r);
+      out.push(h, s);
+    }
+    if (hidden > 0)
+      out.push(`_+${hidden} more working\u2026_`);
+    return stackCardLines(out);
+  };
+  let visible = Math.min(rows.length, maxRows);
+  let body = compose(visible);
+  while (body.length > STATUS_CARD_CHAR_BUDGET && visible > 1) {
+    visible -= 1;
+    body = compose(visible);
+  }
+  return body;
+}
+
+// retry-api-call.ts
+var import_grammy = __toESM(require_mod2(), 1);
+var LOCAL_RESOURCE_EXHAUSTED = "LOCAL_RESOURCE_EXHAUSTED";
+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) {
@@ -40310,16 +40416,20 @@ 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;
+  const maxRows = Math.max(1, Math.floor(opts.maxRows ?? 8));
+  const reconcilePinFn = opts.reconcilePin ?? (() => {});
   const setIntervalFn = opts.setInterval ?? ((cb, ms) => {
     const t = setInterval(cb, ms);
     t.unref?.();
     return t;
   });
   const clearIntervalFn = opts.clearInterval ?? ((handle) => clearInterval(handle));
-  const handles = new Map;
+  const groups = new Map;
+  const agentIndex = new Map;
   const finalized = new Set;
   const FINALIZED_CAP = 256;
   function markFinalized(agentId) {
@@ -40333,242 +40443,356 @@ function createWorkerActivityFeed(opts) {
     }
   }
   let heartbeatTimer = null;
-  function sendOptsFor(h) {
+  function feedKeyOf(chatId, threadId) {
+    return `${chatId} ${threadId ?? ""}`;
+  }
+  function groupOfAgent(agentId) {
+    const key = agentIndex.get(agentId);
+    return key != null ? groups.get(key) : undefined;
+  }
+  function sendOptsFor(g) {
     return {
       disable_web_page_preview: true,
       disable_notification: true,
-      ...h.threadId != null ? { message_thread_id: h.threadId } : {}
+      ...g.threadId != null ? { message_thread_id: g.threadId } : {}
     };
   }
-  function noteRateLimited(h, err, label) {
+  function noteRateLimited(g, err, label) {
     const retryAfter = extractRetryAfterSecs(err);
     if (retryAfter == null)
       return;
-    h.cooldownUntil = nowFn() + retryAfter * 1000 + COOLDOWN_JITTER_MS;
+    g.cooldownUntil = nowFn() + retryAfter * 1000 + COOLDOWN_JITTER_MS;
     log(`worker-feed: ${label} 429 \u2014 backing off ${retryAfter}s`);
   }
-  function accumulateNarrative(h, view) {
+  function parkIfFloodWindowOpen(g) {
+    const remaining = floodWaitRemainingMs();
+    if (remaining <= 0)
+      return false;
+    const until = nowFn() + remaining + COOLDOWN_JITTER_MS;
+    if (until > g.cooldownUntil)
+      g.cooldownUntil = until;
+    return true;
+  }
+  function accumulateNarrative(row, view) {
     const line = view.latestSummary.trim();
     if (line.length === 0)
       return;
-    if (h.narrative.includes(line))
+    if (row.narrative.includes(line))
       return;
-    h.narrative.push(line);
-    h.stepStartedAtMs = nowFn();
-    if (h.narrative.length > STATUS_ROLLING_LINES) {
-      h.narrative.splice(0, h.narrative.length - STATUS_ROLLING_LINES);
-    }
-  }
-  async function doUpdate(h, view, liveSuffix = "") {
-    accumulateNarrative(h, view);
-    const merged = { ...view, narrativeLines: [...h.narrative] };
-    h.lastView = merged;
-    if (h.dispatchAtMs == null)
-      h.dispatchAtMs = nowFn() - view.elapsedMs;
-    if (nowFn() < h.cooldownUntil)
-      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));
-        h.messageId = sent.message_id;
-        h.lastBody = body;
-        h.lastEditAt = nowFn();
-        log(`worker-feed: paint agent=${h.agentId} chat=${h.chatId} ` + `thread=${h.threadId ?? "-"} msgId=${h.messageId} bytes=${body.length}`);
-      } catch (err) {
-        noteRateLimited(h, err, "send");
-        log(`worker-feed: send failed: ${err.message}`);
+    row.narrative.push(line);
+    row.stepStartedAtMs = nowFn();
+    if (row.narrative.length > STATUS_ROLLING_LINES) {
+      row.narrative.splice(0, row.narrative.length - STATUS_ROLLING_LINES);
+    }
+  }
+  function liveElapsed(row, now) {
+    const base = row.dispatchAtMs != null ? now - row.dispatchAtMs : row.lastView?.elapsedMs ?? 0;
+    return Math.max(base, row.lastView?.elapsedMs ?? 0);
+  }
+  function runningRows(g) {
+    return [...g.workers.values()].filter((w) => w.state === "running" && w.lastView != null).sort((a, b) => (a.dispatchAtMs ?? 0) - (b.dispatchAtMs ?? 0));
+  }
+  function renderGroupBody(g, now, terminalRecap, heartbeat) {
+    const running = runningRows(g);
+    if (running.length === 0) {
+      if (terminalRecap == null)
+        return null;
+      return renderWorkerActivity(terminalRecap);
+    }
+    const elapsedFor = (r) => heartbeat ? liveElapsed(r, now) : r.lastView?.elapsedMs ?? liveElapsed(r, now);
+    if (running.length === 1) {
+      const r = running[0];
+      const view = {
+        ...r.lastView,
+        elapsedMs: elapsedFor(r),
+        narrativeLines: [...r.narrative]
+      };
+      let liveSuffix = "";
+      if (heartbeat) {
+        const stepElapsed = r.stepStartedAtMs != null ? now - r.stepStartedAtMs : liveElapsed(r, now);
+        liveSuffix = formatStepSuffix(stepElapsed);
       }
+      return renderWorkerActivity(view, liveSuffix);
+    }
+    const rows = running.map((r) => {
+      const v = r.lastView;
+      const currentStep = r.narrative.length > 0 ? r.narrative[r.narrative.length - 1] : v.latestSummary;
+      return {
+        description: v.description,
+        elapsedMs: elapsedFor(r),
+        toolCount: v.toolCount,
+        currentStep,
+        model: v.model
+      };
+    });
+    return renderCombinedWorkerFeed(rows, { maxRows });
+  }
+  function removeWorker(g, agentId) {
+    g.workers.delete(agentId);
+    agentIndex.delete(agentId);
+    if (g.workers.size === 0)
+      groups.delete(g.feedKey);
+  }
+  function syncPin(g) {
+    const messageId = g.messageId != null && g.workers.size > 0 ? g.messageId : null;
+    reconcilePinFn({ feedKey: g.feedKey, chatId: g.chatId, threadId: g.threadId, messageId });
+  }
+  async function doRender(g, opts2 = {}) {
+    const now = nowFn();
+    const isTerminal = opts2.terminalRecap != null;
+    const settleTerminal = () => {
+      g.pendingFinalize = null;
+      if (opts2.finishingAgentId != null)
+        removeWorker(g, opts2.finishingAgentId);
+      syncPin(g);
+    };
+    if (now < g.cooldownUntil) {
+      if (isTerminal && opts2.terminalRecap != null)
+        g.pendingFinalize = opts2.terminalRecap;
       return;
     }
-    if (body === h.lastBody)
+    if (parkIfFloodWindowOpen(g)) {
+      if (isTerminal && opts2.terminalRecap != null)
+        g.pendingFinalize = opts2.terminalRecap;
       return;
-    if (nowFn() - h.lastEditAt < minEditInterval)
+    }
+    const body = renderGroupBody(g, now, opts2.terminalRecap ?? null, opts2.heartbeat ?? false);
+    if (body == null) {
+      if (isTerminal)
+        settleTerminal();
       return;
-    try {
-      await opts.bot.editMessageText(h.chatId, h.messageId, body, sendOptsFor(h));
-      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}`);
-    } catch (err) {
-      const outcome = classifyEditError(err);
-      if (outcome === "rate_limited") {
-        noteRateLimited(h, err, "edit");
-        return;
-      }
-      if (outcome === "not_modified") {
-        h.lastBody = body;
-        h.lastEditAt = nowFn();
+    }
+    if (g.messageId == null) {
+      const maxElapsed = Math.max(0, ...runningRows(g).map((r) => liveElapsed(r, now)));
+      if (isTerminal) {
+        settleTerminal();
         return;
       }
-      if (outcome === "gone") {
-        h.messageId = null;
-        h.lastBody = null;
+      if (maxElapsed < firstPaintMin)
         return;
+      try {
+        const sent = await opts.bot.sendMessage(g.chatId, body, sendOptsFor(g));
+        if (sent == null || typeof sent.message_id !== "number") {
+          parkIfFloodWindowOpen(g);
+          log(`worker-feed: first paint shed by send gate feed=${g.feedKey} \u2014 not delivered`);
+          return;
+        }
+        g.messageId = sent.message_id;
+        g.lastBody = body;
+        g.lastEditAt = now;
+        syncPin(g);
+        log(`worker-feed: paint feed=${g.feedKey} chat=${g.chatId} ` + `thread=${g.threadId ?? "-"} msgId=${g.messageId} workers=${g.workers.size} bytes=${body.length}`);
+      } catch (err) {
+        noteRateLimited(g, err, "send");
+        log(`worker-feed: send failed: ${err.message}`);
       }
-      log(`worker-feed: edit transient error agent=${h.agentId}: ${err.message}`);
-    }
-  }
-  async function doFinish(h, view) {
-    h.finished = true;
-    markFinalized(h.agentId);
-    if (h.messageId == null) {
-      h.pendingFinish = null;
       return;
     }
-    if (nowFn() < h.cooldownUntil) {
-      h.pendingFinish = view;
+    if (body === g.lastBody) {
+      if (isTerminal)
+        settleTerminal();
       return;
     }
-    const body = renderWorkerActivity({ ...view, narrativeLines: h.narrative });
-    if (body === h.lastBody) {
-      h.pendingFinish = null;
+    if (!opts2.force && now - g.lastEditAt < minEditInterval)
       return;
-    }
     try {
-      await opts.bot.editMessageText(h.chatId, h.messageId, body, sendOptsFor(h));
-      h.lastBody = body;
-      h.lastEditAt = nowFn();
-      h.pendingFinish = null;
-      log(`worker-feed: finish agent=${h.agentId} chat=${h.chatId} ` + `thread=${h.threadId ?? "-"} msgId=${h.messageId} state=${view.state} bytes=${body.length}`);
+      const res = await opts.bot.editMessageText(g.chatId, g.messageId, body, sendOptsFor(g));
+      if (isSendGateShed(res)) {
+        parkIfFloodWindowOpen(g);
+        if (isTerminal && opts2.terminalRecap != null)
+          g.pendingFinalize = opts2.terminalRecap;
+        return;
+      }
+      g.lastBody = body;
+      g.lastEditAt = now;
+      if (isTerminal) {
+        log(`worker-feed: finish feed=${g.feedKey} chat=${g.chatId} thread=${g.threadId ?? "-"} ` + `msgId=${g.messageId} agent=${opts2.finishingAgentId ?? "-"} ` + `state=${opts2.terminalRecap?.state ?? "done"} bytes=${body.length}`);
+      } else {
+        log(`worker-feed: edit feed=${g.feedKey} chat=${g.chatId} ` + `thread=${g.threadId ?? "-"} msgId=${g.messageId} workers=${g.workers.size} bytes=${body.length}`);
+      }
+      if (isTerminal)
+        settleTerminal();
     } catch (err) {
       const outcome = classifyEditError(err);
       if (outcome === "rate_limited") {
-        noteRateLimited(h, err, "finish");
-        h.pendingFinish = view;
+        noteRateLimited(g, err, isTerminal ? "finish" : "edit");
+        if (isTerminal && opts2.terminalRecap != null)
+          g.pendingFinalize = opts2.terminalRecap;
         return;
       }
       if (outcome === "not_modified") {
-        h.lastBody = body;
-        h.lastEditAt = nowFn();
-        h.pendingFinish = null;
+        g.lastBody = body;
+        g.lastEditAt = now;
+        if (isTerminal)
+          settleTerminal();
         return;
       }
       if (outcome === "gone") {
-        h.pendingFinish = null;
+        g.messageId = null;
+        g.lastBody = null;
+        if (isTerminal)
+          settleTerminal();
+        else
+          syncPin(g);
         return;
       }
-      h.pendingFinish = view;
-      log(`worker-feed: finish transient error agent=${h.agentId}: ${err.message}`);
+      if (isTerminal && opts2.terminalRecap != null)
+        g.pendingFinalize = opts2.terminalRecap;
+      log(`worker-feed: edit transient error feed=${g.feedKey}: ${err.message}`);
     }
   }
   function heartbeatTick() {
     const now = nowFn();
-    for (const h of handles.values()) {
-      if (!handles.has(h.agentId))
-        continue;
-      if (h.pendingFinish != null && now >= h.cooldownUntil) {
-        const view2 = h.pendingFinish;
-        h.chain = h.chain.then(() => doFinish(h, view2)).catch((err) => {
-          log(`worker-feed: heartbeat finalize re-drive error ${h.agentId}: ${err.message}`);
-        }).finally(() => {
-          if (handles.get(h.agentId)?.pendingFinish == null) {
-            handles.delete(h.agentId);
-          }
+    for (const g of [...groups.values()]) {
+      if (g.pendingFinalize != null && now >= g.cooldownUntil) {
+        const recap = g.pendingFinalize;
+        const finishingAgentId = [...g.workers.values()].find((w) => w.finished)?.agentId;
+        g.chain = g.chain.then(() => doRender(g, { force: true, terminalRecap: recap, finishingAgentId })).catch((err) => {
+          log(`worker-feed: heartbeat finalize re-drive error feed=${g.feedKey}: ${err.message}`);
         });
         continue;
       }
-      if (h.lastView == null)
+      if (now < g.cooldownUntil)
         continue;
-      if (h.lastView.state !== "running")
+      const running = runningRows(g);
+      if (running.length === 0)
         continue;
-      if (now < h.cooldownUntil)
-        continue;
-      const liveElapsed = h.dispatchAtMs != null ? now - h.dispatchAtMs : h.lastView.elapsedMs;
-      if (h.messageId == null) {
-        if (liveElapsed < firstPaintMin)
+      if (g.messageId == null) {
+        const maxElapsed = Math.max(0, ...running.map((r) => liveElapsed(r, now)));
+        if (maxElapsed < firstPaintMin)
           continue;
-        const view2 = { ...h.lastView, elapsedMs: Math.max(h.lastView.elapsedMs, liveElapsed) };
-        h.chain = h.chain.then(() => doUpdate(h, view2)).catch((err) => {
-          log(`worker-feed: heartbeat first-paint chain error ${h.agentId}: ${err.message}`);
+        g.chain = g.chain.then(() => doRender(g, {})).catch((err) => {
+          log(`worker-feed: heartbeat first-paint chain error feed=${g.feedKey}: ${err.message}`);
         });
         continue;
       }
-      if (now - h.lastEditAt < minEditInterval)
+      if (now - g.lastEditAt < minEditInterval)
         continue;
-      const stale = now - h.lastEditAt >= heartbeatTickMs;
+      const stale = now - g.lastEditAt >= heartbeatTickMs;
       if (!stale)
         continue;
-      const stepElapsed = h.stepStartedAtMs != null ? now - h.stepStartedAtMs : liveElapsed;
-      const liveSuffix = formatStepSuffix(stepElapsed);
-      const view = { ...h.lastView, elapsedMs: Math.max(h.lastView.elapsedMs, liveElapsed) };
-      h.chain = h.chain.then(() => doUpdate(h, view, liveSuffix)).catch((err) => {
-        log(`worker-feed: heartbeat chain error ${h.agentId}: ${err.message}`);
+      g.chain = g.chain.then(() => doRender(g, { heartbeat: true })).catch((err) => {
+        log(`worker-feed: heartbeat chain error feed=${g.feedKey}: ${err.message}`);
       });
     }
   }
   heartbeatTimer = setIntervalFn(heartbeatTick, heartbeatTickMs);
   return {
     has(agentId) {
-      return handles.get(agentId)?.messageId != null;
+      const g = groupOfAgent(agentId);
+      return g != null && g.messageId != null && g.workers.has(agentId);
     },
     messageIdOf(agentId) {
-      return handles.get(agentId)?.messageId ?? null;
+      return groupOfAgent(agentId)?.messageId ?? null;
+    },
+    hasRunningInFeed(feedKey) {
+      const g = groups.get(feedKey);
+      return g != null && g.workers.size > 0;
     },
     get size() {
-      return handles.size;
+      let n = 0;
+      for (const g of groups.values())
+        n += g.workers.size;
+      return n;
     },
     update(agentId, chatId, view, threadId) {
       if (chatId.length === 0)
         return Promise.resolve();
       if (finalized.has(agentId))
         return Promise.resolve();
-      const existing = handles.get(agentId);
-      if (existing?.finished === true)
+      const existingRow = groupOfAgent(agentId)?.workers.get(agentId);
+      if (existingRow?.finished === true)
         return Promise.resolve();
-      let h = existing;
-      if (h == null) {
-        h = {
-          agentId,
+      const feedKey = feedKeyOf(chatId, threadId);
+      let g = groups.get(feedKey);
+      if (g == null) {
+        g = {
+          feedKey,
           chatId,
           threadId,
           messageId: null,
           lastBody: null,
           lastEditAt: 0,
           cooldownUntil: 0,
-          narrative: [],
           chain: Promise.resolve(),
+          workers: new Map,
+          pendingFinalize: null
+        };
+        groups.set(feedKey, g);
+      }
+      let row = g.workers.get(agentId);
+      if (row == null) {
+        row = {
+          agentId,
+          narrative: [],
           lastView: null,
-          dispatchAtMs: null,
-          stepStartedAtMs: null,
+          state: "running",
           finished: false,
-          pendingFinish: null
+          dispatchAtMs: null,
+          stepStartedAtMs: null
         };
-        handles.set(agentId, h);
-      }
-      const handle = h;
-      handle.chain = handle.chain.then(() => doUpdate(handle, view)).catch((err) => {
+        g.workers.set(agentId, row);
+        agentIndex.set(agentId, feedKey);
+      }
+      accumulateNarrative(row, view);
+      row.state = "running";
+      row.lastView = { ...view, narrativeLines: [...row.narrative] };
+      if (row.dispatchAtMs == null)
+        row.dispatchAtMs = nowFn() - view.elapsedMs;
+      const group = g;
+      group.chain = group.chain.then(() => doRender(group)).catch((err) => {
         log(`worker-feed: update chain error ${agentId}: ${err.message}`);
       });
-      return handle.chain;
+      return group.chain;
     },
     finish(agentId, view) {
-      const h = handles.get(agentId);
-      if (h == null)
+      const g = groupOfAgent(agentId);
+      const row = g?.workers.get(agentId);
+      if (g == null || row == null) {
+        markFinalized(agentId);
         return Promise.resolve();
-      h.chain = h.chain.then(() => doFinish(h, view)).catch((err) => {
+      }
+      row.finished = true;
+      row.state = view.state === "failed" ? "failed" : "done";
+      markFinalized(agentId);
+      const group = g;
+      group.chain = group.chain.then(() => {
+        const others = runningRows(group).filter((w) => w.agentId !== agentId);
+        if (others.length > 0) {
+          removeWorker(group, agentId);
+          syncPin(group);
+          return doRender(group, { force: true });
+        }
+        const recap = { ...view, narrativeLines: [...row.narrative] };
+        return doRender(group, { force: true, terminalRecap: recap, finishingAgentId: agentId });
+      }).catch((err) => {
         log(`worker-feed: finish chain error ${agentId}: ${err.message}`);
-      }).finally(() => {
-        if (handles.get(agentId)?.pendingFinish == null) {
-          handles.delete(agentId);
-        }
       });
-      return h.chain;
+      return group.chain;
     },
     drop(agentId) {
       markFinalized(agentId);
-      handles.delete(agentId);
+      const g = groupOfAgent(agentId);
+      if (g == null)
+        return;
+      const hadMessage = g.messageId != null;
+      removeWorker(g, agentId);
+      if (hadMessage)
+        syncPin(g);
+      if (hadMessage && groups.has(g.feedKey) && runningRows(g).length > 0) {
+        g.chain = g.chain.then(() => doRender(g, { force: true })).catch((err) => {
+          log(`worker-feed: drop re-render error ${agentId}: ${err.message}`);
+        });
+      }
     },
     resurrect(agentId) {
       const wasFinalized = finalized.delete(agentId);
-      const h = handles.get(agentId);
-      if (h != null) {
-        h.finished = false;
-        h.pendingFinish = null;
+      const row = groupOfAgent(agentId)?.workers.get(agentId);
+      if (row != null) {
+        row.finished = false;
+        row.state = "running";
       }
-      if (wasFinalized || h != null) {
+      if (wasFinalized || row != null) {
         log(`worker-feed: resurrect agent=${agentId} \u2014 cleared finalized gate; card will repaint on next running cue`);
       }
     },
@@ -41022,55 +41246,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
@@ -44548,6 +44723,14 @@ function holdReasonFor(err) {
 function isHeldUndeliverable2(pend) {
   return pend.undeliverable != null;
 }
+function applyDeliveredHoldReset(entry, now) {
+  if (entry.undeliverable == null)
+    return false;
+  entry.undeliverable = null;
+  entry.redeliveryFailures = 0;
+  entry.startedAt = now;
+  return true;
+}
 var HELD_CARD_REDELIVERY_CAP = 3;
 function selectHeldForRedelivery(entries, opts) {
   const empty = { send: [], deferred: [] };
@@ -45307,6 +45490,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 +45514,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 +45558,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 +45660,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 +45673,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 +55113,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 +55165,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 +55192,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 +55229,8 @@ function createStreamController(cfg) {
     ...initialMessageId != null ? { initialMessageId } : {},
     chatId
   });
+  handleRef = handle;
+  return handle;
 }
 
 // pty-partial-handler.ts
@@ -55133,7 +55362,7 @@ function isLocalResourceError(err) {
   const msg = err instanceof Error ? err.message : String(err ?? "");
   return /\b(ENOSPC|EDQUOT|EIO|ENOMEM)\b/.test(msg) || /no space left on device/i.test(msg) || /disk quota exceeded/i.test(msg);
 }
-var LOCAL_RESOURCE_EXHAUSTED = "LOCAL_RESOURCE_EXHAUSTED";
+var LOCAL_RESOURCE_EXHAUSTED2 = "LOCAL_RESOURCE_EXHAUSTED";
 var GIVE_UP_MESSAGE = "retryApiCall: max retries exceeded";
 var FLOOD_WAIT_ACTIVE2 = "FLOOD_WAIT_ACTIVE";
 function makeFloodWaitActiveError2(retryAfterSec, untilTs, original) {
@@ -55189,13 +55418,13 @@ function createRetryApiCall2(config = {}) {
           log?.(`telegram gateway: LOCAL resource exhaustion (${err.code ?? "disk/mem"}) \u2014 ` + `not retrying the send (would feed a flood ban); surfacing degraded state
 `);
           observer?.onGiveUp?.({ attempts: attempt + 1, error: err });
-          throw Object.assign(new Error(LOCAL_RESOURCE_EXHAUSTED), { original: err });
+          throw Object.assign(new Error(LOCAL_RESOURCE_EXHAUSTED2), { original: err });
         }
         if (isGrammyErr && err.error_code === 429) {
           const retryAfter = Number(err.parameters?.retry_after ?? 5);
           const delayMs = retryAfter * 1000;
           try {
-            onFloodWait?.(retryAfter);
+            onFloodWait?.(retryAfter, opts);
           } catch {}
           if (delayMs > maxFloodSleepMs) {
             log?.(`telegram gateway: 429 flood ban of ${retryAfter}s exceeds the ` + `${Math.round(maxFloodSleepMs / 1000)}s in-process sleep ceiling \u2014 ` + `not sleeping it; surfacing degraded state
@@ -55285,7 +55514,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,17 +55592,26 @@ function stableStringify(value) {
     return v;
   });
 }
-var GROUP_TYPES = new Set(["group", "supergroup"]);
+var GROUP_TYPES2 = new Set(["group", "supergroup"]);
+var SEND_GATE_DEFAULTS = {
+  globalPerSec: 25,
+  globalBurst: 4,
+  perChatPerSec: 1,
+  perChatBurst: 3,
+  perGroupPerMin: 18,
+  perGroupBurst: 2,
+  editFloorMs: 1500
+};
 function createSendGate(config) {
   const enabled2 = config.enabled;
   const clock = config.clock ?? systemClock;
-  const globalPerSec = config.globalPerSec ?? 25;
-  const globalBurst = config.globalBurst ?? 4;
-  const perChatPerSec = config.perChatPerSec ?? 1;
-  const perChatBurst = config.perChatBurst ?? 3;
-  const perGroupPerMin = config.perGroupPerMin ?? 18;
-  const perGroupBurst = config.perGroupBurst ?? 2;
-  const editFloorMs = config.editFloorMs ?? 1500;
+  const globalPerSec = config.globalPerSec ?? SEND_GATE_DEFAULTS.globalPerSec;
+  const globalBurst = config.globalBurst ?? SEND_GATE_DEFAULTS.globalBurst;
+  const perChatPerSec = config.perChatPerSec ?? SEND_GATE_DEFAULTS.perChatPerSec;
+  const perChatBurst = config.perChatBurst ?? SEND_GATE_DEFAULTS.perChatBurst;
+  const perGroupPerMin = config.perGroupPerMin ?? SEND_GATE_DEFAULTS.perGroupPerMin;
+  const perGroupBurst = config.perGroupBurst ?? SEND_GATE_DEFAULTS.perGroupBurst;
+  const editFloorMs = config.editFloorMs ?? SEND_GATE_DEFAULTS.editFloorMs;
   const messageStateTtlMs = config.messageStateTtlMs ?? 60000;
   const maxMessageStates = config.maxMessageStates ?? 5000;
   const usefulTtlMs = config.usefulTtlMs ?? 120000;
@@ -55381,6 +55619,7 @@ function createSendGate(config) {
   const criticalJitterMaxMs = config.criticalJitterMaxMs ?? 250;
   const jitter = config.jitter ?? Math.random;
   const onWindowOpen = config.onWindowOpen;
+  const conservativeGlobalFloodScope = config.conservativeGlobalFloodScope ?? false;
   const counters = {
     sent: 0,
     queued: 0,
@@ -55439,7 +55678,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));
       }
     }
@@ -55451,10 +55690,13 @@ function createSendGate(config) {
     applyWindow(scopeKey, untilTs, true);
   }
   function openScopedWindowsForOpts(opts, untilTs) {
-    applyWindow("global", untilTs, true);
-    if (opts?.chat_id) {
+    const hasChatScope = opts?.chat_id != null && opts.chat_id !== "";
+    if (!hasChatScope || conservativeGlobalFloodScope) {
+      applyWindow("global", untilTs, true);
+    }
+    if (hasChatScope) {
       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 +55910,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 +55955,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++;
@@ -55754,14 +55996,114 @@ function createSendGate(config) {
       }
     };
   }
-  return { gate, openFloodWindow, stats };
+  function openScopedFloodWindows(opts, untilTs) {
+    if (!enabled2)
+      return;
+    openScopedWindowsForOpts(opts, untilTs);
+  }
+  return { gate, openFloodWindow, openScopedFloodWindows, stats };
 }
-function sendGateEnabledFromEnv(env = process.env) {
-  const v = env.SWITCHROOM_TELEGRAM_SEND_GATE;
-  if (v == null)
-    return true;
+function isOffValue(v) {
   const t = v.trim().toLowerCase();
-  return !(t === "0" || t === "false" || t === "off" || t === "no");
+  return t === "0" || t === "false" || t === "off" || t === "no";
+}
+function parsePositiveNumber(raw) {
+  if (raw == null || raw.trim() === "")
+    return;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+function parsePositiveInt(raw) {
+  if (raw == null || raw.trim() === "")
+    return;
+  const n = Number(raw);
+  return Number.isInteger(n) && n > 0 ? n : undefined;
+}
+function parseNonNegativeInt(raw) {
+  if (raw == null || raw.trim() === "")
+    return;
+  const n = Number(raw);
+  return Number.isInteger(n) && n >= 0 ? n : undefined;
+}
+function parseBoolFlag(raw) {
+  if (raw == null || raw.trim() === "")
+    return;
+  const t = raw.trim().toLowerCase();
+  if (t === "1" || t === "true" || t === "on" || t === "yes")
+    return true;
+  if (isOffValue(t))
+    return false;
+  return;
+}
+function sendGateConfigFromEnv(env = process.env) {
+  const killSwitch = env.SWITCHROOM_TELEGRAM_SEND_GATE;
+  let enabled2;
+  if (killSwitch != null && killSwitch.trim() !== "") {
+    enabled2 = !isOffValue(killSwitch);
+  } else {
+    const cfg = env.SWITCHROOM_TG_SEND_GATE_ENABLED;
+    enabled2 = cfg != null && cfg.trim() !== "" ? !isOffValue(cfg) : true;
+  }
+  const out = { enabled: enabled2 };
+  const globalPerSec = parsePositiveNumber(env.SWITCHROOM_TG_SEND_GATE_GLOBAL_PER_SEC);
+  if (globalPerSec !== undefined)
+    out.globalPerSec = globalPerSec;
+  const globalBurst = parsePositiveInt(env.SWITCHROOM_TG_SEND_GATE_GLOBAL_BURST);
+  if (globalBurst !== undefined)
+    out.globalBurst = globalBurst;
+  const perChatPerSec = parsePositiveNumber(env.SWITCHROOM_TG_SEND_GATE_PER_CHAT_PER_SEC);
+  if (perChatPerSec !== undefined)
+    out.perChatPerSec = perChatPerSec;
+  const perChatBurst = parsePositiveInt(env.SWITCHROOM_TG_SEND_GATE_PER_CHAT_BURST);
+  if (perChatBurst !== undefined)
+    out.perChatBurst = perChatBurst;
+  const perGroupPerMin = parsePositiveNumber(env.SWITCHROOM_TG_SEND_GATE_PER_GROUP_PER_MIN);
+  if (perGroupPerMin !== undefined)
+    out.perGroupPerMin = perGroupPerMin;
+  const perGroupBurst = parsePositiveInt(env.SWITCHROOM_TG_SEND_GATE_PER_GROUP_BURST);
+  if (perGroupBurst !== undefined)
+    out.perGroupBurst = perGroupBurst;
+  const editFloorMs = parseNonNegativeInt(env.SWITCHROOM_TG_SEND_GATE_EDIT_FLOOR_MS);
+  if (editFloorMs !== undefined)
+    out.editFloorMs = editFloorMs;
+  const conservativeGlobal = parseBoolFlag(env.SWITCHROOM_TG_SEND_GATE_CONSERVATIVE_GLOBAL);
+  if (conservativeGlobal !== undefined)
+    out.conservativeGlobalFloodScope = conservativeGlobal;
+  return out;
+}
+
+// shared/local-time.ts
+function fmtLocalClock(ms, tz) {
+  return new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true
+  }).format(new Date(ms)).replace(/\s([AP])M$/, (_m, p) => `${p.toLowerCase()}m`);
+}
+function fmtLocalDate(ms, tz) {
+  return new Intl.DateTimeFormat("en-GB", {
+    timeZone: tz,
+    day: "numeric",
+    month: "short"
+  }).format(new Date(ms));
+}
+function localDay(ms, tz) {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone: tz,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(new Date(ms));
+}
+function tzAbbrev(ms, tz) {
+  const at = new Date(ms);
+  for (const loc of ["en-US", "en-AU", "en-GB"]) {
+    const v = new Intl.DateTimeFormat(loc, { timeZone: tz, timeZoneName: "short" }).formatToParts(at).find((p) => p.type === "timeZoneName")?.value;
+    if (v && !/^(?:GMT|UTC)/i.test(v))
+      return v;
+  }
+  return new Intl.DateTimeFormat("en-US", { timeZone: tz, timeZoneName: "short" }).formatToParts(at).find((p) => p.type === "timeZoneName")?.value ?? tz;
 }
 
 // send-gate-observability.ts
@@ -55798,8 +56140,18 @@ function createStatsLogger(config) {
 function isAlertableScope(scopeKey) {
   return scopeKey === "global" || scopeKey.startsWith("chat:") || scopeKey.startsWith("group:");
 }
-function fmtTs(ms) {
-  return new Date(ms).toISOString().replace(/\.\d{3}/, "");
+function fmtLocalStamp(ms, tz, refMs) {
+  const clock = fmtLocalClock(ms, tz);
+  const sameDay = refMs != null && localDay(ms, tz) === localDay(refMs, tz);
+  const body = sameDay ? clock : `${fmtLocalDate(ms, tz)} ${clock}`;
+  return `${body} ${tzAbbrev(ms, tz)}`;
+}
+function fmtLocalRange(startMs, endMs, tz) {
+  const sameDay = localDay(startMs, tz) === localDay(endMs, tz);
+  if (sameDay) {
+    return `${fmtLocalClock(startMs, tz)} to ${fmtLocalClock(endMs, tz)} ${tzAbbrev(endMs, tz)}`;
+  }
+  return `${fmtLocalDate(startMs, tz)} ${fmtLocalClock(startMs, tz)} to ` + `${fmtLocalDate(endMs, tz)} ${fmtLocalClock(endMs, tz)} ${tzAbbrev(endMs, tz)}`;
 }
 function fmtDur(ms) {
   const s = Math.round(ms / 1000);
@@ -55811,6 +56163,7 @@ function fmtDur(ms) {
 }
 function createFloodWindowObserver(config) {
   const alertThresholdMs = config.alertThresholdMs ?? 60000;
+  const tz = config.tz ?? "UTC";
   let lastSeen = new Map;
   let firstTick = true;
   const owedOnClose = new Set;
@@ -55831,14 +56184,14 @@ function createFloodWindowObserver(config) {
   }
   function openAlertText(w, now) {
     const openFor = fmtDur(now - w.observedAt);
-    return `\u26a0\ufe0f Telegram flood ban active (scope \`${w.scopeKey}\`). ` + `Open for ${openFor}, expected to clear at ${fmtTs(w.untilTs)} UTC. ` + `Outbound to that scope is being suppressed.`;
+    return `\u26a0\ufe0f Telegram flood ban active (scope \`${w.scopeKey}\`). ` + `Open for ${openFor}, expected to clear at ${fmtLocalStamp(w.untilTs, tz, now)}. ` + `Outbound to that scope is being suppressed.`;
   }
   function closeAlertText(recs) {
     const observedAt = Math.min(...recs.map((r) => r.observedAt));
     const untilTs = Math.max(...recs.map((r) => r.untilTs));
     const scopes = recs.map((r) => `\`${r.scopeKey}\``).join(", ");
     const plural = recs.length > 1 ? "s" : "";
-    return `\u26a0\ufe0f Telegram flood ban cleared (scope${plural} ${scopes}). ` + `The bot was banned from ${fmtTs(observedAt)} to ${fmtTs(untilTs)} UTC ` + `(~${fmtDur(untilTs - observedAt)}). Some outbound messages during that ` + `window were suppressed.`;
+    return `\u26a0\ufe0f Telegram flood ban cleared (scope${plural} ${scopes}). ` + `The bot was banned from ${fmtLocalRange(observedAt, untilTs, tz)} ` + `(~${fmtDur(untilTs - observedAt)}). Some outbound messages during that ` + `window were suppressed.`;
   }
   async function tick() {
     const s = config.stats();
@@ -63707,18 +64060,28 @@ function createFleetFallbackResumeGate(opts = {}) {
   const maxAgeMs = opts.maxAgeMs ?? DEFAULT_RESUME_MAX_AGE_MS;
   const singleFlightMs = opts.singleFlightMs ?? DEFAULT_RESUME_SINGLE_FLIGHT_MS;
   let lastResumedAtMs = Number.NEGATIVE_INFINITY;
-  function decide(failedTurnStartedAtMs) {
+  function peek(failedTurnStartedAtMs) {
     const now = nowFn();
     if (now - lastResumedAtMs < singleFlightMs)
       return "skip-inflight";
     if (failedTurnStartedAtMs != null && now - failedTurnStartedAtMs > maxAgeMs) {
       return "skip-stale";
     }
-    lastResumedAtMs = now;
     return "resume";
   }
+  function arm() {
+    lastResumedAtMs = nowFn();
+  }
+  function decide(failedTurnStartedAtMs) {
+    const verdict = peek(failedTurnStartedAtMs);
+    if (verdict === "resume")
+      arm();
+    return verdict;
+  }
   return {
     decide,
+    peek,
+    arm,
     reset() {
       lastResumedAtMs = Number.NEGATIVE_INFINITY;
     },
@@ -64420,10 +64783,30 @@ function autoClassifyMidTurnInbound(i) {
     return { decision: "queue", reason: "cross_topic", sameTopic: false };
   return recent && i.msSinceLastAgentOutput <= i.topicSteerWindowMs ? { decision: "steer", reason: "same_topic_recent", sameTopic: true } : { decision: "queue", reason: "same_topic_stale", sameTopic: true };
 }
+// raw-error-scrub.ts
+function stripRawErrorBytes(raw) {
+  if (typeof raw !== "string" || raw.length === 0)
+    return "";
+  let s = raw;
+  s = s.replace(/API Error:?\s*\d*\s*/gi, " ");
+  s = s.replace(/\bb'[^']*'/g, " ");
+  s = s.replace(/\bb"[^"]*"/g, " ");
+  s = s.replace(/[\u00b7\-\s]*\{[\s\S]*?["']type["']\s*:\s*["']error["'][\s\S]*$/i, " ");
+  s = s.replace(/^\s*\{[\s\S]*\}\s*$/g, " ");
+  s = s.replace(/\s+/g, " ").replace(/[\u00b7:\-\s]+$/g, "").replace(/^[\u00b7:\-\s]+/g, "").trim();
+  return s;
+}
+function extractRequestId(raw) {
+  if (typeof raw !== "string" || raw.length === 0)
+    return;
+  const m = raw.match(/["']request[_-]?id["']\s*:\s*["']([A-Za-z0-9._-]+)["']/i) ?? raw.match(/\brequest[_-]?id[=:]\s*([A-Za-z0-9._-]+)/i);
+  return m ? m[1] : undefined;
+}
+
 // operator-events.ts
 function renderOperatorEvent(ev) {
   const agent = escapeMarkdown(ev.agent);
-  const detail = escapeMarkdown(ev.detail);
+  const detail = escapeMarkdown(stripRawErrorBytes(ev.detail));
   switch (ev.kind) {
     case "credentials-expired":
       return {
@@ -64640,6 +65023,13 @@ var transientUpstreamSignals = [
   "would exceed your account\u2019s rate limit",
   "would exceed your account's rate limit"
 ];
+function isTransientUpstreamSignal(text4) {
+  if (typeof text4 !== "string" || text4.length === 0)
+    return false;
+  const sample = text4.length > 16384 ? text4.slice(0, 16384) : text4;
+  const lower = sample.toLowerCase();
+  return transientUpstreamSignals.some((s) => lower.includes(s));
+}
 var litellmProxyLocal429Signals = [
   "deployment over user-defined ratelimit",
   "model rate limit exceeded. tpm limit",
@@ -64660,6 +65050,56 @@ function isLitellmProxyLocal429(text4) {
     return true;
   return litellmV3LimiterSignalPair.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 detectModelUnavailable(stderr) {
   if (typeof stderr !== "string" || stderr.length === 0)
     return null;
@@ -64853,54 +65293,358 @@ function parseRelativeDuration(s) {
   }
   return matched && total > 0 ? total : null;
 }
-function formatModelUnavailableCard(detection, agent, opts = {}) {
+
+// throttle-tier.ts
+init_card_format();
+init_quota_check();
+var accountScopedThrottleSignals = [
+  "would exceed your account's rate limit",
+  "would exceed your account\u2019s rate limit",
+  "not your account"
+];
+function isAccountScopedThrottle(text4) {
+  if (typeof text4 !== "string" || text4.length === 0)
+    return false;
+  const sample = text4.length > 16384 ? text4.slice(0, 16384) : text4;
+  const lower = sample.toLowerCase();
+  return accountScopedThrottleSignals.some((s) => lower.includes(s));
+}
+function classify429Detail(text4) {
+  if (isAccountScopedThrottle(text4))
+    return "account-scoped";
+  if (isLitellmProxyLocal429(text4))
+    return "litellm-local";
+  return "generic-transient";
+}
+var THROTTLE_RETRY_IN_PLACE_MAX_MS_DEFAULT = 5 * 60000;
+var THROTTLE_NOTICE_COOLDOWN_MS = 10 * 60000;
+function evaluateThrottleNotice(prev, account, now, cooldownMs = THROTTLE_NOTICE_COOLDOWN_MS) {
+  const last = prev.lastSentAtMsByAccount[account] ?? 0;
+  if (now - last >= cooldownMs) {
+    return {
+      send: true,
+      next: {
+        lastSentAtMsByAccount: {
+          ...prev.lastSentAtMsByAccount,
+          [account]: now
+        }
+      }
+    };
+  }
+  return { send: false, next: prev };
+}
+function renderThrottleNotice(opts) {
   const now = opts.now ?? new Date;
-  const slotPart = opts.slot ? ` (slot **${escapeMarkdown(opts.slot)}**)` : "";
-  const reason = formatReason(detection, now);
+  const resetStr = formatResetRelative(new Date(opts.throttledUntilMs), now);
+  const acct = opts.account ? `\`${escapeMarkdown(opts.account)}\`` : "the active account";
   const lines = [
-    `\u26a0\ufe0f **Model unavailable** on agent **${escapeMarkdown(agent)}**${slotPart}`,
-    `Reason: ${reason}`,
-    ""
+    `\uD83D\uDEA6 **Rate-limited, staying put** \u2014 ${acct} hit a transient rate limit on **${escapeMarkdown(opts.agent)}**.`,
+    `This is a short throttle, not a quota wall \u2014 ${opts.resetParsed ? resetStr : `no reset given, retrying in ~60s`}.`,
+    `_Staying on ${acct}; no failover needed. The turn retries automatically after the reset._`
   ];
-  if (opts.autoFallbackInFlight) {
-    lines.push("_Auto-failover in progress \u2014 see the announcement below._");
-  } else {
-    lines.push("**What to try**", "\u2022 `/auth use <label>` \u2014 switch the fleet to a healthy account", "\u2022 `/auth add` \u2014 attach another subscription", "\u2022 `/usage` \u2014 show quota breakdown");
-  }
   return lines.join(`
 `);
 }
-function formatReason(d, now) {
-  const reset2 = d.resetAt ? ` (${formatResetRelative(d.resetAt, now)})` : "";
-  switch (d.kind) {
-    case "quota_exhausted":
-      return `quota exhausted${reset2}`;
-    case "overload":
-      return `model overloaded${reset2}`;
-    case "rate_limited":
-      return `account rate-limited${reset2}`;
-    case "network":
-      return "network unreachable";
+function renderThrottleEscalationNotice(opts) {
+  const acct = opts.account ? `\`${escapeMarkdown(opts.account)}\`` : "the active account";
+  const head = `\u26d4\ufe0f **Rate limit was actually a wall** \u2014 repeated 429s on ${acct} ` + `(trigger: **${escapeMarkdown(opts.agent)}**) were corroborated by a live quota probe.`;
+  const tail = opts.rolledTo ? `Marked exhausted and rolled to \`${escapeMarkdown(opts.rolledTo)}\`.` : `Marked exhausted \u2014 no fallback account had quota (all blocked). ` + `Use \`/auth add <label>\` to attach another subscription.`;
+  return `${head}
+${tail}`;
+}
+// operator-events.ts
+function classifyClaudeError(raw) {
+  try {
+    return classifyInner(raw);
+  } catch {
+    return "unknown-4xx";
   }
 }
-function resolveModelUnavailableFromOperatorEvent(ev) {
-  const detail = typeof ev.detail === "string" ? ev.detail : "";
-  if (ev.kind === "quota-exhausted") {
-    return detectModelUnavailable(detail) ?? { kind: "quota_exhausted", raw: detail };
+function classifyInner(raw) {
+  if (raw == null)
+    return "unknown-4xx";
+  const obj = typeof raw === "object" ? raw : {};
+  const errorType = extractString(obj, "error_type") ?? extractString(obj, "type") ?? extractString(getNestedObj(obj, "error"), "type") ?? "";
+  const errorCode = extractString(obj, "code") ?? extractString(getNestedObj(obj, "error"), "code") ?? "";
+  const message = extractString(obj, "message") ?? extractString(getNestedObj(obj, "error"), "message") ?? (typeof raw === "string" ? raw : "") ?? "";
+  const status = extractNumber(obj, "status") ?? extractNumber(obj, "statusCode") ?? extractNumber(obj, "status_code") ?? null;
+  const sdkCode = extractString(obj, "error_code") ?? "";
+  if (errorType === "authentication_error" || errorCode === "authentication_error" || sdkCode === "authentication_error" || message.toLowerCase().includes("authentication_error")) {
+    const msg = message.toLowerCase();
+    if (msg.includes("expired") || msg.includes("refresh")) {
+      return "credentials-expired";
+    }
+    return "credentials-invalid";
   }
-  if (ev.kind === "rate-limited") {
-    const detected = detectModelUnavailable(detail);
-    return detected?.kind === "quota_exhausted" ? detected : null;
+  if (errorType === "invalid_api_key" || errorCode === "invalid_api_key" || sdkCode === "invalid_api_key" || message.toLowerCase().includes("invalid_api_key") || message.toLowerCase().includes("invalid api key")) {
+    return "credentials-invalid";
   }
-  if (ev.kind === "unknown-5xx") {
-    return detectModelUnavailable(detail) ?? { kind: "overload", raw: detail };
+  if (errorType === "credit_balance_too_low" || errorCode === "credit_balance_too_low" || sdkCode === "credit_balance_too_low" || message.toLowerCase().includes("credit_balance_too_low") || message.toLowerCase().includes("credit balance")) {
+    return "credit-exhausted";
+  }
+  if (errorType === "rate_limit_error" || errorCode === "rate_limit_error" || sdkCode === "rate_limit_error" || message.toLowerCase().includes("rate_limit_error") || message.toLowerCase().includes("rate limit")) {
+    return "rate-limited";
+  }
+  if (errorType === "overloaded_error" || errorCode === "overloaded_error" || sdkCode === "overloaded_error" || message.toLowerCase().includes("overloaded_error") || message.toLowerCase().includes("overloaded")) {
+    return "rate-limited";
+  }
+  if (errorType === "agent-crashed" || errorCode === "agent-crashed") {
+    return "agent-crashed";
   }
-  return detectModelUnavailable(detail);
+  if (errorType === "agent-restarted-unexpectedly" || errorCode === "agent-restarted-unexpectedly") {
+    return "agent-restarted-unexpectedly";
+  }
+  if (status != null) {
+    if (status >= 400 && status < 500)
+      return "unknown-4xx";
+    if (status >= 500 && status < 600)
+      return "unknown-5xx";
+  }
+  return "unknown-4xx";
+}
+function extractString(obj, key) {
+  const v = obj[key];
+  return typeof v === "string" && v.length > 0 ? v : null;
 }
+function extractNumber(obj, key) {
+  const v = obj[key];
+  return typeof v === "number" ? v : null;
+}
+function getNestedObj(obj, key) {
+  const v = obj[key];
+  return typeof v === "object" && v != null ? v : {};
+}
+var DEFAULT_OPERATOR_EVENT_COOLDOWN_MS2 = 5 * 60000;
+var cooldownMap2 = new Map;
 
-// throttle-tier.ts
-init_card_format();
-init_quota_check();
+// llm-error-present.ts
+function extractModel(raw) {
+  const m = raw.match(/["']?model["']?\s*[=:]\s*["']?((?:claude|sr)[A-Za-z0-9._-]+)/i);
+  return m ? m[1] : undefined;
+}
+var TRANSIENT_KINDS = new Set([
+  "rate_limit",
+  "overload_529",
+  "transient"
+]);
+function isActionableKind(kind) {
+  return kind === "auth" || kind === "quota_wall";
+}
+function parseLlmError(raw, retryState) {
+  const text4 = typeof raw === "string" ? raw : "";
+  const requestId = extractRequestId(text4);
+  const model = extractModel(text4);
+  const resetAt = parseResetTime(text4);
+  const retryAfterMs = resetAt != null ? Math.max(0, resetAt.getTime() - Date.now()) : undefined;
+  const { kind, source } = classifyKindAndSource(text4);
+  let autoRetrying = false;
+  let terminal = true;
+  if (TRANSIENT_KINDS.has(kind)) {
+    const { retryAttempt, maxRetries } = retryState ?? { retryAttempt: null, maxRetries: null };
+    if (retryAttempt != null && maxRetries != null) {
+      autoRetrying = retryAttempt < maxRetries;
+      terminal = retryAttempt >= maxRetries;
+    } else {
+      autoRetrying = false;
+      terminal = true;
+    }
+  }
+  return {
+    kind,
+    coreText: buildCoreText(kind, source),
+    ...resetAt != null ? { resetAt } : {},
+    ...retryAfterMs != null ? { retryAfterMs } : {},
+    ...model != null ? { model } : {},
+    ...requestId != null ? { requestId } : {},
+    source,
+    autoRetrying,
+    terminal
+  };
+}
+function classifyKindAndSource(text4) {
+  const lower = text4.toLowerCase();
+  const claudeKind = classifyClaudeError({ message: text4, type: text4 });
+  if (claudeKind === "credentials-expired" || claudeKind === "credentials-invalid") {
+    return { kind: "auth", source: "anthropic" };
+  }
+  if (isLitellmProxyLocal429(text4)) {
+    return { kind: "rate_limit", source: "litellm-local" };
+  }
+  const mu = detectModelUnavailable(text4);
+  if (mu != null) {
+    if (mu.kind === "quota_exhausted")
+      return { kind: "quota_wall", source: "anthropic" };
+    if (mu.kind === "network")
+      return { kind: "transient", source: "network" };
+    if (lower.includes("529") || lower.includes("overloaded")) {
+      return { kind: "overload_529", source: "anthropic" };
+    }
+    const c = classify429Detail(text4);
+    return {
+      kind: "rate_limit",
+      source: c === "litellm-local" ? "litellm-local" : "anthropic"
+    };
+  }
+  if (claudeKind === "credit-exhausted") {
+    return { kind: "quota_wall", source: "anthropic" };
+  }
+  if (claudeKind === "rate-limited") {
+    return { kind: "rate_limit", source: "anthropic" };
+  }
+  if (claudeKind === "unknown-5xx") {
+    return { kind: "overload_529", source: "anthropic" };
+  }
+  return { kind: "unknown", source: "anthropic" };
+}
+function buildCoreText(kind, source) {
+  switch (kind) {
+    case "rate_limit":
+      return source === "litellm-local" ? "Hit the local proxy rate limit \u2014 retrying automatically." : "Rate limited by Anthropic \u2014 retrying automatically.";
+    case "overload_529":
+      return "Anthropic is overloaded (529) \u2014 retrying automatically.";
+    case "quota_wall":
+      return "Usage limit reached on this Claude subscription.";
+    case "auth":
+      return "Claude login needs re-authentication.";
+    case "transient":
+      return source === "network" ? "Couldn't reach Anthropic (network) \u2014 retrying automatically." : "A temporary upstream hiccup \u2014 retrying automatically.";
+    case "unknown":
+      return "The model returned an error.";
+  }
+}
+function formatResetLocal(resetAt, tz, now = new Date) {
+  if (resetAt == null)
+    return "";
+  const ms = resetAt.getTime();
+  if (!Number.isFinite(ms))
+    return "";
+  const clock = fmtLocalClock(ms, tz);
+  const abbrev = tzAbbrev(ms, tz);
+  const rel = formatRelativeTail(ms - now.getTime());
+  return rel ? `clears ~${clock} ${abbrev} (${rel})` : `clears ~${clock} ${abbrev}`;
+}
+function formatRelativeTail(deltaMs) {
+  if (deltaMs <= 0)
+    return "~now";
+  const totalMin = Math.round(deltaMs / 60000);
+  if (totalMin < 1)
+    return "~in <1m";
+  if (totalMin < 60)
+    return `~in ${totalMin}m`;
+  const hours = Math.floor(totalMin / 60);
+  const mins = totalMin % 60;
+  if (hours < 24)
+    return mins > 0 ? `~in ${hours}h ${mins}m` : `~in ${hours}h`;
+  const days = Math.floor(hours / 24);
+  const remH = hours % 24;
+  return remH > 0 ? `~in ${days}d ${remH}h` : `~in ${days}d`;
+}
+function renderLlmError(parsed, agent, tz, now = new Date) {
+  const safeAgent = escapeAgent(agent);
+  const emoji = kindEmoji(parsed.kind);
+  const lines = [`${emoji} ${parsed.coreText} (**${safeAgent}**)`];
+  const resetLine = formatResetLocal(parsed.resetAt, tz, now);
+  if (resetLine)
+    lines.push(`_${resetLine}_`);
+  if (parsed.model)
+    lines.push(`_model: ${escapeAgent(parsed.model)}_`);
+  const text4 = lines.join(`
+`);
+  switch (parsed.kind) {
+    case "auth":
+      return {
+        text: text4,
+        keyboard: {
+          inline_keyboard: [
+            [
+              { text: "\uD83D\uDD10 Reauth now", callback_data: `op:reauth:${encodeURIComponent(agent)}` },
+              { text: "\u274c Dismiss", callback_data: `op:dismiss:${encodeURIComponent(agent)}` }
+            ]
+          ]
+        }
+      };
+    case "quota_wall":
+      return {
+        text: text4,
+        keyboard: {
+          inline_keyboard: [
+            [{ text: "\u23f3 Wait", callback_data: `op:dismiss:${encodeURIComponent(agent)}` }]
+          ]
+        }
+      };
+    default:
+      return { text: text4 };
+  }
+}
+function kindEmoji(kind) {
+  switch (kind) {
+    case "rate_limit":
+      return "\uD83D\uDEA6";
+    case "overload_529":
+      return "\uD83D\uDD25";
+    case "quota_wall":
+      return "\u26a0\ufe0f";
+    case "auth":
+      return "\uD83D\uDD11";
+    case "transient":
+      return "\uD83C\uDF10";
+    case "unknown":
+      return "\u26a0\ufe0f";
+  }
+}
+function escapeAgent(s) {
+  return s.replace(/([_*`\[\]])/g, "\\$1");
+}
+var ERROR_COLLAPSE_WINDOW_MS = 60000;
+
+class ErrorPresenceGate {
+  claims = new Map;
+  keyFor(parsed, agent, now) {
+    if (parsed.requestId)
+      return `rid:${parsed.requestId}`;
+    const bucket = Math.floor(now / ERROR_COLLAPSE_WINDOW_MS);
+    return `${parsed.kind}:${agent}:${bucket}`;
+  }
+  claim(key, now = Date.now()) {
+    this.prune(now);
+    const existing = this.claims.get(key);
+    if (existing != null && now - existing < ERROR_COLLAPSE_WINDOW_MS) {
+      return false;
+    }
+    this.claims.set(key, now);
+    return true;
+  }
+  isClaimed(key, now = Date.now()) {
+    const existing = this.claims.get(key);
+    return existing != null && now - existing < ERROR_COLLAPSE_WINDOW_MS;
+  }
+  prune(now) {
+    for (const [k, at] of this.claims) {
+      if (now - at >= ERROR_COLLAPSE_WINDOW_MS)
+        this.claims.delete(k);
+    }
+  }
+  reset() {
+    this.claims.clear();
+  }
+}
+var errorPresenceGate = new ErrorPresenceGate;
+function decideErrorSurface(parsed, agent, opts = { claim: true }) {
+  const now = opts.now ?? Date.now();
+  const gate = opts.gate ?? errorPresenceGate;
+  if (isActionableKind(parsed.kind)) {
+    if (opts.claim)
+      gate.claim(gate.keyFor(parsed, agent, now), now);
+    return "render";
+  }
+  if (parsed.autoRetrying && !parsed.terminal)
+    return "suppress";
+  const key = gate.keyFor(parsed, agent, now);
+  if (opts.claim) {
+    return gate.claim(key, now) ? "render" : "suppress";
+  }
+  return gate.isClaimed(key, now) ? "suppress" : "render";
+}
 
 // model-unavailable.ts
 init_quota_check();
@@ -64915,13 +65659,6 @@ var transientUpstreamSignals2 = [
   "would exceed your account\u2019s rate limit",
   "would exceed your account's rate limit"
 ];
-function isTransientUpstreamSignal(text4) {
-  if (typeof text4 !== "string" || text4.length === 0)
-    return false;
-  const sample = text4.length > 16384 ? text4.slice(0, 16384) : 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",
@@ -64942,55 +65679,76 @@ function isLitellmProxyLocal4292(text4) {
     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;
+function detectModelUnavailable2(stderr) {
+  if (typeof stderr !== "string" || stderr.length === 0)
+    return null;
+  const sample = stderr.length > 16384 ? stderr.slice(0, 16384) : stderr;
   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 (transientUpstreamSignals2.some((s) => lower.includes(s))) {
+    const resetAt = parseResetTime2(sample);
+    return resetAt !== undefined ? { kind: "overload", resetAt, raw: stderr } : { kind: "overload", raw: stderr };
   }
-  if (limitType == null) {
-    const v3Type = lower.match(/limit type:\s*(tokens|requests|max_parallel_requests)/);
-    if (v3Type)
-      limitType = v3Type[1];
+  if (isLitellmProxyLocal4292(sample)) {
+    const resetAt = parseResetTime2(sample);
+    return resetAt !== undefined ? { kind: "overload", resetAt, raw: stderr } : { kind: "overload", raw: stderr };
   }
-  if (limit == null) {
-    const v3Limit = lower.match(/current limit:\s*(\d+)/);
-    if (v3Limit)
-      limit = Number(v3Limit[1]);
+  const quotaSignals = [
+    "out of extra usage",
+    "extra usage",
+    "credit_balance_too_low",
+    "credit balance too low",
+    "usage limit",
+    "usage_limit",
+    "quota exhausted",
+    "quota_exhausted",
+    "plan limit",
+    "subscription limit",
+    "hit your limit",
+    "hit the limit",
+    "session limit",
+    "session cap"
+  ];
+  if (quotaSignals.some((s) => lower.includes(s))) {
+    const resetAt = parseResetTime2(sample);
+    return resetAt !== undefined ? { kind: "quota_exhausted", resetAt, raw: stderr } : { kind: "quota_exhausted", raw: stderr };
   }
-  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();
+  const overloadSignals = [
+    "overloaded_error",
+    "overloaded",
+    "rate_limit_error",
+    "rate limit",
+    "rate-limited",
+    "http 429",
+    '"status":429',
+    "status: 429",
+    " 429 ",
+    "503 service",
+    "service unavailable",
+    '"status":529',
+    "http 529",
+    " 529 "
+  ];
+  if (overloadSignals.some((s) => lower.includes(s))) {
+    const resetAt = parseResetTime2(sample);
+    return resetAt !== undefined ? { kind: "overload", resetAt, raw: stderr } : { kind: "overload", raw: stderr };
   }
-  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);
-      }
-    }
+  const networkSignals = [
+    "econnrefused",
+    "econnreset",
+    "etimedout",
+    "enotfound",
+    "eai_again",
+    "fetch failed",
+    "network error",
+    "socket hang up",
+    "request timed out",
+    "connection refused",
+    "getaddrinfo"
+  ];
+  if (networkSignals.some((s) => lower.includes(s))) {
+    return { kind: "network", raw: stderr };
   }
-  return {
-    limitType,
-    limit: limit != null && Number.isFinite(limit) ? limit : null,
-    currentUsage: currentUsage != null && Number.isFinite(currentUsage) ? currentUsage : null,
-    resetAtMs
-  };
+  return null;
 }
 function parseResetTime2(text4, parseTimeNow = new Date) {
   const lower = text4.toLowerCase();
@@ -65114,31 +65872,77 @@ function parseRelativeDuration2(s) {
   }
   return matched && total > 0 ? total : null;
 }
+function formatModelUnavailableCard(detection, agent, opts = {}) {
+  const now = opts.now ?? new Date;
+  const slotPart = opts.slot ? ` (slot **${escapeMarkdown(opts.slot)}**)` : "";
+  const reason = formatReason(detection, now);
+  const lines = [
+    `\u26a0\ufe0f **Model unavailable** on agent **${escapeMarkdown(agent)}**${slotPart}`,
+    `Reason: ${reason}`,
+    ""
+  ];
+  if (opts.autoFallbackInFlight) {
+    lines.push("_Auto-failover in progress \u2014 see the announcement below._");
+  } else {
+    lines.push("**What to try**", "\u2022 `/auth use <label>` \u2014 switch the fleet to a healthy account", "\u2022 `/auth add` \u2014 attach another subscription", "\u2022 `/usage` \u2014 show quota breakdown");
+  }
+  return lines.join(`
+`);
+}
+function formatReason(d, now) {
+  const reset2 = d.resetAt ? ` (${formatResetRelative(d.resetAt, now)})` : "";
+  switch (d.kind) {
+    case "quota_exhausted":
+      return `quota exhausted${reset2}`;
+    case "overload":
+      return `model overloaded${reset2}`;
+    case "rate_limited":
+      return `account rate-limited${reset2}`;
+    case "network":
+      return "network unreachable";
+  }
+}
+function resolveModelUnavailableFromOperatorEvent(ev) {
+  const detail = typeof ev.detail === "string" ? ev.detail : "";
+  if (ev.kind === "quota-exhausted") {
+    return detectModelUnavailable2(detail) ?? { kind: "quota_exhausted", raw: detail };
+  }
+  if (ev.kind === "rate-limited") {
+    const detected = detectModelUnavailable2(detail);
+    return detected?.kind === "quota_exhausted" ? detected : null;
+  }
+  if (ev.kind === "unknown-5xx") {
+    return detectModelUnavailable2(detail) ?? { kind: "overload", raw: detail };
+  }
+  return detectModelUnavailable2(detail);
+}
 
 // throttle-tier.ts
-var accountScopedThrottleSignals = [
+init_card_format();
+init_quota_check();
+var accountScopedThrottleSignals2 = [
   "would exceed your account's rate limit",
   "would exceed your account\u2019s rate limit",
   "not your account"
 ];
-function isAccountScopedThrottle(text4) {
+function isAccountScopedThrottle2(text4) {
   if (typeof text4 !== "string" || text4.length === 0)
     return false;
   const sample = text4.length > 16384 ? text4.slice(0, 16384) : text4;
   const lower = sample.toLowerCase();
-  return accountScopedThrottleSignals.some((s) => lower.includes(s));
+  return accountScopedThrottleSignals2.some((s) => lower.includes(s));
 }
-function classify429Detail(text4) {
-  if (isAccountScopedThrottle(text4))
+function classify429Detail2(text4) {
+  if (isAccountScopedThrottle2(text4))
     return "account-scoped";
-  if (isLitellmProxyLocal4292(text4))
+  if (isLitellmProxyLocal429(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 anthropicResetMs = parseResetTime(detail, new Date(opts.now))?.getTime() ?? null;
   const resetAtMs = anthropicResetMs ?? litellm.resetAtMs;
   return {
     kind: "rate_limit_429_classified",
@@ -65152,20 +65956,20 @@ function build429ClassifiedMetric(opts) {
     current_usage: litellm.currentUsage
   };
 }
-var THROTTLE_RETRY_IN_PLACE_MAX_MS_DEFAULT = 5 * 60000;
+var THROTTLE_RETRY_IN_PLACE_MAX_MS_DEFAULT2 = 5 * 60000;
 var THROTTLE_DEFAULT_WAIT_MS = 60000;
 function throttleRetryInPlaceMaxMs(env = process.env) {
   const raw = env.SWITCHROOM_THROTTLE_RETRY_IN_PLACE_MAX_MS;
   if (raw == null || raw === "")
-    return THROTTLE_RETRY_IN_PLACE_MAX_MS_DEFAULT;
+    return THROTTLE_RETRY_IN_PLACE_MAX_MS_DEFAULT2;
   const n = Number(raw);
-  return Number.isFinite(n) && n > 0 ? n : THROTTLE_RETRY_IN_PLACE_MAX_MS_DEFAULT;
+  return Number.isFinite(n) && n > 0 ? n : THROTTLE_RETRY_IN_PLACE_MAX_MS_DEFAULT2;
 }
 function decideThrottleTier(opts) {
   const { detail, now, thresholdMs } = opts;
-  if (!isAccountScopedThrottle(detail))
+  if (!isAccountScopedThrottle2(detail))
     return { action: "none" };
-  const resetAt = parseResetTime2(detail, new Date(now));
+  const resetAt = parseResetTime(detail, new Date(now));
   const resetAtMs = resetAt?.getTime();
   if (resetAtMs == null || !Number.isFinite(resetAtMs) || resetAtMs <= now) {
     return {
@@ -65179,47 +65983,7 @@ function decideThrottleTier(opts) {
   }
   return { action: "failover", resetAtMs };
 }
-var THROTTLE_NOTICE_COOLDOWN_MS = 10 * 60000;
-
-// throttle-tier.ts
-init_card_format();
-init_quota_check();
-var THROTTLE_RETRY_IN_PLACE_MAX_MS_DEFAULT2 = 5 * 60000;
 var THROTTLE_NOTICE_COOLDOWN_MS2 = 10 * 60000;
-function evaluateThrottleNotice(prev, account, now, cooldownMs = THROTTLE_NOTICE_COOLDOWN_MS2) {
-  const last = prev.lastSentAtMsByAccount[account] ?? 0;
-  if (now - last >= cooldownMs) {
-    return {
-      send: true,
-      next: {
-        lastSentAtMsByAccount: {
-          ...prev.lastSentAtMsByAccount,
-          [account]: now
-        }
-      }
-    };
-  }
-  return { send: false, next: prev };
-}
-function renderThrottleNotice(opts) {
-  const now = opts.now ?? new Date;
-  const resetStr = formatResetRelative(new Date(opts.throttledUntilMs), now);
-  const acct = opts.account ? `\`${escapeMarkdown(opts.account)}\`` : "the active account";
-  const lines = [
-    `\uD83D\uDEA6 **Rate-limited, staying put** \u2014 ${acct} hit a transient rate limit on **${escapeMarkdown(opts.agent)}**.`,
-    `This is a short throttle, not a quota wall \u2014 ${opts.resetParsed ? resetStr : `no reset given, retrying in ~60s`}.`,
-    `_Staying on ${acct}; no failover needed. The turn retries automatically after the reset._`
-  ];
-  return lines.join(`
-`);
-}
-function renderThrottleEscalationNotice(opts) {
-  const acct = opts.account ? `\`${escapeMarkdown(opts.account)}\`` : "the active account";
-  const head = `\u26d4\ufe0f **Rate limit was actually a wall** \u2014 repeated 429s on ${acct} ` + `(trigger: **${escapeMarkdown(opts.agent)}**) were corroborated by a live quota probe.`;
-  const tail = opts.rolledTo ? `Marked exhausted and rolled to \`${escapeMarkdown(opts.rolledTo)}\`.` : `Marked exhausted \u2014 no fallback account had quota (all blocked). ` + `Use \`/auth add <label>\` to attach another subscription.`;
-  return `${head}
-${tail}`;
-}
 
 // gateway/throttle-tier-wiring.ts
 var THROTTLE_RETRY_NUDGE_SLACK_MS = 5000;
@@ -65240,7 +66004,7 @@ function createThrottleTierRunner(deps) {
       let granted = true;
       if (client3 && account) {
         try {
-          granted = (await client3.claimNotification(`${keyPrefix}:${account}:${chatId}`, THROTTLE_NOTICE_COOLDOWN_MS2)).granted;
+          granted = (await client3.claimNotification(`${keyPrefix}:${account}:${chatId}`, THROTTLE_NOTICE_COOLDOWN_MS)).granted;
         } catch {
           granted = true;
         }
@@ -65325,6 +66089,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();
@@ -68634,7 +69524,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 = [];
@@ -69185,15 +70090,11 @@ var MODEL_ARG_RE2 = /^[A-Za-z0-9][A-Za-z0-9._/\[\]-]{0,99}$/;
 function isValidModelArg2(arg) {
   return MODEL_ARG_RE2.test(arg);
 }
+var MODEL_CALLBACK_ALIAS2 = "mdl:alias:";
 
 // 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");
@@ -69207,17 +70108,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)}`);
@@ -69231,20 +70121,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) {
@@ -69256,40 +70135,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();
@@ -69300,37 +70145,185 @@ function readConfiguredDefaultModel(agentDir) {
 }
 var SESSION_EFFORT_FILE = ".session-effort";
 var EFFORT_LEVEL_RE = /^(low|medium|high|xhigh|max)$/;
-function parseSessionEffort(text4) {
+function writeSessionEffortFile(agentDir, level, configuredDefaultAtWrite) {
+  if (!EFFORT_LEVEL_RE.test(level)) {
+    throw new Error(`refusing to persist non-allowlisted effort level: ${JSON.stringify(level)}`);
+  }
+  atomicWrite(join29(agentDir, SESSION_EFFORT_FILE), `${JSON.stringify({ level, configuredDefaultAtWrite: configuredDefaultAtWrite ?? "", ts: Date.now() })}
+`);
+}
+function clearSessionEffortFile(agentDir) {
+  try {
+    rmSync4(join29(agentDir, SESSION_EFFORT_FILE), { force: true });
+  } catch {}
+}
+var PREMIUM_RECOVERY_FILE = ".premium-recovery";
+function parsePremiumRecovery(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)) {
+    if (typeof raw.premiumModel !== "string" || !isValidModelArg2(raw.premiumModel) || typeof raw.ts !== "number" || !Array.isArray(raw.chats) || raw.chats.length === 0 || !raw.chats.every((c) => typeof c === "string" && c.length > 0)) {
       return null;
     }
-    return { level: raw.level, configuredDefaultAtWrite: raw.configuredDefaultAtWrite, ts: raw.ts };
+    return { premiumModel: raw.premiumModel, chats: raw.chats, 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)}`);
+function writePremiumRecoveryFile(agentDir, premiumModel, chats) {
+  if (!isValidModelArg2(premiumModel)) {
+    throw new Error(`refusing to persist non-canonical premium-recovery token: ${JSON.stringify(premiumModel)}`);
   }
-  atomicWrite(join29(agentDir, SESSION_EFFORT_FILE), `${JSON.stringify({ level, configuredDefaultAtWrite: configuredDefaultAtWrite ?? "", ts: Date.now() })}
+  const clean = chats.filter((c) => typeof c === "string" && c.length > 0);
+  if (clean.length === 0) {
+    throw new Error("refusing to persist premium-recovery marker with no chats to notify");
+  }
+  atomicWrite(join29(agentDir, PREMIUM_RECOVERY_FILE), `${JSON.stringify({ premiumModel, chats: clean, ts: Date.now() })}
 `);
 }
-function readSessionEffortFile(agentDir) {
+function readPremiumRecoveryFile(agentDir) {
+  let raw;
   try {
-    return parseSessionEffort(readFileSync25(join29(agentDir, SESSION_EFFORT_FILE), "utf8"));
+    raw = readFileSync25(join29(agentDir, PREMIUM_RECOVERY_FILE), "utf8");
   } catch {
     return null;
   }
+  const parsed = parsePremiumRecovery(raw);
+  if (parsed == null) {
+    clearPremiumRecoveryFile(agentDir);
+    return null;
+  }
+  return parsed;
 }
-function clearSessionEffortFile(agentDir) {
+function clearPremiumRecoveryFile(agentDir) {
   try {
-    rmSync4(join29(agentDir, SESSION_EFFORT_FILE), { force: true });
+    rmSync4(join29(agentDir, PREMIUM_RECOVERY_FILE), { force: true });
   } catch {}
 }
 
+// tier-downgrade.ts
+function decideTierDowngrade(input) {
+  const configured = typeof input.configuredDefault === "string" ? input.configuredDefault.trim() : "";
+  if (configured.length === 0) {
+    return { action: "skip", reason: "unresolved" };
+  }
+  const override = input.sessionOverride;
+  if (override == null || override.length === 0) {
+    return { action: "skip", reason: "on-default" };
+  }
+  if (input.resolve(override) === input.resolve(configured)) {
+    return { action: "skip", reason: "on-default" };
+  }
+  return { action: "downgrade", toModel: configured, fromModel: override };
+}
+function renderTierDowngradeNotice(fromModel, toModel, agent) {
+  return `\u2935\ufe0f **Downgrading model to keep going** on agent **${agent}**
+` + `\`${fromModel}\` is overloaded across every account right now, so this turn is ` + `resuming on the default \`${toModel}\` to keep working. ` + `Re-issue \`/model ${fromModel}\` once it frees up \u2014 it won't switch back on its own.`;
+}
+function planTierDowngrade(decision, gateVerdict, agent) {
+  if (decision.action !== "downgrade")
+    return { kind: "skip" };
+  if (gateVerdict === "skip-inflight")
+    return { kind: "suppress" };
+  if (gateVerdict === "skip-stale")
+    return { kind: "skip" };
+  return {
+    kind: "downgrade",
+    toModel: decision.toModel,
+    fromModel: decision.fromModel,
+    notice: renderTierDowngradeNotice(decision.fromModel, decision.toModel, agent)
+  };
+}
+
+// gateway/tier-downgrade-wiring.ts
+function runTierDowngrade(triggerAgent, deps) {
+  const agentDir = deps.getAgentDir();
+  if (!agentDir)
+    return "skip";
+  const configuredDefault = deps.getConfiguredDefault() ?? "";
+  const decision = decideTierDowngrade({
+    sessionOverride: deps.getSessionOverride(),
+    configuredDefault,
+    resolve: deps.resolve
+  });
+  const gateVerdict = deps.peekResumeGate();
+  const plan = planTierDowngrade(decision, gateVerdict, triggerAgent);
+  if (plan.kind === "skip") {
+    if (decision.action === "downgrade") {
+      deps.log(`[tier-downgrade] restart suppressed (${gateVerdict}) agent=${triggerAgent}`);
+    }
+    return "skip";
+  }
+  if (plan.kind === "suppress") {
+    deps.log(`[tier-downgrade] give-up suppressed \u2014 a resume restart is already armed agent=${triggerAgent}`);
+    return "restart-pending";
+  }
+  try {
+    deps.writeCarrier(agentDir, plan.toModel, configuredDefault);
+  } catch (err) {
+    deps.log(`[tier-downgrade] failed to write session-model carrier \u2014 aborting downgrade: ${err?.message ?? err}`);
+    return "skip";
+  }
+  deps.armResumeGate();
+  deps.log(`[tier-downgrade] downgrading ${plan.fromModel} \u2192 ${plan.toModel} and resuming via self-restart agent=${triggerAgent}`);
+  try {
+    deps.writeRecoveryMarker(agentDir, plan.fromModel);
+  } catch (err) {
+    deps.log(`[tier-downgrade] premium-recovery marker write failed (non-fatal): ${err?.message ?? err}`);
+  }
+  deps.broadcastNotice(plan.notice);
+  deps.selfRestart(deps.selfAgent(triggerAgent));
+  return "downgraded";
+}
+
+// premium-recovery.ts
+function renderPremiumRecoveryPing(premiumModel) {
+  return {
+    text: `\u2705 \`${premiumModel}\` is available again \u2014 tap to switch back to it for this session.`,
+    buttonText: `Switch to ${premiumModel}`
+  };
+}
+function premiumRecoveryClaimKey(agent, premiumModel) {
+  return `premium-recovery:${agent}:${premiumModel}`;
+}
+
+// gateway/premium-recovery-wiring.ts
+async function runPremiumRecoveryPing(deps) {
+  const agentDir = deps.getAgentDir();
+  if (!agentDir)
+    return;
+  const marker = deps.readMarker(agentDir);
+  if (marker == null)
+    return;
+  if (!deps.decide())
+    return;
+  const agent = deps.getAgent();
+  const granted = await deps.claimNotification(premiumRecoveryClaimKey(agent, marker.premiumModel));
+  if (!granted) {
+    deps.clearMarker(agentDir);
+    return;
+  }
+  deps.clearMarker(agentDir);
+  const ping = renderPremiumRecoveryPing(marker.premiumModel);
+  const keyboard = {
+    inline_keyboard: [
+      [{ text: ping.buttonText, callback_data: `${MODEL_CALLBACK_ALIAS2}${marker.premiumModel}` }]
+    ]
+  };
+  const chats = marker.chats.length > 0 ? marker.chats : deps.fallbackChats();
+  for (const chatId of chats) {
+    deps.sendToChat(chatId, ping, keyboard);
+  }
+  deps.log(`[premium-recovery] ${marker.premiumModel} servable again \u2014 ping sent agent=${agent} chats=${chats.length}`);
+}
+
+// premium-recovery.ts
+function decidePremiumRecovery(opts) {
+  if (!opts.hasMarker)
+    return { fire: false, reason: "no-marker" };
+  const servable = opts.accounts.some((a) => !a.exhausted && !a.premiumWalled);
+  return servable ? { fire: true, reason: "recovered" } : { fire: false, reason: "still-walled" };
+}
+
 // ../src/agents/model-picker.ts
 var HEADER_RE = /Select model/;
 var OPTION_RE = /^\s*(\u276f)?\s*(\d+)\.\s+(.*)$/;
@@ -69699,7 +70692,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 = [];
@@ -76971,71 +77964,6 @@ import {
 } from "fs";
 import { join as join39 } from "path";
 
-// operator-events.ts
-function classifyClaudeError(raw) {
-  try {
-    return classifyInner(raw);
-  } catch {
-    return "unknown-4xx";
-  }
-}
-function classifyInner(raw) {
-  if (raw == null)
-    return "unknown-4xx";
-  const obj = typeof raw === "object" ? raw : {};
-  const errorType = extractString(obj, "error_type") ?? extractString(obj, "type") ?? extractString(getNestedObj(obj, "error"), "type") ?? "";
-  const errorCode = extractString(obj, "code") ?? extractString(getNestedObj(obj, "error"), "code") ?? "";
-  const message = extractString(obj, "message") ?? extractString(getNestedObj(obj, "error"), "message") ?? (typeof raw === "string" ? raw : "") ?? "";
-  const status = extractNumber(obj, "status") ?? extractNumber(obj, "statusCode") ?? extractNumber(obj, "status_code") ?? null;
-  const sdkCode = extractString(obj, "error_code") ?? "";
-  if (errorType === "authentication_error" || errorCode === "authentication_error" || sdkCode === "authentication_error" || message.toLowerCase().includes("authentication_error")) {
-    const msg = message.toLowerCase();
-    if (msg.includes("expired") || msg.includes("refresh")) {
-      return "credentials-expired";
-    }
-    return "credentials-invalid";
-  }
-  if (errorType === "invalid_api_key" || errorCode === "invalid_api_key" || sdkCode === "invalid_api_key" || message.toLowerCase().includes("invalid_api_key") || message.toLowerCase().includes("invalid api key")) {
-    return "credentials-invalid";
-  }
-  if (errorType === "credit_balance_too_low" || errorCode === "credit_balance_too_low" || sdkCode === "credit_balance_too_low" || message.toLowerCase().includes("credit_balance_too_low") || message.toLowerCase().includes("credit balance")) {
-    return "credit-exhausted";
-  }
-  if (errorType === "rate_limit_error" || errorCode === "rate_limit_error" || sdkCode === "rate_limit_error" || message.toLowerCase().includes("rate_limit_error") || message.toLowerCase().includes("rate limit")) {
-    return "rate-limited";
-  }
-  if (errorType === "overloaded_error" || errorCode === "overloaded_error" || sdkCode === "overloaded_error" || message.toLowerCase().includes("overloaded_error") || message.toLowerCase().includes("overloaded")) {
-    return "rate-limited";
-  }
-  if (errorType === "agent-crashed" || errorCode === "agent-crashed") {
-    return "agent-crashed";
-  }
-  if (errorType === "agent-restarted-unexpectedly" || errorCode === "agent-restarted-unexpectedly") {
-    return "agent-restarted-unexpectedly";
-  }
-  if (status != null) {
-    if (status >= 400 && status < 500)
-      return "unknown-4xx";
-    if (status >= 500 && status < 600)
-      return "unknown-5xx";
-  }
-  return "unknown-4xx";
-}
-function extractString(obj, key) {
-  const v = obj[key];
-  return typeof v === "string" && v.length > 0 ? v : null;
-}
-function extractNumber(obj, key) {
-  const v = obj[key];
-  return typeof v === "number" ? v : null;
-}
-function getNestedObj(obj, key) {
-  const v = obj[key];
-  return typeof v === "object" && v != null ? v : {};
-}
-var DEFAULT_OPERATOR_EVENT_COOLDOWN_MS2 = 5 * 60000;
-var cooldownMap2 = new Map;
-
 // session-tail.ts
 function sanitizeCwdToProjectName(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
@@ -77220,7 +78148,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}`) || isLitellmProxyLocal429(`${text4}
 ${errStr}`) ? "rate-limited" : "quota-exhausted" : classifyClaudeError({ type: errStr, status, message: text4 });
     return {
       kind: kind2,
@@ -79529,6 +80457,29 @@ var RESOURCE_KEYS = ["path", "endpoint", "url", "resource", "route"];
 var ARG_SUMMARY_MAX_KEYS = 4;
 var ARG_VALUE_MAX = 40;
 var ARG_SUMMARY_LINE_MAX = 180;
+var CONTEXT_NOISE_KEYS = new Set([
+  "reason",
+  "why",
+  "chat_id",
+  "message_id",
+  "message_thread_id",
+  "thread_id",
+  "origin_turn_id",
+  "reply_to",
+  "quote",
+  "quote_text",
+  "format",
+  "parse_mode",
+  "disable_web_page_preview",
+  "disable_notification",
+  "protect_content",
+  "single_use",
+  "ack_text",
+  "inline_keyboard",
+  "file_id"
+]);
+var SENSITIVE_VALUE_KEY_RE = /token|secret|password|passwd|key|auth|dsn|conn|url|credential|cookie|session/i;
+var NON_HTTP_DSN_RE = /\b(?:postgres(?:ql)?|mysql|mariadb|redis|rediss|mongodb(?:\+srv)?|amqp|amqps):\/\/\S*@\S+/gi;
 var MCP_TOOL_DESCRIPTIONS = {
   "mcp__agent-config__config_get": "Read its own merged config",
   "mcp__agent-config__cron_list": "List its own scheduled tasks",
@@ -79579,8 +80530,12 @@ function formatPermissionCardBody(opts) {
   }
   const callerReason = callerSuppliedReason(opts.inputPreview);
   const rawWhy = (callerReason ?? "").replace(/\s+/g, " ").trim();
-  const truncatedWhy = rawWhy.length > DESCRIPTION_LINE_MAX ? rawWhy.slice(0, DESCRIPTION_LINE_MAX - 1) + "\u2026" : rawWhy;
-  lines.push(truncatedWhy.length > 0 ? `why: _${escapeTgHtml(truncatedWhy)}_` : `why: _not provided_`);
+  if (rawWhy.length > 0) {
+    const truncatedWhy = rawWhy.length > DESCRIPTION_LINE_MAX ? rawWhy.slice(0, DESCRIPTION_LINE_MAX - 1) + "\u2026" : rawWhy;
+    lines.push(`why: _${escapeTgHtml(truncatedWhy)}_`);
+  } else {
+    lines.push(`context: _${escapeTgHtml(synthesizeContext(opts.toolName, opts.inputPreview))}_`);
+  }
   const argSummary = mcpArgSummary(opts.toolName, opts.inputPreview);
   if (argSummary) {
     lines.push(`\u21b3 _${escapeTgHtml(argSummary)}_`);
@@ -79854,6 +80809,50 @@ function callerSuppliedReason(inputPreview) {
   }
   return null;
 }
+function synthesizeContext(toolName, inputPreview) {
+  const input = parseInput2(inputPreview);
+  const summary = input ? salientInputSummary(input) : null;
+  const base = summary ?? naturalAction(toolName, inputPreview);
+  const turnRef = input ? readString2(input, "origin_turn_id") : null;
+  return turnRef ? `${base} \u00b7 turn ${shortTurnRef(turnRef)}` : base;
+}
+function shortTurnRef(turnId) {
+  const t = turnId.trim();
+  return t.length <= 10 ? t : `\u2026${t.slice(-8)}`;
+}
+function salientInputSummary(input) {
+  const parts = [];
+  for (const [key, value] of Object.entries(input)) {
+    if (CONTEXT_NOISE_KEYS.has(key))
+      continue;
+    if (value == null)
+      continue;
+    if (parts.length >= ARG_SUMMARY_MAX_KEYS) {
+      parts.push("\u2026");
+      break;
+    }
+    if (typeof value === "object") {
+      parts.push(key);
+      continue;
+    }
+    const shown = truncate6(redactSalientValue(key, String(value)), ARG_VALUE_MAX);
+    if (shown.length === 0)
+      continue;
+    parts.push(`${key}: ${shown}`);
+  }
+  if (parts.length === 0)
+    return null;
+  const joined = parts.join(", ");
+  return joined.length > ARG_SUMMARY_LINE_MAX ? joined.slice(0, ARG_SUMMARY_LINE_MAX - 1) + "\u2026" : joined;
+}
+function redactSalientValue(key, value) {
+  if (SENSITIVE_VALUE_KEY_RE.test(key))
+    return REDACTED_MARKER;
+  const dsnScrubbed = value.replace(NON_HTTP_DSN_RE, REDACTED_MARKER);
+  const scrubbed = redact(`${key}=${dsnScrubbed}`);
+  const prefix = `${key}=`;
+  return scrubbed.startsWith(prefix) ? scrubbed.slice(prefix.length) : scrubbed;
+}
 function extractReasonFromRaw(raw) {
   const m = /"(?:reason|why)"\s*:\s*"((?:[^"\\]|\\.)*)"/.exec(raw);
   if (!m)
@@ -80744,7 +81743,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)}\`**`,
     ``,
@@ -81081,10 +82081,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.18.15";
-var COMMIT_SHA = "2fa611a1";
-var COMMIT_DATE = "2026-07-12T04:44:56Z";
-var LATEST_PR = 3171;
+var VERSION = "0.18.18";
+var COMMIT_SHA = "a256b3b1";
+var COMMIT_DATE = "2026-07-13T03:10:38Z";
+var LATEST_PR = 3210;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -81137,6 +82137,8 @@ function classifyRejection(err, opts = {}) {
     return "log_only";
   if (err instanceof Error && err.message === FLOOD_WAIT_ACTIVE)
     return "log_only";
+  if (err instanceof Error && err.message === LOCAL_RESOURCE_EXHAUSTED)
+    return "log_only";
   if (!isGrammy)
     return "shutdown";
   const e = err;
@@ -81677,10 +82679,13 @@ async function emitLinearAgentActivity(args, deps = {}) {
 `);
   return { content: [{ type: "text", text: `Linear ${type} emitted on session ${sessionId}` }] };
 }
+function captureDedupComment(dedupKey) {
+  return `<!-- switchroom-capture: ${dedupKey} -->`;
+}
 function captureDedupMarker(dedupKey) {
   return `
 
-<!-- switchroom-capture: ${dedupKey} -->`;
+${captureDedupComment(dedupKey)}`;
 }
 async function createLinearIssue(args, deps = {}) {
   const log = deps.log ?? ((s) => process.stderr.write(s));
@@ -81729,9 +82734,11 @@ async function createLinearIssue(args, deps = {}) {
     return { ok: true, data: json.data };
   };
   if (dedupKey) {
-    const search2 = await gql("query($term: String!) { searchIssues(term: $term) { nodes { id url title } } }", { term: dedupKey });
+    const marker = captureDedupComment(dedupKey);
+    const search2 = await gql("query($term: String!) { searchIssues(term: $term, first: 25) { nodes { id url title description } } }", { term: dedupKey });
     if (search2.ok) {
-      const hit = (search2.data?.searchIssues?.nodes ?? [])[0];
+      const nodes = search2.data?.searchIssues?.nodes ?? [];
+      const hit = nodes.find((n) => typeof n.description === "string" && n.description.includes(marker));
       if (hit?.url) {
         log(`telegram gateway: linear_create_issue: dedup hit key=${dedupKey} agent=${agent}
 `);
@@ -82538,8 +83545,15 @@ function buildBridgeDeadIdleNoticeInbound(args) {
     }
   };
 }
-function isRealBridgeIdentity(agentName3) {
-  return agentName3 != null && agentName3.length > 0 && !isCronIdentity2(agentName3);
+function isRealBridgeIdentity(agentName3, selfAgentName) {
+  if (agentName3 == null || agentName3.length === 0)
+    return false;
+  if (isCronIdentity2(agentName3))
+    return false;
+  if (selfAgentName != null && selfAgentName.length > 0) {
+    return agentName3 === selfAgentName;
+  }
+  return true;
 }
 function createBridgeDeadWatchdog(opts) {
   const setTimer = opts.setTimer ?? ((fn, ms) => {
@@ -82553,6 +83567,7 @@ function createBridgeDeadWatchdog(opts) {
   const readCrashTail = opts.readCrashTail ?? ((p, t) => readFreshCrashLogTail(p, { nowMs: t }));
   const priorStreak = opts.priorStreak ?? 0;
   const maxConsecutive = opts.maxConsecutive ?? MAX_CONSECUTIVE_ESCALATIONS;
+  const selfAgentName = opts.selfAgentName;
   let timer3 = null;
   let bridgeRegistered = false;
   let bridgeEverRegistered = false;
@@ -82630,14 +83645,14 @@ function createBridgeDeadWatchdog(opts) {
   return {
     arm: armInternal,
     noteBridgeRegistered: (agentName3) => {
-      if (!isRealBridgeIdentity(agentName3))
+      if (!isRealBridgeIdentity(agentName3, selfAgentName))
         return;
       bridgeRegistered = true;
       bridgeEverRegistered = true;
       cancel();
     },
     noteBridgeDisconnected: (agentName3) => {
-      if (!isRealBridgeIdentity(agentName3))
+      if (!isRealBridgeIdentity(agentName3, selfAgentName))
         return;
       bridgeRegistered = false;
       armInternal();
@@ -82969,11 +83984,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(() => {
@@ -82986,11 +83996,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 {
@@ -83005,13 +84010,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)
@@ -83215,6 +84213,7 @@ function readAccessFile() {
       parseMode: parsed.parseMode,
       disableLinkPreview: parsed.disableLinkPreview,
       coalescingGapMs: parsed.coalescingGapMs,
+      litellmNoticeWindowMs: parsed.litellmNoticeWindowMs,
       coalesceMaxAttachments: parsed.coalesceMaxAttachments,
       interruptSafeBoundary: parsed.interruptSafeBoundary,
       interruptMaxWaitMs: parsed.interruptMaxWaitMs,
@@ -84760,8 +85759,9 @@ var PHOTO_EXTS = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp"]);
 var FLOOD_STATE_PATH = floodStatePath(STATE_DIR);
 var FLOOD_WINDOWS_PATH = floodWindowsPath(STATE_DIR);
 var recordFloodWindow = makeFloodWindowRecorder(FLOOD_WINDOWS_PATH);
+var sendGateConfig = sendGateConfigFromEnv();
 var sendGate = createSendGate({
-  enabled: sendGateEnabledFromEnv(),
+  ...sendGateConfig,
   initialWindows: loadInitialFloodWindows(FLOOD_STATE_PATH, FLOOD_WINDOWS_PATH, Date.now()),
   bootRamp: {},
   onWindowOpen: (scopeKey, untilTs) => recordFloodWindow(scopeKey, untilTs)
@@ -84769,10 +85769,10 @@ var sendGate = createSendGate({
 var probeFloodWaitRemainingMs = makeFloodWaitProbe2(FLOOD_STATE_PATH);
 var rawRobustApiCall = createRetryApiCall2({
   log: (line) => process.stderr.write(line),
-  onFloodWait: (retryAfterSec) => {
+  onFloodWait: (retryAfterSec, opts) => {
     makeFloodWaitRecorder2(FLOOD_STATE_PATH)(retryAfterSec);
     try {
-      sendGate.openFloodWindow("global", Date.now() + Math.max(0, retryAfterSec) * 1000);
+      sendGate.openScopedFloodWindows(opts, Date.now() + Math.max(0, retryAfterSec) * 1000);
     } catch {}
   },
   floodWaitRemainingMs: probeFloodWaitRemainingMs
@@ -84808,6 +85808,7 @@ var sendGateStatsLogger = createStatsLogger({
 var floodWindowObserver = createFloodWindowObserver({
   clock: { now: () => Date.now(), sleep: (ms) => new Promise((r) => setTimeout(r, ms)) },
   log: (line) => process.stderr.write(line),
+  tz: process.env.SWITCHROOM_TIMEZONE ?? process.env.TZ ?? "UTC",
   stats: () => sendGate.stats(),
   readWindows: (now) => readFloodWindows(FLOOD_WINDOWS_PATH, now),
   markAlerted: (scopeKey, alertedAt) => markFloodWindowAlerted(FLOOD_WINDOWS_PATH, scopeKey, alertedAt, Date.now()),
@@ -84822,7 +85823,7 @@ var floodWindowObserver = createFloodWindowObserver({
     await robustApiCall(() => bot.api.sendRichMessage(operator, richMessage2(text5), {}), { chat_id: String(operator), verb: "send-gate-flood-alert", priorityClass: "critical" });
   }
 });
-if (sendGateEnabledFromEnv()) {
+if (sendGateConfig.enabled) {
   const observeTimer = setInterval(() => {
     try {
       sendGateStatsLogger.tick();
@@ -85292,7 +86293,8 @@ function isAutoFallbackCooldownActive(_agentName, now) {
 async function editCardExpired(chatId, messageId, body) {
   if (messageId == null)
     return;
-  await lockedBot.api.editMessageText(chatId, messageId, richMessage2(body), { reply_markup: { inline_keyboard: [] } }).catch(() => {});
+  const text5 = richMessage2(body);
+  await robustApiCall(() => lockedBot.api.editMessageText(chatId, messageId, text5, { reply_markup: { inline_keyboard: [] } }), { chat_id: chatId, verb: "card-expired.strip", priorityClass: "cosmetic", messageId, editPayload: body }).catch(() => {});
 }
 function recordMissedApproval(opts) {
   if (!MISSED_APPROVAL_REOFFER_ENABLED)
@@ -85519,10 +86521,7 @@ function postPermissionCard(requestId, pend) {
         if (live && sent && typeof sent.message_id === "number") {
           const landedThreadId = sent.message_thread_id ?? undefined;
           live.cards.push({ chatId, messageId: sent.message_id, threadId: landedThreadId });
-          if (live.undeliverable != null) {
-            live.undeliverable = null;
-            live.redeliveryFailures = 0;
-            live.startedAt = Date.now();
+          if (applyDeliveredHoldReset(live, Date.now())) {
             reconcileBlockedApprovals();
             process.stderr.write(`telegram gateway: permission-card RE-DELIVERED request=${requestId} tool=${live.tool_name} chat=${chatId} \u2014 the operator can answer now; ` + `TTL clock restarted (they had zero seconds while the channel was shut)
 `);
@@ -85771,7 +86770,8 @@ function emitGatewayOperatorEvent(event) {
   const { agent, kind } = event;
   let throttleEscalation = null;
   let escalationFired = false;
-  const rateLimit429Classification = kind === "rate-limited" ? classify429Detail(event.detail) : null;
+  let rateLimitedCooldownConsulted = false;
+  const rateLimit429Classification = kind === "rate-limited" ? classify429Detail2(event.detail) : null;
   if (rateLimit429Classification != null && rateLimit429Classification !== "account-scoped") {
     emitRuntimeMetric(build429ClassifiedMetric({
       agent,
@@ -85780,10 +86780,28 @@ function emitGatewayOperatorEvent(event) {
       action: "calm",
       now: Date.now()
     }));
-    if (rateLimit429Classification === "litellm-local") {
+    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({
@@ -85816,7 +86834,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;
@@ -85845,6 +86863,18 @@ function emitGatewayOperatorEvent(event) {
       const untilMs = resolveExhaustUntil(modelUnavailable.resetAt?.getTime());
       fireFleetAutoFallback(agent, untilMs, modelUnavailable.resetAt);
     }
+  } else if (kind === "rate-limited" || kind === "unknown-5xx") {
+    const parsed = parseLlmError(event.detail);
+    const now = Date.now();
+    if (decideErrorSurface(parsed, agent, { claim: true, now }) === "suppress") {
+      process.stderr.write(`telegram gateway: operator-event collapsed (error-presence-gate) agent=${agent} kind=${kind}
+`);
+      return;
+    }
+    const tz = process.env.SWITCHROOM_TIMEZONE ?? process.env.TZ ?? "UTC";
+    const r = renderLlmError(parsed, agent, tz, new Date(now));
+    renderedText = r.text;
+    renderedKeyboard = r.keyboard;
   } else {
     try {
       const r = renderOperatorEvent(event);
@@ -86141,6 +87171,10 @@ async function runMidSessionCardReaper() {
       const reaps = decideWorkerPinReaps({
         pins: candidates,
         statusOf: (agentId) => {
+          if (agentId.startsWith("group:")) {
+            const feedKey = agentId.slice("group:".length);
+            return workerActivityFeed?.hasRunningInFeed(feedKey) ? "running" : "terminal";
+          }
           if (turnsDb == null)
             return "unknown";
           try {
@@ -86240,24 +87274,6 @@ async function reconcileStatusPinInner(pinKey, chatId, desired) {
       statusPinPinnedAt.set(pinKey, Date.now());
   }
 }
-function reconcileWorkerPin(agentId, chatId, running) {
-  if (!PIN_STATUS_WHILE_WORKING)
-    return;
-  const key = `wk:${agentId}`;
-  if (!running) {
-    const unpinChat = chatId ?? statusPinChatIds.get(key);
-    if (unpinChat == null)
-      return;
-    reconcileStatusPin(key, unpinChat, { pinned: false });
-    return;
-  }
-  if (chatId == null)
-    return;
-  const messageId = workerActivityFeed?.messageIdOf(agentId) ?? null;
-  if (messageId == null)
-    return;
-  reconcileStatusPin(key, chatId, { pinned: true, messageId });
-}
 async function unpinAllStatusPins() {
   const keys = [...statusPinState.keys()];
   for (const key of keys) {
@@ -86890,7 +87906,8 @@ var bridgeDeadWatchdog = createBridgeDeadWatchdog({
   markerPath: join54(STATE_DIR, "bridge-dead-escalation.json"),
   log: (line) => process.stderr.write(`${line}
 `),
-  priorStreak: bridgeDeadPriorStreak
+  priorStreak: bridgeDeadPriorStreak,
+  selfAgentName: process.env.SWITCHROOM_AGENT_NAME ?? ""
 });
 if (BRIDGE_DEAD_ESCALATION_ENABLED) {
   bridgeDeadWatchdog.arm();
@@ -86914,11 +87931,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()) {
@@ -92987,11 +93999,6 @@ function buildModelDeps(restartCtx) {
         });
       }
       stampUserRestartReason(reason);
-      {
-        const smDir = resolveAgentDirFromEnv();
-        if (smDir)
-          writeRelaunchModelIntent(smDir, "keep", reason);
-      }
       await sweepBeforeSelfRestart();
       const hostdResp = await tryHostdDispatch2(name, {
         v: 1,
@@ -93006,11 +94013,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)"}`);
       }
     },
@@ -93028,7 +94030,6 @@ function buildModelDeps(restartCtx) {
         if (err?.code !== "restart_in_flight") {
           restoreSessionModelFileRaw(agentDir, prevFileRaw);
           sessionModelSource.setOverride(prevOverride);
-          clearRelaunchModelIntent(agentDir);
         }
         throw err;
       }
@@ -93047,12 +94048,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 "";
@@ -93060,33 +94061,13 @@ 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.`;
-    }
-  }
+  clearPremiumRecoveryOnManualSwitch(reply.selectedModel);
   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)}
-`);
-      }
-    }
+    clearPremiumRecoveryOnManualSwitch(outcome.selectedModel);
   }
   if (outcome.clearedDefault) {
     const smDir = resolveAgentDirFromEnv();
@@ -93183,7 +94164,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":
@@ -93240,14 +94220,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",
@@ -93266,34 +94270,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
   };
 }
@@ -93415,11 +94409,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,
@@ -93516,9 +94505,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,
@@ -93940,6 +94926,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) {
@@ -93960,6 +94966,80 @@ function broadcastFleetFallbackFailure(triggerAgent, reason) {
     swallowingApiCall(() => bot.api.sendRichMessage(chat_id, richMessage2(html), {}), { chat_id, verb: "fleet-fallback:failure-notify" });
   }
 }
+function broadcastTierNotice(markdown) {
+  const access = loadAccess();
+  if (access.allowFrom.length === 0)
+    return;
+  for (const chat_id of access.allowFrom) {
+    swallowingApiCall(() => bot.api.sendRichMessage(chat_id, richMessage2(markdown), { disable_notification: true }), { chat_id: String(chat_id), verb: "tier-downgrade:notify" });
+  }
+}
+function maybeTierDowngrade(triggerAgent) {
+  return runTierDowngrade(triggerAgent, {
+    getAgentDir: () => resolveAgentDirFromEnv() ?? null,
+    getConfiguredDefault: () => {
+      const dir = resolveAgentDirFromEnv();
+      if (!dir)
+        return null;
+      return resolveMainModel(readConfiguredDefaultModel(dir) ?? undefined);
+    },
+    getSessionOverride: () => sessionModelSource.getOverride(),
+    resolve: (t) => resolveMainModel(t),
+    peekResumeGate: () => fleetFallbackResumeGate.peek(newestActiveTurnStartedAtMs()),
+    writeCarrier: (dir, toModel, cfg) => writeSessionModelFile(dir, toModel, cfg),
+    armResumeGate: () => fleetFallbackResumeGate.arm(),
+    writeRecoveryMarker: (dir, premiumModel) => {
+      const chats = loadAccess().allowFrom.map((c) => String(c));
+      if (chats.length > 0)
+        writePremiumRecoveryFile(dir, premiumModel, chats);
+    },
+    broadcastNotice: (md) => broadcastTierNotice(md),
+    selfRestart: (agent) => triggerSelfRestart(agent, "tier-downgrade-resume"),
+    selfAgent: (t) => process.env.SWITCHROOM_AGENT_NAME ?? t,
+    log: (msg) => process.stderr.write(`telegram gateway: ${msg}
+`)
+  });
+}
+async function maybePremiumRecoveryPing(brokerClient, accounts) {
+  return runPremiumRecoveryPing({
+    getAgentDir: () => resolveAgentDirFromEnv() ?? null,
+    readMarker: (dir) => readPremiumRecoveryFile(dir),
+    clearMarker: (dir) => clearPremiumRecoveryFile(dir),
+    getAgent: () => getMyAgentName(),
+    decide: () => decidePremiumRecovery({
+      hasMarker: true,
+      accounts: accounts.map((a) => ({
+        exhausted: a.exhausted,
+        premiumWalled: a.premium_walled === true
+      }))
+    }).fire,
+    claimNotification: (key) => claimQuotaNotification(brokerClient, key),
+    fallbackChats: () => loadAccess().allowFrom.map((c) => String(c)),
+    sendToChat: (chat_id, ping, keyboard) => {
+      swallowingApiCall(() => bot.api.sendRichMessage(chat_id, richMessage2(ping.text), {
+        disable_notification: true,
+        reply_markup: keyboard
+      }), { chat_id: String(chat_id), verb: "premium-recovery:notify" });
+    },
+    log: (msg) => process.stderr.write(`telegram gateway: ${msg}
+`)
+  });
+}
+function clearPremiumRecoveryOnManualSwitch(appliedToken) {
+  if (appliedToken == null || appliedToken.length === 0)
+    return;
+  const agentDir = resolveAgentDirFromEnv();
+  if (!agentDir)
+    return;
+  const marker = readPremiumRecoveryFile(agentDir);
+  if (marker == null)
+    return;
+  if (resolveMainModel(appliedToken) === resolveMainModel(marker.premiumModel)) {
+    clearPremiumRecoveryFile(agentDir);
+    process.stderr.write(`telegram gateway: [premium-recovery] marker cleared \u2014 user manually re-issued /model ${marker.premiumModel}
+`);
+  }
+}
 async function doFireFleetAutoFallback(triggerAgent, untilMs, parsedResetAt, trigger) {
   try {
     const client3 = await getAuthBrokerClient2(triggerAgent);
@@ -93993,6 +95073,10 @@ async function doFireFleetAutoFallback(triggerAgent, untilMs, parsedResetAt, tri
     if (outcome.kind === "switched") {
       fallbackAllBlockedNoticeState = { lastSentAtMs: 0 };
     } else if (outcome.kind === "all-blocked") {
+      const tier = maybeTierDowngrade(triggerAgent);
+      if (tier === "downgraded" || tier === "restart-pending") {
+        return false;
+      }
       const verdict = evaluateAllBlockedNotice(fallbackAllBlockedNoticeState, Date.now());
       if (!verdict.send) {
         process.stderr.write(`telegram gateway: [fleet-fallback] all-blocked card suppressed (cooldown) agent=${triggerAgent}
@@ -94102,6 +95186,10 @@ async function runQuotaWatch(opts = {}) {
   if (!listStateData.accounts || listStateData.accounts.length === 0) {
     return;
   }
+  await maybePremiumRecoveryPing(brokerClient, listStateData.accounts).catch((err) => {
+    process.stderr.write(`telegram gateway: [premium-recovery] ping check failed (non-fatal): ${err?.message ?? err}
+`);
+  });
   const snapshots = buildSnapshotsFromCachedState2(listStateData);
   let watchState = loadQuotaWatchState(stateDir);
   const now = Date.now();
@@ -96639,21 +97727,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 {
@@ -97109,6 +98182,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;
@@ -97210,6 +98291,10 @@ var didOneTimeSetup = false;
           const watcherAgentDir = resolveAgentDirFromEnv();
           if (watcherAgentDir != null) {
             const workerFeedEnabled = isWorkerActivityFeedEnabled(process.env.SWITCHROOM_WORKER_ACTIVITY_FEED);
+            const workerFeedMaxRows = (() => {
+              const raw = Number(process.env.SWITCHROOM_TG_WORKER_FEED_MAX_ROWS);
+              return Number.isInteger(raw) && raw > 0 ? raw : undefined;
+            })();
             const foregroundNestingEnabled = process.env.SWITCHROOM_FOREGROUND_SUBAGENT_NESTING !== "0";
             const orphanStatusEnabled = isOrphanSubagentStatusEnabled(process.env.SWITCHROOM_ORPHAN_SUBAGENT_STATUS);
             workerActivityFeed?.stop();
@@ -97227,6 +98312,21 @@ var didOneTimeSetup = false;
                   editPayload: text5
                 })
               },
+              floodWaitRemainingMs: probeFloodWaitRemainingMs,
+              maxRows: workerFeedMaxRows,
+              reconcilePin: ({ feedKey, chatId, messageId }) => {
+                if (!PIN_STATUS_WHILE_WORKING)
+                  return;
+                const key = `wk:group:${feedKey}`;
+                if (messageId != null) {
+                  reconcileStatusPin(key, chatId, { pinned: true, messageId });
+                } else {
+                  const unpinChat = chatId || statusPinChatIds.get(key);
+                  if (unpinChat != null && unpinChat.length > 0) {
+                    reconcileStatusPin(key, unpinChat, { pinned: false });
+                  }
+                }
+              },
               log: (msg) => process.stderr.write(`telegram gateway: ${msg}
 `)
             });
@@ -97292,7 +98392,6 @@ var didOneTimeSetup = false;
                       state: outcome === "failed" ? "failed" : "done",
                       model: dispatch.feedModel ?? undefined
                     });
-                    reconcileWorkerPin(agentId, null, false);
                   }
                   return;
                 }
@@ -97340,7 +98439,6 @@ var didOneTimeSetup = false;
                       state: outcome === "failed" ? "failed" : "done",
                       model: dispatch.feedModel ?? undefined
                     });
-                    reconcileWorkerPin(agentId, null, false);
                   }
                   return;
                 }
@@ -97354,7 +98452,6 @@ var didOneTimeSetup = false;
                     state: outcome === "failed" ? "failed" : "done",
                     model: dispatch.feedModel ?? undefined
                   });
-                  reconcileWorkerPin(agentId, null, false);
                 }
                 const handbackOrigin = resolveSubagentOriginChat(agentId);
                 const decision = decideSubagentHandback({
@@ -97428,7 +98525,7 @@ var didOneTimeSetup = false;
                       elapsedMs,
                       state: "running",
                       model: feedModel
-                    }, wk.threadId)?.then(() => reconcileWorkerPin(agentId, wkChat, true));
+                    }, wk.threadId);
                     return;
                   }
                   if (surface !== "nest")
@@ -97487,7 +98584,7 @@ var didOneTimeSetup = false;
                     elapsedMs,
                     state: "running",
                     model: feedModel
-                  }, wk.threadId)?.then(() => reconcileWorkerPin(agentId, wkChat, true));
+                  }, wk.threadId);
                   return;
                 }
                 const progressOrigin = resolveSubagentOriginChat(agentId);