switchroom 0.13.40 → 0.13.42

package/dist/cli/switchroom.js

@@ -27303,11 +27303,20 @@ function checkAclByAgent(config, agentName, key) {
       return { allow: true };
     }
   }
+  const mcpServers = agentConfig.mcp_servers ?? {};
+  for (const mcpEntry of Object.values(mcpServers)) {
+    if (!mcpEntry || typeof mcpEntry !== "object")
+      continue;
+    const declared = mcpEntry.secrets;
+    if (Array.isArray(declared) && declared.includes(key)) {
+      return { allow: true };
+    }
+  }
   const schedule = agentConfig.schedule ?? [];
   if (schedule.length === 0) {
     return {
       allow: false,
-      reason: `agent '${agentName}' has no schedule entries declaring 'secrets'; nothing is broker-accessible`
+      reason: `agent '${agentName}' has no schedule entries declaring 'secrets' and no mcp_servers.*.secrets[] declaring '${key}'; nothing is broker-accessible`
     };
   }
   for (const entry of schedule) {
@@ -47747,8 +47756,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.13.40";
-var COMMIT_SHA = "1f8f075b";
+var VERSION = "0.13.42";
+var COMMIT_SHA = "915bf972";
 
 // src/cli/agent.ts
 init_source();
@@ -48778,7 +48787,12 @@ function filterMcpServers(servers) {
   for (const [key, value] of Object.entries(servers)) {
     if (value === false)
       continue;
-    out[key] = value;
+    if (value != null && typeof value === "object" && !Array.isArray(value)) {
+      const { secrets: _secrets, ...rest } = value;
+      out[key] = rest;
+    } else {
+      out[key] = value;
+    }
   }
   return Object.keys(out).length > 0 ? out : undefined;
 }
@@ -49552,6 +49566,20 @@ ${body}
       writeFileSync5(mdPath, content, "utf-8");
     }
   }
