switchroom 0.14.80 → 0.14.82

package/dist/agent-scheduler/index.js

@@ -6932,7 +6932,7 @@ var require_public_api = __commonJS((exports) => {
 });
 
 // src/agent-scheduler/index.ts
-import { resolve as resolve4, join } from "node:path";
+import { resolve as resolve4, join as join2 } from "node:path";
 
 // src/config/loader.ts
 import { readFileSync as readFileSync2, existsSync as existsSync3 } from "node:fs";
@@ -12295,6 +12295,581 @@ class JsonlAuditSink {
   close() {}
 }
 
+// src/scheduler/quota-preflight.ts
+function decideQuotaPreflight(state) {
+  const accounts = state.accounts ?? [];
+  if (accounts.length === 0) {
+    return { defer: false, reason: "no accounts in broker state" };
+  }
+  const healthy = accounts.filter((a) => !a.exhausted);
+  if (healthy.length > 0) {
+    return {
+      defer: false,
+      reason: `${healthy.length}/${accounts.length} account(s) healthy`
+    };
+  }
+  return { defer: true, reason: `all ${accounts.length} account(s) exhausted` };
+}
+
+// src/auth/broker/client.ts
+import * as net from "node:net";
+import { homedir as homedir2 } from "node:os";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+
+// src/auth/broker/protocol.ts
+var MAX_FRAME_BYTES = 64 * 1024;
+var PROTOCOL_VERSION = 1;
+var ProviderNameSchema = exports_external.enum(["anthropic", "google", "microsoft"]);
+var GetCredentialsRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("get-credentials"),
+  id: exports_external.string().min(1),
+  provider: ProviderNameSchema.optional()
+});
+var ListStateRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("list-state"),
+  id: exports_external.string().min(1)
+});
+var SetActiveRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("set-active"),
+  id: exports_external.string().min(1),
+  account: exports_external.string().min(1),
+  provider: ProviderNameSchema.optional()
+});
+var MarkExhaustedRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("mark-exhausted"),
+  id: exports_external.string().min(1),
+  until: exports_external.number().int().positive().optional()
+});
+var RefreshAccountRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("refresh-account"),
+  id: exports_external.string().min(1),
+  account: exports_external.string().min(1),
+  provider: ProviderNameSchema.optional()
+});
+var AnthropicCredentialsSchema = exports_external.object({
+  claudeAiOauth: exports_external.object({
+    accessToken: exports_external.string(),
+    refreshToken: exports_external.string().optional(),
+    expiresAt: exports_external.number().optional(),
+    scopes: exports_external.array(exports_external.string()).optional(),
+    subscriptionType: exports_external.string().optional(),
+    rateLimitTier: exports_external.string().optional()
+  })
+});
+var GoogleCredentialsSchema = exports_external.object({
+  googleOauth: exports_external.object({
+    accessToken: exports_external.string(),
+    refreshToken: exports_external.string(),
+    expiresAt: exports_external.number(),
+    scope: exports_external.string(),
+    clientId: exports_external.string(),
+    accountEmail: exports_external.string(),
+    tokenType: exports_external.literal("Bearer")
+  })
+});
+var MicrosoftCredentialsSchema = exports_external.object({
+  microsoftOauth: exports_external.object({
+    accessToken: exports_external.string(),
+    refreshToken: exports_external.string(),
+    expiresAt: exports_external.number(),
+    scope: exports_external.string(),
+    clientId: exports_external.string(),
+    accountEmail: exports_external.string(),
+    tokenType: exports_external.literal("Bearer"),
+    tenantId: exports_external.string(),
+    accountType: exports_external.enum(["personal", "work"]),
+    homeAccountId: exports_external.string()
+  })
+});
+var ProviderCredentialsSchema = exports_external.union([
+  AnthropicCredentialsSchema,
+  GoogleCredentialsSchema,
+  MicrosoftCredentialsSchema
+]);
+var AddAccountRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("add-account"),
+  id: exports_external.string().min(1),
+  label: exports_external.string().min(1),
+  provider: ProviderNameSchema.optional(),
+  credentials: ProviderCredentialsSchema,
+  replace: exports_external.boolean().optional()
+});
+var RmAccountRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("rm-account"),
+  id: exports_external.string().min(1),
+  label: exports_external.string().min(1),
+  provider: ProviderNameSchema.optional()
+});
+var SetOverrideRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("set-override"),
+  id: exports_external.string().min(1),
+  agent: exports_external.string().min(1),
+  account: exports_external.string().min(1).nullable()
+});
+var ListGoogleAccountsRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("list-google-accounts"),
+  id: exports_external.string().min(1)
+});
+var ListMicrosoftAccountsRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("list-microsoft-accounts"),
+  id: exports_external.string().min(1)
+});
+var ProbeQuotaRequestSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  op: exports_external.literal("probe-quota"),
+  id: exports_external.string().min(1),
+  accounts: exports_external.array(exports_external.string().min(1)).min(1).max(32),
+  timeoutMs: exports_external.number().int().positive().max(60000).optional()
+});
+var RequestSchema = exports_external.discriminatedUnion("op", [
+  GetCredentialsRequestSchema,
+  ListStateRequestSchema,
+  SetActiveRequestSchema,
+  MarkExhaustedRequestSchema,
+  RefreshAccountRequestSchema,
+  AddAccountRequestSchema,
+  RmAccountRequestSchema,
+  SetOverrideRequestSchema,
+  ListGoogleAccountsRequestSchema,
+  ListMicrosoftAccountsRequestSchema,
+  ProbeQuotaRequestSchema
+]);
+var GetCredentialsDataSchema = exports_external.object({
+  account: exports_external.string(),
+  credentials: exports_external.unknown(),
+  expiresAt: exports_external.number().optional()
+});
+var AccountStateSchema = exports_external.object({
+  label: exports_external.string(),
+  expiresAt: exports_external.number().optional(),
+  exhausted: exports_external.boolean(),
+  exhausted_until: exports_external.number().optional(),
+  threshold_violations: exports_external.number().int().nonnegative().optional(),
+  last_refreshed_at: exports_external.number().optional()
+});
+var AgentStateSchema = exports_external.object({
+  name: exports_external.string(),
+  account: exports_external.string(),
+  override: exports_external.string().nullable()
+});
+var ConsumerStateSchema = exports_external.object({
+  name: exports_external.string(),
+  account: exports_external.string(),
+  last_seen_at: exports_external.number().nullable()
+});
+var ListStateDataSchema = exports_external.object({
+  active: exports_external.string(),
+  fallback_order: exports_external.array(exports_external.string()),
+  accounts: exports_external.array(AccountStateSchema),
+  agents: exports_external.array(AgentStateSchema),
+  consumers: exports_external.array(ConsumerStateSchema)
+});
+var SetActiveDataSchema = exports_external.object({
+  active: exports_external.string(),
+  fanned: exports_external.array(exports_external.string())
+});
+var MarkExhaustedDataSchema = exports_external.object({
+  account: exports_external.string(),
+  rolled: exports_external.array(exports_external.string()),
+  rolledTo: exports_external.string().nullable().optional()
+});
+var RefreshAccountDataSchema = exports_external.object({
+  account: exports_external.string(),
+  expiresAt: exports_external.number().optional()
+});
+var AddAccountDataSchema = exports_external.object({
+  label: exports_external.string(),
+  expiresAt: exports_external.number().optional()
+});
+var RmAccountDataSchema = exports_external.object({
+  label: exports_external.string()
+});
+var SetOverrideDataSchema = exports_external.object({
+  agent: exports_external.string(),
+  account: exports_external.string().nullable()
+});
+var GoogleAccountStateSchema = exports_external.object({
+  account: exports_external.string(),
+  expiresAt: exports_external.number(),
+  scope: exports_external.string(),
+  clientId: exports_external.string()
+});
+var ListGoogleAccountsDataSchema = exports_external.object({
+  accounts: exports_external.array(GoogleAccountStateSchema)
+});
+var MicrosoftAccountStateSchema = exports_external.object({
+  account: exports_external.string(),
+  expiresAt: exports_external.number(),
+  scope: exports_external.string(),
+  clientId: exports_external.string(),
+  accountType: exports_external.enum(["personal", "work"])
+});
+var ListMicrosoftAccountsDataSchema = exports_external.object({
+  accounts: exports_external.array(MicrosoftAccountStateSchema)
+});
+var ErrorBodySchema = exports_external.object({
+  code: exports_external.enum([
+    "FORBIDDEN",
+    "INVALID_ARGS",
+    "UNKNOWN_VERB",
+    "VERSION_MISMATCH",
+    "ACCOUNT_NOT_FOUND",
+    "ACCOUNT_ALREADY_EXISTS",
+    "CONFIG_INVALID",
+    "DRIFT_DETECTED",
+    "REFRESH_FAILED",
+    "INTERNAL"
+  ]),
+  message: exports_external.string()
+});
+var SuccessResponseSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  id: exports_external.string(),
+  ok: exports_external.literal(true),
+  data: exports_external.unknown()
+});
+var ErrorResponseSchema = exports_external.object({
+  v: exports_external.literal(PROTOCOL_VERSION),
+  id: exports_external.string(),
+  ok: exports_external.literal(false),
+  error: ErrorBodySchema
+});
+var ResponseSchema = exports_external.discriminatedUnion("ok", [
+  SuccessResponseSchema,
+  ErrorResponseSchema
+]);
+function encodeRequest(req) {
+  const line = JSON.stringify(RequestSchema.parse(req)) + `
+`;
+  if (Buffer.byteLength(line, "utf-8") > MAX_FRAME_BYTES) {
+    throw new Error(`auth-broker request exceeds MAX_FRAME_BYTES (${MAX_FRAME_BYTES})`);
+  }
+  return line;
+}
+function decodeResponse(line) {
+  const trimmed = line.endsWith(`
+`) ? line.slice(0, -1) : line;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new Error("auth-broker response is not valid JSON");
+  }
+  return ResponseSchema.parse(parsed);
+}
+
+// src/auth/broker/client.ts
+var DEFAULT_TIMEOUT_MS = 5000;
+function reviveDate(v) {
+  if (v == null)
+    return null;
+  if (v instanceof Date)
+    return Number.isNaN(v.getTime()) ? null : v;
+  const d = new Date(v);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+function operatorSocketPath(home2 = homedir2()) {
+  return join(home2, ".switchroom", "state", "auth-broker-operator", "sock");
+}
+function resolveAuthBrokerSocketPath(opts) {
+  if (opts?.socket)
+    return opts.socket;
+  const env = process.env.SWITCHROOM_AUTH_BROKER_SOCKET;
+  if (env && env.length > 0)
+    return env;
+  return operatorSocketPath(opts?.home);
+}
+
+class AuthBrokerError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AuthBrokerError";
+  }
+}
+
+class AuthBrokerUnreachableError extends Error {
+  reason;
+  socketPath;
+  constructor(reason, socketPath) {
+    super(`auth-broker unreachable at ${socketPath}: ${reason}. ` + `The broker may be down; existing credentials remain valid until expiry.`);
+    this.reason = reason;
+    this.socketPath = socketPath;
+    this.name = "AuthBrokerUnreachableError";
+  }
+}
+
+class AuthBrokerClient {
+  socketPath;
+  timeoutMs;
+  socket = null;
+  connecting = null;
+  buffer = "";
+  pending = new Map;
+  closed = false;
+  constructor(opts = {}) {
+    this.socketPath = resolveAuthBrokerSocketPath(opts);
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  getSocketPath() {
+    return this.socketPath;
+  }
+  async close() {
+    this.closed = true;
+    const sock = this.socket;
+    this.socket = null;
+    this.connecting = null;
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new Error("auth-broker client closed"));
+    }
+    this.pending.clear();
+    if (sock) {
+      sock.destroy();
+    }
+  }
+  async getCredentials(provider) {
+    const base = {
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "get-credentials"
+    };
+    const req = provider !== undefined ? { ...base, provider } : base;
+    const data = await this.send(req);
+    return data;
+  }
+  async listState() {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "list-state"
+    });
+    return data;
+  }
+  async listGoogleAccounts() {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "list-google-accounts"
+    });
+    return data;
+  }
+  async listMicrosoftAccounts() {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "list-microsoft-accounts"
+    });
+    return data;
+  }
+  async probeQuota(accounts, timeoutMs) {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "probe-quota",
+      accounts: [...accounts],
+      ...timeoutMs !== undefined ? { timeoutMs } : {}
+    });
+    const parsed = data;
+    for (const entry of parsed.results) {
+      if (entry.result.ok) {
+        entry.result.data.fiveHourResetAt = reviveDate(entry.result.data.fiveHourResetAt);
+        entry.result.data.sevenDayResetAt = reviveDate(entry.result.data.sevenDayResetAt);
+      }
+    }
+    return parsed;
+  }
+  async setActive(account) {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "set-active",
+      account
+    });
+    return data;
+  }
+  async markExhausted(until) {
+    const req = until !== undefined ? { v: PROTOCOL_VERSION, id: randomUUID(), op: "mark-exhausted", until } : { v: PROTOCOL_VERSION, id: randomUUID(), op: "mark-exhausted" };
+    const data = await this.send(req);
+    return data;
+  }
+  async refreshAccount(account) {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "refresh-account",
+      account
+    });
+    return data;
+  }
+  async addAccount(label, credentials, replace, provider) {
+    const base = {
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "add-account",
+      label,
+      credentials
+    };
+    const withReplace = replace ? { ...base, replace: true } : base;
+    const req = provider !== undefined ? { ...withReplace, provider } : withReplace;
+    const data = await this.send(req);
+    return data;
+  }
+  async rmAccount(label, provider) {
+    const base = {
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "rm-account",
+      label
+    };
+    const req = provider !== undefined ? { ...base, provider } : base;
+    const data = await this.send(req);
+    return data;
+  }
+  async setOverride(agent, account) {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "set-override",
+      agent,
+      account
+    });
+    return data;
+  }
+  async ensureConnected() {
+    if (this.closed) {
+      throw new Error("auth-broker client is closed");
+    }
+    if (this.socket && !this.socket.destroyed)
+      return this.socket;
+    if (this.connecting)
+      return this.connecting;
+    this.connecting = new Promise((resolve4, reject) => {
+      const sock = new net.Socket;
+      const onError = (err) => {
+        sock.removeAllListeners();
+        sock.destroy();
+        const code = err.code ?? "ERR";
+        let reason;
+        if (code === "ENOENT")
+          reason = "socket file not found";
+        else if (code === "ECONNREFUSED")
+          reason = "connection refused";
+        else if (code === "EACCES")
+          reason = "access denied";
+        else
+          reason = err.message;
+        reject(new AuthBrokerUnreachableError(reason, this.socketPath));
+      };
+      sock.once("error", onError);
+      sock.once("connect", () => {
+        sock.removeListener("error", onError);
+        sock.on("data", (chunk) => this.onData(chunk));
+        sock.on("error", (err) => this.onSocketError(err));
+        sock.on("close", () => this.onSocketClose());
+        this.socket = sock;
+        resolve4(sock);
+      });
+      sock.connect({ path: this.socketPath });
+    });
+    try {
+      return await this.connecting;
+    } finally {
+      this.connecting = null;
+    }
+  }
+  onData(chunk) {
+    this.buffer += chunk.toString("utf8");
+    let idx;
+    while ((idx = this.buffer.indexOf(`
+`)) !== -1) {
+      const line = this.buffer.slice(0, idx);
+      this.buffer = this.buffer.slice(idx + 1);
+      if (line.length === 0)
+        continue;
+      let resp;
+      try {
+        resp = decodeResponse(line);
+      } catch (err) {
+        const msg = `unparseable auth-broker response: ${err instanceof Error ? err.message : String(err)}`;
+        this.failAll(new AuthBrokerUnreachableError(msg, this.socketPath));
+        return;
+      }
+      const p = this.pending.get(resp.id);
+      if (!p) {
+        continue;
+      }
+      this.pending.delete(resp.id);
+      clearTimeout(p.timer);
+      p.resolve(resp);
+    }
+  }
+  onSocketError(err) {
+    this.failAll(new AuthBrokerUnreachableError(err.message, this.socketPath));
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = null;
+    }
+  }
+  onSocketClose() {
+    if (this.pending.size > 0) {
+      this.failAll(new AuthBrokerUnreachableError("connection closed mid-request", this.socketPath));
+    }
+    this.socket = null;
+  }
+  failAll(err) {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+  async send(req) {
+    const sock = await this.ensureConnected();
+    const id = req.id;
+    const frame = encodeRequest(req);
+    return new Promise((resolve4, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new AuthBrokerUnreachableError(`request ${req.op} timed out after ${this.timeoutMs}ms`, this.socketPath));
+      }, this.timeoutMs);
+      this.pending.set(id, {
+        resolve: (resp) => {
+          if (resp.ok) {
+            resolve4(resp.data);
+          } else {
+            reject(new AuthBrokerError(resp.error.code, resp.error.message));
+          }
+        },
+        reject,
+        timer
+      });
+      sock.write(frame, (err) => {
+        if (err) {
+          const p = this.pending.get(id);
+          if (p) {
+            clearTimeout(p.timer);
+            this.pending.delete(id);
+          }
+          reject(new AuthBrokerUnreachableError(`failed to send ${req.op}: ${err.message}`, this.socketPath));
+        }
+      });
+    });
+  }
+}
+
 // src/agent-scheduler/ipc-client.ts
 import { createConnection } from "node:net";
 function createInjectIpcClient(options) {
@@ -12734,12 +13309,55 @@ function readRecentFires(jsonlPath) {
 }
 
 // src/agent-scheduler/index.ts
+var DEFAULT_MAX_QUOTA_DEFER_ATTEMPTS = 3;
+function defaultQuotaDeferBackoffMs(attempt) {
+  return [60000, 180000, 300000][attempt] ?? 300000;
+}
 function registerAgentSchedule(opts) {
   const tasks = [];
   const now = opts.now ?? Date.now;
+  const maxAttempts = opts.maxQuotaDeferAttempts ?? DEFAULT_MAX_QUOTA_DEFER_ATTEMPTS;
+  const backoff = opts.quotaDeferBackoffMs ?? defaultQuotaDeferBackoffMs;
+  const scheduleRetry = opts.scheduleRetry ?? ((fn, ms) => {
+    const t = setTimeout(fn, ms);
+    if (typeof t.unref === "function")
+      t.unref();
+    return { cancel: () => clearTimeout(t) };
+  });
   for (const entry of opts.entries) {
-    const task = opts.cronLib.schedule(entry.cron, () => {
+    const pendingRetries = new Set;
+    const attemptFire = async (attempt) => {
       const startedAt = now();
+      if (opts.quotaGate) {
+        let decision;
+        try {
+          decision = await opts.quotaGate(entry.agent);
+        } catch {
+          decision = { defer: false, reason: "quota gate error (fail-open)" };
+        }
+        if (decision.defer) {
+          const more = attempt + 1 < maxAttempts;
+          const summary2 = `deferred (quota): ${decision.reason} ` + `[attempt ${attempt + 1}/${maxAttempts}]` + (more ? "" : " — giving up; will re-run on next scheduled occurrence");
+          opts.sink.recordFire({
+            agent: entry.agent,
+            scheduleIndex: entry.scheduleIndex,
+            promptKey: entry.promptKey,
+            exitCode: -2,
+            outputSummary: summary2,
+            startedAt,
+            finishedAt: now()
+          });
+          if (more) {
+            let handle;
+            handle = scheduleRetry(() => {
+              pendingRetries.delete(handle);
+              attemptFire(attempt + 1);
+            }, backoff(attempt));
+            pendingRetries.add(handle);
+          }
+          return;
+        }
+      }
       let delivered = false;
       let summary = "";
       try {
@@ -12760,8 +13378,19 @@ function registerAgentSchedule(opts) {
         startedAt,
         finishedAt
       });
+    };
+    const task = opts.cronLib.schedule(entry.cron, () => attemptFire(0));
+    tasks.push({
+      entry,
+      task: {
+        stop: () => {
+          for (const h of pendingRetries)
+            h.cancel();
+          pendingRetries.clear();
+          task.stop();
+        }
+      }
     });
-    tasks.push({ entry, task });
   }
   return tasks;
 }
@@ -12785,7 +13414,7 @@ async function main() {
   }
   const configPath = process.env.SWITCHROOM_CONFIG ?? "/state/config/switchroom.yaml";
   const stateDir = process.env.TELEGRAM_STATE_DIR ?? "/state/agent/telegram";
-  const socketPath = process.env.SWITCHROOM_GATEWAY_SOCKET ?? join(stateDir, "gateway.sock");
+  const socketPath = process.env.SWITCHROOM_GATEWAY_SOCKET ?? join2(stateDir, "gateway.sock");
   const jsonlPath = process.env.SWITCHROOM_AGENT_SCHEDULER_JSONL ?? "/state/agent/scheduler.jsonl";
   const lockPath = process.env.SWITCHROOM_AGENT_SCHEDULER_LOCK ?? "/state/agent/scheduler.lock";
   const lock = acquireLock(lockPath);
@@ -12913,12 +13542,22 @@ Briefly and plainly tell the user these scheduled runs did not ` + "happen so th
     }
   }
   const cronLib = __require("node-cron");
+  const quotaPreflightEnabled = process.env.SWITCHROOM_DISABLE_CRON_QUOTA_PREFLIGHT !== "1";
+  const quotaGate = quotaPreflightEnabled ? async () => {
+    const client = new AuthBrokerClient;
+    try {
+      return decideQuotaPreflight(await client.listState());
+    } finally {
+      await client.close().catch(() => {});
+    }
+  } : undefined;
   const tasks = registerAgentSchedule({
     entries,
     channel,
     sink,
     cronLib,
-    dispatcher
+    dispatcher,
+    ...quotaGate ? { quotaGate } : {}
   });
   process.stdout.write(`agent-scheduler: ${agentName} registered ${tasks.length} task(s); ` + `chat=${channel.chatId} thread=${channel.threadId ?? "(none)"} ` + `socket=${socketPath} jsonl=${jsonlPath}
 `);

package/dist/auth-broker/index.js

@@ -12286,6 +12286,35 @@ async function fetchQuota(opts) {
   return parsed;
 }
 
+// src/auth/broker/consumer-quota-sensor.ts
+var EXHAUSTION_PCT = 99.5;
+var DEFAULT_CONSUMER_PROBE_INTERVAL_MS = 10 * 60 * 1000;
+function quotaIndicatesExhaustion(result) {
+  if (!result.ok)
+    return { exhausted: false, until: null };
+  const d = result.data;
+  const fiveBlocked = d.fiveHourUtilizationPct >= EXHAUSTION_PCT;
+  const sevenBlocked = d.sevenDayUtilizationPct >= EXHAUSTION_PCT;
+  if (!fiveBlocked && !sevenBlocked)
+    return { exhausted: false, until: null };
+  const fiveReset = fiveBlocked ? d.fiveHourResetAt?.getTime() ?? null : null;
+  const sevenReset = sevenBlocked ? d.sevenDayResetAt?.getTime() ?? null : null;
+  const candidates = [fiveReset, sevenReset].filter((x) => x != null);
+  const until = candidates.length > 0 ? Math.max(...candidates) : null;
+  return { exhausted: true, until };
+}
+function resolveConsumerProbeIntervalMs(env) {
+  if (env.SWITCHROOM_DISABLE_CONSUMER_QUOTA_PROBE === "1")
+    return 0;
+  const raw = env.SWITCHROOM_CONSUMER_QUOTA_PROBE_MS;
+  if (raw !== undefined) {
+    const n = Number(raw);
+    if (Number.isFinite(n) && n >= 0)
+      return n;
+  }
+  return DEFAULT_CONSUMER_PROBE_INTERVAL_MS;
+}
+
 // src/util/atomic.ts
 import { randomBytes } from "node:crypto";
 import { closeSync, constants, fsyncSync, openSync, renameSync, rmSync, writeSync } from "node:fs";
@@ -13483,6 +13512,8 @@ class AuthBroker {
   config;
   listeners = new Map;
   refreshTimer = null;
+  consumerProbeTimer = null;
+  fetchQuotaImpl;
   stateDir;
   socketRoot;
   home;
@@ -13506,6 +13537,7 @@ class AuthBroker {
     this.now = opts.now ?? nowMs;
     this.operatorUid = opts.operatorUid;
     this.fetcher = opts.fetcher;
+    this.fetchQuotaImpl = opts._testFetchQuota ?? fetchQuota;
     this.stateDir = opts.stateDir ?? resolve7(this.homeRoot(), ".switchroom", "state", "auth-broker");
     this.socketRoot = opts.socketRoot ?? AUTH_BROKER_ROOT;
     this.providers = new ProviderRegistry;
@@ -13552,6 +13584,16 @@ class AuthBroker {
         });
       }, REFRESH_TICK_INTERVAL_MS);
       this.refreshTimer.unref();
+      const probeMs = resolveConsumerProbeIntervalMs(process.env);
+      const hasConsumers = (this.config.auth?.consumers ?? []).length > 0;
+      if (probeMs > 0 && hasConsumers) {
+        this.consumerProbeTimer = setInterval(() => {
+          this.consumerQuotaProbeTick().catch((err) => {
+            this.logErr(`consumer-quota-probe threw: ${err.message}`);
+          });
+        }, probeMs);
+        this.consumerProbeTimer.unref();
+      }
     }
     const fanned = this.fanoutAll();
     if (fanned.length > 0) {
@@ -13578,6 +13620,10 @@ class AuthBroker {
       clearInterval(this.refreshTimer);
       this.refreshTimer = null;
     }
+    if (this.consumerProbeTimer) {
+      clearInterval(this.consumerProbeTimer);
+      this.consumerProbeTimer = null;
+    }
     for (const [sock, lis] of this.listeners) {
       try {
         lis.server.close();
@@ -13995,7 +14041,7 @@ class AuthBroker {
         this.audit({ op: "probe-quota", identity: identity2, account: label, ok: false, error: "missing-credentials" });
         return { label, result: result2 };
       }
-      const result = await fetchQuota({ accessToken: token, timeoutMs });
+      const result = await this.fetchQuotaImpl({ accessToken: token, timeoutMs });
       this.audit({
         op: "probe-quota",
         identity: identity2,
@@ -14019,6 +14065,34 @@ class AuthBroker {
     }));
     socket.write(encodeSuccess(id, { results }));
   }
+  async consumerQuotaProbeTick() {
+    const accounts = Array.from(new Set((this.config.auth?.consumers ?? []).map((c) => c.account)));
+    for (const label of accounts) {
+      const creds = readAccountCredentials(label, this.home);
+      const token = creds?.claudeAiOauth?.accessToken;
+      if (!token)
+        continue;
+      let result;
+      try {
+        result = await this.fetchQuotaImpl({ accessToken: token });
+      } catch (err) {
+        this.logErr(`consumer-quota-probe ${label}: ${err.message}`);
+        continue;
+      }
+      const decision = quotaIndicatesExhaustion(result);
+      if (!decision.exhausted)
+        continue;
+      const exhaustedUntil = decision.until ?? this.now() + MARK_EXHAUSTED_DEFAULT_MS;
+      const existing = this.quota[label]?.exhausted_until;
+      if (existing !== undefined && existing >= exhaustedUntil)
+        continue;
+      this.quota[label] = { exhausted_until: exhaustedUntil };
+      this.persistQuota();
+      this.audit({ op: "mark-exhausted", identity: { kind: "operator" }, account: label, ok: true });
+      process.stdout.write(`auth-broker: consumer-quota-sensor marked ${label} exhausted until ${new Date(exhaustedUntil).toISOString()} — consumer(s) fail over
+`);
+    }
+  }
   async opSetActive(socket, id, identity2, account) {
     if (!this.isAdmin(identity2)) {
       this.audit({ op: "set-active", identity: identity2, account, ok: false, error: "FORBIDDEN" });

package/dist/cli/switchroom.js

@@ -49700,8 +49700,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.80";
-var COMMIT_SHA = "1198bdb5";
+var VERSION = "0.14.82";
+var COMMIT_SHA = "91bc41d1";
 
 // src/cli/agent.ts
 init_source();

package/package.json

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

@@ -52810,11 +52810,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.80";
-var COMMIT_SHA = "1198bdb5";
-var COMMIT_DATE = "2026-06-07T09:36:25+10:00";
+var VERSION = "0.14.82";
+var COMMIT_SHA = "91bc41d1";
+var COMMIT_DATE = "2026-06-07T12:22:49+10:00";
 var LATEST_PR = null;
-var COMMITS_AHEAD_OF_TAG = 1;
+var COMMITS_AHEAD_OF_TAG = 2;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {