switchroom 0.14.18 → 0.14.19

package/dist/cli/switchroom.js

@@ -49416,8 +49416,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.18";
-var COMMIT_SHA = "dddb8617";
+var VERSION = "0.14.19";
+var COMMIT_SHA = "21863276";
 
 // src/cli/agent.ts
 init_source();
@@ -50216,6 +50216,37 @@ a flood. Going quiet mid-work is fine \u2014 going quiet *instead* of
 acknowledging, or *instead* of an update at a real milestone, is the
 black box this exists to prevent.
 
+### Formatting \u2014 make it scannable
+
+\`reply\` and \`stream_reply\` render Markdown as Telegram HTML for you, so
+\`**bold**\` becomes bold and backtick-wrapped text becomes monospace. Use it.
+
+- **A one- or two-line conversational reply needs almost no markup.** Keep
+  bold for the single fact that matters, never for decoration. "on it, pulling
+  the logs now" is already perfect.
+- **A multi-section message needs visual hierarchy or it reads as a flat
+  wall.** When you group several blocks \u2014 a status update, a "where things
+  stand", a summary with distinct buckets, or **the message you post before
+  kicking off a sub-agent or worker** \u2014 give each section a **bold label on
+  its own line** and separate sections with **one blank line**. A row of
+  emoji and bullets at equal weight with no spacing is the plain-text dump to
+  avoid; bold labels + blank lines are what let the eye find the structure.
+  Example shape:
+
+  **Dispatching**
+  Kicking off a worker to crawl the changelog.
+
+  **What it'll do**
+  \u2022 pull every entry since v0.14
+  \u2022 flag anything user-facing
+
+  **Back in** ~2 min with a synthesized summary.
+- Bullets stay one level deep \u2014 Telegram flattens nested lists awkwardly. Use
+  backtick-wrapped \`inline code\` for filenames, commands, and identifiers.
+- Don't use Markdown headings (\`#\` / \`##\`) in a reply \u2014 bold the label
+  instead (\`**Blockers**\`, not \`## Blockers\`). Keep lines short; long
+  unwrapped lines are hard to read on a phone.
+
 Every turn that answers a user message ends with a user-visible
 \`reply\` (or \`stream_reply\` done=true) \u2014 Telegram is all the user
 sees; your terminal output never reaches them.`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.18",
+  "version": "0.14.19",
   "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/telegram-plugin/dist/gateway/gateway.js

