switchroom 0.16.15 → 0.16.20

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.20";
+var COMMIT_SHA = "6ea6e873";
+var COMMIT_DATE = "2026-06-29T05:16:25Z";
+var LATEST_PR = 2657;
 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();

package/telegram-plugin/gateway/feed-open-gate.ts

@@ -80,10 +80,63 @@
  *     already received.
  */
 
+/**
+ * Inputs for the liveness early-open WHEN-decision (`shouldEarlyOpenLiveness`).
+ * Separate from the OPEN-gate levers above: those answer *may* a card open at
+ * all (reply-is-last / cross-turn); this answers *is it time yet* for the
+ * minimal "Working…" placeholder on a 0-label turn. Both must say yes — the
+ * caller routes the actual open through `mayOpenActivityCard` after this clears.
+ */
+export interface EarlyLivenessOpenInput {
+  /** Feature flag (`SWITCHROOM_FEED_LIVENESS_OPEN`). Off ⇒ never early-open. */
+  enabled: boolean
+  /** Turn age in ms (`now - turn.startedAt`). Must be ≥ `thresholdMs`. */
+  ageMs: number
+  /** The early-open threshold (`FEED_LIVENESS_OPEN_MS`). */
+  thresholdMs: number
+  /** Count of surfaced tool steps this turn (`turn.mirrorLines.length`). >0 ⇒ a
+   *  real label already drives the labelled-feed heartbeat; the placeholder must
+   *  not fight it, so it never opens (unless `forceNarrative` — see below). */
+  mirrorLineCount: number
+  /** Single in-place card transport id. Non-null ⇒ a card is already OPEN, so
+   *  this is a maintain/no-op, not a fresh OPEN. */
+  activityMessageId: number | null
+  /** The session chat id. `null` ⇒ no surface to open on. */
+  sessionChatId: string | null
+}
+
+/**
+ * Pure: is the minimal "Working…" liveness placeholder due to OPEN for a 0-label
+ * turn? True iff the feature is on, the turn has a target chat, it has been alive
+ * past the threshold, and NO card is already open. Once `mirrorLineCount > 0` a
+ * real tool label drives the feed, EXCEPT the edge where narration staged
+ * `mirrorLines` but no card opened yet (`activityMessageId == null`) — there the
+ * accumulated narration should still render on the early open, so it is allowed.
+ *
+ * This is the WHEN gate. The caller still routes the OPEN through
+ * `mayOpenActivityCard` (lever 1/4) so a card never opens below a delivered
+ * answer or on a cross-turn synthetic surface. Two callers consult this — the
+ * enqueue-time early-open timer and the 6 s heartbeat — and because an already-
+ * open card returns false here (and the drain EDITs rather than re-OPENs), they
+ * can never double-open.
+ */
+export function shouldEarlyOpenLiveness(input: EarlyLivenessOpenInput): boolean {
+  if (!input.enabled) return false
+  if (input.sessionChatId == null) return false
+  // A card is already open → maintain via the drain's EDIT path, not a fresh
+  // OPEN. Never double-open. (Reaching past here implies `activityMessageId ==
+  // null`, so a non-zero `mirrorLineCount` is the "narration staged but no card
+  // opened yet" edge — allowed below so the accumulated narration renders.)
+  if (input.activityMessageId != null) return false
+  if (input.ageMs < input.thresholdMs) return false
+  return true
+}
+
 /** Which producer triggered this drain — determines lever-5 OPEN eligibility. */
 export type FeedOpenProducer =
   /** Narrative SHOW (producer A): plain assistant text, no tool, no time
-   *  threshold. May only EDIT, never OPEN, while the turn has 0 tool labels. */
+   *  threshold. Pre-answer it is OPEN-eligible (lever 5 INERT); after a
+   *  substantive final answer it is blocked by lever 1. */
   | 'narrative'
   /** Tool label (producer B): the model dispatched a tool. OPEN-eligible unless a
    *  substantive final already landed (lever 1).