switchroom 0.13.5 → 0.13.8

package/profiles/_shared/telegram-style.md.hbs

@@ -4,19 +4,20 @@ Telegram is a chat — replies should feel like one, not a terminal dump or a tr
 
 **Every turn that responds to a user message MUST end with a `reply` (or `stream_reply` with `done=true`).** The user is on Telegram — they don't see your CLI output, tool-use trace, or inline thinking. The ONLY path for words to reach them is an MCP tool call. If you have a final answer, send it via `reply`. The text in your terminal is not the conversation.
 
-**Conversational pacing.**
-- **Open with an acknowledgement.** A person answers in a beat — *"got it"*, *"on it, checking now"* — before the work is done. Default to that: unless the real answer lands within a second or two, your **first `reply` is a short human one-liner** in persona voice, sent fast (`disable_notification: true`). It is the line between a colleague and a black box. Skip it only when the answer itself arrives in the first couple of seconds — then the answer is the acknowledgement.
-- **Mid-turn updates at meaningful punctuation only.** Finished a hard step; hit a blocker; pivoting; dispatching a sub-agent; waiting on a slow tool; found something worth surfacing. **Not** on every tool call, **not** on a cadence, **not** to fill silence — the reaction on the user's inbound message already signals alive.
-- **Mid-turn updates pass `disable_notification: true`.** The user only gets pinged on the final answer (or a genuine heads-up). Update freely without notification fatigue.
-- **Narrate sub-agent dispatches** — *"spinning up @reviewer to look at this"* — and summarise their reply when they report back. Sub-agent work belongs in the chat, not inferred from absence.
-- **Final answer is a fresh `reply`** (omit `disable_notification`, or pass false). Pings once.
-- **Silence-poke reminders.** A `<system-reminder>` containing `[silence-poke]` means the framework detected you've been quiet too long — send one short `reply` (*"still working through X"*, *"npm install is slow"*), brief, no task restatement. Skip if you're within ~5s of finishing.
+**Conversational pacing — a human is on the other side.** Match the rhythm of a capable colleague messaging you back. Five beats:
+- **1 · Acknowledge first.** Your first action on any turn that needs real work — a file read, a search, a command — is a short one-liner via `reply`, persona voice, sent fast (`disable_notification: true`): *"on it — checking now"*. Skip it only when the whole answer is one sentence you can give immediately (*"what's 2+2"*). This is a beat, not filler — it's the line between a colleague and a black box.
+- **2 · Then go quiet and work.** Heads-down is right — do **not** narrate every tool call. A typing indicator runs for you automatically; you don't keep it alive.
+- **3 · Surface meaningful progress** at genuine inflection points — a hard step finished, a blocker, a pivot, dispatching a sub-agent, a notably slow wait, a finding worth knowing now. One short `reply`, `disable_notification: true` (no mid-turn ping).
+- **4 · Hand back delegations with synthesis.** When a sub-agent reports back, re-enter in your own voice — what it found, what you're doing next (*"reviewer flagged the auth gap; fixing it now"*). Never let its raw report stand as your reply.
+- **5 · Deliver the answer** as a fresh `reply` (omit `disable_notification` — pings once).
+
+The one thing to avoid is **spam**: a reply on every tool call, on a cadence, or repeating yourself. Responsive and human, never a flood. A `<system-reminder>` containing `[silence-poke]` means you've gone quiet too long — send one short `reply` and carry on; skip it only if you're within ~5s of finishing.
 
 **`stream_reply` vs `reply`.**
-- **`reply`** is the default. Use for soft-commits, mid-turn updates, sub-agent narration, final answers. Pass `disable_notification: true` mid-turn.
+- **`reply`** is the default. Use for acks, mid-turn updates, sub-agent handbacks, final answers. Pass `disable_notification: true` mid-turn.
 - **`stream_reply`** is for content whose final answer benefits from streaming character-by-character (long prose, code blocks). First call sends fresh; subsequent calls edit (no ping until `done=true`). Don't use it just to "show progress" — that's what `reply` is for.
 
-The status-reaction lifecycle (👀 → 🤔 → 🔥 → 👍) on the user's inbound message signals "working" automatically; you don't need a typing message or periodic "still working" replies just to keep that signal alive.
+The 👀→🤔→🔥→👍 status reaction and the typing indicator are *ambient* liveness — they tell the user the agent is alive and working, automatically. They do **not** replace the five beats: ambient says "alive", your `reply` messages say "here's what's happening." Different layers; both run.
 
 **Reactions ON your replies.** Sometimes you'll receive a turn whose body is wrapped in `<channel source="reaction">`. That means the user reacted to one of your earlier messages and the gateway forwarded the reaction as a synthetic turn (the message preview is included so you know which reply they reacted to). 👎 / ❌ are stop signals — pause, reconsider the approach, ask what's off. 👍 / ✅ are acknowledgements — keep going if mid-task, no extra reply needed. A brief explicit acknowledgement is fine but not required; don't ceremonially reply to every reaction. The allowlist + per-hour cap are operator-tunable (default 10/hour); other emojis you might see don't trigger turns.
 