@@ -31645,6 +31645,7 @@ var REACTION_VARIANTS = {
   coding: ["\uD83D\uDC68\u200d\uD83D\uDCBB", "\u270d", "\u26a1"],
   web: ["\u26a1", "\uD83E\uDD14", "\uD83D\uDC4C"],
   compacting: ["\u270d", "\uD83E\uDD14", "\uD83D\uDC40"],
+  awaiting: ["\uD83D\uDE4F", "\uD83E\uDD14", "\uD83D\uDC40"],
   done: ["\uD83D\uDC4D", "\uD83D\uDCAF", "\uD83C\uDF89"],
   error: ["\uD83D\uDE31", "\uD83D\uDE28", "\uD83E\uDD2F"],
   stallSoft: ["\uD83E\uDD71", "\uD83D\uDE34", "\uD83E\uDD14"],
@@ -31697,6 +31698,12 @@ class StatusReactionController {
   setCompacting() {
     this.scheduleState("compacting");
   }
+  setAwaiting() {
+    if (this.finished)
+      return;
+    this.scheduleState("awaiting", { immediate: true, skipStallReset: true });
+    this.clearStallTimers();
+  }
   setError() {
     this.scheduleState("error");
   }
@@ -51237,10 +51244,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.18";
-var COMMIT_SHA = "dddb8617";
-var COMMIT_DATE = "2026-05-30T23:35:26Z";
-var LATEST_PR = 2010;
+var VERSION = "0.14.19";
+var COMMIT_SHA = "21863276";
+var COMMIT_DATE = "2026-05-31T00:15:08Z";
+var LATEST_PR = 2013;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -52458,6 +52465,12 @@ function countRunningWorkers() {
   }
   return n;
 }
+function resumeReactionAfterVerdict() {
+  const turn = currentTurn;
+  if (turn == null)
+    return;
+  activeStatusReactions.get(statusKey(turn.sessionChatId, turn.sessionThreadId))?.setThinking();
+}
 function resolveThreadId(chat_id, explicit) {
   if (explicit != null)
     return Number(explicit);
@@ -52891,6 +52904,7 @@ var pendingStateReaper = setInterval(() => {
   for (const [k, v] of pendingPermissions) {
     if (now - v.startedAt > PERMISSION_TTL_MS) {
       dispatchPermissionVerdict({ type: "permission", requestId: k, behavior: "deny" });
+      resumeReactionAfterVerdict();
       process.stderr.write(`telegram gateway: permission TTL expired \u2014 auto-deny request=${k} tool=${v.tool_name} (no operator response in ${Math.round(PERMISSION_TTL_MS / 60000)}m)
 `);
       pendingPermissions.delete(k);
@@ -53532,6 +53546,9 @@ var ipcServer = createIpcServer({
 `);
       });
     }
+    if (activeTurn != null) {
+      activeStatusReactions.get(statusKey(activeTurn.sessionChatId, activeTurn.sessionThreadId))?.setAwaiting();
+    }
   },
   onHeartbeat(_client, _msg) {},
   onScheduleRestart(client3, msg) {
@@ -56283,6 +56300,7 @@ async function handleInbound(ctx, text, downloadImage, attachment) {
       requestId: request_id,
       behavior
     });
+    resumeReactionAfterVerdict();
     if (msgId != null) {
       const emoji = behavior === "allow" ? "\u2705" : "\u274C";
       bot.api.setMessageReaction(chat_id, msgId, [
@@ -57988,6 +58006,7 @@ async function handlePermissionSlash(ctx, behavior) {
     return;
   }
   dispatchPermissionVerdict({ type: "permission", requestId: request_id, behavior });
+  resumeReactionAfterVerdict();
   pendingPermissions.delete(request_id);
   process.stderr.write(`[telegram gateway] slash-${behavior} request_id=${request_id} tool=${details.tool_name} by=${senderId}
 `);
@@ -60284,6 +60303,7 @@ ${preBlock(formatSwitchroomOutput(err.message ?? "unknown error"))}`, { html: tr
       behavior: "allow",
       rule: chosen.rule
     });
+    resumeReactionAfterVerdict();
     let durable = false;
     let legacy = false;
     let failReason = "";
@@ -60385,7 +60405,9 @@ ${editLabel}` : editLabel,
     return;
   }
   pendingPermissions.delete(request_id);
-  const label = behavior === "allow" ? "\u2705 Allowed" : "\u274C Denied";
+  const resumeAgent = process.env.SWITCHROOM_AGENT_NAME;
+  const resumeBeat = resumeAgent ? `\u25B6\uFE0F ${escapeHtmlForTg(resumeAgent)} resuming\u2026` : "\u25B6\uFE0F resuming\u2026";
+  const label = `${behavior === "allow" ? "\u2705 Allowed" : "\u274C Denied"} \xB7 ${resumeBeat}`;
   const msg = ctx.callbackQuery?.message;
   const baseText = msg && "text" in msg && msg.text ? escapeHtmlForTg(msg.text) : "";
   await finalizeCallback(ctx, {
@@ -60400,6 +60422,7 @@ ${label}` : label,
         requestId: request_id,
         behavior
       });
+      resumeReactionAfterVerdict();
     }
   });
 });

package/telegram-plugin/gateway/gateway.ts

@@ -1954,6 +1954,24 @@ function paintStatusReactionError(chatId: string, threadId: number | undefined):
   ctrl.setError()
 }
 
