switchroom 0.16.15 → 0.16.16

package/dist/cli/switchroom.js

@@ -51692,8 +51692,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.16.15";
-var COMMIT_SHA = "a9c59169";
+var VERSION = "0.16.17";
+var COMMIT_SHA = "de202ab1";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {
@@ -77596,11 +77596,19 @@ async function injectInbound(agentsDir, agentName, chatId, threadId, text, promp
   });
 }
 async function handleHermesRest(method, pathname, config) {
-  if (method === "GET" && pathname === "/api/sessions") {
+  if (method === "GET" && (pathname === "/api/sessions" || pathname === "/api/profiles/sessions")) {
     const agents = await handleGetAgents(config);
-    const agentsDir = resolveAgentsDir(config);
     const sessions = agents.map((a) => toHermesSession(a, agentLiveness(config, a.name)));
-    return { status: 200, body: { sessions } };
+    return {
+      status: 200,
+      body: {
+        sessions,
+        total: sessions.length,
+        limit: sessions.length,
+        offset: 0,
+        profile_totals: { default: sessions.length }
+      }
+    };
   }
   const sessionMatch = pathname.match(/^\/api\/sessions\/([^/]+)$/);
   if (method === "GET" && sessionMatch) {
@@ -77639,15 +77647,38 @@ async function handleHermesRest(method, pathname, config) {
     };
   }
   if (method === "GET" && pathname === "/api/config") {
-    const agentNames = Object.keys(config.agents ?? {});
     return {
       status: 200,
       body: {
         provider: "switchroom",
-        agents: agentNames
+        model: null,
+        context_length: null,
+        system_prompt: null
       }
     };
   }
+  if (method === "GET" && (pathname === "/api/config/defaults" || pathname === "/api/config/schema")) {
+    return { status: 200, body: {} };
+  }
+  if (method === "GET" && pathname === "/api/model/info") {
+    return {
+      status: 200,
+      body: {
+        model: "claude",
+        provider: "switchroom",
+        capabilities: {}
+      }
+    };
+  }
+  if (method === "GET" && pathname.startsWith("/api/logs")) {
+    return { status: 200, body: { file: "gateway.log", lines: [] } };
+  }
+  if (method === "GET" && (pathname.startsWith("/api/cron") || pathname.startsWith("/api/messaging") || pathname.startsWith("/api/profiles") || pathname === "/api/memory/providers")) {
+    if (pathname.includes("sessions")) {
+      return { status: 200, body: { sessions: [], total: 0, limit: 0, offset: 0 } };
+    }
+    return { status: 200, body: {} };
+  }
   return null;
 }
 function sendEvent(ctx, type, sessionId, payload) {

package/dist/host-control/main.js

@@ -22587,7 +22587,7 @@ import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:f
 import { dirname as dirname4, join as join2 } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.16.15";
+var VERSION = "0.16.17";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.16.15",
+  "version": "0.16.16",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/answer-stream.ts

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

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

@@ -34032,6 +34032,40 @@ function createTypingWrapper(deps) {
   };
 }
 
+// gateway/turn-typing-loop.ts
+function createTurnTypingLoop(deps) {
+  const refreshMs = deps.refreshMs ?? 4000;
+  const intervals = new Map;
+  function stop(chatId, threadId = null) {
+    const key = deps.chatKey(chatId, threadId);
+    const iv = intervals.get(key);
+    if (iv != null) {
+      clearInterval(iv);
+      intervals.delete(key);
+    }
+  }
+  function start(chatId, threadId = null) {
+    stop(chatId, threadId);
+    const key = deps.chatKey(chatId, threadId);
+    const send = () => deps.sendChatAction(chatId, threadId);
+    send();
+    const iv = setInterval(send, refreshMs);
+    iv.unref?.();
+    intervals.set(key, iv);
+  }
+  function stopAll() {
+    for (const iv of [...intervals.values()])
+      clearInterval(iv);
+    intervals.clear();
+  }
+  return {
+    start,
+    stop,
+    stopAll,
+    activeCount: () => intervals.size
+  };
+}
+
 // draft-stream.ts
 var TELEGRAM_MAX_CHARS = 4096;
 var DEFAULT_DM_THROTTLE_MS = 400;
@@ -40362,6 +40396,7 @@ function createAnswerStream(config) {
     replyToMessageId,
     sendMessage,
     editMessageText,
+    renderText,
     onSuperseded,
     log,
     warn,
@@ -40370,6 +40405,7 @@ function createAnswerStream(config) {
     recordDedup,
     recordOutbound
   } = config;
+  const render = (text) => renderText != null ? renderText(text) : text;
   const effectiveThrottle = Math.max(250, throttleMs);
   let streamMsgId;
   let pendingText = null;
@@ -40404,6 +40440,7 @@ function createAnswerStream(config) {
     }
   }
   async function sendOrEditViaMessage(trimmed, gen, prevText) {
+    const rendered = render(trimmed);
     if (typeof streamMsgId === "number") {
       const editParams = {
         parse_mode: "HTML",
@@ -40412,7 +40449,7 @@ function createAnswerStream(config) {
       if (threadId != null)
         editParams.message_thread_id = threadId;
       try {
-        await editMessageText(chatId, streamMsgId, trimmed, editParams);
+        await editMessageText(chatId, streamMsgId, rendered, editParams);
         onMetric?.({ kind: "answer_lane_update", chatId, messageId: streamMsgId, charCount: trimmed.length, transport: "edit" });
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -40437,7 +40474,7 @@ function createAnswerStream(config) {
         sendParams.message_thread_id = threadId;
       if (replyToMessageId != null)
         sendParams.reply_parameters = { message_id: replyToMessageId };
-      const sent = await sendMessage(chatId, trimmed, sendParams);
+      const sent = await sendMessage(chatId, rendered, sendParams);
       const sentId = sent?.message_id;
       if (typeof sentId !== "number" || !Number.isFinite(sentId)) {
         warn?.("answer-stream: sendMessage returned no message_id");
@@ -40552,7 +40589,7 @@ function createAnswerStream(config) {
       if (threadId != null)
         sendParams.message_thread_id = threadId;
       try {
-        const sent = await sendMessage(chatId, textToSend, sendParams);
+        const sent = await sendMessage(chatId, render(textToSend), sendParams);
         const sentId = sent?.message_id;
         if (typeof sentId === "number" && Number.isFinite(sentId)) {
           streamMsgId = sentId;
@@ -43708,6 +43745,131 @@ function getOpenTags(html) {
   return tagStack;
 }
 
+// html-sanitize.ts
+var ALLOWED_TAGS2 = new Set([
+  "b",
+  "strong",
+  "i",
+  "em",
+  "u",
+  "ins",
+  "s",
+  "strike",
+  "del",
+  "a",
+  "code",
+  "pre",
+  "span",
+  "tg-spoiler",
+  "tg-emoji",
+  "blockquote"
+]);
+var ALLOWED_ATTRS2 = {
+  a: new Set(["href"]),
+  code: new Set(["class"]),
+  span: new Set(["class"]),
+  "tg-emoji": new Set(["emoji-id"]),
+  blockquote: new Set(["expandable"]),
+  pre: new Set(["language"])
+};
+var ALLOWED_HREF_SCHEMES2 = /^(?:https?|mailto|tel|tg):/i;
+function escapeAllHtml2(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function sanitizeTelegramHtml2(input) {
+  const out = [];
+  const stack = [];
+  let i = 0;
+  const len = input.length;
+  while (i < len) {
+    const ch = input[i];
+    if (ch === "&") {
+      const m = /^&(?:#\d+|#x[0-9a-f]+|[a-z]+);/i.exec(input.slice(i, i + 12));
+      if (m) {
+        out.push(m[0]);
+        i += m[0].length;
+      } else {
+        out.push("&amp;");
+        i++;
+      }
+      continue;
+    }
+    if (ch !== "<") {
+      out.push(ch);
+      i++;
+      continue;
+    }
+    const tagMatch = /^<\s*(\/?)\s*([a-zA-Z][a-zA-Z0-9-]*)\b([^>]*)>/.exec(input.slice(i));
+    if (!tagMatch) {
+      out.push("&lt;");
+      i++;
+      continue;
+    }
+    const isClose = tagMatch[1] === "/";
+    const tagName = tagMatch[2].toLowerCase();
+    const attrText = tagMatch[3];
+    if (!ALLOWED_TAGS2.has(tagName)) {
+      out.push(escapeAllHtml2(tagMatch[0]));
+      i += tagMatch[0].length;
+      continue;
+    }
+    if (isClose) {
+      const idx = stack.lastIndexOf(tagName);
+      if (idx === -1) {
+        i += tagMatch[0].length;
+        continue;
+      }
+      while (stack.length > idx + 1) {
+        const top = stack.pop();
+        out.push(`</${top}>`);
+      }
+      stack.pop();
+      out.push(`</${tagName}>`);
+      i += tagMatch[0].length;
+      continue;
+    }
+    const cleanAttrs = sanitizeAttrs2(tagName, attrText);
+    out.push(`<${tagName}${cleanAttrs}>`);
+    stack.push(tagName);
+    i += tagMatch[0].length;
+  }
+  while (stack.length > 0) {
+    const top = stack.pop();
+    out.push(`</${top}>`);
+  }
+  return out.join("");
+}
+function sanitizeAttrs2(tagName, attrText) {
+  const allowed = ALLOWED_ATTRS2[tagName];
+  if (!allowed || allowed.size === 0)
+    return "";
+  const attrRe = /([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+  const kept = [];
+  let m;
+  while ((m = attrRe.exec(attrText)) != null) {
+    const name = m[1].toLowerCase();
+    if (!allowed.has(name))
+      continue;
+    const rawValue = m[2] ?? m[3] ?? m[4] ?? "";
+    if (tagName === "a" && name === "href") {
+      const trimmed = rawValue.trim();
+      if (!ALLOWED_HREF_SCHEMES2.test(trimmed))
+        continue;
+      kept.push(`href="${escapeAttrValue2(trimmed)}"`);
+      continue;
+    }
+    if (rawValue.length === 0) {
+      kept.push(name);
+      continue;
+    }
+    kept.push(`${name}="${escapeAttrValue2(rawValue)}"`);
+  }
+  return kept.length > 0 ? " " + kept.join(" ") : "";
+}
+function escapeAttrValue2(v) {
+  return v.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
 // text-voice-scrub.ts
 var NULL = "\x00";
 var FENCE_PH = `${NULL}VS_FENCE`;
@@ -50477,6 +50639,17 @@ function decideFeedReopen(input) {
 }
 
 // gateway/feed-open-gate.ts
+function shouldEarlyOpenLiveness(input) {
+  if (!input.enabled)
+    return false;
+  if (input.sessionChatId == null)
+    return false;
+  if (input.activityMessageId != null)
+    return false;
+  if (input.ageMs < input.thresholdMs)
+    return false;
+  return true;
+}
 function mayOpenActivityCard(input) {
   if (input.crossTurnAnswerDelivered)
     return false;
@@ -56073,10 +56246,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.16.15";
-var COMMIT_SHA = "a9c59169";
-var COMMIT_DATE = "2026-06-28T22:48:22Z";
-var LATEST_PR = 2643;
+var VERSION = "0.16.17";
+var COMMIT_SHA = "de202ab1";
+var COMMIT_DATE = "2026-06-29T02:55:27Z";
+var LATEST_PR = 2652;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -58076,7 +58249,7 @@ var FEED_LIVENESS_OPEN_ENABLED = process.env.SWITCHROOM_FEED_LIVENESS_OPEN !== "
 var FEED_LIVENESS_OPEN_MS = (() => {
   const raw = process.env.SWITCHROOM_FEED_LIVENESS_OPEN_MS;
   const n = raw ? Number(raw) : NaN;
-  return Number.isFinite(n) && n > 0 ? n : 12000;
+  return Number.isFinite(n) && n > 0 ? n : 1200;
 })();
 var POST_ANSWER_LIVENESS_STALE_MS = parsePostAnswerLivenessMs(process.env.SWITCHROOM_POST_ANSWER_LIVENESS_STALE_MS) || 30000;
 function formatFeedElapsed3(ms) {
@@ -58484,6 +58657,7 @@ function purgeReactionTracking(key, endingTurn) {
     const threadId = threadPart === "_" || threadPart === "" ? null : Number(threadPart);
     stopTurnTypingLoop(chatId, Number.isFinite(threadId) ? threadId : null);
   }
+  stopEarlyLivenessOpen(key);
   if (msgInfo) {
     const agentDir = resolveAgentDirFromEnv();
     if (agentDir != null)
@@ -58682,34 +58856,13 @@ function maybeIdleClear() {
   idleClearDispatching = true;
   process.stderr.write(`telegram gateway: idle auto-/clear for ${agentName3} (idle >= ${Math.round(idleClearMs / 60000)}m)
 `);
-  injectSlashCommand(agentName3, "/clear").then(() => {
-    postIdleClearNotice(idleClearMs);
-  }).catch((err) => {
+  injectSlashCommand(agentName3, "/clear").catch((err) => {
     process.stderr.write(`telegram gateway: idle /clear inject failed for ${agentName3}: ${err instanceof Error ? err.message : String(err)}
 `);
   }).finally(() => {
     idleClearDispatching = false;
   });
 }
-async function postIdleClearNotice(idleClearMs) {
-  try {
-    const chatId = loadAccess().allowFrom[0];
-    if (!chatId)
-      return;
-    const threadId = topicForRecipient({
-      recipientChatId: chatId,
-      resolvedTopic: resolveAgentOutboundTopic({ kind: "compact-watchdog" }) ?? chatThreadMap.get(chatId),
-      supergroupChatId: resolveAgentSupergroupChatId()
-    });
-    const hrs = Math.round(idleClearMs / 3600000 * 10) / 10;
-    const text2 = `\uD83E\uDDF9 <b>Cleared after ${hrs}h idle</b> \u2014 fresh slate next message; ` + `long-term memory is in Hindsight.`;
-    await swallowingApiCall(() => bot.api.sendMessage(chatId, text2, {
-      parse_mode: "HTML",
-      disable_notification: true,
-      ...threadId != null ? { message_thread_id: threadId } : {}
-    }), { chat_id: chatId, verb: "idleAutoClear.notice" });
-  } catch {}
-}
 async function postCompactCard(occ, cap) {
   try {
     const chatId = loadAccess().allowFrom[0];
@@ -58983,24 +59136,18 @@ function stopTypingLoop(chat_id, thread_id = null) {
     typingRetryTimers.delete(key);
   }
 }
-var turnTypingIntervals = new Map;
-function startTurnTypingLoop(chat_id, thread_id = null) {
-  stopTurnTypingLoop(chat_id, thread_id);
-  const key = chatKey2(chat_id, thread_id);
-  const sendOpts = thread_id != null ? { message_thread_id: thread_id } : undefined;
-  const send = () => {
+var turnTypingLoop = createTurnTypingLoop({
+  sendChatAction: (chat_id, thread_id) => {
+    const sendOpts = thread_id != null ? { message_thread_id: thread_id } : undefined;
     bot.api.sendChatAction(chat_id, "typing", sendOpts).catch(() => {});
-  };
-  send();
-  turnTypingIntervals.set(key, setInterval(send, 4000));
+  },
+  chatKey: (chat_id, thread_id) => chatKey2(chat_id, thread_id)
+});
+function startTurnTypingLoop(chat_id, thread_id = null) {
+  turnTypingLoop.start(chat_id, thread_id);
 }
 function stopTurnTypingLoop(chat_id, thread_id = null) {
-  const key = chatKey2(chat_id, thread_id);
-  const iv = turnTypingIntervals.get(key);
-  if (iv) {
-    clearInterval(iv);
-    turnTypingIntervals.delete(key);
-  }
+  turnTypingLoop.stop(chat_id, thread_id);
 }
 var typingWrapper = createTypingWrapper({
   startTypingLoop,
@@ -62619,6 +62766,62 @@ async function drainActivitySummary(turn, producer = "tool", openFlags) {
     turn.activityInFlight = null;
   }
 }
+function openLivenessFeedIfDue(turn) {
+  const age = Date.now() - turn.startedAt;
+  if (!shouldEarlyOpenLiveness({
+    enabled: FEED_LIVENESS_OPEN_ENABLED,
+    ageMs: age,
+    thresholdMs: FEED_LIVENESS_OPEN_MS,
+    mirrorLineCount: turn.mirrorLines.length,
+    activityMessageId: turn.activityMessageId,
+    sessionChatId: turn.sessionChatId
+  }))
+    return;
+  const lines = turn.mirrorLines.length > 0 ? turn.mirrorLines : ["Working\u2026"];
+  const livenessHeader = {
+    label: "Agent",
+    elapsedMs: age,
+    toolCount: turn.labeledToolCount,
+    state: "running"
+  };
+  const rendered = renderActivityFeedWithNested(lines, [], false, ` \xB7 ${formatFeedElapsed3(age)}`, undefined, livenessHeader);
+  if (rendered == null)
+    return;
+  turn.activityPendingRender = rendered;
+  const ea = emissionAuthorityFor(turn);
+  cardDrainGate(turn, ea, () => {
+    if (ea.mayDrain(turn)) {
+      ea.openOrEditCard("liveness", () => {
+        turn.activityInFlight = drainActivitySummary(turn, "liveness");
+      });
+    }
+  });
+}
+var earlyLivenessOpenTimers = new Map;
+function scheduleEarlyLivenessOpen(turn) {
+  if (STATIC || !FEED_HEARTBEAT_ENABLED || !FEED_LIVENESS_OPEN_ENABLED)
+    return;
+  if (turn.sessionChatId == null)
+    return;
+  const key = statusKey(turn.sessionChatId, turn.sessionThreadId);
+  stopEarlyLivenessOpen(key);
+  const t = setTimeout(() => {
+    earlyLivenessOpenTimers.delete(key);
+    const live = currentTurnMap.get(key);
+    if (live == null || live.turnId !== turn.turnId)
+      return;
+    openLivenessFeedIfDue(live);
+  }, FEED_LIVENESS_OPEN_MS);
+  t.unref?.();
+  earlyLivenessOpenTimers.set(key, t);
+}
+function stopEarlyLivenessOpen(key) {
+  const t = earlyLivenessOpenTimers.get(key);
+  if (t != null) {
+    clearTimeout(t);
+    earlyLivenessOpenTimers.delete(key);
+  }
+}
 function feedHeartbeatTick() {
   const turn = currentTurn;
   if (turn == null)
@@ -62659,29 +62862,7 @@ function feedHeartbeatTick() {
     return;
   }
   if (turn.mirrorLines.length === 0) {
-    if (!FEED_LIVENESS_OPEN_ENABLED || turn.sessionChatId == null)
-      return;
-    const age = Date.now() - turn.startedAt;
-    if (age < FEED_LIVENESS_OPEN_MS)
-      return;
-    const livenessHeader = {
-      label: "Agent",
-      elapsedMs: age,
-      toolCount: 0,
-      state: "running"
-    };
-    const rendered2 = renderActivityFeedWithNested(["Working\u2026"], [], false, ` \xB7 ${formatFeedElapsed3(age)}`, undefined, livenessHeader);
-    if (rendered2 == null)
-      return;
-    turn.activityPendingRender = rendered2;
-    const ea2 = emissionAuthorityFor(turn);
-    cardDrainGate(turn, ea2, () => {
-      if (ea2.mayDrain(turn)) {
-        ea2.openOrEditCard("liveness", () => {
-          turn.activityInFlight = drainActivitySummary(turn, "liveness");
-        });
-      }
-    });
+    openLivenessFeedIfDue(turn);
     return;
   }
   if (turn.activityMessageId == null)
@@ -62813,6 +62994,7 @@ function handleSessionEvent(ev) {
         };
         setCurrentTurn(next, statusKey(ev.chatId, enqThreadIdNum));
         markIdleActivity();
+        scheduleEarlyLivenessOpen(next);
         process.stderr.write(`telegram gateway: ${formatTurnLifecycle("set", "enqueue", next, startedAt)}
 `);
         rememberRecentTurn(next);
@@ -62951,6 +63133,7 @@ function handleSessionEvent(ev) {
             chatId: turn.sessionChatId,
             threadId: turn.sessionThreadId,
             minInitialChars: ANSWER_LANE.minInitialChars,
+            renderText: (text2) => sanitizeTelegramHtml2(markdownToHtml(text2)),
             sendMessage: async (chatId, text2, params) => {
               const tid = params?.message_thread_id;
               const silent = params?.purpose !== "materialize";
@@ -69510,9 +69693,10 @@ async function shutdown(signal) {
   for (const iv of [...typingIntervals.values()])
     clearInterval(iv);
   typingIntervals.clear();
-  for (const iv of [...turnTypingIntervals.values()])
-    clearInterval(iv);
-  turnTypingIntervals.clear();
+  turnTypingLoop.stopAll();
+  for (const t of [...earlyLivenessOpenTimers.values()])
+    clearTimeout(t);
+  earlyLivenessOpenTimers.clear();
   for (const t of [...typingRetryTimers.values()])
     clearTimeout(t);
   typingRetryTimers.clear();