@@ -59,7 +60,7 @@ Don't use `accent` on routine conversational replies — it's for status communi
 
 **When stickers / GIFs land well**: confirming a real milestone the user celebrated (✅ workout logged, 🎉 deal closed); softening genuinely awkward news; mirroring back a sticker or GIF the user just sent — once, not as a habit. Use the user's emoji-sticker (echo back the file_id from inbound `(sticker — 😊 from "PackName")`) to acknowledge their tone. The agent persona's own curated aliases — declared by the operator under `telegram.stickers` in switchroom.yaml — are the standard alphabet (`happy`, `thinking`, `done`, etc.); call `send_sticker(chat_id, sticker='happy')`. Errors list available aliases when an unknown one is asked for.
 
-**When stickers / GIFs land badly**: in lieu of an actual answer, decorating routine acknowledgements ("got it 👍 [+sticker]"), peppering a long thread, or any time the user is task-focused. If you find yourself wanting to send one to lighten an otherwise empty reply, send no reply instead — silence is a valid answer when you have nothing to add. Two stickers in a row is always wrong.
+**When stickers / GIFs land badly**: in lieu of an actual answer, decorating routine acknowledgements ("got it 👍 [+sticker]"), peppering a long thread, or any time the user is task-focused. If you find yourself wanting to send one to lighten an otherwise empty reply, don't — a sticker is never a substitute for an actual answer. Two stickers in a row is always wrong.
 
 **Interrupt marker.** If a user asks how to stop you mid-turn, tell them: *"Start your message with `!` — it interrupts whatever I'm doing and treats the rest as a fresh request."* For implementation detail (cgroup escape, `tmux send-keys`, doubled-bang, empty-bang gateway behavior), invoke the `/switchroom-runtime` skill. The `!` interrupt wakes a fresh `SWITCHROOM_PENDING_TURN` cycle, so the resume protocol fires on the next turn.
 
@@ -67,4 +68,4 @@ Don't use `accent` on routine conversational replies — it's for status communi
 
 **"Why did you restart?"** If the user asks about a restart, crash, or absence, invoke `/switchroom-runtime`. The `SWITCHROOM_PENDING_*` env vars are one-shot and gone by the time the user asks; the skill knows which on-disk sources to read (`clean-shutdown.json`, container/journal logs, watchdog audit log) and how to quote the reason verbatim. Never answer from memory.
 
-**"status?" / "still there?" / "any update?" is a UX-failure signal**, not a feature request. The progress card and stream-reply pattern exist precisely so the user never has to ask. When you see one of those messages, answer the literal question in one sentence and invoke `/switchroom-runtime` for the offer-RCA flow (the skill walks the `/file-bug` integration).
+**"status?" / "still there?" / "any update?" is a UX-failure signal**, not a feature request. The five-beat conversational pacing exists precisely so the user never has to ask. When you see one of those messages, answer the literal question in one sentence and invoke `/switchroom-runtime` for the offer-RCA flow (the skill walks the `/file-bug` integration).

package/profiles/default/CLAUDE.md

@@ -41,19 +41,20 @@ Telegram is a chat — replies should feel like one, not a terminal dump or a tr
 
 **Every turn that responds to a user message MUST end with a `reply` (or `stream_reply` with `done=true`).** The user is on Telegram — they don't see your CLI output, tool-use trace, or inline thinking. The ONLY path for words to reach them is an MCP tool call. If you have a final answer, send it via `reply`. The text in your terminal is not the conversation.
 
-**Conversational pacing.**
-- **Open with an acknowledgement.** A person answers in a beat — *"got it"*, *"on it, checking now"* — before the work is done. Default to that: unless the real answer lands within a second or two, your **first `reply` is a short human one-liner** in persona voice, sent fast (`disable_notification: true`). It is the line between a colleague and a black box. Skip it only when the answer itself arrives in the first couple of seconds — then the answer is the acknowledgement.
-- **Mid-turn updates at meaningful punctuation only.** Finished a hard step; hit a blocker; pivoting; dispatching a sub-agent; waiting on a slow tool; found something worth surfacing. **Not** on every tool call, **not** on a cadence, **not** to fill silence — the reaction on the user's inbound message already signals alive.
-- **Mid-turn updates pass `disable_notification: true`.** The user only gets pinged on the final answer (or a genuine heads-up). Update freely without notification fatigue.
-- **Narrate sub-agent dispatches** — *"spinning up @reviewer to look at this"* — and summarise their reply when they report back. Sub-agent work belongs in the chat, not inferred from absence.
-- **Final answer is a fresh `reply`** (omit `disable_notification`, or pass false). Pings once.
-- **Silence-poke reminders.** A `<system-reminder>` containing `[silence-poke]` means the framework detected you've been quiet too long — send one short `reply` (*"still working through X"*, *"npm install is slow"*), brief, no task restatement. Skip if you're within ~5s of finishing.
+**Conversational pacing — a human is on the other side.** Match the rhythm of a capable colleague messaging you back. Five beats:
+- **1 · Acknowledge first.** Your first action on any turn that needs real work — a file read, a search, a command — is a short one-liner via `reply`, persona voice, sent fast (`disable_notification: true`): *"on it — checking now"*. Skip it only when the whole answer is one sentence you can give immediately (*"what's 2+2"*). This is a beat, not filler — it's the line between a colleague and a black box.
+- **2 · Then go quiet and work.** Heads-down is right — do **not** narrate every tool call. A typing indicator runs for you automatically; you don't keep it alive.
+- **3 · Surface meaningful progress** at genuine inflection points — a hard step finished, a blocker, a pivot, dispatching a sub-agent, a notably slow wait, a finding worth knowing now. One short `reply`, `disable_notification: true` (no mid-turn ping).
+- **4 · Hand back delegations with synthesis.** When a sub-agent reports back, re-enter in your own voice — what it found, what you're doing next (*"reviewer flagged the auth gap; fixing it now"*). Never let its raw report stand as your reply.
+- **5 · Deliver the answer** as a fresh `reply` (omit `disable_notification` — pings once).
+
+The one thing to avoid is **spam**: a reply on every tool call, on a cadence, or repeating yourself. Responsive and human, never a flood. A `<system-reminder>` containing `[silence-poke]` means you've gone quiet too long — send one short `reply` and carry on; skip it only if you're within ~5s of finishing.
 
 **`stream_reply` vs `reply`.**
