switchroom 0.13.63 → 0.13.65

package/dist/cli/switchroom.js

@@ -49083,8 +49083,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.13.63";
-var COMMIT_SHA = "9aaa5939";
+var VERSION = "0.13.65";
+var COMMIT_SHA = "51894764";
 
 // src/cli/agent.ts
 init_source();
@@ -49940,6 +49940,10 @@ var AGENT_CONFIG_MCP_TOOLS = [
 var HOSTD_MCP_TOOLS = [
   "mcp__hostd__update_check"
 ];
+var WEBKITE_MCP_TOOLS = [
+  "mcp__webkite",
+  "mcp__webkite__*"
+];
 var LEGACY_SWITCHROOM_MCP_TOKENS = ["mcp__switchroom", "mcp__switchroom__*"];
 var LEGACY_HOSTD_BLANKET_TOKENS = ["mcp__hostd", "mcp__hostd__*"];
 var DEFAULT_READ_ONLY_PREAPPROVED_TOOLS = [
@@ -50755,7 +50759,8 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
     ...usesSwitchroomTelegramPlugin(agentConfig) ? SWITCHROOM_TELEGRAM_MCP_TOOLS : [],
     ...hindsightEnabled ? HINDSIGHT_MCP_TOOLS : [],
     ...AGENT_CONFIG_MCP_TOOLS,
-    ...HOSTD_MCP_TOOLS
+    ...HOSTD_MCP_TOOLS,
+    ...agentConfig.mcp_servers?.["webkite"] === false ? [] : WEBKITE_MCP_TOOLS
   ]);
   const hindsightAutoRecallEnabled = hindsightEnabled && agentConfig.memory?.auto_recall !== false;
   const hindsightBankId = agentConfig.memory?.collection ?? name;
@@ -50816,7 +50821,8 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
       }
       settings.permissions = settings.permissions ?? {};
       const allow = (Array.isArray(settings.permissions.allow) ? settings.permissions.allow : []).filter((p) => !LEGACY_HOSTD_BLANKET_TOKENS.includes(p));
