switchroom 0.14.66 → 0.14.68

package/dist/cli/ui/index.html

@@ -409,7 +409,7 @@
     <button id="tab-agents" onclick="switchTab('agents')">Agents</button>
     <button id="tab-accounts" onclick="switchTab('accounts')">Accounts</button>
     <button id="tab-system" onclick="switchTab('system')">System</button>
-    <button id="tab-google" onclick="switchTab('google')">Google</button>
+    <button id="tab-connections" onclick="switchTab('connections')">Connections</button>
     <button id="tab-schedule" onclick="switchTab('schedule')">Schedule</button>
     <button id="tab-approvals" onclick="switchTab('approvals')">Approvals</button>
   </nav>
@@ -419,7 +419,7 @@
     <div id="agents" style="display:none" class="loading">Loading agents...</div>
     <div id="accounts" style="display:none"></div>
     <div id="system" style="display:none"></div>
-    <div id="google" style="display:none"></div>
+    <div id="connections" style="display:none"></div>
     <div id="schedule" style="display:none"></div>
     <div id="approvals" style="display:none"></div>
   </main>
@@ -493,14 +493,17 @@
       }
     }
 
-    async function fetchGoogleAccounts() {
+    async function fetchConnections() {
       try {
-        const res = await fetch(`${API}/api/google-accounts`, { headers: authHeaders() });
-        if (!res.ok) throw new Error(`HTTP ${res.status}`);
-        renderGoogleAccounts(await res.json());
+        const [google, microsoft, notion] = await Promise.all([
+          fetch(`${API}/api/google-accounts`, { headers: authHeaders() }).then(r => r.ok ? r.json() : []),
+          fetch(`${API}/api/microsoft-accounts`, { headers: authHeaders() }).then(r => r.ok ? r.json() : []),
+          fetch(`${API}/api/notion-workspace`, { headers: authHeaders() }).then(r => r.ok ? r.json() : { configured: false, databases: [] }),
+        ]);
+        renderConnections({ google, microsoft, notion });
         clearError();
       } catch (err) {
-        showError(`Failed to fetch Google accounts: ${err.message}`);
+        showError(`Failed to fetch connections: ${err.message}`);
       }
     }
 
@@ -527,7 +530,7 @@
     }
 
     function switchTab(tab) {
-      const tabs = ['summary', 'agents', 'accounts', 'system', 'google', 'schedule', 'approvals'];
+      const tabs = ['summary', 'agents', 'accounts', 'system', 'connections', 'schedule', 'approvals'];
       for (const t of tabs) {
         document.getElementById(`tab-${t}`).classList.toggle('active', tab === t);
         document.getElementById(t).style.display = tab === t ? '' : 'none';
@@ -535,7 +538,7 @@
       if (tab === 'summary') fetchSummary();
       if (tab === 'accounts') fetchAccounts();
       if (tab === 'system') fetchSystemHealth();
-      if (tab === 'google') fetchGoogleAccounts();
+      if (tab === 'connections') fetchConnections();
       if (tab === 'schedule') fetchSchedule();
       if (tab === 'approvals') fetchApprovals();
     }
@@ -988,37 +991,99 @@
       return String(ts).replace('T', ' ').replace(/\.\d+Z?$/, '').replace(/Z$/, '');
     }
 