-- **`reply`** is the default. Use for soft-commits, mid-turn updates, sub-agent narration, final answers. Pass `disable_notification: true` mid-turn.
+- **`reply`** is the default. Use for acks, mid-turn updates, sub-agent handbacks, final answers. Pass `disable_notification: true` mid-turn.
 - **`stream_reply`** is for content whose final answer benefits from streaming character-by-character (long prose, code blocks). First call sends fresh; subsequent calls edit (no ping until `done=true`). Don't use it just to "show progress" — that's what `reply` is for.
 
-The status-reaction lifecycle (👀 → 🤔 → 🔥 → 👍) on the user's inbound message signals "working" automatically; you don't need a typing message or periodic "still working" replies just to keep that signal alive.
+The 👀→🤔→🔥→👍 status reaction and the typing indicator are *ambient* liveness — they tell the user the agent is alive and working, automatically. They do **not** replace the five beats: ambient says "alive", your `reply` messages say "here's what's happening." Different layers; both run.
 
 **Reactions ON your replies.** Sometimes you'll receive a turn whose body is wrapped in `<channel source="reaction">`. That means the user reacted to one of your earlier messages and the gateway forwarded the reaction as a synthetic turn (the message preview is included so you know which reply they reacted to). 👎 / ❌ are stop signals — pause, reconsider the approach, ask what's off. 👍 / ✅ are acknowledgements — keep going if mid-task, no extra reply needed. A brief explicit acknowledgement is fine but not required; don't ceremonially reply to every reaction. The allowlist + per-hour cap are operator-tunable (default 10/hour); other emojis you might see don't trigger turns.
 
@@ -96,7 +97,7 @@ Don't use `accent` on routine conversational replies — it's for status communi
 
 **When stickers / GIFs land well**: confirming a real milestone the user celebrated (✅ workout logged, 🎉 deal closed); softening genuinely awkward news; mirroring back a sticker or GIF the user just sent — once, not as a habit. Use the user's emoji-sticker (echo back the file_id from inbound `(sticker — 😊 from "PackName")`) to acknowledge their tone. The agent persona's own curated aliases — declared by the operator under `telegram.stickers` in switchroom.yaml — are the standard alphabet (`happy`, `thinking`, `done`, etc.); call `send_sticker(chat_id, sticker='happy')`. Errors list available aliases when an unknown one is asked for.
 
-**When stickers / GIFs land badly**: in lieu of an actual answer, decorating routine acknowledgements ("got it 👍 [+sticker]"), peppering a long thread, or any time the user is task-focused. If you find yourself wanting to send one to lighten an otherwise empty reply, send no reply instead — silence is a valid answer when you have nothing to add. Two stickers in a row is always wrong.
+**When stickers / GIFs land badly**: in lieu of an actual answer, decorating routine acknowledgements ("got it 👍 [+sticker]"), peppering a long thread, or any time the user is task-focused. If you find yourself wanting to send one to lighten an otherwise empty reply, don't — a sticker is never a substitute for an actual answer. Two stickers in a row is always wrong.
 
 **Interrupt marker.** If a user asks how to stop you mid-turn, tell them: *"Start your message with `!` — it interrupts whatever I'm doing and treats the rest as a fresh request."* For implementation detail (cgroup escape, `tmux send-keys`, doubled-bang, empty-bang gateway behavior), invoke the `/switchroom-runtime` skill. The `!` interrupt wakes a fresh `SWITCHROOM_PENDING_TURN` cycle, so the resume protocol fires on the next turn.
 
@@ -104,7 +105,7 @@ Don't use `accent` on routine conversational replies — it's for status communi
 
 **"Why did you restart?"** If the user asks about a restart, crash, or absence, invoke `/switchroom-runtime`. The `SWITCHROOM_PENDING_*` env vars are one-shot and gone by the time the user asks; the skill knows which on-disk sources to read (`clean-shutdown.json`, container/journal logs, watchdog audit log) and how to quote the reason verbatim. Never answer from memory.
 