-      for (const t of [...AGENT_CONFIG_MCP_TOOLS, ...HOSTD_MCP_TOOLS]) {
+      const webkiteAllowTools = agentConfig.mcp_servers?.["webkite"] === false ? [] : WEBKITE_MCP_TOOLS;
+      for (const t of [...AGENT_CONFIG_MCP_TOOLS, ...HOSTD_MCP_TOOLS, ...webkiteAllowTools]) {
         if (!allow.includes(t))
           allow.push(t);
       }
@@ -51373,16 +51379,14 @@ function buildSettingsHooksBlock(p) {
   const useHotReloadStable = agentConfig.channels?.telegram?.hotReloadStable === true;
   const turnPacingDirective = "<turn-pacing>You are messaging a human via Telegram. The framework " + "automatically shows the user a live preview in their compose area as " + 'you work \u2014 they see "Read a file", "Ran 2 commands", etc. as your ' + `tool_use events stream. You do NOT need to ack manually.
 
-` + 'Do NOT call the reply tool with placeholder acks like "on it", ' + '"good question \u2014 one sec", "let me dig in", "checking now", etc. ' + "Those add chat clutter on top of the activity preview the user is " + "already seeing. The activity preview clears the moment you send a " + `real reply.
-
-` + `Call reply only when you have something substantive to deliver:
-` + `  - The actual answer (any length \u2014 short or long)
-` + `  - A genuine question back to the user
-` + "  - A real mid-work milestone or pivot that changes what the user " + 'should expect (e.g. "halfway through \u2014 found an unexpected issue, ' + `want me to continue?"). Not "still working".
+` + "ALWAYS reply to a message the user sends you. A direct message " + 'expects a response: a greeting ("hi", "hey", "you there?") gets a ' + "greeting back; a thanks gets a brief acknowledgement; a question " + "gets an answer. NEVER end a turn with NO_REPLY when the user has " + "just sent you something \u2014 NO_REPLY is only for genuine non-prompts " + `(a system-synthesized event you have already fully handled).
 
-` + "For trivial one-sentence answers: just reply with the answer. The " + `reply IS the answer, not an ack.
+` + "What you should NOT do is send a placeholder ack BEFORE doing the " + 'work \u2014 no "on it", "good question \u2014 one sec", "let me dig in", ' + '"checking now". Those add chat clutter on top of the activity ' + "preview the user already sees, and the preview clears the moment " + `your real reply lands. Do not ack-then-answer; just answer.
 
-` + "For complex tool-driven work: go straight to the tools. The compose-" + "area preview is the ambient liveness signal. Reply once you have " + "the answer or a real reason to break in.</turn-pacing>";
+` + `So:
+` + "  - Trivial / social message \u2192 reply once, briefly, in your voice. " + `The reply IS the response.
+` + `  - Question with a short answer \u2192 just reply with the answer.
+` + "  - Complex tool-driven work \u2192 go straight to the tools (the " + "compose-area preview is the ambient liveness signal), then reply " + 'once with the answer or a genuine mid-work pivot ("halfway ' + 'through \u2014 found an unexpected issue, want me to continue?"). Not ' + '"still working".</turn-pacing>';
   const switchroomUserPromptSubmit = [
     ...useHotReloadStable ? [
       {
@@ -51541,7 +51545,8 @@ function reconcileAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchr
     ...usesSwitchroomTelegramPlugin(agentConfig) ? SWITCHROOM_TELEGRAM_MCP_TOOLS : [],
     ...hindsightEnabled ? HINDSIGHT_MCP_TOOLS : [],
     ...AGENT_CONFIG_MCP_TOOLS,
-    ...HOSTD_MCP_TOOLS
+    ...HOSTD_MCP_TOOLS,
+    ...agentConfig.mcp_servers?.["webkite"] === false ? [] : WEBKITE_MCP_TOOLS
   ]);
   const desiredDeny = dedupe2([
     ...tools.deny ?? [],

package/package.json

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

@@ -49716,10 +49716,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.13.63";
-var COMMIT_SHA = "9aaa5939";
-var COMMIT_DATE = "2026-05-28T03:28:57Z";
-var LATEST_PR = 1945;
+var VERSION = "0.13.65";
+var COMMIT_SHA = "51894764";
+var COMMIT_DATE = "2026-05-28T05:00:08Z";
+var LATEST_PR = 1950;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -51489,6 +51489,13 @@ var ANSWER_STREAM_VISIBLE_ENABLED = (() => {
     return false;
   return true;
 })();
+var DRAFT_MIRROR_ENABLED = (() => {
+  const raw = process.env.SWITCHROOM_DRAFT_MIRROR;
+  if (raw == null)
+    return false;
+  const v = raw.trim().toLowerCase();
+  return !(v === "0" || v === "false" || v === "off" || v === "no");
+})();
 var progressDriver = null;
 var unpinProgressCardForChat = null;
 var getPinnedProgressCardMessageId = null;
@@ -53856,7 +53863,7 @@ function handleSessionEvent(ev) {
           clearActivitySummary(turn);
         }
       }
-      if (!turn.replyCalled && !isTelegramSurfaceTool(name)) {
+      if (!DRAFT_MIRROR_ENABLED && !turn.replyCalled && !isTelegramSurfaceTool(name)) {
         const rendered = registerAndRender(turn.toolActivity, name);
         if (rendered != null) {
           turn.activityPendingRender = rendered;
@@ -53884,7 +53891,7 @@ function handleSessionEvent(ev) {
             chatId: turn.sessionChatId,
             isPrivateChat: turn.isDm,
             threadId: turn.sessionThreadId,
-            ...ANSWER_STREAM_VISIBLE_ENABLED ? { minInitialChars: 1 } : { sendMessageDraft: sendMessageDraftFn },
+            ...DRAFT_MIRROR_ENABLED ? { sendMessageDraft: sendMessageDraftFn } : ANSWER_STREAM_VISIBLE_ENABLED ? { minInitialChars: 1 } : { sendMessageDraft: sendMessageDraftFn },
             sendMessage: async (chatId, text, params) => {
               const tid = params?.message_thread_id;
               const silent = params?.purpose !== "materialize";

package/telegram-plugin/gateway/gateway.ts

@@ -3192,6 +3192,26 @@ const ANSWER_STREAM_VISIBLE_ENABLED = (() => {
   if (v === '0' || v === 'false' || v === 'off' || v === 'no') return false
   return true
 })()
+
+// Draft-mirror preview (RFC docs/rfcs/draft-mirror-preview.md), Phase 1.
+// When enabled, the model's prose narration streams into the ephemeral
+// compose-area draft (sendMessageDraft) instead of a visible real
+// message — a live "what's it doing" preview that clears when the
+// reply lands. Default OFF (canary flag). When on it (a) forces the
+// answer-stream onto draft transport regardless of
+// ANSWER_STREAM_VISIBLE_ENABLED, and (b) suppresses the activity-summary
+// tool-count draft so the two don't collide on the single per-chat
+// draft slot. Delivery on a no-reply turn is owned by turn-flush
+// (decideTurnFlush → capturedText fresh send), NOT answer-stream
+// materialize() — which is dead on the draft-only path (streamMsgId
+// stays null, so its turn-end gate is false). Kill switch:
+// SWITCHROOM_DRAFT_MIRROR unset/0/false/off/no.
+const DRAFT_MIRROR_ENABLED = (() => {
+  const raw = process.env.SWITCHROOM_DRAFT_MIRROR
+  if (raw == null) return false
+  const v = raw.trim().toLowerCase()
+  return !(v === '0' || v === 'false' || v === 'off' || v === 'no')
+})()
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const progressDriver: any = null
 const unpinProgressCardForChat: ((chatId: string, threadId: number | undefined) => void) | null = null
@@ -7110,7 +7130,13 @@ function handleSessionEvent(ev: SessionEvent): void {
       // exactly once at a time and re-running until pending matches
       // the last-sent. Captures `turn` so a late drain after turn-swap
       // can't corrupt the next turn's atom.
-      if (!turn.replyCalled && !isTelegramSurfaceTool(name)) {
+      // DRAFT_MIRROR (RFC draft-mirror-preview, Phase 1): the model's
+      // prose narration owns the single per-chat draft slot. Suppress
+      // the activity-summary tool-count draft so the two don't collide
+      // (Telegram shows one draft per chat — the later write clobbers
+      // the earlier). The activity-summary code stays intact for the
+      // kill-switch path; it's retired for good only in Phase 4.
+      if (!DRAFT_MIRROR_ENABLED && !turn.replyCalled && !isTelegramSurfaceTool(name)) {
         const rendered = registerAndRender(turn.toolActivity, name)
         if (rendered != null) {
           turn.activityPendingRender = rendered
@@ -7158,13 +7184,20 @@ function handleSessionEvent(ev: SessionEvent): void {
             chatId: turn.sessionChatId,
             isPrivateChat: turn.isDm,
             threadId: turn.sessionThreadId,
-            // #869-Phase1 visible-answer-stream: omit the draft API so
-            // the lane uses the real sendMessage / editMessageText path
-            // and edits a user-visible chat-timeline message instead
-            // of the invisible compose-box draft.
-            ...(ANSWER_STREAM_VISIBLE_ENABLED
-              ? { minInitialChars: 1 }
-              : { sendMessageDraft: sendMessageDraftFn }),
+            // Transport selection:
+            // - DRAFT_MIRROR (RFC draft-mirror-preview, Phase 1): force
+            //   the ephemeral compose-area draft so narration is a
+            //   clears-on-reply preview. Wins over visible-answer-stream.
+            //   No-reply delivery is owned by turn-flush, not materialize.
+            // - else #869-Phase1 visible-answer-stream: omit the draft
+            //   API so the lane edits a user-visible chat-timeline
+            //   message (minInitialChars:1 opens it on the first chunk).
+            // - else legacy: draft transport.
+            ...(DRAFT_MIRROR_ENABLED
+              ? { sendMessageDraft: sendMessageDraftFn }
+              : ANSWER_STREAM_VISIBLE_ENABLED
+                ? { minInitialChars: 1 }
+                : { sendMessageDraft: sendMessageDraftFn }),
             // #1075: route through robustApiCall so flood-wait,
             // benign-400, and THREAD_NOT_FOUND are handled uniformly
             // instead of crashing the answer-stream loop on a deleted

package/telegram-plugin/uat/scenarios/greeting-reply-dm.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Greeting reply scenario — driver DMs the test bot a bare "hi", bot
+ * MUST reply (not NO_REPLY).
+ *
+ * Regression gate for the v0.13.61 turn-pacing v3 over-correction: the
+ * "don't ack" directive made the model classify a bare greeting as
+ * "not substantive" and end the turn with NO_REPLY, leaving the user
+ * staring at silence. v4 (this fix) re-asserts "always reply to a
+ * direct message; a greeting gets a greeting."
+ *
+ * Runs against real Telegram. Same env requirements as
+ * smoke-dm-reply.test.ts. Invoke via `bun run test:uat greeting`.
+ */
+
+import { describe, it, expect } from "vitest";
+import { spinUp } from "../harness.js";
+
+describe("uat: greeting gets a reply (v4 turn-pacing regression gate)", () => {
+  it(
+    "driver DMs a bare 'hi' and the bot replies within 60s (not NO_REPLY)",
+    async () => {
+      const sc = await spinUp({ agent: "test-harness" });
+
+      try {
+        const started = Date.now();
+        await sc.sendDM("hi");
+
+        // A greeting should come back fast — well under the silence-poke
+        // soft window. 60s budget tolerates a cold turn but a NO_REPLY
+        // (the bug) would blow past it via the 300s framework fallback.
+        const reply = await sc.expectMessage(/.+/, {
+          from: "bot",
+          timeout: 60_000,
+        });
+        const elapsed = Date.now() - started;
+
+        expect(reply.text.length).toBeGreaterThan(0);
+        expect(reply.senderUserId).toBe(sc.botUserId);
+        // The bug path replies only after the 300s framework fallback.
+        // A real greeting reply lands fast; assert it beat the fallback.
+        expect(elapsed).toBeLessThan(60_000);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    90_000,
+  );
+});

package/telegram-plugin/uat/scenarios/jtbd-webkite-read-dm.test.ts

@@ -0,0 +1,115 @@
+/**
+ * JTBD scenario — the agent fetches the web via webkite, transparently.
+ *
+ * Validates the v0.13.62/63 webkite rollout end-to-end through real
+ * Telegram: the user sends a URL and asks about its content WITHOUT
+ * ever naming "webkite". The agent must:
+ *
+ *   1. Reach for webkite on its own (the native WebFetch/WebSearch
+ *      tools are denied fleet-wide — see scaffold.ts
+ *      WEBKITE_FLEET_DENY_TOOLS — so the ONLY way the agent can answer
+ *      a "read this URL" prompt is via the webkite_* MCP tools). If the
+ *      agent returns the page's content, webkite did the work by
+ *      construction — there is no other web-fetch tool available.
+ *
+ *   2. Render JavaScript. The target is `quotes.toscrape.com/js/`, a
+ *      purpose-built scraping-practice SPA whose quotes are injected by
+ *      JS at runtime. A raw HTTP fetch (what the old WebFetch did) sees
+ *      an empty page — `curl` returns zero `class="quote"` nodes. Only
+ *      a JS-executing renderer (webkite → cloakbrowser headless
+ *      Chromium) produces the visible quote text. So a correct quote in
+ *      the reply is positive proof that JS rendering happened.
+ *
+ * The first quote on that page is Einstein's "The world as we have
+ * created it is a process of our thinking…". We assert the reply names
+ * Einstein AND carries a recognizable fragment of that quote.
+ *
+ * ## What this catches that other UATs don't
+ *
+ * - `jtbd-fast-trivial-dm` proves the agent replies fast, but never
+ *   touches a tool. This is the first UAT that forces a real web fetch.
+ * - The in-container `webkite read` smoke proves the binary works, but
+ *   not that the *model* chooses webkite unprompted over a denied
+ *   WebFetch, nor that the full inbound→claude→MCP→outbound path works.
+ *
+ * ## Failure modes this guards against
+ *
+ * - A regression that re-enables WebFetch (the model might fetch raw
+ *   HTML and miss the JS-rendered quotes → wrong/empty answer).
+ * - webkite MCP not wired / not trusted (agent says it can't browse).
+ * - cloakbrowser broken (agent returns the empty static page → no
+ *   quote, or a "page had no content" apology).
+ * - The glibc regression that the v0.13.62 canary caught (webkite
+ *   dead-on-arrival → agent can't browse at all).
+ */
+
+import { describe, it, expect } from "vitest";
+import { spinUp } from "../harness.js";
+
+const AGENT = "test-harness";
+
+// JS-rendered scraping-practice page. Quotes exist ONLY after JS runs;
+// a raw fetch sees none. Stable, purpose-built, no auth.
+const JS_URL = "https://quotes.toscrape.com/js/";
+
+// Deliberately does NOT mention webkite, fetch, browser, or any tool —
+// a natural "read this for me" ask. The agent must pick the tool.
+const PROMPT =
+  `Open ${JS_URL} and tell me the exact text of the very first quote ` +
+  `on the page and who said it. Just the quote and the author.`;
+
+// The first quote's author + a distinctive fragment of its text.
+const EXPECTED_AUTHOR = /einstein/i;
+const EXPECTED_FRAGMENT =
+  /world as we have created it|process of our thinking|changing our thinking/i;
+
+// Phrases that would indicate the agent FAILED to browse (fell back to
+// "I can't access the web" or got the empty static page).
+const CANT_BROWSE = [
+  /can.?t (access|browse|open|reach|fetch)/i,
+  /unable to (access|browse|open|reach|fetch)/i,
+  /no content|empty page|couldn.?t (find|load)/i,
+  /don.?t have (web|internet|browsing)/i,
+];
+
+describe("uat: agent fetches the web via webkite (JS page, unprompted)", () => {
+  it(
+    "URL prompt → agent returns JS-rendered content (proves webkite + cloakbrowser)",
+    async () => {
+      const sc = await spinUp({ agent: AGENT });
+      try {
+        await sc.sendDM(PROMPT);
+
+        // Generous budget: a real cloakbrowser render of an SPA is
+        // slower than a trivial reply (Chromium spawn + JS execution).
+        const reply = await sc.expectMessage(EXPECTED_FRAGMENT, {
+          from: "bot",
+          timeout: 90_000,
+        });
+
+        // Positive proof: the JS-gated quote text came back.
+        expect(reply.text).toMatch(EXPECTED_FRAGMENT);
+        // And the author — confirms it parsed the actual quote, not noise.
+        expect(reply.text).toMatch(EXPECTED_AUTHOR);
+
+        // Negative proof: no "I can't browse" fallback. (WebFetch is
+        // denied, so a failure to use webkite surfaces as an apology,
+        // not a wrong fetch.)
+        const failedToBrowse = CANT_BROWSE.some((re) => re.test(reply.text));
+        expect(
+          failedToBrowse,
+          `agent reply looks like a can't-browse fallback: ${JSON.stringify(reply.text.slice(0, 300))}`,
+        ).toBe(false);
+
+        console.log(
+          `[webkite-read] agent returned JS-rendered quote via webkite — ` +
+          `WebFetch denied, cloakbrowser rendered the SPA. ` +
+          `reply: ${JSON.stringify(reply.text.slice(0, 200))}`,
+        );
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    120_000,
+  );
+});