+  {
+    const telegramDir = join8(agentDir, "telegram");
+    if (existsSync11(telegramDir)) {
+      for (const file of readdirSync5(telegramDir)) {
+        const isCronScript = CRON_SCRIPT_BASENAME_RE.test(file) || LEGACY_CRON_SCRIPT_BASENAME_RE.test(file);
+        if (isCronScript) {
+          unlinkSync4(join8(telegramDir, file));
+          const sidecar = join8(telegramDir, file.replace(/\.sh$/, ".source"));
+          if (existsSync11(sidecar))
+            unlinkSync4(sidecar);
+        }
+      }
+    }
+  }
   copyProfileSkills(profilePath, join8(agentDir, ".claude", "skills"));
   renderProfileClaudeTemplate(agentConfig.extends ?? DEFAULT_PROFILE);
   if (agentConfig.skills && agentConfig.skills.length > 0) {

package/dist/cli/ui/index.html

@@ -774,16 +774,24 @@
       // usage % cell: live 5h/7d utilization from the last cached
       // probe (cost-gated — see refreshQuota). null → "—" + a per-
       // account ↻ that force-probes. quotaStale → value shown muted
-      // with ↻ to refresh.
-      const pctCell = (pct, label, stale) => {
+      // with ↻ to refresh. When `resetAt` is provided we append a
+      // muted "resets in Xh" line so the operator can see WHEN the
+      // window rolls over without hovering for a tooltip — matches
+      // anthropic-ratelimit-unified-{5h,7d}-reset headers exposed by
+      // the broker probe (src/auth/quota.ts:97-98).
+      const pctCell = (pct, label, stale, resetAt) => {
         if (pct == null) return '<span style="color:var(--text-dim)">—</span>';
         let cls = 'quota-pct';
         if (pct >= 90) cls += ' high';
         else if (pct >= 70) cls += ' mid';
         const v = `${Math.round(pct)}%`;
-        return stale
+        const reset = resetAt
+          ? `<div style="font-size:.72rem;color:var(--text-dim);font-weight:normal;margin-top:.1rem">resets ${formatTimestamp(resetAt)}</div>`
+          : '';
+        const pctSpan = stale
           ? `<span class="${cls}" title="stale — click ↻" style="opacity:.55">${v}</span>`
           : `<span class="${cls}">${v}</span>`;
+        return reset ? `<div>${pctSpan}${reset}</div>` : pctSpan;
       };
       const enriched = accounts.map(a => {
         const q = a.quota || null;
@@ -792,9 +800,8 @@
         return {
           a,
           usedBy: a.usedBy || [],
-          fiveH: pctCell(u ? u.fiveHourPct : null, '5h', a.quotaStale),
-          sevenD: pctCell(u ? u.sevenDayPct : null, '7d', a.quotaStale),
-          fiveReset: u && u.fiveHourResetAt ? formatTimestamp(u.fiveHourResetAt) : '<span style="color:var(--text-dim)">—</span>',
+          fiveH: pctCell(u ? u.fiveHourPct : null, '5h', a.quotaStale, u ? u.fiveHourResetAt : null),
+          sevenD: pctCell(u ? u.sevenDayPct : null, '7d', a.quotaStale, u ? u.sevenDayResetAt : null),
           captured: u && u.capturedAt
             ? formatTimestamp(u.capturedAt)
             : '<span style="color:var(--text-dim)">never</span>',

package/dist/vault/broker/server.js

@@ -13055,11 +13055,20 @@ function checkAclByAgent(config, agentName, key) {
       return { allow: true };
     }
   }
+  const mcpServers = agentConfig.mcp_servers ?? {};
+  for (const mcpEntry of Object.values(mcpServers)) {
+    if (!mcpEntry || typeof mcpEntry !== "object")
+      continue;
+    const declared = mcpEntry.secrets;
+    if (Array.isArray(declared) && declared.includes(key)) {
+      return { allow: true };
+    }
+  }
   const schedule = agentConfig.schedule ?? [];
   if (schedule.length === 0) {
     return {
       allow: false,
-      reason: `agent '${agentName}' has no schedule entries declaring 'secrets'; nothing is broker-accessible`
+      reason: `agent '${agentName}' has no schedule entries declaring 'secrets' and no mcp_servers.*.secrets[] declaring '${key}'; nothing is broker-accessible`
     };
   }
   for (const entry of schedule) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.13.40",
+  "version": "0.13.42",
   "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

@@ -37679,7 +37679,7 @@ function clearSilentEndState(turnKey, deps) {
     return;
   try {
     const prev = JSON.parse(readFileSync3(statePath, "utf8"));
-    if (prev.turnKey !== turnKey)
+    if (prev.turnKey != null && prev.turnKey !== turnKey)
       return;
     unlinkSync(statePath);
     emitLog(deps, `silent-end: cleared state file turnKey=${turnKey}
@@ -48730,10 +48730,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.13.40";
-var COMMIT_SHA = "1f8f075b";
-var COMMIT_DATE = "2026-05-25T07:28:32Z";
-var LATEST_PR = 1800;
+var VERSION = "0.13.42";
+var COMMIT_SHA = "915bf972";
+var COMMIT_DATE = "2026-05-25T08:37:49Z";
+var LATEST_PR = 1808;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -52580,6 +52580,7 @@ function handleSessionEvent(ev) {
         };
         currentTurn = next;
         preambleSuppressor.reset();
+        clearSilentEndState(statusKey(ev.chatId, ev.threadId != null ? Number(ev.threadId) : null));
         if (turnsDb != null) {
           const evThreadIdNum = ev.threadId != null ? Number(ev.threadId) : null;
           const turnKey = chatKeyWithSuffix(ev.chatId, evThreadIdNum, String(startedAt));

package/telegram-plugin/gateway/gateway.ts

@@ -6503,6 +6503,23 @@ function handleSessionEvent(ev: SessionEvent): void {
         currentTurn = next
         // #549 fix — fresh turn, reset preamble-suppression state.
         preambleSuppressor.reset()
+        // Reset the silent-end retry budget for this chat. The stored
+        // turnKey is `chat:thread` shape (no per-instance suffix), so
+        // without an explicit per-turn clear, `writeSilentEndState`
+        // (silent-end.ts:114) inherits `retryCount` across turns
+        // whenever a prior turn for the same chat hit retryCount=1.
+        // The Stop hook then sees `retryCount >= MAX_RETRIES=1` on the
+        // very first silent-end of every subsequent turn and bails
+        // without re-prompting. finn hit this on 2026-05-25 with a
+        // stuck retryCount=1 file. A new turn invalidates any prior
+        // turn's retry budget by definition; clear it eagerly here.
+        // ev.threadId is `string | null` (Telegram's wire shape);
+        // statusKey wants `number | null` — same conversion as the
+        // registry-key branch a few lines down.
+        clearSilentEndState(statusKey(
+          ev.chatId,
+          ev.threadId != null ? Number(ev.threadId) : null,
+        ))
         // Stage 3b: stamp turn-start in the registry. turn_key is
         // chat:thread:startTs — unique per turn, distinct from the
         // progress-card-driver's per-chat sequence number (these are two

package/telegram-plugin/silent-end.ts

@@ -150,6 +150,18 @@ export function writeSilentEndState(
  * Called the moment a reply / stream_reply first-emit lands so the
  * Stop hook doesn't fire a stale block on the next stop.
  *
+ * Pre-#1664 (`commit f664cde8`) state files lacked a `turnKey` field
+ * entirely. The strict `prev.turnKey !== turnKey` check meant
+ * `undefined !== <anything>` was always true, so legacy files survived
+ * every clear path and remained readable by the Stop hook indefinitely.
+ * In production this stranded clerk with `retryCount=1` for ~hours
+ * across two container restarts, breaking the Stop hook's retry budget
+ * for every subsequent silent-end (the 2026-05-25 incident).
+ *
+ * Tolerance: treat a missing `prev.turnKey` as "stale unknown, unlink
+ * it" rather than "preserve". Strict comparison still applies when
+ * both sides are present, so the same-turn invariant is preserved.
+ *
  * Fail-silent: missing file, mismatched turnKey, or read/unlink errors
  * are all benign. The Stop hook itself defends against stale files via
  * the retryCount mechanism.
@@ -159,7 +171,7 @@ export function clearSilentEndState(turnKey: string, deps?: SilentEndDeps): void
   if (!existsSync(statePath)) return
   try {
     const prev = JSON.parse(readFileSync(statePath, 'utf8')) as Partial<SilentEndState>
-    if (prev.turnKey !== turnKey) return
+    if (prev.turnKey != null && prev.turnKey !== turnKey) return
     unlinkSync(statePath)
     emitLog(deps, `silent-end: cleared state file turnKey=${turnKey}\n`)
   } catch {

package/telegram-plugin/tests/silent-end.test.ts

@@ -62,6 +62,38 @@ describe('silent-end.ts — gateway state writer', () => {
     expect(state!.retryCount).toBe(0)
   })
 
+  it('turn-start clear pattern resets retryCount for a new turn on the same chat', () => {
+    // 2026-05-25 finn incident: the stored turnKey is `chat:thread`
+    // shape (no per-instance startedAt suffix). When a prior turn for
+    // a chat left the silent-end-pending.json at retryCount=1 (Stop
+    // hook had incremented but no successful reply cleared it),
+    // writeSilentEndState on the next silent-end for the SAME chat
+    // matches `prev.turnKey === args.turnKey` and inherits
+    // retryCount=1 — so the Stop hook bails on the very first
+    // silent-end of the new turn without re-prompting.
+    //
+    // The gateway's fix (gateway.ts:6503) calls
+    // clearSilentEndState(statusKey(chatId, threadId)) at turn-start.
+    // This test pins the contract: clear-then-write yields
+    // retryCount=0, not the inherited 1.
+    const path = join(stateDir, 'silent-end-pending.json')
+    // Prior turn left retryCount=1 stuck on this chat.
+    writeFileSync(path, JSON.stringify({
+      chatId: '12345', threadId: null, turnKey: '12345:_',
+      retryCount: 1, timestamp: 0,
+    }))
+
+    // Gateway turn-start hook fires for a NEW turn on the same chat.
+    clearSilentEndState('12345:_')
+    expect(existsSync(path)).toBe(false)
+
+    // The new turn later ends silent → writeSilentEndState writes
+    // fresh state. Without the turn-start clear above, retryCount
+    // would have inherited as 1 (per the test at line 42 above).
+    writeSilentEndState({ chatId: '12345', threadId: null, turnKey: '12345:_' })
+    expect(readSilentEndState()!.retryCount).toBe(0)
+  })
+
   it('writeSilentEndState falls back to ~/.claude/channels/telegram when TELEGRAM_STATE_DIR is unset', () => {
     // Updated 2026-05-13 UAT overnight: discovered the writer used to
     // silently no-op when the env var was unset, while the Stop hook
@@ -106,6 +138,30 @@ describe('silent-end.ts — gateway state writer', () => {
     expect(() => clearSilentEndState('123:_')).not.toThrow()
   })
 
+  it('clearSilentEndState unlinks a pre-#1664 legacy-format file (no turnKey field)', () => {
+    // 2026-05-25 incident: clerk had a stale `{retryCount:1,timestamp:...}`
+    // file with NO `turnKey` field — written by a pre-#1664 build before
+    // the chatId/threadId/turnKey schema landed. The strict
+    // `prev.turnKey !== turnKey` check meant `undefined !== <anything>`
+    // returned true and every clear callsite no-op'd against it. The file
+    // survived two container restarts. When a new turn ended silently
+    // ~hours later, the Stop hook read the stale retryCount=1 and bailed
+    // without re-prompting, leaving the user with no reply for 5 minutes
+    // (until the framework's silence-poke fallback fired).
+    //
+    // Contract: any clearSilentEndState call must be able to evict a
+    // legacy file whose turnKey is missing. Strict matching still applies
+    // when both sides have a turnKey (the `clearSilentEndState leaves the
+    // file alone when turnKey does NOT match` test above pins that).
+    const path = join(stateDir, 'silent-end-pending.json')
+    writeFileSync(path, JSON.stringify({ retryCount: 1, timestamp: 1779692417907 }))
+    expect(existsSync(path)).toBe(true)
+
+    clearSilentEndState('any-turn-key-here')
+
+    expect(existsSync(path)).toBe(false)
+  })
+
   it('writeSilentEndState handles corrupt prior file by resetting retryCount', () => {
     const path = join(stateDir, 'silent-end-pending.json')
     writeFileSync(path, 'not valid json {{{')