+/**
+ * Flip the current turn's status reaction off 🙏 (awaiting-approval) back
+ * to a working glyph once a permission verdict has been dispatched. The
+ * turn was suspended *inside* the bridge's permission call, so `currentTurn`
+ * still points at it; the verdict un-parks claude and it resumes the SAME
+ * turn. `setThinking()` re-arms the stall watchdog that `setAwaiting()`
+ * suspended, so a genuine post-approval hang still promotes to 🥱/😨, and
+ * it is replaced by the real tool glyph (✍/⚡) as soon as the resumed turn
+ * fires its next PreToolUse. Non-terminal — 👍 still waits for `turn_end`.
+ */
+function resumeReactionAfterVerdict(): void {
+  const turn = currentTurn
+  if (turn == null) return
+  activeStatusReactions
+    .get(statusKey(turn.sessionChatId, turn.sessionThreadId))
+    ?.setThinking()
+}
+
 function resolveThreadId(chat_id: string, explicit?: string | number | null): number | undefined {
   if (explicit != null) return Number(explicit)
   return chatThreadMap.get(chat_id)
@@ -2876,6 +2894,9 @@ const pendingStateReaper = setInterval(() => {
       // dispatchPermissionVerdict so it's buffered+redelivered too if
       // the bridge is also offline at sweep time.
       dispatchPermissionVerdict({ type: 'permission', requestId: k, behavior: 'deny' })
+      // The auto-deny un-parks the suspended turn — flip 🙏 → working so
+      // it doesn't sit on the awaiting glyph (or stall) after the timeout.
+      resumeReactionAfterVerdict()
       process.stderr.write(
         `telegram gateway: permission TTL expired — auto-deny request=${k} ` +
         `tool=${v.tool_name} (no operator response in ` +
@@ -4227,6 +4248,16 @@ const ipcServer: IpcServer = createIpcServer({
         process.stderr.write(`telegram gateway: permission_request send to ${chat_id} failed: ${e}\n`)
       })
     }
+    // Park the turn's status reaction on 🙏 (awaiting your tap) and
+    // suspend the stall watchdog — a turn blocked on the operator is not
+    // stalled, so it must not degrade to 🥱/😨 while the card sits
+    // unanswered. The verdict path (`resumeReactionAfterVerdict`) flips it
+    // back to a working state the instant you tap.
+    if (activeTurn != null) {
+      activeStatusReactions
+        .get(statusKey(activeTurn.sessionChatId, activeTurn.sessionThreadId))
+        ?.setAwaiting()
+    }
   },
 
   onHeartbeat(_client: IpcClient, _msg: HeartbeatMessage) {
@@ -8924,6 +8955,7 @@ async function handleInbound(
       requestId: request_id,
       behavior,
     })
+    resumeReactionAfterVerdict()
     if (msgId != null) {
       const emoji = behavior === 'allow' ? '✅' : '❌'
       void bot.api.setMessageReaction(chat_id, msgId, [
@@ -11759,6 +11791,7 @@ async function handlePermissionSlash(ctx: Context, behavior: 'allow' | 'deny'):
   }
   // Forward to connected bridges — same IPC the button handler uses.
   dispatchPermissionVerdict({ type: 'permission', requestId: request_id, behavior })
+  resumeReactionAfterVerdict()
   pendingPermissions.delete(request_id)
   process.stderr.write(
     `[telegram gateway] slash-${behavior} request_id=${request_id} tool=${details.tool_name} by=${senderId}\n`,
@@ -15409,6 +15442,10 @@ bot.on('callback_query:data', async ctx => {
       behavior: 'allow',
       rule: chosen.rule,
     })
+    // The turn resumes now (independent of the host persistence round-trip
+    // below). Un-park 🙏 → working immediately so the operator sees the
+    // agent continue while hostd writes the durable rule.
+    resumeReactionAfterVerdict()
 
     // (3) Decide the persistence path. tryHostdDispatch returns
     // "not-configured" when host_control is disabled or the per-agent
@@ -15562,7 +15599,16 @@ bot.on('callback_query:data', async ctx => {
 
   // Forward permission decision to connected bridges
   pendingPermissions.delete(request_id)
-  const label = behavior === 'allow' ? '✅ Allowed' : '❌ Denied'
+  // Deterministic "▶️ resuming…" beat (framework-posted, not model text):
+  // the verdict un-parks the suspended turn, so confirm to the operator
+  // that the agent received it and is continuing — closing the "is it
+  // working or did my tap do nothing?" gap. Allow and deny both resume the
+  // turn (deny just hands claude a refusal it then handles).
+  const resumeAgent = process.env.SWITCHROOM_AGENT_NAME
+  const resumeBeat = resumeAgent
+    ? `▶️ ${escapeHtmlForTg(resumeAgent)} resuming…`
+    : '▶️ resuming…'
+  const label = `${behavior === 'allow' ? '✅ Allowed' : '❌ Denied'} · ${resumeBeat}`
   // HTML-escape the source text — same hazard as the scope-commit and
   // recent-denial paths above. The permission card body
   // (formatPermissionCardBody) appends claude-supplied `description`
@@ -15590,6 +15636,9 @@ bot.on('callback_query:data', async ctx => {
         requestId: request_id,
         behavior: behavior as 'allow' | 'deny',
       })
+      // Un-park the status reaction: 🙏 → working, re-arming the stall
+      // watchdog that setAwaiting() suspended.
+      resumeReactionAfterVerdict()
     },
   })
 })

package/telegram-plugin/status-reactions.ts

@@ -53,6 +53,7 @@ export type ReactionState =
   | 'web'
   | 'tool'
   | 'compacting'
+  | 'awaiting'
   | 'done'
   | 'error'
   | 'stallSoft'
@@ -78,6 +79,7 @@ export const REACTION_VARIANTS: Record<ReactionState, string[]> = {
   coding:    ['👨‍💻', '✍', '⚡'],     // WORKING: writing / running code
   web:       ['⚡', '🤔', '👌'],      // WORKING: lookup in motion
   compacting:['✍', '🤔', '👀'],
+  awaiting:  ['🙏', '🤔', '👀'],      // BLOCKED ON HUMAN: parked on a permission card
   done:      ['👍', '💯', '🎉'],      // FINISHED: turn_end fired
   error:     ['😱', '😨', '🤯'],      // NON-TERMINAL — recovery allowed
   stallSoft: ['🥱', '😴', '🤔'],
@@ -180,6 +182,22 @@ export class StatusReactionController {
     this.scheduleState('compacting')
   }
 
+  /**
+   * 🙏 — the turn is parked on a human decision (a permission card is
+   * waiting for the operator to tap Allow/Deny). Immediate, non-terminal,
+   * and crucially SUSPENDS the stall watchdog: a turn blocked on the
+   * operator is not stalled, so it must NOT promote to 🥱/😨 while the
+   * card sits unanswered. The next working transition (setTool /
+   * setThinking, fired when the verdict resumes the turn) re-arms the
+   * watchdog normally. Bypasses debounce so 🙏 lands as soon as the card
+   * is posted.
+   */
+  setAwaiting(): void {
+    if (this.finished) return
+    this.scheduleState('awaiting', { immediate: true, skipStallReset: true })
+    this.clearStallTimers()
+  }
+
   /**
    * 😱 — non-terminal error indicator. Paints the error emoji but does
    * NOT end the controller — recovery to a working state is permitted

package/telegram-plugin/tests/status-reactions.test.ts

@@ -341,6 +341,75 @@ describe('StatusReactionController', () => {
     expect(calls).toEqual(['👀'])
   })
 
+  // setAwaiting(): park on 🙏 while a permission card waits for the
+  // operator. A turn blocked on a human is NOT stalled, so the watchdog
+  // must stay quiet — but it re-arms once the verdict resumes work.
+  describe('setAwaiting() — park on a human permission decision', () => {
+    it('emits 🙏 immediately (bypasses debounce)', async () => {
+      const { emit, calls } = makeEmitter()
+      const ctrl = new StatusReactionController(emit)
+      ctrl.setQueued()
+      await flush()
+      ctrl.setAwaiting()
+      await flush()
+      expect(calls).toEqual(['👀', '🙏'])
+    })
+
+    it('suppresses stall promotion (no 🥱/😨) while the card sits unanswered', async () => {
+      const { emit, calls } = makeEmitter()
+      const ctrl = new StatusReactionController(emit)
+      ctrl.setQueued()
+      ctrl.setTool('Bash') // working: 👨‍💻
+      vi.advanceTimersByTime(3500)
+      await flush()
+      ctrl.setAwaiting()
+      await flush()
+      // Well past both stall thresholds — awaiting must not yawn or panic.
+      vi.advanceTimersByTime(120000)
+      await flush()
+      expect(calls).not.toContain('🥱')
+      expect(calls).not.toContain('😨')
+      expect(calls[calls.length - 1]).toBe('🙏')
+    })
+
+    it('re-arms the stall watchdog once a working transition resumes the turn', async () => {
+      const { emit, calls } = makeEmitter()
+      const ctrl = new StatusReactionController(emit)
+      ctrl.setQueued()
+      await flush()
+      ctrl.setAwaiting()
+      await flush()
+      vi.advanceTimersByTime(120000) // long human wait — no stall
+      await flush()
+      expect(calls).toEqual(['👀', '🙏'])
+
+      // Verdict dispatched → gateway calls setThinking() to un-park.
+      ctrl.setThinking()
+      vi.advanceTimersByTime(3500)
+      await flush()
+      expect(calls).toEqual(['👀', '🙏', '🤔'])
+
+      // A genuine post-approval hang must still promote to 🥱 — the
+      // watchdog was re-armed by the resuming transition.
+      vi.advanceTimersByTime(30000)
+      await flush()
+      expect(calls).toContain('🥱')
+    })
+
+    it('is a no-op after finalize (cannot resurrect a finished controller)', async () => {
+      const { emit, calls } = makeEmitter()
+      const ctrl = new StatusReactionController(emit)
+      ctrl.setQueued()
+      ctrl.finalize('done')
+      await flush()
+      const snapshot = [...calls]
+      ctrl.setAwaiting()
+      vi.advanceTimersByTime(5000)
+      await flush()
+      expect(calls).toEqual(snapshot)
+    })
+  })
+
   // hold(): freeze on a WORKING glyph while background sub-agent workers
   // outlive the parent turn, deferring the terminal 👍 (worker-reaction fix).
   describe('hold() — defer 👍 while a background worker runs', () => {