-**"status?" / "still there?" / "any update?" is a UX-failure signal**, not a feature request. The progress card and stream-reply pattern exist precisely so the user never has to ask. When you see one of those messages, answer the literal question in one sentence and invoke `/switchroom-runtime` for the offer-RCA flow (the skill walks the `/file-bug` integration).
+**"status?" / "still there?" / "any update?" is a UX-failure signal**, not a feature request. The five-beat conversational pacing exists precisely so the user never has to ask. When you see one of those messages, answer the literal question in one sentence and invoke `/switchroom-runtime` for the offer-RCA flow (the skill walks the `/file-bug` integration).
 
 ## Memory — Hindsight is your single backend
 

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

@@ -23361,6 +23361,13 @@ function detectErrorInTranscriptLine(line) {
   if (typeof obj !== "object" || obj == null)
     return null;
   const type = obj.type;
+  if (obj.isApiErrorMessage === true) {
+    const status = typeof obj.apiErrorStatus === "number" ? obj.apiErrorStatus : null;
+    const errStr = typeof obj.error === "string" ? obj.error : "";
+    const text = extractAssistantText(obj);
+    const kind2 = status === 429 ? "quota-exhausted" : classifyClaudeError({ type: errStr, status, message: text });
+    return { kind: kind2, raw: obj, detail: text || errStr || "api error" };
+  }
   const isErrorLine = type === "api_error" || type === "error";
   const embeddedError = typeof obj.error === "object" && obj.error != null ? obj.error : null;
   if (!isErrorLine && !embeddedError)
@@ -23376,6 +23383,23 @@ function extractDetailMessage(obj) {
   const msg = obj.message;
   return typeof msg === "string" && msg.length > 0 ? msg : null;
 }
+function extractAssistantText(obj) {
+  const message = obj.message;
+  if (typeof message !== "object" || message == null)
+    return "";
+  const content = message.content;
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "object" && block != null && block.type === "text") {
+      const t = block.text;
+      if (typeof t === "string")
+        parts.push(t);
+    }
+  }
+  return parts.join(" ").trim();
+}
 function startSessionTail(config2) {
   const cwd = config2.cwd ?? process.cwd();
   const claudeHome = config2.claudeHome ?? process.env.CLAUDE_CONFIG_DIR ?? join3(homedir2(), ".claude");

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

@@ -23592,7 +23592,7 @@ var init_dist = __esm(() => {
 });
 
 // ../src/config/schema.ts
-var CodeRepoEntrySchema, AgentBindMountSchema, ScheduleEntrySchema, AgentSoulSchema, AgentToolsSchema, AgentMemorySchema, HookEntrySchema, AgentHooksSchema, SubagentSchema, SessionSchema, SessionContinuitySchema, TelegramChannelSchema, ChannelsSchema, TIMEZONE_REGEX, ApproverIdSchema, GoogleWorkspaceTierSchema, GoogleWorkspaceConfigSchema, AgentGoogleWorkspaceConfigSchema, ReactionsSchema, ReleaseBlock, NetworkIsolationSchema, profileFields, ProfileSchema, _omitExtends, defaultsFields, AgentDefaultsSchema, AgentSchema, TelegramConfigSchema, MemoryBackendConfigSchema, VaultConfigSchema, QuotaConfigSchema, HostControlConfigSchema, SwitchroomConfigSchema;
+var CodeRepoEntrySchema, AgentBindMountSchema, ScheduleEntrySchema, AgentSoulSchema, AgentToolsSchema, AgentMemorySchema, HookEntrySchema, AgentHooksSchema, SubagentSchema, SessionSchema, SessionContinuitySchema, TelegramChannelSchema, ChannelsSchema, TIMEZONE_REGEX, ApproverIdSchema, GoogleWorkspaceTierSchema, GoogleWorkspaceConfigSchema, AgentGoogleWorkspaceConfigSchema, ReactionsSchema, ReleaseBlock, NetworkIsolationSchema, profileFields, ProfileSchema, _omitExtends, defaultsFields, AgentDefaultsSchema, AgentSchema, TelegramConfigSchema, MemoryBackendConfigSchema, VaultConfigSchema, QuotaConfigSchema, HostControlConfigSchema, HostdConfigSchema, SwitchroomConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   CodeRepoEntrySchema = exports_external.object({
@@ -23943,6 +23943,10 @@ var init_schema = __esm(() => {
   HostControlConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true).describe("Whether the host-control daemon is in use. Default: true (since " + "RFC C Phase 2 default-flip \u2014 the gateway's /restart, /new, /reset, " + "and /update apply slash-commands all dispatch through hostd, and " + "without it those verbs fail on docker-mode installs because the " + "agent container has no docker binary/socket). " + "When true, the compose generator emits per-agent bind mounts " + "at `~/.switchroom/hostd/<name>/sock` for every admin-flagged " + "agent. Install the daemon with `switchroom hostd install` \u2014 " + "it runs as a docker container in its own compose project " + "(`switchroom-hostd`), separate from the agent fleet's compose " + "project so `up -d --remove-orphans` cycles of the fleet " + "can't recreate the daemon mid-RPC. See RFC C \u00a75.1. " + "Set enabled: false only on legacy systemd-mode installs that " + "still rely on the in-container `spawnSwitchroomDetached` " + "shellout (removal is tracked as RFC C Phase 3).")
   });
+  HostdConfigSchema = exports_external.object({
+    config_edit_enabled: exports_external.boolean().default(false).describe("Opt-in toggle for the `config_propose_edit` hostd verb (RFC " + "admin-agent-config-edit \u00a73). Default false \u2014 the verb returns " + "`E_CONFIG_EDIT_DISABLED` until the operator explicitly flips " + "this to true. When true (and once PR 1c lands the apply path), " + "admin agents can propose unified-diff patches against " + "`/state/config/switchroom.yaml`, gated by an operator approval " + "card in the primary chat. Same trust posture as `update_apply` " + "and `agent_restart`: the human-in-the-loop tap is the security " + "boundary, not the agent's judgement."),
+    config_edit_rate_per_hour: exports_external.number().int().min(1).max(20).default(3).describe("Per-requesting-agent rate cap for `config_propose_edit` cards " + "(RFC admin-agent-config-edit \u00a75). Default 3 cards/hour; min 1, " + "max 20. Implemented as a sqlite token bucket in PR 1c; the " + "field is wired here in PR 1a so operators can pin it before the " + "limiter is live. Above the cap, the verb returns " + "`E_RATE_LIMITED` without raising a card.")
+  });
   SwitchroomConfigSchema = exports_external.object({
     switchroom: exports_external.object({
       version: exports_external.literal(1).describe("Config schema version"),
@@ -23969,6 +23973,7 @@ var init_schema = __esm(() => {
     google_workspace: GoogleWorkspaceConfigSchema.describe("RFC G canonical key. Top-level Google Workspace configuration \u2014 " + "OAuth client credentials, approver allowlist, and tier knob (`core` " + "| `extended` | `complete`, default `core`). Mutually exclusive with " + "`drive:` at the top level (loader fails fast if both are set)."),
     quota: QuotaConfigSchema.optional().describe("Optional weekly/monthly USD spend budgets rendered in the session " + "greeting. Usage is read from ccusage at runtime; no network calls."),
     host_control: HostControlConfigSchema.default({}).describe("Host-control daemon configuration. Defaults to enabled=true since " + "RFC C Phase 2 (docs/rfcs/host-control-daemon.md). Omit the block " + "to accept defaults; set `enabled: false` only on legacy systemd-" + "mode installs (removal tracked as RFC C Phase 3)."),
+    hostd: HostdConfigSchema.default({}).describe("hostd verb-level knobs (RFC admin-agent-config-edit). Distinct " + "from `host_control:` which governs whether the daemon runs at " + "all. Currently scopes the opt-in flag and rate cap for the new " + "`config_propose_edit` verb (PR 1a \u2014 disabled by default)."),
     google_accounts: exports_external.record(exports_external.string().regex(/^[^@\s:]+@[^@\s:]+\.[^@\s:]+$/, {
       message: "Account key must be a Google account email like 'alice@example.com' (colons not allowed)"
     }).transform((v) => v.trim().toLowerCase()), exports_external.object({
@@ -39342,7 +39347,9 @@ function detectModelUnavailable(stderr) {
     "quota exhausted",
     "quota_exhausted",
     "plan limit",
-    "subscription limit"
+    "subscription limit",
+    "hit your limit",
+    "hit the limit"
   ];
   if (quotaSignals.some((s) => lower.includes(s))) {
     const resetAt = parseResetTime(sample);
@@ -42801,6 +42808,15 @@ var AgentSmokeRequestSchema = exports_external.object({
     deep: exports_external.boolean().optional()
   })
 });
+var ConfigProposeEditRequestSchema = exports_external.object({
+  ...RequestEnvelope,
+  op: exports_external.literal("config_propose_edit"),
+  args: exports_external.object({
+    unified_diff: exports_external.string().min(1).max(MAX_FRAME_BYTES3 - 1024),
+    reason: exports_external.string().min(1).max(500),
+    target_path: exports_external.literal("/state/config/switchroom.yaml")
+  })
+});
 var RequestSchema3 = exports_external.discriminatedUnion("op", [
   AgentRestartRequestSchema,
   UpgradeStatusRequestSchema,
@@ -42813,7 +42829,8 @@ var RequestSchema3 = exports_external.discriminatedUnion("op", [
   AgentLogsRequestSchema,
   AgentExecRequestSchema,
   DoctorRequestSchema,
-  AgentSmokeRequestSchema
+  AgentSmokeRequestSchema,
+  ConfigProposeEditRequestSchema
 ]);
 var ResultSchema = exports_external.enum(["started", "completed", "denied", "error"]);
 var ResponseEnvelope = {
@@ -44023,6 +44040,10 @@ function chatKey(chatId, threadId) {
 function chatKeyWithSuffix(chatId, threadId, suffix) {
   return `${chatKey(chatId, threadId)}:${suffix}`;
 }
+function chatIdOfChatKey(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
 
 // gateway/inbound-delivery-machine.ts
 function initialState() {
@@ -47720,11 +47741,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.13.5";
-var COMMIT_SHA = "cb688641";
-var COMMIT_DATE = "2026-05-22T05:10:31+10:00";
+var VERSION = "0.13.8";
+var COMMIT_SHA = "bb713414";
+var COMMIT_DATE = "2026-05-22T10:15:33+10:00";
 var LATEST_PR = null;
-var COMMITS_AHEAD_OF_TAG = 6;
+var COMMITS_AHEAD_OF_TAG = 4;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -48681,6 +48702,7 @@ function purgeReactionTracking(key, endingTurn) {
   activeStatusReactions.delete(key);
   activeReactionMsgIds.delete(key);
   activeTurnStartedAt.delete(key);
+  stopTurnTypingLoop(chatIdOfChatKey(key));
   if (msgInfo) {
     const agentDir = resolveAgentDirFromEnv();
     if (agentDir != null)
@@ -48982,6 +49004,22 @@ function stopTypingLoop(chat_id) {
     typingRetryTimers.delete(chat_id);
   }
 }
+var turnTypingIntervals = new Map;
+function startTurnTypingLoop(chat_id) {
+  stopTurnTypingLoop(chat_id);
+  const send = () => {
+    bot.api.sendChatAction(chat_id, "typing").catch(() => {});
+  };
+  send();
+  turnTypingIntervals.set(chat_id, setInterval(send, 4000));
+}
+function stopTurnTypingLoop(chat_id) {
+  const iv = turnTypingIntervals.get(chat_id);
+  if (iv) {
+    clearInterval(iv);
+    turnTypingIntervals.delete(chat_id);
+  }
+}
 var typingWrapper = createTypingWrapper({
   startTypingLoop,
   stopTypingLoop,
@@ -52367,6 +52405,7 @@ ${preBlock(write.output)}`;
         logStreamingEvent({ kind: "inbound_ack", chatId: chat_id, messageId: msgId, ackDelayMs: Date.now() - inboundReceivedAt });
         reset(statusKey(chat_id, messageThreadId), Date.now());
         startTurn(statusKey(chat_id, messageThreadId), Date.now());
+        startTurnTypingLoop(chat_id);
         emitRuntimeMetric({
           kind: "turn_started",
           chat_id,
@@ -56527,6 +56566,9 @@ async function shutdown(signal) {
   for (const iv of [...typingIntervals.values()])
     clearInterval(iv);
   typingIntervals.clear();
+  for (const iv of [...turnTypingIntervals.values()])
+    clearInterval(iv);
+  turnTypingIntervals.clear();
   for (const t of [...typingRetryTimers.values()])
     clearTimeout(t);
   typingRetryTimers.clear();

package/telegram-plugin/dist/server.js

@@ -17399,6 +17399,13 @@ function detectErrorInTranscriptLine(line) {
   if (typeof obj !== "object" || obj == null)
     return null;
   const type = obj.type;
+  if (obj.isApiErrorMessage === true) {
+    const status = typeof obj.apiErrorStatus === "number" ? obj.apiErrorStatus : null;
+    const errStr = typeof obj.error === "string" ? obj.error : "";
+    const text = extractAssistantText(obj);
+    const kind2 = status === 429 ? "quota-exhausted" : classifyClaudeError({ type: errStr, status, message: text });
+    return { kind: kind2, raw: obj, detail: text || errStr || "api error" };
+  }
   const isErrorLine = type === "api_error" || type === "error";
   const embeddedError = typeof obj.error === "object" && obj.error != null ? obj.error : null;
   if (!isErrorLine && !embeddedError)
@@ -17414,6 +17421,23 @@ function extractDetailMessage(obj) {
   const msg = obj.message;
   return typeof msg === "string" && msg.length > 0 ? msg : null;
 }
+function extractAssistantText(obj) {
+  const message = obj.message;
+  if (typeof message !== "object" || message == null)
+    return "";
+  const content = message.content;
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "object" && block != null && block.type === "text") {
+      const t = block.text;
+      if (typeof t === "string")
+        parts.push(t);
+    }
+  }
+  return parts.join(" ").trim();
+}
 function startSessionTail(config2) {
   const cwd = config2.cwd ?? process.cwd();
   const claudeHome = config2.claudeHome ?? process.env.CLAUDE_CONFIG_DIR ?? join4(homedir3(), ".claude");

package/telegram-plugin/gateway/gateway.ts

@@ -264,7 +264,7 @@ import { createInboundSpool } from './inbound-spool.js'
 import { purgeStaleTurnsForChat } from './turn-state-purge.js'
 import { decideInboundDelivery } from './inbound-delivery-gate.js'
 import { createPendingPermissionBuffer } from './pending-permission-decisions.js'
-import { chatKey, chatKeyWithSuffix } from './chat-key.js'
+import { chatKey, chatKeyWithSuffix, chatIdOfChatKey } from './chat-key.js'
 // Phase 2b PR 2 — shadow mode. Each event-site below calls shadowEmit()
 // to record what the InboundDeliveryStateMachine PREDICTS the gateway
 // should do. Behavior unchanged in this PR — the imperative code below
@@ -1310,6 +1310,13 @@ function purgeReactionTracking(key: string, endingTurn?: CurrentTurn): void {
   activeStatusReactions.delete(key)
   activeReactionMsgIds.delete(key)
   activeTurnStartedAt.delete(key)
+  // Human-feel UX: stop the turn-long `typing…` indicator started in
+  // the turn-start block. `purgeReactionTracking` is the canonical
+  // turn-end, so this is the single owner of the stop. (If an abnormal
+  // abort skips purge, the stray loop self-heals: the next turn on this
+  // chat calls `startTurnTypingLoop`, which stops the old interval
+  // first.)
+  stopTurnTypingLoop(chatIdOfChatKey(key as _ChatKey))
   if (msgInfo) {
     const agentDir = resolveAgentDirFromEnv()
     if (agentDir != null) removeActiveReaction(agentDir, msgInfo.chatId, msgInfo.messageId)
@@ -1781,6 +1788,32 @@ function stopTypingLoop(chat_id: string): void {
   if (retry) { clearTimeout(retry); typingRetryTimers.delete(chat_id) }
 }
 
+// Turn-level `typing…` indicator. Deliberately a SEPARATE interval map
+// from `typingIntervals` (which the reply handler and the tool-use
+// typing wrapper share and freely stop). If the turn loop lived in the
+// shared map, a mid-turn reply's `finally { stopTypingLoop }` would
+// kill it and the chat would go dark for the rest of the turn — the
+// exact black-box gap this is here to close. A dedicated map makes the
+// turn loop structurally immune to those stops: only `stopTurnTypingLoop`
+// (called at the canonical turn-end) clears it. The redundant `typing`
+// pings while a reply is mid-flight are harmless — same action, and
+// sendChatAction is cheap.
+const turnTypingIntervals = new Map<string, ReturnType<typeof setInterval>>()
+
+function startTurnTypingLoop(chat_id: string): void {
+  stopTurnTypingLoop(chat_id)
+  const send = () => {
+    void bot.api.sendChatAction(chat_id, 'typing').catch(() => {})
+  }
+  send()
+  turnTypingIntervals.set(chat_id, setInterval(send, 4000))
+}
+
+function stopTurnTypingLoop(chat_id: string): void {
+  const iv = turnTypingIntervals.get(chat_id)
+  if (iv) { clearInterval(iv); turnTypingIntervals.delete(chat_id) }
+}
+
 const typingWrapper = createTypingWrapper({
   startTypingLoop,
   stopTypingLoop,
@@ -7563,6 +7596,16 @@ async function handleInbound(
         // the framework can nudge the model if it goes quiet past the
         // soft / firm thresholds.
         silencePoke.startTurn(statusKey(chat_id, messageThreadId), Date.now())
+        // Human-feel UX: hold a continuous `typing…` indicator for the
+        // WHOLE turn, not just the split-second a reply is transmitted.
+        // A person you message shows as typing the entire time they
+        // compose; switchroom used to fire only one-shot ~5s pings, so
+        // any turn that read a file or thought for a moment went dark
+        // after 5s. Self-renews every 4s; stopped at the canonical
+        // turn-end (`purgeReactionTracking → stopTurnTypingLoop`).
+        // Deterministic, framework-owned, no prose — the mechanical
+        // ambient layer of the pacing contract.
+        startTurnTypingLoop(chat_id)
         // #1122 KPI: emit turn_started so dashboards can compute funnel
         // start counts + correlate to turn_ended for duration / TTFO.
         emitRuntimeMetric({
@@ -14111,6 +14154,8 @@ async function shutdown(signal: string): Promise<void> {
 
   for (const iv of [...typingIntervals.values()]) clearInterval(iv)
   typingIntervals.clear()
+  for (const iv of [...turnTypingIntervals.values()]) clearInterval(iv)
+  turnTypingIntervals.clear()
   for (const t of [...typingRetryTimers.values()]) clearTimeout(t)
   typingRetryTimers.clear()
 

package/telegram-plugin/model-unavailable.ts

@@ -80,6 +80,10 @@ export function detectModelUnavailable(
     'quota_exhausted',
     'plan limit',
     'subscription limit',
+    // Claude Code v2.1.x usage-limit wording: "You've hit your limit ·
+    // resets 8:50am (Australia/Melbourne)".
+    'hit your limit',
+    'hit the limit',
   ]
   if (quotaSignals.some(s => lower.includes(s))) {
     const resetAt = parseResetTime(sample)

package/telegram-plugin/session-tail.ts

@@ -423,6 +423,33 @@ export function detectErrorInTranscriptLine(
 
   const type = obj.type as string | undefined
 
+  // Claude Code (v2.1.x) records a usage-limit / API error as a
+  // SYNTHETIC ASSISTANT MESSAGE, not an api_error / error line:
+  //   { type: "assistant",
+  //     message: { role: "assistant",
+  //       content: [{ type: "text", text: "You've hit your limit · resets …" }] },
+  //     error: "rate_limit", isApiErrorMessage: true, apiErrorStatus: 429 }
+  // It has no `api_error`/`error` top-type and no nested error OBJECT
+  // (`error` is a bare string), so the structured checks below miss it
+  // entirely. That silent miss is what kept fleet auto-fallback from
+  // ever firing on a quota hit — the exhaustion signal never reached
+  // the operator-event path. Detect this shape explicitly.
+  if (obj.isApiErrorMessage === true) {
+    const status =
+      typeof obj.apiErrorStatus === 'number' ? obj.apiErrorStatus : null
+    const errStr = typeof obj.error === 'string' ? obj.error : ''
+    const text = extractAssistantText(obj)
+    // A 429 in this shape is a subscription usage-limit hit (it carries
+    // a reset time) — classify it quota-exhausted so the operator event
+    // resolves to an auto-fallback-eligible kind. Other statuses fall
+    // through to the shared classifier.
+    const kind: OperatorEventKind =
+      status === 429
+        ? 'quota-exhausted'
+        : classifyClaudeError({ type: errStr, status, message: text })
+    return { kind, raw: obj, detail: text || errStr || 'api error' }
+  }
+
   // Explicit error line types from Claude Code JSONL
   const isErrorLine = type === 'api_error' || type === 'error'
 
@@ -454,6 +481,32 @@ function extractDetailMessage(obj: Record<string, unknown> | null): string | nul
   return typeof msg === 'string' && msg.length > 0 ? msg : null
 }
 
+/**
+ * Pull the human-readable text out of a synthetic assistant message
+ * (`message.content[].text`, joined). Used for the v2.1.x
+ * `isApiErrorMessage` shape, where the user-facing error string lives
+ * inside the assistant message rather than in an `error` object.
+ * Returns '' for any non-conforming shape — never throws.
+ */
+function extractAssistantText(obj: Record<string, unknown>): string {
+  const message = obj.message
+  if (typeof message !== 'object' || message == null) return ''
+  const content = (message as Record<string, unknown>).content
+  if (!Array.isArray(content)) return ''
+  const parts: string[] = []
+  for (const block of content) {
+    if (
+      typeof block === 'object'
+      && block != null
+      && (block as Record<string, unknown>).type === 'text'
+    ) {
+      const t = (block as Record<string, unknown>).text
+      if (typeof t === 'string') parts.push(t)
+    }
+  }
+  return parts.join(' ').trim()
+}
+
 // ─── The tail watcher ─────────────────────────────────────────────────────
 
 /** Emitted to onOperatorEvent when the tail detects a Claude API error. */

package/telegram-plugin/tests/model-unavailable.test.ts

@@ -42,6 +42,15 @@ describe('detectModelUnavailable — quota / billing strings', () => {
   it('classifies "quota exhausted" verbatim', () => {
     expect(detectModelUnavailable('quota exhausted on slot main')?.kind).toBe('quota_exhausted')
   })
+
+  it("classifies Claude Code v2.1.x 'You've hit your limit' wording", () => {
+    // The exact text claude writes inside the synthetic
+    // isApiErrorMessage assistant message on a subscription quota hit.
+    const d = detectModelUnavailable(
+      "You've hit your limit · resets 8:50am (Australia/Melbourne)",
+    )
+    expect(d?.kind).toBe('quota_exhausted')
+  })
 })
 
 describe('detectModelUnavailable — overload / 429 / 5xx strings', () => {

package/telegram-plugin/tests/operator-events-session-tail.test.ts

@@ -70,6 +70,49 @@ describe('detectErrorInTranscriptLine — error detection', () => {
     expect(detectErrorInTranscriptLine(line)).toBeNull()
   })
 
+  // Regression — the fleet-auto-failover dead-zone. Claude Code v2.1.x
+  // records a usage-limit hit as a synthetic assistant message with
+  // isApiErrorMessage:true (no api_error type, no nested error OBJECT).
+  // Pre-fix, detectErrorInTranscriptLine missed it entirely → the
+  // operator-event path never ran → fleet auto-fallback never fired.
+  it('detects the v2.1.x synthetic-assistant-message usage-limit shape', () => {
+    // The exact on-disk line shape, verbatim from a real quota hit.
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        role: 'assistant',
+        model: '<synthetic>',
+        content: [
+          {
+            type: 'text',
+            text: "You've hit your limit · resets 8:50am (Australia/Melbourne)",
+          },
+        ],
+      },
+      error: 'rate_limit',
+      isApiErrorMessage: true,
+      apiErrorStatus: 429,
+    })
+    const result = detectErrorInTranscriptLine(line)
+    expect(result).not.toBeNull()
+    // A 429 in this shape is a subscription usage-limit hit → must
+    // classify quota-exhausted so the operator event resolves to an
+    // auto-fallback-eligible kind.
+    expect(result!.kind).toBe('quota-exhausted')
+    // The user-facing text must survive into `detail` (the model-
+    // unavailable card + the text-pattern path both rely on it).
+    expect(result!.detail).toContain('hit your limit')
+  })
+
+  it('still returns null for a normal (non-error) assistant message', () => {
+    // No isApiErrorMessage flag → must NOT be treated as an error.
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: { role: 'assistant', content: [{ type: 'text', text: 'Done.' }] },
+    })
+    expect(detectErrorInTranscriptLine(line)).toBeNull()
+  })
+
   it('returns null for lines with null error field', () => {
     const line = JSON.stringify({ type: 'assistant', error: null })
     expect(detectErrorInTranscriptLine(line)).toBeNull()