switchroom 0.13.63 → 0.13.64

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,
+  );
+});