switchroom 0.14.84 → 0.14.85

package/dist/cli/switchroom.js

@@ -49815,8 +49815,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.84";
-var COMMIT_SHA = "af97bc41";
+var VERSION = "0.14.85";
+var COMMIT_SHA = "292c683f";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.84",
+  "version": "0.14.85",
   "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/credits-watch.ts

@@ -27,20 +27,53 @@ import { join } from "path";
 const STATE_FILE = "credits-watch.json";
 
 /**
- * Possible values of `cachedExtraUsageDisabledReason` in `.claude.json`
- * that warrant a user-facing notification. Other values (null,
- * undefined, transient unknowns) are treated as "no notification
- * needed".
+ * Which `cachedExtraUsageDisabledReason` values warrant a user-facing alarm.
  *
- * Conservative list: only fatal-billing reasons. We don't want to fire
- * on every transient API blip the cache happens to write.
+ * IMPORTANT — empty by default (subscription-only model). The flag name says it
+ * all: `cachedExtraUsageDisabledReason` is *always* "why **extra usage** (the
+ * optional pay-as-you-go layer beyond the Pro/Max plan) is disabled." switchroom
+ * is subscription-only by design (compliance pillar 3 — "the plan is the
+ * ceiling, no API/pay-as-you-go"), so extra usage being OFF is the **expected,
+ * desired** state. Every value (`out_of_credits`, `extra_usage_disabled`,
+ * `credits_exhausted`, even `org_level_disabled` = "org admin disabled extra
+ * usage") describes that benign state — none indicates a real switchroom
+ * failure. Firing a "cron + replies will fail, buy credits" card on it is a
+ * false alarm AND advises something that contradicts the subscription-honest
+ * model.
+ *
+ * The genuine failure modes are covered elsewhere:
+ *   - an account's subscription window exhausts → stderr → fleet auto-fallback
+ *     (model-unavailable.ts → fireFleetAutoFallback) rolls to a healthy account;
+ *   - the WHOLE fleet exhausts → the quota-watch all-exhausted operator alert.
+ *
+ * So credits-watch defaults to silent. An operator who actually runs on
+ * pay-as-you-go and wants the alarm can opt specific reasons back in via
+ * `SWITCHROOM_CREDITS_WATCH_FATAL_REASONS` (comma-separated). See
+ * `resolveCreditWatchFatalReasons`.
  */
