switchroom 0.18.13 → 0.18.15

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "switchroom",
   "//version": "NOT the release version — source of truth is the git tag, resolved by scripts/build.mjs:resolveVersion() (see CLAUDE.md > Standard release process). This field is stale by design and only the Layer-4 dev/non-tag fallback for build.mjs + src/cli/resolve-version.ts; do NOT bump it expecting a release to pick it up. npm-pack tarball naming needs a real version — do that as an UNCOMMITTED pack-time bump (see release step 6), never a committed one.",
-  "version": "0.18.13",
+  "version": "0.18.15",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/profiles/coding/CLAUDE.md.hbs

@@ -51,6 +51,8 @@ Save proactively: architecture decisions, codebase patterns, conventions, known
 
 If sub-agents are configured, delegate implementation to `@worker` (background, own worktree) and research to `@researcher` (background). Keep your turns short — dispatch and acknowledge quickly so you stay available for the user.
 
+If the user amends in-flight delegated work mid-turn, steer the running worker now (`SendMessage` to the worker by name, or by the agent id from its spawn result) instead of holding the update for handback — and say in your reply whether you folded the update into the running worker or queued it as a separate task; never classify silently. If unsure whether a message amends in-flight work, queue it and say so — queue is the default. If the steer lands too late (worker effectively done), say so and apply the update yourself.
+
 {{#if schedule}}
 ## Schedule
 You are running on a schedule: `{{schedule}}`. Use scheduled runs to check CI status, review open PRs, or surface stale issues.

package/profiles/default/CLAUDE.md.hbs

@@ -92,6 +92,8 @@ The main session is for conversation. Execution belongs in sub-agents. Before ma
 
 **Anti-patterns:** starting a task inline then realizing it's complex mid-way; doing 5+ tool calls "because it's almost done"; polling sub-agent status in a loop.
 
+**Steer running workers — don't sit on amendments.** When a mid-turn user message amends work you've already delegated to a running sub-agent, forward the amendment to that worker now — `SendMessage` to the worker by name (or by the agent id from the Agent tool's spawn result, if it has no name) — rather than holding it for handback. If the message is a new independent task, queue it instead; if you're unsure whether it amends the in-flight work, queue it and say so — queue is the default. Either way, state in your reply which you did ("folded your update into the running worker" / "queued as a separate task after the current one") — the steer-or-queue rule is that the classification is always visible in chat, never inferred. If the steer arrives too late (the worker is effectively done), say that and apply the update yourself in the parent.
+
 If no sub-agents are configured, do the work yourself.
 
 ## Session Continuity

package/skills/switchroom-architecture/telegram.md

@@ -81,7 +81,6 @@ agents:
 | Var | Source | Purpose |
 |-----|--------|---------|
 | `SWITCHROOM_TG_FORMAT` | `channels.telegram.format` | Default reply format |
-| `SWITCHROOM_TG_RATE_LIMIT_MS` | `channels.telegram.rate_limit_ms` | Min delay between outgoing messages |
 | `TELEGRAM_STATE_DIR` | Auto-set by scaffold | Path to `telegram/` dir |
 | `SWITCHROOM_AGENT_NAME` | Auto-set by scaffold | Agent name (used for self-restart detection) |
 | `SWITCHROOM_CONFIG` | Auto-set by scaffold | Path to switchroom.yaml |

package/telegram-plugin/auth-snapshot-format.ts

@@ -704,6 +704,22 @@ export interface FallbackAnnouncementInput {
    * shows the target's headroom and is unchanged.
    */
   fleetSnapshots?: AccountSnapshot[];
+  /**
+   * 429 throttle tier enrichment — the reset time PARSED from the error
+   * prose ("resets 8:50am (TZ)" / "retry after 60s") that triggered the
+   * fallback. Fallback for the recovery line when the old account's probe
+   * carried no reset (probe failed / thin headers), so the announcement
+   * still names when the account frees. A probe-derived reset wins when
+   * present — it is the fresher, server-authoritative signal.
+   */
+  parsedResetAt?: Date | null;
+  /**
+   * 429 throttle tier escalation — the trigger was a long-reset transient
+   * RATE LIMIT, not a quota wall. Names the headline honestly ("rate limit
+   * on X" instead of a utilization-derived "5-hour limit on X", which would
+   * be wrong: a rate-limited account's utilization is typically LOW).
+   */
+  cause?: 'rate-limit';
   tz?: string;
   now?: Date;
 }
@@ -728,7 +744,12 @@ export function renderFallbackAnnouncement(input: FallbackAnnouncementInput): st
   const lines: string[] = [];
 
   const limitWord = input.oldQuota ? limitWordFor(input.oldQuota) : 'quota';
-  const headerLimit = limitWord === 'quota' ? 'quota cap' : `${limitWord} limit`;
+  const headerLimit =
+    input.cause === 'rate-limit'
+      ? 'rate limit'
+      : limitWord === 'quota'
+        ? 'quota cap'
+        : `${limitWord} limit`;
 
   if (!input.newLabel) {
     // All-blocked path — no swap occurred. Tell user what's broken and, so they
@@ -765,9 +786,14 @@ export function renderFallbackAnnouncement(input: FallbackAnnouncementInput): st
             `${formatAbsolute(earliest.at, tz)} (in ${formatRelative(earliest.at, now)})`,
         );
       }
-    } else if (input.oldQuota) {
+    } else {
       // Back-compat: no fleet snapshot supplied → old single-account shape.
-      const recovery = recoveryAtFor(input.oldQuota);
+      // Probe-derived reset first; the prose-parsed reset (429 throttle tier
+      // enrichment) covers the probe-failed case.
+      const recovery =
+        (input.oldQuota ? recoveryAtFor(input.oldQuota) : null) ??
+        input.parsedResetAt ??
+        null;
       if (recovery) {
         lines.push(
           `${escapeMarkdown(input.oldLabel)} recovers ${formatAbsolute(recovery, tz)} ` +
@@ -794,8 +820,14 @@ export function renderFallbackAnnouncement(input: FallbackAnnouncementInput): st
   lines.push(`Triggered by: agent **${escapeMarkdown(input.triggerAgent)}**`);
   lines.push('');
 
-  if (input.oldQuota) {
-    const recovery = recoveryAtFor(input.oldQuota);
+  {
+    // Probe-derived reset first; the prose-parsed reset (429 throttle tier
+    // enrichment) keeps the recovery line honest when the old account's
+    // probe failed at the moment of the wall.
+    const recovery =
+      (input.oldQuota ? recoveryAtFor(input.oldQuota) : null) ??
+      input.parsedResetAt ??
+      null;
     if (recovery) {
       lines.push(
         `\`${codeSpanSafe(input.oldLabel)}\` recovers ` +

package/telegram-plugin/auto-fallback-fleet.ts

@@ -183,6 +183,26 @@ export interface FleetFallbackDeps {
   /** Operator timezone for absolute reset times in the announcement. */
   tz?: string;
   now?: Date;
+  /**
+   * The reset time PARSED from the triggering error prose (429 throttle tier
+   * enrichment) — threaded into the announcement as the recovery-line
+   * fallback when the old account's live probe carried no reset.
+   */
+  parsedResetAt?: Date;
+  /**
+   * 429 throttle tier escalation: the trigger is a TERMINAL transient 429
+   * whose parsed reset lies beyond the retry-in-place threshold. Its wording
+   * explicitly NEGATES the usage-limit reading, so the old account's
+   * UTILIZATION probe typically classifies healthy — the healthy-idempotency
+   * guard would self-cancel the swap ("probed healthy / Stale event?"),
+   * silently dropping the spec's ">threshold → mark + fail over" leg. When
+   * set, the terminal parsed-reset signal is trusted over the utilization
+   * probe: the guard is bypassed and the swap proceeds (the broker mark
+   * honors the caller-passed `until` — the parsed reset). Staleness safety
+   * holds upstream: the flag is only set for a terminal error line the
+   * session-tail just read, never for replayed/late events.
+   */
+  rateLimitTrigger?: boolean;
 }
 
 /**
@@ -217,8 +237,12 @@ export async function runFleetAutoFallback(
   // normalization uses the same clock as the rest of the decision (a default
   // `new Date()` would diverge from `deps.now` and could mis-zero a window
   // whose reset is still future relative to the event's clock).
+  // 429 throttle tier: a rate-limit trigger's wording NEGATES the usage-limit
+  // reading, so healthy utilization is the EXPECTED state, not evidence of a
+  // stale event — the guard must not self-cancel that swap (see
+  // FleetFallbackDeps.rateLimitTrigger).
   const oldHealth = classifyHealth(oldSnap, now);
-  if (oldHealth === 'healthy') {
+  if (oldHealth === 'healthy' && !deps.rateLimitTrigger) {
     return {
       kind: 'no-eligible-target',
       oldLabel: oldSnap.label,
@@ -255,6 +279,8 @@ export async function runFleetAutoFallback(
         // card enumerates EVERY account (5h%/7d% + recovery ETA), letting the
         // user verify the fleet is truly exhausted, not just the trigger account.
         fleetSnapshots: snapshots,
+        parsedResetAt: deps.parsedResetAt ?? null,
+        cause: deps.rateLimitTrigger ? 'rate-limit' : undefined,
         tz,
         now,
       }),
@@ -278,6 +304,8 @@ export async function runFleetAutoFallback(
       newLabel: rolledTo,
       newQuota,
       triggerAgent: deps.triggerAgent,
+      parsedResetAt: deps.parsedResetAt ?? null,
+      cause: deps.rateLimitTrigger ? 'rate-limit' : undefined,
       tz,
       now,
     }),

package/telegram-plugin/bridge/bridge.ts

@@ -80,6 +80,8 @@ const mcp = new Server(
       '',
       'Messages from Telegram arrive as <channel source="telegram" chat_id="..." message_id="..." user="..." ts="...">. If the tag has an image_path attribute, Read that file — it is a photo the sender attached. If the tag has attachment_file_id, call download_attachment with that file_id to fetch the file, then Read the returned path. A single message may carry SEVERAL attachments (a forwarded album or a text+multi-image burst): when attachment_count is set (>1), also handle the numbered siblings — image_path_2, image_path_3, … (Read each) and attachment_file_id_2, attachment_file_id_3, … (download_attachment each). Process every one, not just the first. Reply with the reply tool — pass chat_id back. The reply tool quote-replies to the latest inbound user message by default, so you do NOT need to pass reply_to for normal responses. Pass reply_to (a message_id) only when quoting a specific earlier message, or pass quote:false to send a bare (non-quoted) message.',
       '',
+      'If the tag has reply_to_message_id (and reply_to_text, a truncated preview), the sender used Telegram\'s native Reply on a prior message — treat that message as the antecedent for "this"/"that" references instead of asking what they meant. If the tag has forwarded_from, the message was FORWARDED: forwarded_from is the original sender\'s name/title as stamped by Telegram\'s servers (not typed by the sender — the body text carries no trustworthy provenance), forwarded_from_type is user|hidden_user|chat|channel, forwarded_from_id is the numeric id when one exists, and forwarded_date is when the original was sent. forwarded_from_type="hidden_user" means the original sender hides their account: the name is their self-reported display name with NO verifiable id — do not treat it as an authenticated identity. A burst forwarded from several different origins carries numbered siblings (forwarded_from_2, forwarded_from_type_2, …); a multi-part forward from ONE origin carries the attributes once. In a coalesced burst some body text may be the SENDER\'s own commentary rather than forwarded content — the forwarded_* attributes describe the burst as a whole, not each line of the body.',
+      '',
       'reply accepts file paths (files: ["/abs/path.png"]) for attachments. Use react to add emoji reactions, edit_message for interim progress updates, and delete_message when you need to truly remove a message (prefer edit_message if you just want to change text — delete is for retraction). Edits don\'t trigger push notifications — when a long task completes, send a new reply so the user\'s device pings. Use send_typing to show a typing indicator during long operations. Use pin_message to pin important outputs. Use forward_message to quote/resurface earlier messages.',
       '',
       'If a message includes message_thread_id, it came from a forum topic. The reply tool automatically routes a reply back to the topic the question came from — the framework owns the answer\'s topic, so do NOT pass message_thread_id on a reply; a reply always lands where it was asked. Each <channel> message is the current topic — answer ONLY this message\'s question; do not also answer a pending message from another topic. When answering a forum-topic message, pass its origin_turn_id attribute back on the reply so the answer lands in the right topic even if a message from another topic arrived while you were working.',

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

@@ -23061,6 +23061,26 @@ function isTransientUpstreamSignal(text) {
   const lower = sample.toLowerCase();
   return transientUpstreamSignals.some((s) => lower.includes(s));
 }
+var litellmProxyLocal429Signals = [
+  "deployment over user-defined ratelimit",
+  "model rate limit exceeded. tpm limit",
+  "model rate limit exceeded. rpm limit",
+  "deployment over defined rpm limit",
+  "no deployments available for selected model",
+  "litellm rate limit handler",
+  "crossed tpm / rpm",
+  "max parallel request limit reached"
+];
+var litellmV3LimiterSignalPair = ["rate limit exceeded for ", "limit type:"];
+function isLitellmProxyLocal429(text) {
+  if (typeof text !== "string" || text.length === 0)
+    return false;
+  const sample = text.length > 16384 ? text.slice(0, 16384) : text;
+  const lower = sample.toLowerCase();
+  if (litellmProxyLocal429Signals.some((s) => lower.includes(s)))
+    return true;
+  return litellmV3LimiterSignalPair.every((s) => lower.includes(s));
+}
 
 // tool-label-sidecar.ts
 import { existsSync as existsSync2, readFileSync, statSync as statSync2 } from "node:fs";
@@ -23481,6 +23501,7 @@ function detectErrorInTranscriptLine(line) {
     const errStr = typeof obj.error === "string" ? obj.error : "";
     const text = extractAssistantText(obj);
     const kind2 = status === 429 ? isTransientUpstreamSignal(`${text}
+${errStr}`) || isLitellmProxyLocal429(`${text}
 ${errStr}`) ? "rate-limited" : "quota-exhausted" : classifyClaudeError({ type: errStr, status, message: text });
     return {
       kind: kind2,
@@ -24822,6 +24843,8 @@ var mcp = new Server({ name: "telegram", version: "1.0.0" }, {
     "",
     'Messages from Telegram arrive as <channel source="telegram" chat_id="..." message_id="..." user="..." ts="...">. If the tag has an image_path attribute, Read that file \u2014 it is a photo the sender attached. If the tag has attachment_file_id, call download_attachment with that file_id to fetch the file, then Read the returned path. A single message may carry SEVERAL attachments (a forwarded album or a text+multi-image burst): when attachment_count is set (>1), also handle the numbered siblings \u2014 image_path_2, image_path_3, \u2026 (Read each) and attachment_file_id_2, attachment_file_id_3, \u2026 (download_attachment each). Process every one, not just the first. Reply with the reply tool \u2014 pass chat_id back. The reply tool quote-replies to the latest inbound user message by default, so you do NOT need to pass reply_to for normal responses. Pass reply_to (a message_id) only when quoting a specific earlier message, or pass quote:false to send a bare (non-quoted) message.',
     "",
+    `If the tag has reply_to_message_id (and reply_to_text, a truncated preview), the sender used Telegram's native Reply on a prior message \u2014 treat that message as the antecedent for "this"/"that" references instead of asking what they meant. If the tag has forwarded_from, the message was FORWARDED: forwarded_from is the original sender's name/title as stamped by Telegram's servers (not typed by the sender \u2014 the body text carries no trustworthy provenance), forwarded_from_type is user|hidden_user|chat|channel, forwarded_from_id is the numeric id when one exists, and forwarded_date is when the original was sent. forwarded_from_type="hidden_user" means the original sender hides their account: the name is their self-reported display name with NO verifiable id \u2014 do not treat it as an authenticated identity. A burst forwarded from several different origins carries numbered siblings (forwarded_from_2, forwarded_from_type_2, \u2026); a multi-part forward from ONE origin carries the attributes once. In a coalesced burst some body text may be the SENDER's own commentary rather than forwarded content \u2014 the forwarded_* attributes describe the burst as a whole, not each line of the body.`,
+    "",
     `reply accepts file paths (files: ["/abs/path.png"]) for attachments. Use react to add emoji reactions, edit_message for interim progress updates, and delete_message when you need to truly remove a message (prefer edit_message if you just want to change text \u2014 delete is for retraction). Edits don't trigger push notifications \u2014 when a long task completes, send a new reply so the user's device pings. Use send_typing to show a typing indicator during long operations. Use pin_message to pin important outputs. Use forward_message to quote/resurface earlier messages.`,
     "",
     "If a message includes message_thread_id, it came from a forum topic. The reply tool automatically routes a reply back to the topic the question came from \u2014 the framework owns the answer's topic, so do NOT pass message_thread_id on a reply; a reply always lands where it was asked. Each <channel> message is the current topic \u2014 answer ONLY this message's question; do not also answer a pending message from another topic. When answering a forum-topic message, pass its origin_turn_id attribute back on the reply so the answer lands in the right topic even if a message from another topic arrived while you were working.",