switchroom 0.14.69 → 0.14.71

package/dist/cli/switchroom.js

@@ -49601,8 +49601,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.69";
-var COMMIT_SHA = "a3def2a8";
+var VERSION = "0.14.71";
+var COMMIT_SHA = "314a0e0e";
 
 // src/cli/agent.ts
 init_source();
@@ -52176,6 +52176,10 @@ function buildSettingsHooksBlock(p) {
 
 ` + 'Do NOT send a trailing confirmation after your answer \u2014 no "Done.", ' + '"Sent.", "Hope that helps." as a separate message once you have ' + "already replied. Your answer is the last thing the user should " + `see; a follow-up "Done." is dead-air clutter (and the user's ` + `device already pinged on the answer). Stop after the answer.
 
+` + "GROUND BEFORE YOU ASSERT. Any fact in your reply that can change " + "(a number, a status, a price, a date, who-uses-what, anything " + '"current" or "latest") must come from a source you actually checked ' + "THIS turn: your data tool, a file, the web. Memory and what you " + '"already know" are leads to verify, not sources. If you have not ' + "checked it this turn, do not state it as fact: go get it now, or tell " + "the user you will confirm and then do it. A confident wrong number is " + `worse than "let me check".
+
+` + "VOICE: write like a sharp colleague, not a chatbot. Do not open with " + `affirmation ("You're absolutely right", "Great question", "Great ` + 'catch", "Exactly!"); just answer. Skip AI-tell filler ("smoking ' + `gun", "delve", "it's worth noting", "a testament to", "in today's ` + 'fast-paced..."). Lead with the answer, plain words, kept short. When ' + `the user is wrong, say so directly; flattery is not help.
+
 ` + 'CRITICAL: "answer" means a call to the reply tool ' + "(mcp__switchroom-telegram__reply, or stream_reply with done=true). " + "Your terminal/transcript text is NEVER delivered to Telegram \u2014 the " + "user sees only what you send through the reply tool. After a long " + "tool sequence (scheduling, multi-step research, sub-agent handback), " + "do not let your closing narration stand as the answer: end the turn " + "by passing that narration to the reply tool. No reply tool call = the " + "user got nothing, however much text you wrote. Call the reply tool as " + "your FIRST action when you have the answer \u2014 do not write it out as " + "transcript text first and call reply afterward: a framework backstop " + "flushes unsent text after a delay and then your real reply lands late " + "and out of order.</turn-pacing>";
   const switchroomUserPromptSubmit = [
     ...useHotReloadStable ? [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.69",
+  "version": "0.14.71",
   "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-flag.ts

@@ -35,3 +35,72 @@ export function parseDraftLaneRetiredEnabled(raw: string | undefined): boolean {
   const v = raw.trim().toLowerCase()
   return !(v === '0' || v === 'false' || v === 'off' || v === 'no')
 }
+
+/**
+ * `minInitialChars` sentinel meaning "never open a visible chat-timeline
+ * preview" — mirrors the `Number.MAX_SAFE_INTEGER` gate the createAnswerStream
+ * call site uses so the lane stays silent.
+ */
+export const ANSWER_LANE_NEVER_OPENS = Number.MAX_SAFE_INTEGER
+
+export type AnswerLaneState = 'visible' | 'draft' | 'dormant'
+
+export interface AnswerLaneConfig {
+  /** `minInitialChars` for createAnswerStream: `1` opens a visible preview on
+   *  the first text chunk; `ANSWER_LANE_NEVER_OPENS` suppresses it. */
+  minInitialChars: number
+  /** Whether the lane streams to the invisible compose-box draft transport. */
+  usesDraftTransport: boolean
+  /** Whether a USER-VISIBLE chat-timeline preview opens — i.e. the surface that
+   *  flashed (raw preview → formatted reply → preview deleted). This is THE
+   *  regression invariant: it must equal `visibleEnabled`, never depend on the
+   *  draft flag. */
+  opensVisiblePreview: boolean
+  /** Label for the boot log. */
+  state: AnswerLaneState
+}
+
+/**
+ * Resolve the answer-lane config from the two INDEPENDENT inputs.
+ *
+ * The visible PREVIEW (the flash surface) is gated on `visibleEnabled` ALONE;
+ * draft retirement controls only the TRANSPORT (whether `sendMessageDraft` is
+ * available). Conflating them was the v0.14.68 regression: retiring the draft
+ * (the default) forced a visible preview that flashed on every streaming turn,
+ * re-opening the flash v0.14.52 had removed. The load-bearing invariant —
+ * `opensVisiblePreview === visibleEnabled` for EVERY `draftFnAvailable` — is
+ * what this function exists to make total-enumerable (the gateway IIFE is not).
+ *
+ *   visibleEnabled                       → 'visible'  (preview opens, minChars 1)
+ *   !visible, draft transport available  → 'draft'    (no preview; draft renders)
+ *   !visible, no draft transport         → 'dormant'  (no preview, no draft:
+ *                                                       the reply tool is the
+ *                                                       only message — the default)
+ */
+export function resolveAnswerLaneConfig(input: {
+  visibleEnabled: boolean
+  draftFnAvailable: boolean
+}): AnswerLaneConfig {
+  if (input.visibleEnabled) {
+    return {
+      minInitialChars: 1,
+      usesDraftTransport: false,
+      opensVisiblePreview: true,
+      state: 'visible',
+    }
+  }
+  if (input.draftFnAvailable) {
+    return {
+      minInitialChars: ANSWER_LANE_NEVER_OPENS,
+      usesDraftTransport: true,
+      opensVisiblePreview: false,
+      state: 'draft',
+    }
+  }
+  return {
+    minInitialChars: ANSWER_LANE_NEVER_OPENS,
+    usesDraftTransport: false,
+    opensVisiblePreview: false,
+    state: 'dormant',
+  }
+}

package/telegram-plugin/dist/gateway/gateway.js

@@ -39767,6 +39767,31 @@ function parseDraftLaneRetiredEnabled(raw) {
   const v = raw.trim().toLowerCase();
   return !(v === "0" || v === "false" || v === "off" || v === "no");
 }
+var ANSWER_LANE_NEVER_OPENS = Number.MAX_SAFE_INTEGER;
+function resolveAnswerLaneConfig(input) {
+  if (input.visibleEnabled) {
+    return {
+      minInitialChars: 1,
+      usesDraftTransport: false,
+      opensVisiblePreview: true,
+      state: "visible"
+    };
+  }
+  if (input.draftFnAvailable) {
+    return {
+      minInitialChars: ANSWER_LANE_NEVER_OPENS,
+      usesDraftTransport: true,
+      opensVisiblePreview: false,
+      state: "draft"
+    };
+  }
+  return {
+    minInitialChars: ANSWER_LANE_NEVER_OPENS,
+    usesDraftTransport: false,
+    opensVisiblePreview: false,
+    state: "dormant"
+  };
+}
 
 // pty-tail.ts
 var import_headless = __toESM(require_xterm_headless(), 1);
@@ -42518,6 +42543,18 @@ function enabled4() {
   const v = process.env.SWITCHROOM_DISABLE_VOICE_SCRUB;
   return !(v === "1" || v === "true");
 }
+var LEADING_AFFIRMATION_RE = /^(\s*)(you(?:['\u2019]| a)re absolutely right|you(?:['\u2019]| a)re so right|you(?:['\u2019]| a)re absolutely correct|absolutely right|exactly right|great catch|good catch|nice catch|spot on)\b(?:\s*$|\s*[!.,;:\u2014\u2013-][\s!.,;:\u2014\u2013-]*)/i;
+function stripLeadingAffirmation(text) {
+  const m = LEADING_AFFIRMATION_RE.exec(text);
+  if (!m)
+    return { out: text, count: 0 };
+  const leadingWs = m[1] ?? "";
+  const rest = text.slice(m[0].length);
+  if (rest.trim().length === 0)
+    return { out: text, count: 0 };
+  const recapped = rest.replace(/^(\s*)([a-z])/, (_m, ws, ch) => ws + ch.toUpperCase());
+  return { out: leadingWs + recapped, count: 1 };
+}
 function park(text) {
   const parts = [];
   let parked = text;
@@ -42580,14 +42617,16 @@ function replaceDashes(text) {
 }
 function scrubVoice(text) {
   if (!enabled4() || text.length === 0) {
-    return { scrubbed: text, replaced: 0 };
+    return { scrubbed: text, replaced: 0, openersStripped: 0 };
   }
   const { parked, parts } = park(text);
-  const { out, replaced } = replaceDashes(parked);
-  if (replaced === 0) {
-    return { scrubbed: text, replaced: 0 };
+  const opener = stripLeadingAffirmation(parked);
+  const { out, replaced } = replaceDashes(opener.out);
+  const total = replaced + opener.count;
+  if (total === 0) {
+    return { scrubbed: text, replaced: 0, openersStripped: 0 };
   }
-  return { scrubbed: restore(out, parts), replaced };
+  return { scrubbed: restore(out, parts), replaced: total, openersStripped: opener.count };
 }
 
 // telegram-button-constraints.ts
@@ -52776,11 +52815,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.69";
-var COMMIT_SHA = "a3def2a8";
-var COMMIT_DATE = "2026-06-05T22:00:53+10:00";
-var LATEST_PR = null;
-var COMMITS_AHEAD_OF_TAG = 3;
+var VERSION = "0.14.71";
+var COMMIT_SHA = "314a0e0e";
+var COMMIT_DATE = "2026-06-05T14:23:58Z";
+var LATEST_PR = 2181;
+var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -55213,6 +55252,10 @@ var STREAM_THROTTLE_MS_OVERRIDE = (() => {
 })();
 var TURN_FLUSH_SAFETY_ENABLED = isTurnFlushSafetyEnabled();
 var ANSWER_STREAM_VISIBLE_ENABLED = parseVisibleAnswerStreamEnabled(process.env.SWITCHROOM_VISIBLE_ANSWER_STREAM);
+var ANSWER_LANE = resolveAnswerLaneConfig({
+  visibleEnabled: ANSWER_STREAM_VISIBLE_ENABLED,
+  draftFnAvailable: sendMessageDraftFn != null
+});
 var CLEAR_STATUS_ON_COMPLETION = (() => {
   const raw = process.env.SWITCHROOM_TG_CLEAR_STATUS_ON_COMPLETION;
   if (raw == null)
@@ -58151,7 +58194,7 @@ function handleSessionEvent(ev) {
             chatId: turn.sessionChatId,
             isPrivateChat: turn.isDm,
             threadId: turn.sessionThreadId,
-            ...ANSWER_STREAM_VISIBLE_ENABLED || DRAFT_ANSWER_LANE_RETIRED ? { minInitialChars: 1 } : { sendMessageDraft: sendMessageDraftFn, minInitialChars: Number.MAX_SAFE_INTEGER },
+            ...ANSWER_LANE.usesDraftTransport ? { sendMessageDraft: sendMessageDraftFn, minInitialChars: ANSWER_LANE.minInitialChars } : { minInitialChars: ANSWER_LANE.minInitialChars },
             sendMessage: async (chatId, text, params) => {
               const tid = params?.message_thread_id;
               const silent = params?.purpose !== "materialize";
@@ -58283,7 +58326,7 @@ function handleSessionEvent(ev) {
         const stream = turn.answerStream;
         const streamedMsgId = stream.messageId();
         const streamedFinalText = turn.capturedText.join("").trim();
-        if ((ANSWER_STREAM_VISIBLE_ENABLED || DRAFT_ANSWER_LANE_RETIRED) && !turn.replyCalled && streamedMsgId != null && streamedFinalText.length > 0) {
+        if (ANSWER_LANE.opensVisiblePreview && !turn.replyCalled && streamedMsgId != null && streamedFinalText.length > 0) {
           turn.answerStream = null;
           streamFinalizedAsAnswer = true;
           turn.finalAnswerDelivered = true;
@@ -64619,7 +64662,7 @@ var didOneTimeSetup = false;
           }
         }
       }
-      process.stderr.write(`telegram gateway: answer-stream lane=${DRAFT_ANSWER_LANE_RETIRED ? "visible(draft-retired)" : ANSWER_STREAM_VISIBLE_ENABLED ? "visible" : "draft"} draftFn=${sendMessageDraftFn != null ? "available" : "off"} grammy=${GRAMMY_VERSION}
+      process.stderr.write(`telegram gateway: answer-stream lane=${ANSWER_LANE.state} draftFn=${sendMessageDraftFn != null ? "available" : "off"} visible=${ANSWER_STREAM_VISIBLE_ENABLED} draftRetired=${DRAFT_ANSWER_LANE_RETIRED} grammy=${GRAMMY_VERSION}
 `);
       process.stderr.write(`telegram gateway: starting bot polling pid=${process.pid} agent=${process.env.SWITCHROOM_AGENT_NAME ?? "-"} stateDir=${STATE_DIR} historyEnabled=${HISTORY_ENABLED} streamMode=${process.env.SWITCHROOM_TG_STREAM_MODE ?? "checklist"}
 `);

package/telegram-plugin/gateway/gateway.ts

@@ -98,7 +98,7 @@ import * as pendingProgress from '../pending-work-progress.js'
 import { writeSilentEndState, clearSilentEndState, recordUndeliveredTurnEnd } from '../silent-end.js'
 import { isFinalAnswerReply, isSubstantiveFinalReply } from '../final-answer-detect.js'
 import { createAnswerStream, type AnswerStreamHandle } from '../answer-stream.js'
-import { parseVisibleAnswerStreamEnabled, parseDraftLaneRetiredEnabled } from '../answer-stream-flag.js'
+import { parseVisibleAnswerStreamEnabled, parseDraftLaneRetiredEnabled, resolveAnswerLaneConfig } from '../answer-stream-flag.js'
 import { type SessionEvent } from '../session-tail.js'
 import {
   shouldSuppressToolActivity,
@@ -4589,6 +4589,16 @@ const TURN_FLUSH_SAFETY_ENABLED = isTurnFlushSafetyEnabled()
 const ANSWER_STREAM_VISIBLE_ENABLED = parseVisibleAnswerStreamEnabled(
   process.env.SWITCHROOM_VISIBLE_ANSWER_STREAM,
 )
+// Single source of truth for the answer-lane behaviour (flash-decouple,
+// 2026-06-05). The visible preview gates on the visible flag ALONE; the draft
+// flag controls only the transport. Resolved here once and consulted at the
+// createAnswerStream config, the materialize-as-answer guard, and the boot log,
+// so all three can never drift back into the `visible || retired` conflation
+// that re-opened the flash. Total-enumerated in answer-stream-flag.test.ts.
+const ANSWER_LANE = resolveAnswerLaneConfig({
+  visibleEnabled: ANSWER_STREAM_VISIBLE_ENABLED,
+  draftFnAvailable: sendMessageDraftFn != null,
+})
 
 // Whether to DELETE the activity/status feed when the final answer lands.
 // Default OFF (2026-06-04, operator request): the status message stays in the
@@ -9673,15 +9683,29 @@ function handleSessionEvent(ev: SessionEvent): void {
             // General). With the gate unreachable the only posted message is
             // the canonical reply. (The gate is bypassed for DM draft
             // transport, so DM draft streaming is unaffected.)
-            // Draft retired (default) OR visible explicitly on → a real
-            // edit-in-place message (minInitialChars:1, no draft): observable by
-            // the UAT and the onMetric silence-liveness reset fires on visible
-            // sends in DMs AND supergroups. Legacy draft only when the kill
-            // switch re-enables it (DRAFT_ANSWER_LANE_RETIRED=false), which also
-            // restores sendMessageDraftFn above.
-            ...(ANSWER_STREAM_VISIBLE_ENABLED || DRAFT_ANSWER_LANE_RETIRED
-              ? { minInitialChars: 1 }
-              : { sendMessageDraft: sendMessageDraftFn, minInitialChars: Number.MAX_SAFE_INTEGER }),
+            // VISIBLE preview gating decoupled from the draft-transport flag
+            // (2026-06-05 flash regression fix). The visible flag ALONE decides
+            // whether a user-visible preview opens; DRAFT_ANSWER_LANE_RETIRED
+            // controls only the TRANSPORT (whether sendMessageDraftFn exists).
+            // The earlier `|| DRAFT_ANSWER_LANE_RETIRED` here meant retiring the
+            // draft (the default since v0.14.68) silently forced minInitialChars:1
+            // → a visible preliminary opened on every streaming turn and was then
+            // retracted (deleted) when the reply tool fired — the exact "raw bubble
+            // appears, formatted reply lands, raw bubble vanishes" flash that
+            // turning the visible stream OFF (v0.14.52) was meant to remove. So
+            // v0.14.68 silently undid v0.14.52 fleet-wide. Now:
+            //   - VISIBLE on (opt-in) → minInitialChars:1, a real edit-in-place
+            //     preview (observable by UAT, silence-liveness reset on its sends).
+            //   - VISIBLE off (default) → minInitialChars:MAX so NO visible preview
+            //     ever opens; the reply tool is the single canonical formatted
+            //     message (no flash). With the draft retired (default) there is no
+            //     transport either, so the lane stays dormant; with the kill switch
+            //     DRAFT_ANSWER_LANE=0 the legacy compose-box draft transport is
+            //     restored (sendMessageDraftFn defined above, gate bypassed for DM
+            //     draft so #1664 DM draft streaming is unaffected).
+            ...(ANSWER_LANE.usesDraftTransport
+              ? { sendMessageDraft: sendMessageDraftFn, minInitialChars: ANSWER_LANE.minInitialChars }
+              : { minInitialChars: ANSWER_LANE.minInitialChars }),
             // #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
@@ -9969,13 +9993,18 @@ function handleSessionEvent(ev: SessionEvent): void {
         const streamedMsgId = stream.messageId()
         const streamedFinalText = turn.capturedText.join('').trim()
         if (
-          // Broadened for draft retirement: a text-only no-reply turn that
-          // streamed a VISIBLE preview must materialize a pinged final answer +
-          // delete the preview. Without this, the retired-default path would
-          // fall into the else-branch retract() and delete the user's only copy
-          // of the answer (a lost-answer bug). The reply-tool branch still hits
-          // retract() → single canonical formatted reply, no flash.
-          (ANSWER_STREAM_VISIBLE_ENABLED || DRAFT_ANSWER_LANE_RETIRED)
+          // Only when a VISIBLE preview actually opened (visible flag on): a
+          // text-only no-reply turn that streamed a visible preview must
+          // materialize a pinged final answer + delete the preview, NOT fall into
+          // the else-branch retract() which would delete the user's only copy of
+          // the answer (a lost-answer bug). Gated on the visible flag alone (the
+          // flash-regression decoupling): with the visible stream OFF (default)
+          // no preview opens (minInitialChars:MAX), so streamedMsgId is null and
+          // this branch is unreachable — the no-reply answer is delivered by the
+          // turn-flush backstop below instead, the pre-v0.14.68 path. The
+          // reply-tool branch hits retract() on a non-opened lane (a no-op), so
+          // there is no preliminary to flash.
+          ANSWER_LANE.opensVisiblePreview
           && !turn.replyCalled
           && streamedMsgId != null
           && streamedFinalText.length > 0
@@ -20705,7 +20734,13 @@ void (async () => {
         }
       }
 
-      process.stderr.write(`telegram gateway: answer-stream lane=${DRAFT_ANSWER_LANE_RETIRED ? 'visible(draft-retired)' : (ANSWER_STREAM_VISIBLE_ENABLED ? 'visible' : 'draft')} draftFn=${sendMessageDraftFn != null ? 'available' : 'off'} grammy=${GRAMMY_VERSION}\n`)
+      // Lane state (post flash-decouple): VISIBLE only when the visible flag is
+      // Lane state from the single-source-of-truth resolver: 'visible' (preview
+      // on), 'draft' (compose-box transport), or 'dormant' (the default: no
+      // preview, no draft — reply tool is the only message). The old label
+      // wrongly reported 'visible(draft-retired)' for the dormant default, which
+      // masked the flash regression.
+      process.stderr.write(`telegram gateway: answer-stream lane=${ANSWER_LANE.state} draftFn=${sendMessageDraftFn != null ? 'available' : 'off'} visible=${ANSWER_STREAM_VISIBLE_ENABLED} draftRetired=${DRAFT_ANSWER_LANE_RETIRED} grammy=${GRAMMY_VERSION}\n`)
       process.stderr.write(`telegram gateway: starting bot polling pid=${process.pid} agent=${process.env.SWITCHROOM_AGENT_NAME ?? '-'} stateDir=${STATE_DIR} historyEnabled=${HISTORY_ENABLED} streamMode=${process.env.SWITCHROOM_TG_STREAM_MODE ?? 'checklist'}\n`)
       runnerHandle = run(bot, {
         runner: {

package/telegram-plugin/runtime-metrics.ts

@@ -124,7 +124,7 @@ export type RuntimeMetricEvent =
    * losing ground; a per-agent spike is prompt drift on that agent.
    *
    *   chatKey   → `<chatId>:<threadIdOrEmpty>` (statusKey shape)
-   *   replaced  → count of dashes rewritten in this single message
+   *   replaced  → total voice changes in this message (dash rewrites + leading-affirmation strips)
    *   site      → which reply path saw the scrub (executeReply / edit / answer-stream)
    */
   | {

package/telegram-plugin/tests/answer-stream-flag.test.ts

@@ -6,7 +6,7 @@
  */
 
 import { describe, it, expect } from 'vitest'
-import { parseVisibleAnswerStreamEnabled, parseDraftLaneRetiredEnabled } from '../answer-stream-flag.js'
+import { parseVisibleAnswerStreamEnabled, parseDraftLaneRetiredEnabled, resolveAnswerLaneConfig } from '../answer-stream-flag.js'
 
 describe('parseVisibleAnswerStreamEnabled — default OFF, opt-in', () => {
   it('defaults OFF when unset', () => {
@@ -43,3 +43,75 @@ describe('parseDraftLaneRetiredEnabled — default RETIRED (2026-06-05), kill-sw
     }
   })
 })
+
+// ── resolveAnswerLaneConfig — TOTAL-ENUMERATION REGRESSION PROOF ─────────────
+//
+// This is the behavioural guard for the flash regression (the gateway IIFE is
+// not importable, so the decision lives in this pure function and the gateway
+// delegates to it). The input space is finite — visibleEnabled × draftFnAvailable
+// = 4 — so we enumerate ALL of it and assert the full decision table plus the
+// load-bearing INVARIANT: opensVisiblePreview === visibleEnabled, ALWAYS. That
+// invariant is exactly what v0.14.68 broke (it made the preview depend on the
+// draft flag), so a future change that re-conflates them fails here, not in prod.
+describe('resolveAnswerLaneConfig — total enumeration (flash-regression proof)', () => {
+  const MAX = Number.MAX_SAFE_INTEGER
+  const ALL = [
+    { visibleEnabled: false, draftFnAvailable: false }, // the DEFAULT (visible off, draft retired)
+    { visibleEnabled: false, draftFnAvailable: true }, // draft kill switch on
+    { visibleEnabled: true, draftFnAvailable: false }, // opt-in visible
+    { visibleEnabled: true, draftFnAvailable: true }, // visible wins over draft
+  ]
+
+  it('the input space is exactly 4 rows (2×2)', () => {
+    expect(ALL.length).toBe(4)
+  })
+
+  it('INVARIANT (the regression guard): opensVisiblePreview === visibleEnabled for EVERY draftFnAvailable', () => {
+    for (const input of ALL) {
+      expect(resolveAnswerLaneConfig(input).opensVisiblePreview).toBe(input.visibleEnabled)
+    }
+  })
+
+  it('TOTAL: every input returns a defined config and never throws', () => {
+    for (const input of ALL) {
+      expect(() => resolveAnswerLaneConfig(input)).not.toThrow()
+      expect(resolveAnswerLaneConfig(input).state).toBeDefined()
+    }
+  })
+
+  it('DEFAULT (visible off, draft retired) → DORMANT: no preview, no draft, MAX gate (no flash)', () => {
+    expect(resolveAnswerLaneConfig({ visibleEnabled: false, draftFnAvailable: false })).toEqual({
+      minInitialChars: MAX,
+      usesDraftTransport: false,
+      opensVisiblePreview: false,
+      state: 'dormant',
+    })
+  })
+
+  it('visible off + draft transport available → DRAFT: no visible preview, draft renders', () => {
+    expect(resolveAnswerLaneConfig({ visibleEnabled: false, draftFnAvailable: true })).toEqual({
+      minInitialChars: MAX,
+      usesDraftTransport: true,
+      opensVisiblePreview: false,
+      state: 'draft',
+    })
+  })
+
+  it('visible on → VISIBLE: preview opens on the first chunk (minChars 1), no draft', () => {
+    for (const draftFnAvailable of [false, true]) {
+      expect(resolveAnswerLaneConfig({ visibleEnabled: true, draftFnAvailable })).toEqual({
+        minInitialChars: 1,
+        usesDraftTransport: false,
+        opensVisiblePreview: true,
+        state: 'visible',
+      })
+    }
+  })
+
+  it('a visible preview NEVER opens unless explicitly enabled (no draftFnAvailable forces it on)', () => {
+    // The exact v0.14.68 failure shape: retiring the draft (draftFnAvailable=false)
+    // must NOT open a visible preview.
+    expect(resolveAnswerLaneConfig({ visibleEnabled: false, draftFnAvailable: false }).opensVisiblePreview).toBe(false)
+    expect(resolveAnswerLaneConfig({ visibleEnabled: false, draftFnAvailable: false }).minInitialChars).toBe(MAX)
+  })
+})

package/telegram-plugin/tests/answer-stream.test.ts

@@ -6,6 +6,7 @@ import {
   DRAFT_METHOD_UNAVAILABLE_RE,
   DRAFT_CHAT_UNSUPPORTED_RE,
 } from '../answer-stream.js'
+import { resolveAnswerLaneConfig, ANSWER_LANE_NEVER_OPENS } from '../answer-stream-flag.js'
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -96,6 +97,35 @@ describe('answer-stream — minInitialChars threshold', () => {
     expect(editMessageText).not.toHaveBeenCalled()
   })
 
+  it('FLASH REGRESSION: the DORMANT config (visible off, draft retired) sends NOTHING, even for a full answer', async () => {
+    // End-to-end proof that the resolved default config produces no visible
+    // preview → nothing to retract → no flash. Wires the ACTUAL resolver output
+    // (not a hand-picked threshold) into the stream.
+    const lane = resolveAnswerLaneConfig({ visibleEnabled: false, draftFnAvailable: false })
+    expect(lane.state).toBe('dormant')
+    expect(lane.minInitialChars).toBe(ANSWER_LANE_NEVER_OPENS)
+
+    const sendMessage = makeSendMessage()
+    const editMessageText = makeEditMessageText()
+    const stream = createAnswerStream({
+      chatId: 'chat1',
+      isPrivateChat: false,
+      minInitialChars: lane.minInitialChars,
+      throttleMs: 250,
+      sendMessage,
+      editMessageText,
+      // no sendMessageDraft — dormant lane has no transport
+    })
+
+    // A realistic full answer — 2000 chars, far above any normal threshold.
+    stream.update('The answer is '.repeat(150))
+    vi.advanceTimersByTime(5000)
+    await flushMicrotasks()
+
+    expect(sendMessage).not.toHaveBeenCalled()
+    expect(editMessageText).not.toHaveBeenCalled()
+  })
+
   it('calls transport exactly once when text meets minInitialChars', async () => {
     const sendMessage = makeSendMessage()
     const editMessageText = makeEditMessageText()

package/telegram-plugin/tests/draft-retirement-wiring.test.ts

@@ -1,18 +1,24 @@
 /**
- * Draft-answer-lane retirement — gateway wiring guards (2026-06-05).
+ * Answer-lane wiring guards — draft retirement + flash decoupling.
  *
- * The retirement switches the live answer lane from the invisible compose-box
- * draft to a real, mtcute-observable edit-in-place message, default-on. The
- * design review flagged two ways this silently breaks (gateway IIFE can't be
- * instantiated in-process, so these are source-level assertions, same pattern as
- * silence-liveness-wiring.test):
+ * History:
+ *  - v0.14.52 turned the VISIBLE answer-stream OFF by default to remove the
+ *    "raw preview appears, formatted reply lands, raw preview deleted" flash.
+ *  - v0.14.68 retired the invisible compose-box DRAFT transport. The original
+ *    wiring (and the first version of this test) conflated the two flags —
+ *    `ANSWER_STREAM_VISIBLE_ENABLED || DRAFT_ANSWER_LANE_RETIRED` — so retiring
+ *    the draft (default) silently forced a VISIBLE preview (minInitialChars:1)
+ *    even with the visible flag off, re-introducing the flash FLEET-WIDE
+ *    (v0.14.68 undid v0.14.52). The first revision of this file pinned that
+ *    conflation as a "guard" — i.e. it asserted the bug.
+ *  - 2026-06-05 flash-decouple: the VISIBLE preview now gates on the visible
+ *    flag ALONE; DRAFT_ANSWER_LANE_RETIRED controls only the TRANSPORT. With
+ *    defaults (visible off, draft retired) the lane is DORMANT — no preview, the
+ *    reply tool is the single formatted message, no flash. The no-reply text-only
+ *    answer is delivered by the turn-flush backstop (the pre-v0.14.68 path).
  *
- *  PRIMARY: drop sendMessageDraftFn but FORGET to flip minInitialChars to 1 →
- *  the lane becomes a total no-op (the MAX gate never opens it), losing ALL
- *  answer-lane status AND the #2169 onMetric silence-liveness reset.
- *  SECONDARY: flip the lane to visible but FORGET to broaden the
- *  materialize-as-answer guard → a text-only no-reply turn falls into retract()
- *  and deletes the user's only copy of the answer (a lost-answer bug).
+ * gateway IIFE can't be instantiated in-process, so these are source-level
+ * assertions (same pattern as silence-liveness-wiring.test).
  */
 import { describe, it, expect } from 'vitest'
 import { readFileSync } from 'node:fs'
@@ -20,8 +26,8 @@ import { resolve } from 'node:path'
 
 const gatewaySrc = readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf-8')
 
-describe('draft-retirement wiring', () => {
-  it('sendMessageDraftFn is gated on the retirement (the single chokepoint)', () => {
+describe('answer-lane wiring (draft retirement + flash decoupling)', () => {
+  it('sendMessageDraftFn is gated on the retirement (the single transport chokepoint)', () => {
     expect(gatewaySrc).toMatch(/!DRAFT_ANSWER_LANE_RETIRED && typeof _rawSendMessageDraft === 'function'/)
   })
 
@@ -32,19 +38,43 @@ describe('draft-retirement wiring', () => {
     expect(firstUseIdx).toBeGreaterThan(declIdx)
   })
 
-  it('PRIMARY GUARD: retired lane uses minInitialChars:1 (visible), never the MAX no-op gate', () => {
-    // The config must pick the {minInitialChars:1} branch when retired, so the
-    // lane actually opens a real message. The MAX branch is draft-only (legacy).
-    expect(gatewaySrc).toMatch(/ANSWER_STREAM_VISIBLE_ENABLED \|\| DRAFT_ANSWER_LANE_RETIRED\s*\n?\s*\?\s*\{ minInitialChars: 1 \}/)
+  it('the lane behaviour is resolved by the single-source-of-truth pure function', () => {
+    // The flag→config decision lives in resolveAnswerLaneConfig (total-enumerated
+    // in answer-stream-flag.test.ts); the gateway delegates so the three use-sites
+    // can never drift apart.
+    expect(gatewaySrc).toMatch(/const ANSWER_LANE = resolveAnswerLaneConfig\(\{/)
+    expect(gatewaySrc).toMatch(/visibleEnabled: ANSWER_STREAM_VISIBLE_ENABLED/)
+    expect(gatewaySrc).toMatch(/draftFnAvailable: sendMessageDraftFn != null/)
   })
 
-  it('SECONDARY GUARD: the materialize-as-answer guard is broadened in lockstep', () => {
-    // A text-only no-reply turn must materialize (ping + delete preview), not
-    // retract() the answer away.
-    expect(gatewaySrc).toMatch(/\(ANSWER_STREAM_VISIBLE_ENABLED \|\| DRAFT_ANSWER_LANE_RETIRED\)\s*\n?\s*&& !turn\.replyCalled/)
+  it('FLASH GUARD: the createAnswerStream config is driven by ANSWER_LANE (preview gated on the visible flag alone)', () => {
+    // The minInitialChars / draft-transport choice comes from the resolved lane,
+    // never from a `visible || retired` inline conflation.
+    expect(gatewaySrc).toMatch(/\.\.\.\(ANSWER_LANE\.usesDraftTransport/)
+    expect(gatewaySrc).toMatch(/minInitialChars: ANSWER_LANE\.minInitialChars/)
   })
 
-  it('the #2169 onMetric silence-liveness reset is preserved (fires on visible sends now)', () => {
+  it('FLASH GUARD: the visible-OR-retired conflation is GONE everywhere (it pinned the flash)', () => {
+    // No answer-lane path may re-introduce `VISIBLE || RETIRED` — that is the
+    // exact regression this fix removes.
+    expect(gatewaySrc).not.toMatch(/ANSWER_STREAM_VISIBLE_ENABLED \|\| DRAFT_ANSWER_LANE_RETIRED/)
+  })
+
+  it('LOST-ANSWER GUARD: materialize-as-answer gates on ANSWER_LANE.opensVisiblePreview (only fires when a preview actually opened)', () => {
+    // A text-only no-reply turn materializes (ping + keep) ONLY when a visible
+    // preview opened. With visible off the lane is dormant (minInitialChars:MAX),
+    // so this branch is unreachable and the answer is delivered by turn-flush
+    // instead — never retracted away.
+    expect(gatewaySrc).toMatch(/\n\s*ANSWER_LANE\.opensVisiblePreview\s*\n\s*&& !turn\.replyCalled/)
+  })
+
+  it('LOST-ANSWER GUARD: turn-flush is skipped ONLY when the stream finalized as the answer (so dormant-lane no-reply turns still flush)', () => {
+    // flushDecision skips only on streamFinalizedAsAnswer; with the lane dormant
+    // that stays false, so decideTurnFlush runs and delivers the no-reply answer.
+    expect(gatewaySrc).toMatch(/const flushDecision = streamFinalizedAsAnswer\s*\n?\s*\?/)
+  })
+
+  it('the #2169 onMetric silence-liveness reset is still wired (fires on visible sends when opted in)', () => {
     const onMetric = (gatewaySrc.split('onMetric: (metricEv) => {')[1] ?? '').split('\n            },')[0]
     expect(onMetric).toMatch(/silencePoke\.noteProduction/)
     expect(onMetric).toMatch(/currentTurn === turn/)

package/telegram-plugin/tests/text-voice-scrub.test.ts

@@ -172,3 +172,92 @@ describe('scrubVoice — em / en dash replacement', () => {
     })
   })
 })
+
+describe('scrubVoice — leading sycophancy openers', () => {
+  beforeEach(() => {
+    delete process.env.SWITCHROOM_DISABLE_VOICE_SCRUB
+  })
+  afterEach(() => {
+    delete process.env.SWITCHROOM_DISABLE_VOICE_SCRUB
+  })
+
+  it('strips a leading "You\'re absolutely right" and recapitalizes', () => {
+    const r = scrubVoice("You're absolutely right, the build is broken.")
+    expect(r.scrubbed).toBe('The build is broken.')
+    expect(r.openersStripped).toBe(1)
+    expect(r.replaced).toBeGreaterThan(0) // total counts the opener
+  })
+
+  it('strips the affirmation even when only an opener changed (no dashes)', () => {
+    // Regression: the gateway gates on `replaced > 0`; an opener-only
+    // strip MUST still report replaced > 0 or the scrub is discarded.
+    const r = scrubVoice('Great catch! I fixed the off-by-one.')
+    expect(r.scrubbed).toBe('I fixed the off-by-one.')
+    expect(r.replaced).toBe(1)
+    expect(r.openersStripped).toBe(1)
+  })
+
+  it('consumes a trailing em-dash after the opener (no leftover dash)', () => {
+    const r = scrubVoice('Exactly right — the token had expired.')
+    expect(r.scrubbed).toBe('The token had expired.')
+    expect(r.openersStripped).toBe(1)
+  })
+
+  it('handles curly apostrophe and "you are" form', () => {
+    expect(scrubVoice('You’re absolutely right. Done.').scrubbed).toBe('Done.')
+    expect(scrubVoice('You are absolutely right, done.').scrubbed).toBe('Done.')
+  })
+
+  it('leaves a standalone affirmation ack intact (no content follows)', () => {
+    const r = scrubVoice("You're absolutely right!")
+    expect(r.scrubbed).toBe("You're absolutely right!")
+    expect(r.openersStripped).toBe(0)
+  })
+
+  it('does NOT strip bare "you\'re right" (often load-bearing)', () => {
+    const r = scrubVoice("You're right that the config drifted.")
+    expect(r.scrubbed).toBe("You're right that the config drifted.")
+    expect(r.openersStripped).toBe(0)
+  })
+
+  it('does NOT strip an affirmation mid-message', () => {
+    const r = scrubVoice('I checked the logs. Great catch on the typo.')
+    expect(r.scrubbed).toBe('I checked the logs. Great catch on the typo.')
+    expect(r.openersStripped).toBe(0)
+  })
+
+  it('does NOT over-strip when the phrase is a literal sentence start (no separator)', () => {
+    // The affirmation must be followed by a separator/end, not a bare
+    // space into more words — otherwise "Spot on the map..." loses "Spot
+    // on". These are real sentences, not detachable affirmations.
+    for (const s of [
+      'Spot on the map shows three sites.',
+      'Good catch basin overflow is the root cause.',
+      'Exactly right now, the count is 3.',
+      'Absolutely right turns are banned on that road.',
+    ]) {
+      const r = scrubVoice(s)
+      expect(r.scrubbed, s).toBe(s)
+      expect(r.openersStripped, s).toBe(0)
+    }
+  })
+
+  it('still strips when a separator follows (comma / period / dash)', () => {
+    expect(scrubVoice('Spot on, the value is 5.').scrubbed).toBe('The value is 5.')
+    expect(scrubVoice('Good catch. Fixed it.').scrubbed).toBe('Fixed it.')
+  })
+
+  it('does not touch an opener-like phrase inside code', () => {
+    const r = scrubVoice('`spot on` is the variable name. Here is the value.')
+    expect(r.scrubbed).toContain('`spot on`')
+    expect(r.openersStripped).toBe(0)
+  })
+
+  it('kill switch disables opener strip too', () => {
+    process.env.SWITCHROOM_DISABLE_VOICE_SCRUB = '1'
+    const r = scrubVoice("You're absolutely right, the build is broken.")
+    expect(r.scrubbed).toBe("You're absolutely right, the build is broken.")
+    expect(r.replaced).toBe(0)
+    expect(r.openersStripped).toBe(0)
+  })
+})

package/telegram-plugin/text-voice-scrub.ts

@@ -12,13 +12,22 @@
  * owns enforcement, soft instructions fail under load. Make the
  * framework do it.
  *
- * Scope. Em / en dashes only. The wider "AI-tell phrase denylist"
- * (smoking gun, by design, etc.) was scoped OUT after data showed
- * those phrases land in <0.5% of fleet messages and substituting
- * them risks semantic loss. Em-dash → comma/period is a pure
- * mechanical transform with no semantic loss when the surrounding
- * text is whitespace-separated prose, and a no-op when the dash
- * is inside code or a URL.
+ * Scope. Two mechanical transforms, both semantically safe:
+ *   1. Em / en dashes -> comma/period/hyphen. Pure transform with no
+ *      semantic loss on whitespace-separated prose; a no-op inside code
+ *      or a URL.
+ *   2. Leading sycophancy openers ("You're absolutely right", "Great
+ *      catch", "Exactly right") -> deleted, next word recapitalized. A
+ *      leading pure-affirmation clause carries near-zero meaning, so
+ *      removing it strips the AI-tell without touching the substance.
+ *      Conservative by construction: only at the very start, only the
+ *      known affirmation set, only when real content follows (a
+ *      standalone "You're absolutely right!" ack is left intact).
+ *
+ * Still scoped OUT: the wider mid-sentence "AI-tell phrase denylist"
+ * (smoking gun, delve, etc.). Substituting those mid-clause risks
+ * semantic loss, so they stay with the prompt-side voice guidance
+ * (the turn-pacing VOICE directive), not this mechanical gate.
  *
  * Pipeline integration. Apply BEFORE markdownToHtml so the scrub
  * runs on the original model text, not on rendered HTML where
@@ -46,10 +55,17 @@ export interface VoiceScrubResult {
   /** The scrubbed text. Equal to input when no replacements made or
    *  when the kill switch is set. */
   scrubbed: string
-  /** Count of dash replacements made across the whole input. Surfaces
-   *  to the runtime-metrics fan-out so the cadence dashboard can track
-   *  fleet-wide voice-scrub rate over time. */
+  /** TOTAL voice changes across the whole input = dash replacements +
+   *  leading-affirmation strips. Callers gate on `replaced > 0` to decide
+   *  whether to apply `scrubbed`, so this MUST count every change (an
+   *  opener-only strip with zero dashes still needs `replaced > 0`).
+   *  Surfaces to the runtime-metrics fan-out as the fleet voice-scrub
+   *  rate. */
   replaced: number
+  /** Breakdown: leading sycophancy openers stripped (subset of
+   *  `replaced`). Lets the dashboard separate opener-strips from dash
+   *  fixes. */
+  openersStripped: number
 }
 
 const NULL = '\x00'
@@ -66,6 +82,44 @@ function enabled(): boolean {
   return !(v === '1' || v === 'true')
 }
 
+/**
+ * Leading sycophancy/affirmation openers. Matched ONLY at the very start
+ * of the message, ONLY this known pure-filler set, and the trailing
+ * punctuation/separators (incl. em/en dash) are consumed with it.
+ *
+ * Deliberately excludes bare "you're right" (often load-bearing, e.g.
+ * "you're right that X") and "great/good question" (overlaps the
+ * legitimate short-ack pattern). Kept to phrases whose only content is
+ * the affirmation itself. Apostrophe matches straight or curly.
+ *
+ * The affirmation must be followed by end-of-string OR a clause/sentence
+ * separator (punctuation, possibly with surrounding whitespace) — NOT a
+ * bare space into more words. This is what stops over-strips like
+ * "Spot on the map shows...", "Good catch basin overflow...", "Exactly
+ * right now, the count is 3" — there the phrase is a literal sentence
+ * start, not a detachable affirmation. "Spot on, the value is 5" (comma)
+ * still strips.
+ */
+const LEADING_AFFIRMATION_RE =
+  /^(\s*)(you(?:['’]| a)re absolutely right|you(?:['’]| a)re so right|you(?:['’]| a)re absolutely correct|absolutely right|exactly right|great catch|good catch|nice catch|spot on)\b(?:\s*$|\s*[!.,;:—–-][\s!.,;:—–-]*)/i
+
+/**
+ * Strip a single leading affirmation opener and recapitalize the next
+ * word. No-op (count 0) when there's no match, or when stripping would
+ * leave no substantive content (a standalone affirmation ack survives).
+ */
+function stripLeadingAffirmation(text: string): { out: string; count: number } {
+  const m = LEADING_AFFIRMATION_RE.exec(text)
+  if (!m) return { out: text, count: 0 }
+  const leadingWs = m[1] ?? ''
+  const rest = text.slice(m[0].length)
+  if (rest.trim().length === 0) return { out: text, count: 0 }
+  // Recapitalize the first alphabetic char of the remainder so the new
+  // opening word reads as a sentence start.
+  const recapped = rest.replace(/^(\s*)([a-z])/, (_m, ws: string, ch: string) => ws + ch.toUpperCase())
+  return { out: leadingWs + recapped, count: 1 }
+}
+
 /**
  * Park code-like regions behind placeholders so the dash-replacement
  * pass can't touch them. Returns the parked-string and the original
@@ -179,8 +233,13 @@ function replaceDashes(text: string): { out: string; replaced: number } {
 }
 
 /**
- * Public entry: scrub em / en dashes from outbound text while
- * preserving dashes inside code and URLs.
+ * Public entry: strip a leading sycophancy opener and scrub em/en dashes
+ * from outbound text, preserving anything inside code and URLs.
+ *
+ * Order: park code/URLs -> strip leading affirmation -> replace dashes ->
+ * restore. The opener strip runs on parked text so it can never touch a
+ * code region, and before the dash pass so a dash trailing the opener is
+ * consumed by the strip rather than converted.
  *
  * Pure: no IO, no module-scope state, deterministic. Kill switch is
  * checked per call so an operator can flip it via env var without a
@@ -188,12 +247,14 @@ function replaceDashes(text: string): { out: string; replaced: number } {
  */
 export function scrubVoice(text: string): VoiceScrubResult {
   if (!enabled() || text.length === 0) {
-    return { scrubbed: text, replaced: 0 }
+    return { scrubbed: text, replaced: 0, openersStripped: 0 }
   }
   const { parked, parts } = park(text)
-  const { out, replaced } = replaceDashes(parked)
-  if (replaced === 0) {
-    return { scrubbed: text, replaced: 0 }
+  const opener = stripLeadingAffirmation(parked)
+  const { out, replaced } = replaceDashes(opener.out)
+  const total = replaced + opener.count
+  if (total === 0) {
+    return { scrubbed: text, replaced: 0, openersStripped: 0 }
   }
-  return { scrubbed: restore(out, parts), replaced }
+  return { scrubbed: restore(out, parts), replaced: total, openersStripped: opener.count }
 }

package/telegram-plugin/uat/scenarios/fuzz-voice-scrub-dm.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Voice-scrub fuzz — end-to-end proof of the deterministic voice gate.
+ *
+ * The gateway's `scrubVoice` strips em/en dashes and leading sycophancy
+ * openers ("You're absolutely right", "Great catch", ...) from every
+ * outbound reply. This fuzz file drives REAL Telegram inbounds engineered
+ * to bait those exact AI-tells (statements the agent will want to affirm;
+ * prose asks where models reach for em-dashes) and asserts the observed
+ * reply carries neither.
+ *
+ * Why this is a good UAT target: unlike the grounding/voice PROMPT
+ * guidance (soft, semantic, not cleanly observable), the scrub is a
+ * deterministic transform on the wire, so mtcute's view of the sent
+ * message is ground truth. If an em-dash or a leading affirmation reaches
+ * the user, the gate failed.
+ *
+ * Self-skips green when the harness can't spin up (env unwired) — same as
+ * the sibling fuzz files; uat/** is excluded from gating CI.
+ */
+
+import { describe, it, expect } from "vitest";
+import { spinUp } from "../harness.js";
+
+interface VoiceCase {
+  name: string;
+  prompt: string;
+  timeout: number;
+}
+
+// Prompts engineered to bait the two AI-tells the gate removes.
+const VOICE_CASES: readonly VoiceCase[] = [
+  // ── Bait leading affirmation: an assertion the agent will agree with ──
+  { name: "affirm-bait: await", prompt: "I'm pretty sure the bug is a missing await on the handler. Am I right?", timeout: 60_000 },
+  { name: "affirm-bait: timezone", prompt: "So the off-by-one is just a timezone offset, correct?", timeout: 60_000 },
+  { name: "affirm-bait: cache", prompt: "I worked out it's the cache not invalidating. Good call on my part, no?", timeout: 60_000 },
+  { name: "affirm-bait: restart", prompt: "To pick up the new config I just need to restart the process, yeah?", timeout: 60_000 },
+  { name: "affirm-bait: correction", prompt: "Actually I think 2 + 2 is 4, not 5 like I said before. Right?", timeout: 60_000 },
+  { name: "affirm-bait: praise-fish", prompt: "I refactored it into one pure function. Pretty clean solution, right?", timeout: 60_000 },
+
+  // ── Bait em-dashes: prose explanations / tradeoff asks ──
+  { name: "dash-bait: tradeoff", prompt: "In a sentence or two, what's the tradeoff between threads and async?", timeout: 60_000 },
+  { name: "dash-bait: definition", prompt: "Explain what a closure is, briefly, in your own words.", timeout: 60_000 },
+  { name: "dash-bait: contrast", prompt: "Quick: difference between TCP and UDP, a couple sentences.", timeout: 60_000 },
+  { name: "dash-bait: aside", prompt: "Give me a one-line summary of what a load balancer does, with the nuance.", timeout: 60_000 },
+  { name: "dash-bait: list-prose", prompt: "What are the two biggest risks of caching, written as flowing prose not bullets?", timeout: 60_000 },
+
+  // ── Combined: agree AND explain (both tells in one reply) ──
+  { name: "combo: agree+explain", prompt: "I think REST is simpler than GraphQL for small apps. Agree? Explain why in a couple sentences.", timeout: 60_000 },
+];
+
+const TYPO_DASH_RE = /[—–]/; // em-dash, en-dash
+
+// Mirrors the gateway scrubber's exact strip condition (affirmation +
+// separator/end). Asserting THIS, not a looser "starts with the word",
+// keeps the UAT a reliable regression test of the deterministic gate: it
+// fails only when a strippable opener actually survived to the user, not
+// when the soft prompt layer emits a non-strippable variant.
+const LEADING_AFFIRMATION_RE =
+  /^(you(?:['’]| a)re absolutely right|you(?:['’]| a)re so right|you(?:['’]| a)re absolutely correct|absolutely right|exactly right|great catch|good catch|nice catch|spot on)\b(?:\s*$|\s*[!.,;:—–-])/i;
+
+describe("uat: voice-scrub fuzz — no em-dashes, no sycophancy openers reach the user", () => {
+  for (const vc of VOICE_CASES) {
+    it(
+      `[voice] ${vc.name} — reply is dash-free and affirmation-free`,
+      async () => {
+        const sc = await spinUp({ agent: "test-harness" });
+        try {
+          await sc.sendDM(vc.prompt);
+          const reply = await sc.expectMessage(/\S/, {
+            from: "bot",
+            timeout: vc.timeout,
+          });
+          const text = reply.text ?? "";
+
+          // Invariant 1: non-empty reply (user not ghosted).
+          expect(text.trim().length).toBeGreaterThan(0);
+
+          // Invariant 2: no typographic em/en dash reached the user.
+          // The scrubber converts every surviving dash outside code to a
+          // comma/period/hyphen, so any [—–] in the wire text is
+          // a gate miss. (Em-dash-inside-code is astronomically unlikely
+          // for these prose/agreement prompts.)
+          if (TYPO_DASH_RE.test(text)) {
+            throw new Error(
+              `[voice] ${vc.name}: em/en dash reached the user (scrub miss). `
+              + `Reply: ${JSON.stringify(text.slice(0, 400))}`,
+            );
+          }
+
+          // Invariant 3: reply does not OPEN with a sycophancy affirmation.
+          if (LEADING_AFFIRMATION_RE.test(text.trim())) {
+            throw new Error(
+              `[voice] ${vc.name}: reply opened with a stripped-class affirmation. `
+              + `Reply: ${JSON.stringify(text.slice(0, 200))}`,
+            );
+          }
+        } finally {
+          await sc.tearDown();
+        }
+      },
+      vc.timeout + 30_000,
+    );
+  }
+});