-const FATAL_REASONS = new Set([
+export const DEFAULT_CREDIT_FATAL_REASONS = new Set<string>();
+
+/** All reason strings recognized for opt-in via the env var. */
+const KNOWN_CREDIT_REASONS = [
   "out_of_credits",
   "org_level_disabled",
   "credits_exhausted",
   "extra_usage_disabled",
-]);
+] as const;
+
+/**
+ * Resolve the active fatal-reason set. Empty by default (subscription-only);
+ * if `SWITCHROOM_CREDITS_WATCH_FATAL_REASONS` is set, parse it as a
+ * comma-separated list (tokens kept verbatim — an unknown token is harmless,
+ * it simply never matches a real reason value). `*` opts in all known reasons.
+ */
+export function resolveCreditWatchFatalReasons(env: NodeJS.ProcessEnv): Set<string> {
+  const raw = env.SWITCHROOM_CREDITS_WATCH_FATAL_REASONS;
+  if (!raw || raw.trim().length === 0) return new Set(DEFAULT_CREDIT_FATAL_REASONS);
+  if (raw.trim() === "*") return new Set(KNOWN_CREDIT_REASONS);
+  const wanted = new Set(raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0));
+  return wanted;
+}
 
 export interface CreditState {
   /** Last reason we notified the user about. null when healthy / never notified. */
@@ -103,15 +136,22 @@ export function evaluateCreditState(args: {
   currentReason: string | null;
   prev: CreditState;
   now: number;
+  /**
+   * Which reasons are treated as fatal (worth alarming). Defaults to
+   * `DEFAULT_CREDIT_FATAL_REASONS` (empty — subscription-only: extra-usage-off
+   * is never a real failure). The gateway passes the env-resolved set.
+   */
+  fatalReasons?: Set<string>;
 }): CreditDecision {
   const { agentName, currentReason, prev, now } = args;
+  const fatalReasons = args.fatalReasons ?? DEFAULT_CREDIT_FATAL_REASONS;
 
   // Non-fatal current state (null, or some unknown reason) — no
   // notification regardless of prev (we already notified on entry to
   // fatal; recovery from a known-fatal state below is the only path
   // that fires when current is null).
-  const currentIsFatal = currentReason != null && FATAL_REASONS.has(currentReason);
-  const prevIsFatal = prev.lastNotifiedReason != null && FATAL_REASONS.has(prev.lastNotifiedReason);
+  const currentIsFatal = currentReason != null && fatalReasons.has(currentReason);
+  const prevIsFatal = prev.lastNotifiedReason != null && fatalReasons.has(prev.lastNotifiedReason);
 
   // Recovery path: last-notified was fatal, current is null/non-fatal.
   if (!currentIsFatal && prevIsFatal) {

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

@@ -52507,12 +52507,22 @@ function extractFlowItems(line) {
 import { readFileSync as readFileSync32, writeFileSync as writeFileSync21, existsSync as existsSync33, mkdirSync as mkdirSync21 } from "fs";
 import { join as join30 } from "path";
 var STATE_FILE = "credits-watch.json";
-var FATAL_REASONS = new Set([
+var DEFAULT_CREDIT_FATAL_REASONS = new Set;
+var KNOWN_CREDIT_REASONS = [
   "out_of_credits",
   "org_level_disabled",
   "credits_exhausted",
   "extra_usage_disabled"
-]);
+];
+function resolveCreditWatchFatalReasons(env) {
+  const raw = env.SWITCHROOM_CREDITS_WATCH_FATAL_REASONS;
+  if (!raw || raw.trim().length === 0)
+    return new Set(DEFAULT_CREDIT_FATAL_REASONS);
+  if (raw.trim() === "*")
+    return new Set(KNOWN_CREDIT_REASONS);
+  const wanted = new Set(raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0));
+  return wanted;
+}
 function emptyCreditState() {
   return { lastNotifiedReason: null, lastNotifiedAt: 0 };
 }
@@ -52541,8 +52551,9 @@ function readClaudeJsonOverage(claudeConfigDir) {
 }
 function evaluateCreditState(args) {
   const { agentName: agentName3, currentReason, prev, now } = args;
-  const currentIsFatal = currentReason != null && FATAL_REASONS.has(currentReason);
-  const prevIsFatal = prev.lastNotifiedReason != null && FATAL_REASONS.has(prev.lastNotifiedReason);
+  const fatalReasons = args.fatalReasons ?? DEFAULT_CREDIT_FATAL_REASONS;
+  const currentIsFatal = currentReason != null && fatalReasons.has(currentReason);
+  const prevIsFatal = prev.lastNotifiedReason != null && fatalReasons.has(prev.lastNotifiedReason);
   if (!currentIsFatal && prevIsFatal) {
     return {
       kind: "notify",
@@ -52869,9 +52880,9 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.84";
-var COMMIT_SHA = "af97bc41";
-var COMMIT_DATE = "2026-06-07T13:38:19+10:00";
+var VERSION = "0.14.85";
+var COMMIT_SHA = "292c683f";
+var COMMIT_DATE = "2026-06-07T14:50:17+10:00";
 var LATEST_PR = null;
 var COMMITS_AHEAD_OF_TAG = 2;
 
@@ -61040,7 +61051,8 @@ async function runCreditWatch() {
     agentName: agentName3,
     currentReason: reason,
     prev,
-    now: Date.now()
+    now: Date.now(),
+    fatalReasons: resolveCreditWatchFatalReasons(process.env)
   });
   if (decision.kind === "skip") {
     return;

package/telegram-plugin/gateway/gateway.ts

@@ -408,6 +408,7 @@ import { synthesizeAllowRuleDiff, extractAddedAllowRule } from '../permission-di
 import {
   readClaudeJsonOverage,
   evaluateCreditState,
+  resolveCreditWatchFatalReasons,
   loadCreditState,
   saveCreditState,
 } from '../credits-watch.js'
@@ -14742,6 +14743,9 @@ async function runCreditWatch(): Promise<void> {
     currentReason: reason,
     prev,
     now: Date.now(),
+    // Subscription-only: empty by default → extra-usage-off never alarms.
+    // Opt back in via SWITCHROOM_CREDITS_WATCH_FATAL_REASONS. See credits-watch.ts.
+    fatalReasons: resolveCreditWatchFatalReasons(process.env),
   })
   if (decision.kind === 'skip') {
     return

package/telegram-plugin/tests/credits-watch.test.ts

@@ -13,6 +13,7 @@ import { join } from "path";
 import {
   readClaudeJsonOverage,
   evaluateCreditState,
+  resolveCreditWatchFatalReasons,
   loadCreditState,
   saveCreditState,
   emptyCreditState,
@@ -81,10 +82,14 @@ describe("readClaudeJsonOverage", () => {
   });
 });
 
-describe("evaluateCreditState — transition decisions", () => {
+describe("evaluateCreditState — transition decisions (machinery, explicit fatal set)", () => {
   const NOW = 1_780_000_000_000;
   const HEALTHY = emptyCreditState();
   const FATAL_OUT = { lastNotifiedReason: "out_of_credits", lastNotifiedAt: NOW - 1000 };
+  // The transition machinery is policy-agnostic — pass an explicit fatal set so
+  // these tests pin entered/changed/exited behaviour independent of the (now
+  // empty) subscription-only default.
+  const FATAL = new Set(["out_of_credits", "org_level_disabled", "credits_exhausted", "extra_usage_disabled"]);
 
   it("entry: healthy → fatal triggers a notify", () => {
     const d = evaluateCreditState({
@@ -92,6 +97,7 @@ describe("evaluateCreditState — transition decisions", () => {
       currentReason: "out_of_credits",
       prev: HEALTHY,
       now: NOW,
+      fatalReasons: FATAL,
     });
     expect(d.kind).toBe("notify");
     if (d.kind !== "notify") return;
@@ -108,6 +114,7 @@ describe("evaluateCreditState — transition decisions", () => {
       currentReason: "out_of_credits",
       prev: FATAL_OUT,
       now: NOW,
+      fatalReasons: FATAL,
     });
     expect(d.kind).toBe("skip");
     if (d.kind !== "skip") return;
@@ -120,6 +127,7 @@ describe("evaluateCreditState — transition decisions", () => {
       currentReason: "org_level_disabled",
       prev: FATAL_OUT,
       now: NOW,
+      fatalReasons: FATAL,
     });
     expect(d.kind).toBe("notify");
     if (d.kind !== "notify") return;
@@ -134,6 +142,7 @@ describe("evaluateCreditState — transition decisions", () => {
       currentReason: null,
       prev: FATAL_OUT,
       now: NOW,
+      fatalReasons: FATAL,
     });
     expect(d.kind).toBe("notify");
     if (d.kind !== "notify") return;
@@ -148,6 +157,7 @@ describe("evaluateCreditState — transition decisions", () => {
       currentReason: "some_unknown_transient_reason",
       prev: HEALTHY,
       now: NOW,
+      fatalReasons: FATAL,
     });
     expect(d.kind).toBe("skip");
     if (d.kind !== "skip") return;
@@ -160,6 +170,7 @@ describe("evaluateCreditState — transition decisions", () => {
       currentReason: null,
       prev: HEALTHY,
       now: NOW,
+      fatalReasons: FATAL,
     });
     expect(d.kind).toBe("skip");
   });
@@ -170,6 +181,7 @@ describe("evaluateCreditState — transition decisions", () => {
       currentReason: "out_of_credits",
       prev: HEALTHY,
       now: NOW,
+      fatalReasons: FATAL,
     });
     expect(d.kind).toBe("notify");
     if (d.kind !== "notify") return;
@@ -178,6 +190,58 @@ describe("evaluateCreditState — transition decisions", () => {
   });
 });
 
+describe("evaluateCreditState — subscription-only default (the fix)", () => {
+  const NOW = 1_780_000_000_000;
+  const HEALTHY = emptyCreditState();
+
+  // With the default (empty) fatal set, NONE of the extra-usage reasons alarm —
+  // because for subscription-only switchroom, extra-usage-off is the expected
+  // state and real exhaustion is handled by failover. This is the bug fix.
+  for (const reason of ["out_of_credits", "extra_usage_disabled", "credits_exhausted", "org_level_disabled"]) {
+    it(`default: '${reason}' does NOT alarm (no false 'out of credits' card)`, () => {
+      const d = evaluateCreditState({
+        agentName: "clerk",
+        currentReason: reason,
+        prev: HEALTHY,
+        now: NOW,
+        // fatalReasons omitted → DEFAULT_CREDIT_FATAL_REASONS (empty)
+      });
+      expect(d.kind).toBe("skip");
+    });
+  }
+
+  it("opt-in via explicit set restores the alarm (operator on pay-as-you-go)", () => {
+    const d = evaluateCreditState({
+      agentName: "clerk",
+      currentReason: "out_of_credits",
+      prev: HEALTHY,
+      now: NOW,
+      fatalReasons: new Set(["out_of_credits"]),
+    });
+    expect(d.kind).toBe("notify");
+  });
+});
+
+describe("resolveCreditWatchFatalReasons", () => {
+  it("defaults to EMPTY (subscription-only)", () => {
+    expect(resolveCreditWatchFatalReasons({}).size).toBe(0);
+  });
+  it("parses a comma-separated opt-in list", () => {
+    const s = resolveCreditWatchFatalReasons({ SWITCHROOM_CREDITS_WATCH_FATAL_REASONS: "out_of_credits, org_level_disabled" });
+    expect(s.has("out_of_credits")).toBe(true);
+    expect(s.has("org_level_disabled")).toBe(true);
+    expect(s.size).toBe(2);
+  });
+  it("'*' opts in all known reasons", () => {
+    const s = resolveCreditWatchFatalReasons({ SWITCHROOM_CREDITS_WATCH_FATAL_REASONS: "*" });
+    expect(s.has("out_of_credits")).toBe(true);
+    expect(s.size).toBeGreaterThanOrEqual(4);
+  });
+  it("blank/whitespace → empty", () => {
+    expect(resolveCreditWatchFatalReasons({ SWITCHROOM_CREDITS_WATCH_FATAL_REASONS: "  " }).size).toBe(0);
+  });
+});
+
 describe("loadCreditState / saveCreditState — round-trip", () => {
   let tmp: string;