switchroom 0.18.17 → 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."),
@@ -40238,9 +40251,45 @@ 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), {
@@ -40371,13 +40420,16 @@ function createWorkerActivityFeed(opts) {
   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) {
@@ -40391,267 +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 parkIfFloodWindowOpen(h) {
+  function parkIfFloodWindowOpen(g) {
     const remaining = floodWaitRemainingMs();
     if (remaining <= 0)
       return false;
     const until = nowFn() + remaining + COOLDOWN_JITTER_MS;
-    if (until > h.cooldownUntil)
-      h.cooldownUntil = until;
+    if (until > g.cooldownUntil)
+      g.cooldownUntil = until;
     return true;
   }
-  function accumulateNarrative(h, view) {
+  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)
+    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 (parkIfFloodWindowOpen(g)) {
+      if (isTerminal && opts2.terminalRecap != null)
+        g.pendingFinalize = opts2.terminalRecap;
       return;
-    if (parkIfFloodWindowOpen(h))
+    }
+    const body = renderGroupBody(g, now, opts2.terminalRecap ?? null, opts2.heartbeat ?? false);
+    if (body == null) {
+      if (isTerminal)
+        settleTerminal();
       return;
-    const body = renderWorkerActivity(merged, liveSuffix);
-    if (h.messageId == null) {
-      if (view.elapsedMs < firstPaintMin)
+    }
+    if (g.messageId == null) {
+      const maxElapsed = Math.max(0, ...runningRows(g).map((r) => liveElapsed(r, now)));
+      if (isTerminal) {
+        settleTerminal();
+        return;
+      }
+      if (maxElapsed < firstPaintMin)
         return;
       try {
-        const sent = await opts.bot.sendMessage(h.chatId, body, sendOptsFor(h));
+        const sent = await opts.bot.sendMessage(g.chatId, body, sendOptsFor(g));
         if (sent == null || typeof sent.message_id !== "number") {
-          parkIfFloodWindowOpen(h);
-          log(`worker-feed: first paint shed by send gate agent=${h.agentId} \u2014 not delivered`);
+          parkIfFloodWindowOpen(g);
+          log(`worker-feed: first paint shed by send gate feed=${g.feedKey} \u2014 not delivered`);
           return;
         }
-        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}`);
+        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(h, err, "send");
+        noteRateLimited(g, err, "send");
         log(`worker-feed: send failed: ${err.message}`);
       }
       return;
     }
-    if (body === h.lastBody)
-      return;
-    if (nowFn() - h.lastEditAt < minEditInterval)
-      return;
-    try {
-      const res = await opts.bot.editMessageText(h.chatId, h.messageId, body, sendOptsFor(h));
-      if (isSendGateShed(res)) {
-        parkIfFloodWindowOpen(h);
-        return;
-      }
-      h.lastBody = body;
-      h.lastEditAt = nowFn();
-      log(`worker-feed: edit agent=${h.agentId} chat=${h.chatId} ` + `thread=${h.threadId ?? "-"} msgId=${h.messageId} bytes=${body.length}`);
-    } 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();
-        return;
-      }
-      if (outcome === "gone") {
-        h.messageId = null;
-        h.lastBody = null;
-        return;
-      }
-      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 (parkIfFloodWindowOpen(h) || 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 {
-      const res = await opts.bot.editMessageText(h.chatId, h.messageId, body, sendOptsFor(h));
+      const res = await opts.bot.editMessageText(g.chatId, g.messageId, body, sendOptsFor(g));
       if (isSendGateShed(res)) {
-        parkIfFloodWindowOpen(h);
-        h.pendingFinish = view;
+        parkIfFloodWindowOpen(g);
+        if (isTerminal && opts2.terminalRecap != null)
+          g.pendingFinalize = opts2.terminalRecap;
         return;
       }
-      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}`);
+      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)
-        continue;
-      if (h.lastView.state !== "running")
+      if (now < g.cooldownUntil)
         continue;
-      if (now < h.cooldownUntil)
+      const running = runningRows(g);
+      if (running.length === 0)
         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`);
       }
     },
@@ -44582,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: [] };
@@ -55213,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) {
@@ -55269,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
@@ -55444,16 +55593,25 @@ function stableStringify(value) {
   });
 }
 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;
@@ -55461,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,
@@ -55531,8 +55690,11 @@ 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_TYPES2.has(opts.chatType)) {
         applyWindow(`group:${opts.chat_id}`, untilTs, true);
@@ -55834,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
@@ -55878,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);
@@ -55891,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;
@@ -55911,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();
@@ -63787,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;
     },
@@ -64500,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 {
@@ -64720,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",
@@ -64740,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;
@@ -64933,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";
   }
-  return detectModelUnavailable(detail);
+  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;
 
-// 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();
@@ -64995,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",
@@ -65022,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();
@@ -65194,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",
@@ -65232,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 {
@@ -65259,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;
@@ -65320,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;
         }
@@ -69406,6 +70090,7 @@ 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";
@@ -69472,6 +70157,172 @@ function clearSessionEffortFile(agentDir) {
     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.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 { premiumModel: raw.premiumModel, chats: raw.chats, ts: raw.ts };
+  } catch {
+    return null;
+  }
+}
+function writePremiumRecoveryFile(agentDir, premiumModel, chats) {
+  if (!isValidModelArg2(premiumModel)) {
+    throw new Error(`refusing to persist non-canonical premium-recovery token: ${JSON.stringify(premiumModel)}`);
+  }
+  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 readPremiumRecoveryFile(agentDir) {
+  let raw;
+  try {
+    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 clearPremiumRecoveryFile(agentDir) {
+  try {
+    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/;
@@ -77113,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, "-");
@@ -77362,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,
@@ -79671,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",
@@ -79721,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)}_`);
@@ -79996,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)
@@ -81224,10 +82081,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.18.17";
-var COMMIT_SHA = "372a4968";
-var COMMIT_DATE = "2026-07-12T09:18:05Z";
-var LATEST_PR = 3190;
+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
@@ -81280,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;
@@ -81820,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));
@@ -81872,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}
 `);
@@ -82681,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) => {
@@ -82696,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;
@@ -82773,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();
@@ -84887,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)
@@ -84896,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
@@ -84935,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()),
@@ -84949,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();
@@ -85419,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)
@@ -85646,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)
 `);
