switchroom 0.16.14 → 0.16.16

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.14";
-var COMMIT_SHA = "6daa5e37";
+var VERSION = "0.16.17";
+var COMMIT_SHA = "de202ab1";
 
 // 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;
@@ -77417,11 +77596,19 @@ async function injectInbound(agentsDir, agentName, chatId, threadId, text, promp
   });
 }
 async function handleHermesRest(method, pathname, config) {
-  if (method === "GET" && pathname === "/api/sessions") {
+  if (method === "GET" && (pathname === "/api/sessions" || pathname === "/api/profiles/sessions")) {
     const agents = await handleGetAgents(config);
-    const agentsDir = resolveAgentsDir(config);
     const sessions = agents.map((a) => toHermesSession(a, agentLiveness(config, a.name)));
-    return { status: 200, body: { sessions } };
+    return {
+      status: 200,
+      body: {
+        sessions,
+        total: sessions.length,
+        limit: sessions.length,
+        offset: 0,
+        profile_totals: { default: sessions.length }
+      }
+    };
   }
   const sessionMatch = pathname.match(/^\/api\/sessions\/([^/]+)$/);
   if (method === "GET" && sessionMatch) {
@@ -77460,15 +77647,38 @@ async function handleHermesRest(method, pathname, config) {
     };
   }
   if (method === "GET" && pathname === "/api/config") {
-    const agentNames = Object.keys(config.agents ?? {});
     return {
       status: 200,
       body: {
         provider: "switchroom",
-        agents: agentNames
+        model: null,
+        context_length: null,
+        system_prompt: null
       }
     };
   }
+  if (method === "GET" && (pathname === "/api/config/defaults" || pathname === "/api/config/schema")) {
+    return { status: 200, body: {} };
+  }
+  if (method === "GET" && pathname === "/api/model/info") {
+    return {
+      status: 200,
+      body: {
+        model: "claude",
+        provider: "switchroom",
+        capabilities: {}
+      }
+    };
+  }
+  if (method === "GET" && pathname.startsWith("/api/logs")) {
+    return { status: 200, body: { file: "gateway.log", lines: [] } };
+  }
+  if (method === "GET" && (pathname.startsWith("/api/cron") || pathname.startsWith("/api/messaging") || pathname.startsWith("/api/profiles") || pathname === "/api/memory/providers")) {
+    if (pathname.includes("sessions")) {
+      return { status: 200, body: { sessions: [], total: 0, limit: 0, offset: 0 } };
+    }
+    return { status: 200, body: {} };
+  }
   return null;
 }
 function sendEvent(ctx, type, sessionId, payload) {
@@ -87819,6 +88029,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 +88045,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 +88132,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.14";
+var VERSION = "0.16.17";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.16.14",
+  "version": "0.16.16",
   "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/answer-stream.ts

@@ -93,6 +93,24 @@ export interface AnswerStreamConfig {
   ) => Promise<unknown>
   deleteMessage?: (chatId: string, messageId: number) => Promise<unknown>
 
+  /**
+   * Render the raw assistant transcript text into the wire format used for
+   * `parse_mode: 'HTML'` sends/edits. Every OTHER outbound lane in the gateway
+   * (handleStreamReply, the reply handler, the turn-flush backstop, the PTY
+   * partial handler) converts markdown → Telegram HTML via
+   * `sanitizeTelegramHtml(markdownToHtml(...))` before sending. The
+   * answer-stream lane historically shipped the RAW transcript under
+   * `parse_mode: 'HTML'`, so `**bold**` reached the user as literal asterisks
+   * and agent narration read as unformatted text.
+   *
+   * Injected as a dependency (mirroring `renderText` on the PTY partial
+   * handler) rather than hard-importing `format`/`html-sanitize` here, so this
+   * module stays free of a grammy/format dependency and remains fully
+   * testable. When absent, text is sent verbatim — preserving the old
+   * behaviour for callers (and tests) that don't wire it.
+   */
+  renderText?: (text: string) => string
+
   /** Called when a late edit/send resolves but this stream has been superseded. */
   onSuperseded?: OnSupersededCallback
   log?: (msg: string) => void
@@ -179,6 +197,7 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
     replyToMessageId,
     sendMessage,
     editMessageText,
+    renderText,
     onSuperseded,
     log,
     warn,
@@ -188,6 +207,13 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
     recordOutbound,
   } = config
 
+  /**
+   * Convert raw transcript text to the wire format before any
+   * `parse_mode: 'HTML'` send/edit. Falls back to the verbatim text when no
+   * renderer is injected (old behaviour / unwired tests).
+   */
+  const render = (text: string): string => (renderText != null ? renderText(text) : text)
+
   const effectiveThrottle = Math.max(250, throttleMs)
 
   // Stream state
@@ -229,6 +255,10 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
   }
 
   async function sendOrEditViaMessage(trimmed: string, gen: number, prevText: string): Promise<void> {
+    // Convert raw transcript markdown → Telegram HTML before sending under
+    // parse_mode: 'HTML'. Without this, `**bold**` ships as literal asterisks
+    // (the answer-stream-raw-markdown bug). Mirrors every other outbound lane.
+    const rendered = render(trimmed)
     if (typeof streamMsgId === 'number') {
       // Edit existing message
       const editParams: Parameters<typeof editMessageText>[3] = {
@@ -237,7 +267,7 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
       }
       if (threadId != null) editParams.message_thread_id = threadId
       try {
-        await editMessageText(chatId, streamMsgId, trimmed, editParams)
+        await editMessageText(chatId, streamMsgId, rendered, editParams)
         onMetric?.({ kind: 'answer_lane_update', chatId, messageId: streamMsgId, charCount: trimmed.length, transport: 'edit' })
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err)
@@ -266,7 +296,7 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
       }
       if (threadId != null) sendParams.message_thread_id = threadId
       if (replyToMessageId != null) sendParams.reply_parameters = { message_id: replyToMessageId }
-      const sent = await sendMessage(chatId, trimmed, sendParams)
+      const sent = await sendMessage(chatId, rendered, sendParams)
       const sentId = sent?.message_id
       if (typeof sentId !== 'number' || !Number.isFinite(sentId)) {
         warn?.('answer-stream: sendMessage returned no message_id')
@@ -424,7 +454,11 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
       // nested quote that looks wrong.
 
       try {
-        const sent = await sendMessage(chatId, textToSend, sendParams)
+        // Render markdown → Telegram HTML for the wire send. The dedup /
+        // silent-marker / history checks above all run on the raw textToSend
+        // (so they match the comparisons the other lanes make on raw text);
+        // only the actual outbound payload is converted.
+        const sent = await sendMessage(chatId, render(textToSend), sendParams)
         const sentId = sent?.message_id
         if (typeof sentId === 'number' && Number.isFinite(sentId)) {
           streamMsgId = sentId