-    function renderGoogleAccounts(rows) {
-      const container = document.getElementById('google');
-      if (!rows || rows.length === 0) {
-        container.innerHTML = '<div class="loading">No Google accounts. Add one under <code>google_accounts:</code> in switchroom.yaml and run <code>switchroom auth google account add</code>.</div>';
-        return;
+    const _dimC = (s) => `<span style="color:var(--text-dim)">${escapeHtml(s)}</span>`;
+
+    // One OAuth-account card (Google or Microsoft — same shape; Microsoft
+    // adds an account-type pill).
+    function renderOAuthAccountCard(a, opts) {
+      const expires = a.expiresAt ? formatTimestamp(a.expiresAt) : _dimC('—');
+      const known = a.brokerKnown
+        ? '<span class="usage-pill primary">slot present</span>'
+        : '<span style="color:var(--yellow)">config-only (no broker slot)</span>';
+      const acl = (a.enabledFor && a.enabledFor.length)
+        ? a.enabledFor.map(escapeHtml).join(', ')
+        : _dimC('no agents enabled');
+      const typePill = (opts && opts.showType && a.accountType)
+        ? `<span class="usage-pill" style="margin-left:.4rem">${escapeHtml(a.accountType)}</span>`
+        : '';
+      return `
+      <div class="account-card">
+        <div class="account-card-header">
+          <div class="account-label">${escapeHtml(a.account)}${typePill}</div>
+          <span style="margin-left:auto">${known}</span>
+        </div>
+        <div class="account-usage"><label style="color:var(--text-dim);opacity:.7">Enabled for: </label>${acl}</div>
+        <div class="card-meta" style="padding:0">
+          <div class="meta-item"><label>Expires </label><span>${expires}</span></div>
+          <div class="meta-item" title="${a.scope ? escapeHtml(a.scope) : ''}"><label>Scope </label><span>${a.scope ? escapeHtml(a.scope.split(' ').length + ' scope(s)') : _dimC('—')}</span></div>
+          <div class="meta-item"><label>Client </label><span>${a.clientId ? escapeHtml(a.clientId.slice(0, 16) + '…') : _dimC('—')}</span></div>
+        </div>
+      </div>`;
+    }
+
+    function _connectionSection(title, emptyHtml, cardsHtml) {
+      return `
+        <div style="margin-bottom:1.5rem">
+          <h3 style="margin:0 0 .6rem;font-size:.95rem;color:var(--text-dim);text-transform:uppercase;letter-spacing:.04em">${title}</h3>
+          ${cardsHtml ? `<div class="accounts-grid">${cardsHtml}</div>` : `<div class="loading" style="padding:.8rem">${emptyHtml}</div>`}
+        </div>`;
+    }
+
+    // Unified external-connections view: Google + Microsoft accounts and
+    // the Notion workspace, each showing which agents have access.
+    function renderConnections(data) {
+      const container = document.getElementById('connections');
+      const google = data.google || [];
+      const microsoft = data.microsoft || [];
+      const notion = data.notion || { configured: false, databases: [] };
+
+      const googleSection = _connectionSection(
+        'Google',
+        'No Google accounts. Add one under <code>google_accounts:</code> and run <code>switchroom auth google account add</code>.',
+        google.map(a => renderOAuthAccountCard(a, { showType: false })).join(''),
+      );
+
+      const microsoftSection = _connectionSection(
+        'Microsoft 365',
+        'No Microsoft accounts. Connect one from Telegram with <code>/connect microsoft</code> (admin DM), or <code>switchroom auth microsoft account add</code>.',
+        microsoft.map(a => renderOAuthAccountCard(a, { showType: true })).join(''),
+      );
+
+      let notionCards = '';
+      if (notion.configured) {
+        notionCards = (notion.databases || []).map(db => {
+          const acl = (db.enabledFor && db.enabledFor.length)
+            ? db.enabledFor.map(escapeHtml).join(', ')
+            : _dimC('no agents enabled');
+          return `
+          <div class="account-card">
+            <div class="account-card-header">
+              <div class="account-label">${escapeHtml(db.name)}</div>
+              <span style="margin-left:auto" class="usage-pill">database</span>
+            </div>
+            <div class="account-usage"><label style="color:var(--text-dim);opacity:.7">Enabled for: </label>${acl}</div>
+            <div class="card-meta" style="padding:0">
+              <div class="meta-item"><label>DB id </label><span>${escapeHtml(db.id.slice(0, 12))}…</span></div>
+            </div>
+          </div>`;
+        }).join('');
       }
-      const dim = (s) => `<span style="color:var(--text-dim)">${escapeHtml(s)}</span>`;
-      const cards = rows.map(a => {
-        const expires = a.expiresAt ? formatTimestamp(a.expiresAt) : dim('—');
-        const scope = a.scope ? escapeHtml(a.scope) : dim('broker offline');
-        const known = a.brokerKnown
-          ? '<span class="usage-pill primary">slot present</span>'
-          : '<span style="color:var(--yellow)">config-only (no broker slot)</span>';
-        const acl = (a.enabledFor && a.enabledFor.length)
-          ? a.enabledFor.map(escapeHtml).join(', ')
-          : dim('no agents enabled');
-        return `
-        <div class="account-card">
-          <div class="account-card-header">
-            <div class="account-label">${escapeHtml(a.account)}</div>
-            <span style="margin-left:auto">${known}</span>
-          </div>
-          <div class="account-usage"><label style="color:var(--text-dim);opacity:.7">Enabled for: </label>${acl}</div>
-          <div class="card-meta" style="padding:0">
-            <div class="meta-item"><label>Expires </label><span>${expires}</span></div>
-            <div class="meta-item" title="${a.scope ? escapeHtml(a.scope) : ''}"><label>Scope </label><span>${a.scope ? escapeHtml(a.scope.split(' ').length + ' scope(s)') : dim('—')}</span></div>
-            <div class="meta-item"><label>Client </label><span>${a.clientId ? escapeHtml(a.clientId.slice(0, 16) + '…') : dim('—')}</span></div>
-          </div>
+      const notionTitle = 'Notion' + (notion.configured && notion.vaultKey ? ` <span style="text-transform:none;font-weight:400">· token <code>${escapeHtml(notion.vaultKey)}</code></span>` : '');
+      const fullAccessBanner = (notion.fullAccessAgents && notion.fullAccessAgents.length)
+        ? `<div style="margin:0 0 .6rem;font-size:.85rem;color:var(--text-dim)">Full access (all databases): ${notion.fullAccessAgents.map(escapeHtml).join(', ')}</div>`
+        : '';
+      const notionBody = notionCards
+        ? `<div class="accounts-grid">${notionCards}</div>`
+        : `<div class="loading" style="padding:.8rem">${notion.configured
+            ? 'Notion configured but no databases declared. Add them under <code>notion_workspace.databases:</code>.'
+            : 'Notion not configured. See <code>docs/notion-integration.md</code>.'}</div>`;
+      const notionSection = `
+        <div style="margin-bottom:1.5rem">
+          <h3 style="margin:0 0 .6rem;font-size:.95rem;color:var(--text-dim);text-transform:uppercase;letter-spacing:.04em">${notionTitle}</h3>
+          ${fullAccessBanner}${notionBody}
         </div>`;
-      }).join('');
-      container.innerHTML = `<div class="accounts-grid">${cards}</div>`;
+
+      container.innerHTML = googleSection + microsoftSection + notionSection;
     }
 
     function renderSchedule(data) {

package/package.json

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

@@ -16,3 +16,22 @@ export function parseVisibleAnswerStreamEnabled(raw: string | undefined): boolea
   const v = raw.trim().toLowerCase()
   return v === '1' || v === 'true' || v === 'on' || v === 'yes'
 }
+
+/**
+ * Draft-answer-lane retirement (2026-06-05). The compose-box draft transport
+ * (`sendMessageDraft`) is invisible to the mtcute UAT harness, so the live
+ * answer-stream surface couldn't be tested. Retired by DEFAULT: the answer lane
+ * now opens a real, observable edit-in-place message instead of the compose-box
+ * draft (and the onMetric silence-liveness reset from #2169 now fires on visible
+ * sends in BOTH DMs and supergroups, not just DM drafts). Kill switch
+ * `SWITCHROOM_DRAFT_ANSWER_LANE=0` (also false/off/no) restores the legacy
+ * invisible draft.
+ *
+ * Returns true when the draft lane is RETIRED (the default — env unset or any
+ * truthy value); false only for an explicit disable of the retirement.
+ */
+export function parseDraftLaneRetiredEnabled(raw: string | undefined): boolean {
+  if (raw == null) return true
+  const v = raw.trim().toLowerCase()
+  return !(v === '0' || v === 'false' || v === 'off' || v === 'no')
+}

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

@@ -39034,6 +39034,13 @@ function noteOutbound2(key, now) {
   s.lastOutboundAt = now;
   s.fallbackFired = false;
 }
+function noteProduction(key, now) {
+  const s = state2.get(key);
+  if (s == null)
+    return;
+  s.lastOutboundAt = now;
+  s.fallbackFired = false;
+}
 function noteThinking(key, now) {
   const s = state2.get(key);
   if (s == null)
@@ -39754,6 +39761,12 @@ function parseVisibleAnswerStreamEnabled(raw) {
   const v = raw.trim().toLowerCase();
   return v === "1" || v === "true" || v === "on" || v === "yes";
 }
+function parseDraftLaneRetiredEnabled(raw) {
+  if (raw == null)
+    return true;
+  const v = raw.trim().toLowerCase();
+  return !(v === "0" || v === "false" || v === "off" || v === "no");
+}
 
 // pty-tail.ts
 var import_headless = __toESM(require_xterm_headless(), 1);
@@ -52763,11 +52776,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.66";
-var COMMIT_SHA = "0f4f029d";
-var COMMIT_DATE = "2026-06-05T07:05:45Z";
-var LATEST_PR = 2167;
-var COMMITS_AHEAD_OF_TAG = 2;
+var VERSION = "0.14.68";
+var COMMIT_SHA = "4f371b79";
+var COMMIT_DATE = "2026-06-05T10:24:42Z";
+var LATEST_PR = 2174;
+var COMMITS_AHEAD_OF_TAG = 3;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -53567,6 +53580,7 @@ var TOPIC_ID = process.env.TELEGRAM_TOPIC_ID ? Number(process.env.TELEGRAM_TOPIC
 var AGENT_ADMIN = process.env.SWITCHROOM_AGENT_ADMIN === "true";
 var bot = new import_grammy9.Bot(TOKEN);
 installTgPostLogger(bot);
+var DRAFT_ANSWER_LANE_RETIRED = parseDraftLaneRetiredEnabled(process.env.SWITCHROOM_DRAFT_ANSWER_LANE);
 var _rawSendMessageDraft = bot.api.raw.sendMessageDraft;
 var GRAMMY_VERSION = (() => {
   try {
@@ -53576,7 +53590,7 @@ var GRAMMY_VERSION = (() => {
     return "unknown";
   }
 })();
-var sendMessageDraftFn = typeof _rawSendMessageDraft === "function" ? (chatId, draftId, text, params) => _rawSendMessageDraft({
+var sendMessageDraftFn = !DRAFT_ANSWER_LANE_RETIRED && typeof _rawSendMessageDraft === "function" ? (chatId, draftId, text, params) => _rawSendMessageDraft({
   chat_id: Number(chatId),
   draft_id: draftId,
   text,
@@ -54075,7 +54089,7 @@ function findLatestEndedTurnForChat(chatId) {
   return latest;
 }
 function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, liveTurn, surface) {
-  const recovered = LATE_REPLY_TOPIC_RECOVERY_ENABLED && explicitThreadId == null && originTurn == null && liveTurn?.sessionThreadId == null ? findLatestEndedTurnForChat(chatId) : null;
+  const recovered = LATE_REPLY_TOPIC_RECOVERY_ENABLED && explicitThreadId == null && originTurn == null && liveTurn == null ? findLatestEndedTurnForChat(chatId) : null;
   const threadId = resolveAnswerThreadId({
     explicitThreadId,
     originResolved: originTurn != null,
@@ -55260,6 +55274,7 @@ function parsePositiveMsEnv(name, fallbackMs) {
 var SILENCE_FALLBACK_MS = parsePositiveMsEnv("SWITCHROOM_SILENCE_FALLBACK_MS", 300000);
 var SILENCE_FALLBACK_HARD_MS = parsePositiveMsEnv("SWITCHROOM_SILENCE_FALLBACK_HARD_MS", 900000);
 var SILENCE_DEFER_INFLIGHT_TOOLS = process.env.SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS === "1";
+var SILENCE_LIVENESS_PRODUCTION = process.env.SWITCHROOM_SILENCE_LIVENESS_PRODUCTION !== "0";
 startTimer({
   thresholdsMs: { fallback: SILENCE_FALLBACK_MS, fallbackHardCeiling: SILENCE_FALLBACK_HARD_MS },
   deferFallbackWhileToolInFlight: SILENCE_DEFER_INFLIGHT_TOOLS,
@@ -55351,8 +55366,11 @@ startTimer({
       const sib = silenceMsForKey(siblingKey, fbNow);
       return sib == null || sib >= DEFAULT_THRESHOLDS.fallback;
     });
-    if (turnMatchesFallback && currentTurn === wedgedTurn)
+    if (turnMatchesFallback && currentTurn === wedgedTurn && wedgedTurn != null) {
+      process.stderr.write(`telegram gateway: ${formatTurnLifecycle("clear", "silence_fallback", wedgedTurn, Date.now())}
+`);
       currentTurn = null;
+    }
     try {
       clearSilentEndState(fbKey);
     } catch {}
@@ -58076,6 +58094,9 @@ function handleSessionEvent(ev) {
       const rendered = appendActivityLabel(turn.mirrorLines, ev.label);
       if (rendered != null) {
         turn.lastToolLabelAt = Date.now();
+        if (SILENCE_LIVENESS_PRODUCTION && currentTurn === turn) {
+          noteProduction(statusKey(turn.sessionChatId, turn.sessionThreadId), Date.now());
+        }
         turn.activityPendingRender = composeTurnActivity(turn) ?? rendered;
         if (turn.activityInFlight == null) {
           turn.activityInFlight = drainActivitySummary(turn);
@@ -58092,7 +58113,7 @@ function handleSessionEvent(ev) {
             chatId: turn.sessionChatId,
             isPrivateChat: turn.isDm,
             threadId: turn.sessionThreadId,
-            ...ANSWER_STREAM_VISIBLE_ENABLED ? { minInitialChars: 1 } : { sendMessageDraft: sendMessageDraftFn, minInitialChars: Number.MAX_SAFE_INTEGER },
+            ...ANSWER_STREAM_VISIBLE_ENABLED || DRAFT_ANSWER_LANE_RETIRED ? { minInitialChars: 1 } : { sendMessageDraft: sendMessageDraftFn, minInitialChars: Number.MAX_SAFE_INTEGER },
             sendMessage: async (chatId, text, params) => {
               const tid = params?.message_thread_id;
               const silent = params?.purpose !== "materialize";
@@ -58130,6 +58151,9 @@ function handleSessionEvent(ev) {
               logStreamingEvent(metricEv);
               if (currentTurn === turn) {
                 noteSignal(statusKey(turn.sessionChatId, turn.sessionThreadId), Date.now());
+                if (SILENCE_LIVENESS_PRODUCTION) {
+                  noteProduction(statusKey(turn.sessionChatId, turn.sessionThreadId), Date.now());
+                }
               }
             },
             checkDedup: (text) => {
@@ -58221,7 +58245,7 @@ function handleSessionEvent(ev) {
         const stream = turn.answerStream;
         const streamedMsgId = stream.messageId();
         const streamedFinalText = turn.capturedText.join("").trim();
-        if (ANSWER_STREAM_VISIBLE_ENABLED && !turn.replyCalled && streamedMsgId != null && streamedFinalText.length > 0) {
+        if ((ANSWER_STREAM_VISIBLE_ENABLED || DRAFT_ANSWER_LANE_RETIRED) && !turn.replyCalled && streamedMsgId != null && streamedFinalText.length > 0) {
           turn.answerStream = null;
           streamFinalizedAsAnswer = true;
           turn.finalAnswerDelivered = true;
@@ -64557,7 +64581,7 @@ var didOneTimeSetup = false;
           }
         }
       }
-      process.stderr.write(`telegram gateway: answer-stream draft transport=${sendMessageDraftFn != null ? "available" : "unavailable"} grammy=${GRAMMY_VERSION}
+      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: 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 } from '../answer-stream-flag.js'
+import { parseVisibleAnswerStreamEnabled, parseDraftLaneRetiredEnabled } from '../answer-stream-flag.js'
 import { type SessionEvent } from '../session-tail.js'
 import {
   shouldSuppressToolActivity,
@@ -678,6 +678,14 @@ const AGENT_ADMIN = process.env.SWITCHROOM_AGENT_ADMIN === 'true'
 const bot = new Bot(TOKEN)
 installTgPostLogger(bot)
 
+// Draft-answer-lane retirement (2026-06-05): default RETIRED so the live answer
+// lane uses a real, mtcute-observable message instead of the invisible
+// compose-box draft. Declared HERE (above the boot-probe block) because
+// `sendMessageDraftFn` below reads it — keep it above its first use to avoid a
+// temporal-dead-zone ReferenceError at boot. Kill switch
+// SWITCHROOM_DRAFT_ANSWER_LANE=0 restores the legacy draft.
+const DRAFT_ANSWER_LANE_RETIRED = parseDraftLaneRetiredEnabled(process.env.SWITCHROOM_DRAFT_ANSWER_LANE)
+
 // ─── sendMessageDraft boot probe ──────────────────────────────────────────
 // grammY 1.x exposes all Telegram Bot API methods through bot.api.raw.
 // bot.api.sendMessageDraft (the typed wrapper) takes chat_id as number, but
@@ -695,7 +703,11 @@ const GRAMMY_VERSION: string = (() => {
 const sendMessageDraftFn: (
   (chatId: string, draftId: number, text: string, params?: { message_thread_id?: number; parse_mode?: 'HTML' }) => Promise<unknown>
 ) | undefined =
-  typeof _rawSendMessageDraft === 'function'
+  // When the draft lane is retired (default), force this undefined so BOTH
+  // consumers (the answer-stream config + the stream_reply handler) drop the
+  // draft transport and fall back to visible message transport — the single
+  // chokepoint for the retirement.
+  !DRAFT_ANSWER_LANE_RETIRED && typeof _rawSendMessageDraft === 'function'
     ? (chatId, draftId, text, params) =>
         (_rawSendMessageDraft as (args: Record<string, unknown>) => Promise<unknown>)({
           chat_id: Number(chatId),
@@ -1930,11 +1942,17 @@ function resolveAnswerThreadWithLog(
   liveTurn: CurrentTurn | null,
   surface: 'reply' | 'stream_reply',
 ): number | undefined {
+  // Recover ONLY for a genuinely LATE reply — no live turn at all. Gating on
+  // `liveTurn?.sessionThreadId == null` (the original) also fired for a
+  // threadless DM that still had a live turn, marking every DM reply
+  // `via=recovered`/RECOVERED in the telemetry (routing result unchanged —
+  // DM → undefined — but it drowned the real supergroup recoveries the marker
+  // exists to surface). `liveTurn == null` is the precise late-reply condition.
   const recovered =
     LATE_REPLY_TOPIC_RECOVERY_ENABLED &&
     explicitThreadId == null &&
     originTurn == null &&
-    liveTurn?.sessionThreadId == null
+    liveTurn == null
       ? findLatestEndedTurnForChat(chatId)
       : null
   const threadId = resolveAnswerThreadId({
@@ -4673,6 +4691,12 @@ function parsePositiveMsEnv(name: string, fallbackMs: number): number {
 const SILENCE_FALLBACK_MS = parsePositiveMsEnv('SWITCHROOM_SILENCE_FALLBACK_MS', 300_000)
 const SILENCE_FALLBACK_HARD_MS = parsePositiveMsEnv('SWITCHROOM_SILENCE_FALLBACK_HARD_MS', 900_000)
 const SILENCE_DEFER_INFLIGHT_TOOLS = process.env.SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS === '1'
+// Production-liveness (2026-06-05 UAT finding). Count an activity-feed render or
+// an answer-stream draft update as liveness for the silence clock, so a long
+// tool/composition turn that's visibly producing doesn't trip the 300s fallback
+// and null currentTurn mid-work. Default ON; SWITCHROOM_SILENCE_LIVENESS_PRODUCTION=0
+// restores the legacy "only a real reply resets the clock" behaviour.
+const SILENCE_LIVENESS_PRODUCTION = process.env.SWITCHROOM_SILENCE_LIVENESS_PRODUCTION !== '0'
 
 silencePoke.startTimer({
   thresholdsMs: { fallback: SILENCE_FALLBACK_MS, fallbackHardCeiling: SILENCE_FALLBACK_HARD_MS },
@@ -4889,7 +4913,16 @@ silencePoke.startTimer({
     // returns null and the regular teardown short-circuits. Without
     // this, the late event would re-emit `turn_ended` AND clobber
     // whatever fresh turn the next inbound started.
-    if (turnMatchesFallback && currentTurn === wedgedTurn) currentTurn = null
+    if (turnMatchesFallback && currentTurn === wedgedTurn && wedgedTurn != null) {
+      // Status-surface observability: emit the lifecycle CLEAR for the
+      // silence-poke teardown so a fallback-nulled turn has a turn-lifecycle
+      // line like every other clear path (the framework-fallback line below is
+      // its own format — this makes the dark-out greppable in the same shape).
+      process.stderr.write(
+        `telegram gateway: ${formatTurnLifecycle('clear', 'silence_fallback', wedgedTurn, Date.now())}\n`,
+      )
+      currentTurn = null
+    }
     // Best-effort: clear any pending silent-end marker so the Stop hook
     // doesn't double-block when claude eventually exits the wedged turn.
     try {
@@ -9452,6 +9485,16 @@ function handleSessionEvent(ev: SessionEvent): void {
         // the " · Ns" elapsed restarts from this step (and the feed itself just
         // advanced, so it isn't stale).
         turn.lastToolLabelAt = Date.now()
+        // Production-liveness: a NEW model-driven activity label is genuine
+        // liveness (the model emitted a new step), so reset the silence-poke
+        // clock — this is the safe site, NOT drainActivitySummary, because the
+        // framework feedHeartbeatTick also drains (climbing-elapsed re-renders)
+        // and would falsely reset the clock forever on a hung-mid-tool turn,
+        // reintroducing the #1556 dangling-turn wedge. Only the model emitting a
+        // fresh label reaches here.
+        if (SILENCE_LIVENESS_PRODUCTION && currentTurn === turn) {
+          silencePoke.noteProduction(statusKey(turn.sessionChatId, turn.sessionThreadId), Date.now())
+        }
         // Recompose so any active foreground sub-agent's nested block (Model A)
         // is preserved when the parent appends its own step. composeTurnActivity
         // == the flat render when no foreground sub-agent is active.
@@ -9514,7 +9557,13 @@ 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.)
-            ...(ANSWER_STREAM_VISIBLE_ENABLED
+            // 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 }),
             // #1075: route through robustApiCall so flood-wait,
@@ -9612,6 +9661,15 @@ function handleSessionEvent(ev: SessionEvent): void {
                   statusKey(turn.sessionChatId, turn.sessionThreadId),
                   Date.now(),
                 )
+                // Production-liveness: a draft update is the agent visibly
+                // composing — reset the silence-poke clock so a long
+                // compose-only turn (no tools, no reply yet) isn't torn down.
+                if (SILENCE_LIVENESS_PRODUCTION) {
+                  silencePoke.noteProduction(
+                    statusKey(turn.sessionChatId, turn.sessionThreadId),
+                    Date.now(),
+                  )
+                }
               }
             },
             // #646 — wire the shared outboundDedup into the answer-stream
@@ -9795,7 +9853,13 @@ function handleSessionEvent(ev: SessionEvent): void {
         const streamedMsgId = stream.messageId()
         const streamedFinalText = turn.capturedText.join('').trim()
         if (
-          ANSWER_STREAM_VISIBLE_ENABLED
+          // 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)
           && !turn.replyCalled
           && streamedMsgId != null
           && streamedFinalText.length > 0
@@ -20525,7 +20589,7 @@ void (async () => {
         }
       }
 
-      process.stderr.write(`telegram gateway: answer-stream draft transport=${sendMessageDraftFn != null ? 'available' : 'unavailable'} grammy=${GRAMMY_VERSION}\n`)
+      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`)
       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/silence-poke.ts

@@ -196,6 +196,31 @@ export function noteOutbound(key: string, now: number): void {
   s.fallbackFired = false
 }
 
+/**
+ * Record observable PRODUCTION that isn't a final reply — an activity-feed
+ * render (`→/✓` edit-in-place message) or an answer-stream draft update. Resets
+ * the silence clock exactly like a reply.
+ *
+ * Why this exists (2026-06-05): the header's "only a real reply counts; tool
+ * churn / the model ripping through 20 tool calls is still SILENT to the user"
+ * rule predates the live activity feed (#2162) and the compose draft. Those
+ * surfaces ARE user-visible now, so a turn actively rendering them is NOT
+ * silent — yet the 300s fallback (which nulls `currentTurn` and kills the very
+ * feed/draft the user is watching) still fired on a long tool/composition turn,
+ * darkening the live status mid-work. Counting production as liveness makes the
+ * fallback fire only on GENUINE silence (no reply, no feed, no draft, no tool
+ * events for the window) — a real wedge. A wedged agent produces nothing
+ * observable, so its clock is never reset and it still recovers.
+ *
+ * No-op when the kill switch is on or the key has no turn.
+ */
+export function noteProduction(key: string, now: number): void {
+  const s = state.get(key)
+  if (s == null) return
+  s.lastOutboundAt = now
+  s.fallbackFired = false
+}
+
 /**
  * Record a `thinking` session event. Used to pick "still thinking…" vs
  * "still working…" wording for the 300s framework fallback.

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

@@ -6,7 +6,7 @@
  */
 
 import { describe, it, expect } from 'vitest'
-import { parseVisibleAnswerStreamEnabled } from '../answer-stream-flag.js'
+import { parseVisibleAnswerStreamEnabled, parseDraftLaneRetiredEnabled } from '../answer-stream-flag.js'
 
 describe('parseVisibleAnswerStreamEnabled — default OFF, opt-in', () => {
   it('defaults OFF when unset', () => {
@@ -25,3 +25,21 @@ describe('parseVisibleAnswerStreamEnabled — default OFF, opt-in', () => {
     }
   })
 })
+
+describe('parseDraftLaneRetiredEnabled — default RETIRED (2026-06-05), kill-switch off', () => {
+  it('defaults to RETIRED (true) when unset — the draft lane is gone by default', () => {
+    expect(parseDraftLaneRetiredEnabled(undefined)).toBe(true)
+  })
+
+  it('stays RETIRED for any non-disable value (including unrecognized)', () => {
+    for (const v of ['1', 'true', 'on', 'yes', '', '   ', 'whatever', 'retired']) {
+      expect(parseDraftLaneRetiredEnabled(v)).toBe(true)
+    }
+  })
+
+  it('restores the legacy draft (false) ONLY on an explicit disable (case/space-insensitive)', () => {
+    for (const v of ['0', 'false', 'off', 'no', ' FALSE ', 'Off', 'NO']) {
+      expect(parseDraftLaneRetiredEnabled(v)).toBe(false)
+    }
+  })
+})

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

@@ -0,0 +1,52 @@
+/**
+ * Draft-answer-lane retirement — gateway wiring guards (2026-06-05).
+ *
+ * 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):
+ *
+ *  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).
+ */
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+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)', () => {
+    expect(gatewaySrc).toMatch(/!DRAFT_ANSWER_LANE_RETIRED && typeof _rawSendMessageDraft === 'function'/)
+  })
+
+  it('DRAFT_ANSWER_LANE_RETIRED is declared before its first use (no TDZ at boot)', () => {
+    const declIdx = gatewaySrc.indexOf('const DRAFT_ANSWER_LANE_RETIRED =')
+    const firstUseIdx = gatewaySrc.indexOf('!DRAFT_ANSWER_LANE_RETIRED && typeof _rawSendMessageDraft')
+    expect(declIdx).toBeGreaterThan(0)
+    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('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('the #2169 onMetric silence-liveness reset is preserved (fires on visible sends now)', () => {
+    const onMetric = (gatewaySrc.split('onMetric: (metricEv) => {')[1] ?? '').split('\n            },')[0]
+    expect(onMetric).toMatch(/silencePoke\.noteProduction/)
+    expect(onMetric).toMatch(/currentTurn === turn/)
+  })
+})