@@ -85899,7 +86771,7 @@ function emitGatewayOperatorEvent(event) {
   let throttleEscalation = null;
   let escalationFired = false;
   let rateLimitedCooldownConsulted = false;
-  const rateLimit429Classification = kind === "rate-limited" ? classify429Detail(event.detail) : null;
+  const rateLimit429Classification = kind === "rate-limited" ? classify429Detail2(event.detail) : null;
   if (rateLimit429Classification != null && rateLimit429Classification !== "account-scoped") {
     emitRuntimeMetric(build429ClassifiedMetric({
       agent,
@@ -85991,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);
@@ -86287,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 {
@@ -86386,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) {
@@ -87036,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();
@@ -93190,11 +94061,13 @@ function recordTypedModelSwitch(reply, requestedModelArg, _deps) {
   if (!reply.selectedModel)
     return "";
   sessionModelSource.setOverride(reply.selectedModel);
+  clearPremiumRecoveryOnManualSwitch(reply.selectedModel);
   return "";
 }
 function recordModelMenuSideEffects(outcome, modelDeps, cbChatId, cbThreadId, prevSessionModel) {
   if (outcome.selectedModel) {
     sessionModelSource.setOverride(outcome.selectedModel);
+    clearPremiumRecoveryOnManualSwitch(outcome.selectedModel);
   }
   if (outcome.clearedDefault) {
     const smDir = resolveAgentDirFromEnv();
@@ -94093,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);
@@ -94126,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}
@@ -94235,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();
@@ -97336,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();
@@ -97354,6 +98313,20 @@ var didOneTimeSetup = false;
                 })
               },
               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}
 `)
             });
@@ -97419,7 +98392,6 @@ var didOneTimeSetup = false;
                       state: outcome === "failed" ? "failed" : "done",
                       model: dispatch.feedModel ?? undefined
                     });
-                    reconcileWorkerPin(agentId, null, false);
                   }
                   return;
                 }
@@ -97467,7 +98439,6 @@ var didOneTimeSetup = false;
                       state: outcome === "failed" ? "failed" : "done",
                       model: dispatch.feedModel ?? undefined
                     });
-                    reconcileWorkerPin(agentId, null, false);
                   }
                   return;
                 }
@@ -97481,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({
@@ -97555,7 +98525,7 @@ var didOneTimeSetup = false;
                       elapsedMs,
                       state: "running",
                       model: feedModel
-                    }, wk.threadId)?.then(() => reconcileWorkerPin(agentId, wkChat, true));
+                    }, wk.threadId);
                     return;
                   }
                   if (surface !== "nest")
@@ -97614,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);