switchroom 0.16.13 → 0.16.15

package/dist/cli/switchroom.js

@@ -15589,6 +15589,10 @@ var init_helpers = __esm(() => {
 function isKnownCheapModel(model) {
   return model !== undefined && CHEAP_MODEL_RE.test(model);
 }
+function isCheapCronEnabled(env2 = process.env) {
+  const v = (env2.SWITCHROOM_CHEAP_CRON ?? "").toLowerCase();
+  return !(v === "0" || v === "false" || v === "off");
+}
 function resolveCronModel(model) {
   return isKnownCheapModel(model) ? model : DEFAULT_CRON_MODEL;
 }
@@ -50753,6 +50757,10 @@ function dispatchTool(name, args) {
       cliArgs = buildArgs(["cron", "list"], args);
       parseMode = "json";
       break;
+    case "cron_doctor":
+      cliArgs = buildArgs(["cron", "doctor"], args);
+      parseMode = "json";
+      break;
     case "skill_list":
       cliArgs = buildArgs(["skill", "list"], args);
       parseMode = "json";
@@ -50970,7 +50978,17 @@ var init_server3 = __esm(() => {
     },
     {
       name: "cron_list",
-      description: "List the agent's scheduled cron entries (schedule array) as JSON.",
+      description: "List the agent's scheduled cron entries (schedule array) as JSON. " + "Each entry is self-describing: `source` (base-config vs overlay), " + "`file` (switchroom.yaml or the schedule.d path), resolved " + "`tier`/`context`, and a `duplicate_of` back-reference when another " + "entry shares the same cron expression. Original entry fields are " + "preserved.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          agent: { type: "string" }
+        }
+      }
+    },
+    {
+      name: "cron_doctor",
+      description: "Read-only cron health report: duplicate cron expressions (the " + "double-fire hazard), base-config-vs-overlay name conflicts, and " + "entries missing a resolved tier/context. Returns " + "{agent, entry_count, healthy, findings[]}. Call this BEFORE adding " + "a cron, or when a schedule misbehaves (firing twice, removing the " + "wrong entry).",
       inputSchema: {
         type: "object",
         properties: {
@@ -51674,8 +51692,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.16.13";
-var COMMIT_SHA = "d4f3ac38";
+var VERSION = "0.16.15";
+var COMMIT_SHA = "a9c59169";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {
@@ -51828,6 +51846,138 @@ import {
   appendFileSync,
   readFileSync as readFileSync5
 } from "node:fs";
+
+// src/scheduler/cron-introspect.ts
+init_overlay_loader();
+init_cron_routing();
+function normalizeCronExpr(expr) {
+  if (typeof expr !== "string")
+    return null;
+  const t = expr.trim();
+  if (t === "")
+    return null;
+  return t.replace(/\s+/g, " ");
+}
+function attributeEntry(raw) {
+  const entry = raw ?? {};
+  const isOverlay = entry[OVERLAY_SOURCE] === true;
+  const overlayTitle = entry[OVERLAY_TITLE];
+  const explicitName = typeof entry.name === "string" && entry.name.trim() !== "" ? entry.name : null;
+  if (isOverlay) {
+    const title = typeof overlayTitle === "string" && overlayTitle.trim() !== "" ? overlayTitle : explicitName;
+    const cron = typeof entry.cron === "string" ? entry.cron : "";
+    const prompt = typeof entry.prompt === "string" ? entry.prompt : undefined;
+    const file = `schedule.d/cron-${cronUnitHash(cron, prompt)}.yaml`;
+    return { entry, source: "overlay", file, name: title };
+  }
+  return { entry, source: "base-config", file: "switchroom.yaml", name: explicitName };
+}
+function resolveTierContext(entry, cheapCronEnabled) {
+  const routing = resolveCronRouting({ kind: entry.kind, model: entry.model, context: entry.context }, { cheapCronEnabled });
+  const ctx = routing.tier === "poll" || routing.tier === "action" ? null : routing.session === "cron" ? "fresh" : "agent";
+  return { tier: routing.tier, context: ctx };
+}
+function buildCronList(schedule, opts) {
+  const raws = (schedule ?? []).map(attributeEntry);
+  const byExpr = new Map;
+  raws.forEach((r, i) => {
+    const expr = normalizeCronExpr(r.entry.cron);
+    if (expr === null)
+      return;
+    const arr = byExpr.get(expr);
+    if (arr)
+      arr.push(i);
+    else
+      byExpr.set(expr, [i]);
+  });
+  return raws.map((r, i) => {
+    const { tier, context } = resolveTierContext(r.entry, opts.cheapCronEnabled);
+    const expr = normalizeCronExpr(r.entry.cron);
+    const out = {
+      ...r.entry,
+      name: r.name,
+      source: r.source,
+      file: r.file,
+      tier,
+      context
+    };
+    if (expr !== null) {
+      const siblings = (byExpr.get(expr) ?? []).filter((j) => j !== i);
+      if (siblings.length > 0) {
+        out.duplicate_of = siblings.map((j) => ({ name: raws[j].name, file: raws[j].file }));
+      }
+    }
+    return out;
+  });
+}
+function cronDoctor(agent, schedule, opts) {
+  const raws = (schedule ?? []).map(attributeEntry);
+  const findings = [];
+  const byExpr = new Map;
+  for (const r of raws) {
+    const expr = normalizeCronExpr(r.entry.cron);
+    if (expr === null)
+      continue;
+    const arr = byExpr.get(expr);
+    if (arr)
+      arr.push(r);
+    else
+      byExpr.set(expr, [r]);
+  }
+  for (const [expr, group] of byExpr) {
+    if (group.length > 1) {
+      findings.push({
+        kind: "duplicate_cron",
+        severity: "error",
+        message: `${group.length} entries share cron expression "${expr}" \u2014 they will ` + `all fire together (double-fire). Remove the redundant one(s).`,
+        cron: expr,
+        entries: group.map((r) => ({ name: r.name, file: r.file }))
+      });
+    }
+  }
+  const byName = new Map;
+  for (const r of raws) {
+    if (r.name === null)
+      continue;
+    const arr = byName.get(r.name);
+    if (arr)
+      arr.push(r);
+    else
+      byName.set(r.name, [r]);
+  }
+  for (const [name, group] of byName) {
+    const sources = new Set(group.map((r) => r.source));
+    if (group.length > 1 && sources.size > 1) {
+      findings.push({
+        kind: "name_conflict",
+        severity: "warn",
+        message: `name "${name}" is used by both a base-config and an overlay entry \u2014 ` + `removing by name is ambiguous.`,
+        conflicting_name: name,
+        entries: group.map((r) => ({ name: r.name, file: r.file }))
+      });
+    }
+  }
+  for (const r of raws) {
+    const expr = normalizeCronExpr(r.entry.cron);
+    if (expr === null) {
+      findings.push({
+        kind: "missing_tier",
+        severity: "warn",
+        message: `entry ${r.name ? `"${r.name}"` : "(unnamed)"} has no valid cron ` + `expression, so its tier/context cannot be resolved.`,
+        entries: [{ name: r.name, file: r.file }]
+      });
+    }
+  }
+  return {
+    agent,
+    entry_count: raws.length,
+    findings,
+    healthy: findings.length === 0
+  };
+}
+
+// src/cli/agent-config.ts
+init_cron_routing();
 var AUDIT_ROOT = join3(homedir2(), ".switchroom", "audit");
 function auditPathFor(agent) {
   return join3(AUDIT_ROOT, agent, "agent-config.jsonl");
@@ -52068,7 +52218,10 @@ function registerAgentConfigCommands(program2) {
     const cfg = getConfig(program2);
     try {
       const slice = getAgentSlice(cfg, agent);
-      const tasks = stripSecretValues(slice.schedule ?? []);
+      const rows = buildCronList(slice.schedule ?? [], {
+        cheapCronEnabled: isCheapCronEnabled()
+      });
+      const tasks = stripSecretValues(rows);
       process.stdout.write(JSON.stringify(tasks) + `
 `);
       appendAudit(agent, "cron.list", { ...opts }, 0);
@@ -52079,6 +52232,32 @@ function registerAgentConfigCommands(program2) {
       process.exit(1);
     }
   }));
+  cron.command("doctor").description("Report cron health: duplicate cron expressions, base-vs-overlay " + "name conflicts, and entries missing a resolved tier/context. " + "Read-only.").option("--agent <name>", "Target agent (defaults to $SWITCHROOM_AGENT_NAME)").action(withConfigError(async (opts) => {
+    let agent;
+    try {
+      agent = resolveTargetAgent(opts.agent);
+    } catch (err) {
+      process.stderr.write(`${err.message}
+`);
+      appendAudit(opts.agent ?? "<unknown>", "cron.doctor", { ...opts }, 7);
+      process.exit(7);
+    }
+    const cfg = getConfig(program2);
+    try {
+      const slice = getAgentSlice(cfg, agent);
+      const report = cronDoctor(agent, slice.schedule ?? [], {
+        cheapCronEnabled: isCheapCronEnabled()
+      });
+      process.stdout.write(JSON.stringify(report) + `
+`);
+      appendAudit(agent, "cron.doctor", { ...opts }, 0);
+    } catch (err) {
+      process.stderr.write(`${err.message}
+`);
+      appendAudit(agent, "cron.doctor", { ...opts }, 1);
+      process.exit(1);
+    }
+  }));
   const skill = program2.commands.find((c) => c.name() === "skill") ?? program2.command("skill").description("Read-only access to an agent's skill list");
   skill.command("list").description("List the agent's configured skills as JSON").option("--agent <name>", "Target agent (defaults to $SWITCHROOM_AGENT_NAME)").action(withConfigError(async (opts) => {
     let agent;
@@ -87819,6 +87998,7 @@ function exitCodeFor(code) {
   switch (code) {
     case "E_OVERLAY_SECRETS_REQUIRES_APPROVAL":
     case "E_CRON_TOO_FREQUENT":
+    case "E_CRON_DUPLICATE":
     case "E_QUOTA_EXCEEDED":
     case "E_WRITE_REQUIRES_RECREATE":
     case "E_SLUG_COLLISION":
@@ -87834,6 +88014,24 @@ function exitCodeFor(code) {
       return 10;
   }
 }
+function parseOverlayCronAndName(e) {
+  let cron;
+  let name;
+  const headerMatch = e.raw.match(/^#[^\S\n]*name:[^\S\n]*(\S.*?)[^\S\n]*$/m);
+  if (headerMatch)
+    name = headerMatch[1];
+  try {
+    const doc = import_yaml21.parse(e.raw);
+    const first = doc?.schedule?.[0];
+    if (first) {
+      if (typeof first.cron === "string")
+        cron = first.cron;
+      if (!name && typeof first.name === "string")
+        name = first.name;
+    }
+  } catch {}
+  return { cron, name };
+}
 function scheduleAdd(opts) {
   let agent;
   try {
@@ -87903,6 +88101,28 @@ function scheduleAdd(opts) {
       meta: { current: existing.length }
     };
   }
+  const wantExpr = normalizeCronExpr(opts.cronExpr);
+  for (const e of existing) {
+    const parsed = parseOverlayCronAndName(e);
+    if (opts.name && parsed.name && parsed.name === opts.name) {
+      return {
+        ok: false,
+        code: "E_CRON_DUPLICATE",
+        message: `an overlay cron named "${opts.name}" already exists ` + `(${e.slug}.yaml) \u2014 remove it first or choose a different name`,
+        exit: 9,
+        meta: { conflicting_slug: e.slug, conflicting_name: parsed.name }
+      };
+    }
+    if (wantExpr && parsed.cron && normalizeCronExpr(parsed.cron) === wantExpr) {
+      return {
+        ok: false,
+        code: "E_CRON_DUPLICATE",
+        message: `an overlay cron with expression "${wantExpr}" already exists ` + `(${e.slug}.yaml${parsed.name ? `, name "${parsed.name}"` : ""}) \u2014 ` + `adding another would double-fire. Remove the existing one first.`,
+        exit: 9,
+        meta: { conflicting_slug: e.slug, conflicting_cron: wantExpr }
+      };
+    }
+  }
   const hash2 = cronUnitHash(opts.cronExpr, opts.prompt);
   const slug = `cron-${hash2}`;
   let priorContent = null;

package/dist/host-control/main.js

@@ -22587,7 +22587,7 @@ import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:f
 import { dirname as dirname4, join as join2 } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.16.13";
+var VERSION = "0.16.15";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/package.json

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

@@ -46272,7 +46272,7 @@ async function handleModelMenuCallback(data, deps) {
 `).map((l) => l.trim()).find((l) => /set model|switched/i.test(l)) ?? `Switched to ${friendlyName} (session)`;
       return {
         answer: confirmation,
-        reply: await menuWithBanner(deps, `\u2705 ${deps.escapeHtml(confirmation)}`),
+        reply: await menuWithBannerStatic(deps, `\u2705 ${deps.escapeHtml(confirmation)}`),
         selectedModel: srName
       };
     }
@@ -46334,6 +46334,14 @@ async function menuWithBanner(deps, banner) {
     ...fresh.keyboard ? { keyboard: fresh.keyboard } : {}
   };
 }
+async function menuWithBannerStatic(deps, banner) {
+  const v1 = await handleModelCommand({ kind: "show" }, deps);
+  return {
+    text: [banner, "", v1.text].join(`
+`),
+    html: true
+  };
+}
 
 // ../src/agents/model-picker.ts
 var HEADER_RE = /Select model/;
@@ -54753,6 +54761,7 @@ var ARG_SUMMARY_LINE_MAX = 180;
 var MCP_TOOL_DESCRIPTIONS = {
   "mcp__agent-config__config_get": "Read its own merged config",
   "mcp__agent-config__cron_list": "List its own scheduled tasks",
+  "mcp__agent-config__cron_doctor": "Health-check its own cron schedule",
   "mcp__agent-config__skill_list": "List its own installed skills",
   "mcp__agent-config__audit_tail": "Read its own recent tool-call audit log",
   "mcp__agent-config__peers_list": "List the other agents on this instance",
@@ -56064,11 +56073,11 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.16.13";
-var COMMIT_SHA = "d4f3ac38";
-var COMMIT_DATE = "2026-06-28T21:45:50+10:00";
-var LATEST_PR = null;
-var COMMITS_AHEAD_OF_TAG = 2;
+var VERSION = "0.16.15";
+var COMMIT_SHA = "a9c59169";
+var COMMIT_DATE = "2026-06-28T22:48:22Z";
+var LATEST_PR = 2643;
+var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -68285,13 +68294,19 @@ bot.on("callback_query:data", async (ctx) => {
       return;
     }
     await ctx.answerCallbackQuery({ text: "Switching\u2026" }).catch(() => {});
+    let didInterimSrEdit = false;
+    if (data.startsWith(MODEL_CALLBACK_SR)) {
+      const srLabel = escapeHtmlForTg(srFriendlyLabel(data.slice(MODEL_CALLBACK_SR.length)));
+      await ctx.editMessageText(`\u23F3 Switching session to <b>${srLabel}</b>\u2026`, { parse_mode: "HTML", reply_markup: { inline_keyboard: [] } }).catch(() => {});
+      didInterimSrEdit = true;
+    }
     try {
       const prevSessionModel = activeSessionModelOverride;
       const outcome = await handleModelMenuCallback(data, modelDeps);
       if (outcome.selectedModel) {
         activeSessionModelOverride = outcome.selectedModel;
       }
-      if (outcome.toastOnly)
+      if (outcome.toastOnly && !didInterimSrEdit)
         return;
       if (outcome.selectedModel && isSrToClaudeTransition(prevSessionModel, outcome.selectedModel)) {
         const agentName3 = getMyAgentName();

package/telegram-plugin/gateway/gateway.ts

@@ -278,6 +278,8 @@ import {
   isSrToClaudeTransition,
   MODEL_CALLBACK_PREFIX,
   MODEL_CALLBACK_HEADER,
+  MODEL_CALLBACK_SR,
+  srFriendlyLabel,
   type ModelMenuDeps,
   type ModelCommandDeps,
   type ModelMenuReply,
@@ -20849,6 +20851,23 @@ bot.on('callback_query:data', async ctx => {
       return
     }
     await ctx.answerCallbackQuery({ text: 'Switching…' }).catch(() => {})
+    // sr-* inject waits for claude to respond (can take 10-30s). Edit the
+    // menu immediately to show a "working on it" state so the operator isn't
+    // left looking at a stale menu with no feedback. The final edit (✅/❌)
+    // replaces this once the inject returns.
+    // NOTE: this await yields the event loop, so a new inbound turn could
+    // start between here and handleModelMenuCallback's inner isBusy() check.
+    // We track whether we applied the interim edit so we can skip the
+    // toastOnly short-circuit if we did — a toastOnly return after the interim
+    // edit would leave the menu stuck button-less.
+    let didInterimSrEdit = false
+    if (data.startsWith(MODEL_CALLBACK_SR)) {
+      const srLabel = escapeHtmlForTg(srFriendlyLabel(data.slice(MODEL_CALLBACK_SR.length)))
+      await ctx
+        .editMessageText(`⏳ Switching session to <b>${srLabel}</b>…`, { parse_mode: 'HTML', reply_markup: { inline_keyboard: [] } })
+        .catch(() => {})
+      didInterimSrEdit = true
+    }
     try {
       const prevSessionModel = activeSessionModelOverride
       const outcome = await handleModelMenuCallback(data, modelDeps)
@@ -20858,9 +20877,11 @@ bot.on('callback_query:data', async ctx => {
       if (outcome.selectedModel) {
         activeSessionModelOverride = outcome.selectedModel
       }
-      // toastOnly: a no-op outcome that should not disturb the menu (defence
-      // in depth — the isBusy() short-circuit above is the live path).
-      if (outcome.toastOnly) return
+      // toastOnly: leave the menu untouched — but only if we haven't already
+      // cleared its buttons with the interim sr-* edit. If we have, fall
+      // through to the final edit so the message is recovered (busyReply or
+      // the full menu) rather than left permanently button-less.
+      if (outcome.toastOnly && !didInterimSrEdit) return
 
       // sr-* → Claude transition via the model menu: trigger a graceful restart.
       // Switching FROM an sr-* (LiteLLM/OpenRouter) model BACK to a Claude model

package/telegram-plugin/gateway/model-command.ts

@@ -345,7 +345,7 @@ export function expandSrAlias(arg: string): string {
   return SR_MODEL_ALIASES[arg.toLowerCase()] ?? arg
 }
 
-function srFriendlyLabel(srName: string): string {
+export function srFriendlyLabel(srName: string): string {
   return SR_MODEL_LABELS[srName] ?? srName.replace(/^sr-/, '').replace(/-/g, ' ')
 }
 
@@ -560,7 +560,11 @@ export async function handleModelMenuCallback(
           .find((l) => /set model|switched/i.test(l)) ?? `Switched to ${friendlyName} (session)`
       return {
         answer: confirmation,
-        reply: await menuWithBanner(deps, `✅ ${deps.escapeHtml(confirmation)}`),
+        // Use the static (no-discover) path — after a text-inject the picker
+        // is in flux and discover() reliably fails, producing a spurious
+        // "(picker unavailable)" line that reads as an error when the switch
+        // actually succeeded.
+        reply: await menuWithBannerStatic(deps, `✅ ${deps.escapeHtml(confirmation)}`),
         selectedModel: srName,
       }
     }
@@ -683,3 +687,20 @@ async function menuWithBanner(
     ...(fresh.keyboard ? { keyboard: fresh.keyboard } : {}),
   }
 }
+
+// Static variant — skips discover() entirely and uses the v1 text path.
+// Use after a text-inject where the picker state is inherently uncertain:
+// discover() reliably fails immediately post-inject, producing a spurious
+// "(picker unavailable)" warning that reads as an error.
+async function menuWithBannerStatic(
+  deps: ModelMenuDeps & ModelCommandDeps,
+  banner: string,
+): Promise<ModelMenuReply> {
+  const v1 = await handleModelCommand({ kind: 'show' }, deps)
+  return {
+    text: [banner, '', v1.text].join('\n'),
+    html: true,
+    // No keyboard — picker state is unknown after a text-inject; operator
+    // can tap /model to get a fresh interactive menu.
+  }
+}

package/telegram-plugin/permission-title.ts

@@ -46,6 +46,7 @@ const MCP_TOOL_DESCRIPTIONS: Record<string, string> = {
   // agent-config — every agent's self-service surface (#1163, #1215)
   "mcp__agent-config__config_get": "Read its own merged config",
   "mcp__agent-config__cron_list": "List its own scheduled tasks",
+  "mcp__agent-config__cron_doctor": "Health-check its own cron schedule",
   "mcp__agent-config__skill_list": "List its own installed skills",
   "mcp__agent-config__audit_tail": "Read its own recent tool-call audit log",
   "mcp__agent-config__peers_list": "List the other agents on this instance",

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

@@ -713,7 +713,13 @@ describe("handleModelMenuCallback — sr-* selection", () => {
     expect(calls.select).toHaveLength(0);
     expect(out.answer).toContain("Set model to sonnet");
     expect(out.selectedModel).toBe("sr-gemini-2.5-pro");
-    expect(out.reply.keyboard).toBeDefined();
+    // No keyboard on success: static reply path skips discover() to avoid the
+    // spurious "(picker unavailable)" line that discover() reliably produces
+    // immediately after an inject. Operator taps /model for a fresh menu.
+    expect(out.reply.keyboard).toBeUndefined();
+    // Banner present and text doesn't contain picker-unavailable noise
+    expect(out.reply.text).toContain('✅');
+    expect(out.reply.text).not.toContain('picker unavailable');
   });
 
   it("sr-* tap while busy returns toast-only with no inject", async () => {

package/telegram-plugin/uat/scenarios/jtbd-model-litellm-sr-dm.test.ts

@@ -140,11 +140,11 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
       const sc = await spinUp({ agent: AGENT });
       try {
         await sc.sendDM("/model");
-        // 60s — test 2 runs after test 1's restore restart, which takes ~15s.
-        // If the restart is still finishing when /model lands, it may be queued.
+        // 90s — test 2 runs after test 1's restore restart. The model-switch
+        // restart can take 30–60s to fully boot; 90s gives comfortable margin.
         const menu = await sc.expectMessage(/Default \(new sessions\):/i, {
           from: "bot",
-          timeout: 60_000,
+          timeout: 90_000,
         });
         const kb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
         const flat = (kb ?? []).flat();