@llblab/pi-telegram 0.18.4 → 0.18.5

package/lib/bus.ts

@@ -5,7 +5,7 @@
  * cross-instance forwarding helpers, and the live follower registry model.
  */
 
-import { createHash, randomBytes } from "node:crypto";
+import { randomBytes } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
 import {
   createConnection,
@@ -16,6 +16,19 @@ import {
 import { homedir, platform as getPlatform } from "node:os";
 import { dirname, join, resolve } from "node:path";
 
+import {
+  classifyTelegramBusTransportError,
+  createTelegramBusTransportTimeoutError,
+  delayTelegramBusTransportRetry,
+  getTelegramBusEndpointDiagnostics,
+  getTelegramBusFollowerEndpoint,
+  getTelegramBusLeaderEndpoint,
+  getTelegramBusTransportRetryPolicy,
+  isTelegramBusPipePath,
+  isRetryableTelegramBusTransportError,
+  type TelegramBusTransportEventRecorder,
+  type TelegramBusTransportRetryPolicy,
+} from "./bus-transport.ts";
 import type { TelegramTarget } from "./target.ts";
 
 export type TelegramBusRole = "leader" | "follower";
@@ -30,30 +43,11 @@ export function createTelegramBusAuthSecret(): string {
   return randomBytes(32).toString("base64url");
 }
 
-function getTelegramBusPipePath(input: {
-  agentDir: string;
-  scope: string;
-}): string {
-  const digest = createHash("sha256")
-    .update(resolve(input.agentDir))
-    .digest("base64url")
-    .slice(0, 16);
-  const scope = input.scope.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 80);
-  return `\\\\.\\pipe\\pi-telegram-${digest}-${scope}`;
-}
-
-function isWindowsPipePath(socketPath: string): boolean {
-  return /^\\\\[.?]\\pipe\\/i.test(socketPath);
-}
-
 export function getTelegramBusSocketPath(
   agentDir = getAgentDir(),
   platform = getPlatform(),
 ): string {
-  if (platform === "win32") {
-    return getTelegramBusPipePath({ agentDir, scope: "bus" });
-  }
-  return join(agentDir, "tmp", "telegram", "bus.sock");
+  return getTelegramBusLeaderEndpoint({ agentDir, platform });
 }
 
 export function getTelegramBusFollowerSocketPath(
@@ -61,19 +55,7 @@ export function getTelegramBusFollowerSocketPath(
   agentDir = getAgentDir(),
   platform = getPlatform(),
 ): string {
-  if (platform === "win32") {
-    return getTelegramBusPipePath({
-      agentDir,
-      scope: `follower-${instanceId}`,
-    });
-  }
-  return join(
-    agentDir,
-    "tmp",
-    "telegram",
-    "followers",
-    `${instanceId.replace(/[^a-zA-Z0-9_.-]/g, "_")}.sock`,
-  );
+  return getTelegramBusFollowerEndpoint({ agentDir, platform, instanceId });
 }
 
 export interface TelegramBusInstanceRegistration {
@@ -91,6 +73,35 @@ export interface TelegramBusFollowerView extends TelegramBusInstanceRegistration
   lastHeartbeatMs: number;
 }
 
+export function getTelegramFollowerTargetOwnership(input: {
+  target: TelegramTarget;
+  followers: TelegramBusFollowerView[];
+  activeThreadRecords?: Array<{
+    status?: string;
+    instanceId?: string;
+    target: TelegramTarget;
+  }>;
+  currentInstanceId?: string;
+}): { instanceId: string } | undefined {
+  const liveFollower = input.followers.find((follower) => {
+    return (
+      follower.target?.chatId === input.target.chatId &&
+      follower.target.threadId === input.target.threadId
+    );
+  });
+  if (liveFollower) return { instanceId: liveFollower.instanceId };
+  const record = input.activeThreadRecords?.find((candidate) => {
+    return (
+      candidate.status === "active" &&
+      candidate.instanceId &&
+      candidate.instanceId !== input.currentInstanceId &&
+      candidate.target.chatId === input.target.chatId &&
+      candidate.target.threadId === input.target.threadId
+    );
+  });
+  return record?.instanceId ? { instanceId: record.instanceId } : undefined;
+}
+
 export function isTelegramFollowerApiCallAllowed(input: {
   follower: TelegramBusFollowerView;
   method: string;
@@ -310,12 +321,15 @@ export interface TelegramBusLocalServerDeps {
     | Promise<TelegramBusEnvelope | undefined>
     | TelegramBusEnvelope
     | undefined;
+  recordTransportEvent?: TelegramBusTransportEventRecorder;
 }
 
 export interface TelegramBusLocalClientOptions {
   socketPath: string;
   envelope: TelegramBusEnvelope;
   timeoutMs?: number;
+  retry?: TelegramBusTransportRetryPolicy;
+  recordTransportEvent?: TelegramBusTransportEventRecorder;
 }
 
 export interface TelegramBusForeignOwnedForwarderDeps {
@@ -362,6 +376,10 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
       socketPath: deps.socketPath,
       envelope,
       timeoutMs: deps.timeoutMs,
+      retry: getTelegramBusTransportRetryPolicy({
+        endpoint: deps.socketPath,
+        operation: "operation",
+      }),
     });
     return response?.kind === "bus.ack" && response.ok;
   };
@@ -449,6 +467,10 @@ export function createTelegramBusFollowerTargetController(
         socketPath: follower.busSocketPath,
         envelope,
         timeoutMs: deps.timeoutMs,
+        retry: getTelegramBusTransportRetryPolicy({
+          endpoint: follower.busSocketPath,
+          operation: "operation",
+        }),
       });
       return response?.kind === "bus.ack" && response.ok;
     },
@@ -517,7 +539,11 @@ export function createTelegramBusLocalServer(
   return {
     start: async () => {
       if (server) return;
-      const usesWindowsPipe = isWindowsPipePath(deps.socketPath);
+      const usesWindowsPipe = isTelegramBusPipePath(deps.socketPath);
+      deps.recordTransportEvent?.(
+        "server-start",
+        getTelegramBusEndpointDiagnostics(deps.socketPath),
+      );
       if (!usesWindowsPipe) {
         const socketDir = dirname(deps.socketPath);
         mkdirSync(socketDir, { recursive: true, mode: 0o700 });
@@ -533,16 +559,40 @@ export function createTelegramBusLocalServer(
           const lines = buffer.split("\n");
           buffer = lines.pop() ?? "";
           for (const line of lines) {
-            void handleTelegramBusSocketLine(line, socket, deps.handleEnvelope);
+            void handleTelegramBusSocketLine(
+              line,
+              socket,
+              deps.handleEnvelope,
+              deps.recordTransportEvent,
+              deps.socketPath,
+            );
           }
         });
         socket.on("close", () => sockets.delete(socket));
-        socket.on("error", () => closeSocket(socket));
-      });
-      await new Promise<void>((resolve, reject) => {
-        server?.once("error", reject);
-        server?.listen(deps.socketPath, resolve);
+        socket.on("error", (error) => {
+          deps.recordTransportEvent?.("server-socket-error", {
+            ...getTelegramBusEndpointDiagnostics(deps.socketPath),
+            ...classifyTelegramBusTransportError(error),
+          });
+          closeSocket(socket);
+        });
       });
+      try {
+        await new Promise<void>((resolve, reject) => {
+          server?.once("error", reject);
+          server?.listen(deps.socketPath, resolve);
+        });
+        deps.recordTransportEvent?.(
+          "server-started",
+          getTelegramBusEndpointDiagnostics(deps.socketPath),
+        );
+      } catch (error) {
+        deps.recordTransportEvent?.("server-start-failed", {
+          ...getTelegramBusEndpointDiagnostics(deps.socketPath),
+          ...classifyTelegramBusTransportError(error),
+        });
+        throw error;
+      }
       if (!usesWindowsPipe) chmodSync(deps.socketPath, 0o600);
     },
     stop: async () => {
@@ -554,14 +604,27 @@ export function createTelegramBusLocalServer(
           activeServer.close(() => resolve()),
         );
       }
-      if (!isWindowsPipePath(deps.socketPath) && existsSync(deps.socketPath)) {
+      if (!isTelegramBusPipePath(deps.socketPath) && existsSync(deps.socketPath)) {
         unlinkSync(deps.socketPath);
       }
+      deps.recordTransportEvent?.(
+        "server-stopped",
+        getTelegramBusEndpointDiagnostics(deps.socketPath),
+      );
     },
   };
 }
 
-export function sendTelegramBusLocalEnvelope(
+function getTelegramBusEnvelopeDiagnostics(
+  envelope: TelegramBusEnvelope,
+): Record<string, unknown> {
+  return {
+    envelopeKind: envelope.kind,
+    requestId: envelope.requestId,
+  };
+}
+
+function sendTelegramBusLocalEnvelopeOnce(
   options: TelegramBusLocalClientOptions,
 ): Promise<TelegramBusEnvelope | undefined> {
   const timeoutMs = options.timeoutMs ?? 1000;
@@ -578,7 +641,11 @@ export function sendTelegramBusLocalEnvelope(
     };
     const timeout = setTimeout(() => {
       settle(() =>
-        reject(new Error("Timed out waiting for Telegram bus response")),
+        reject(
+          createTelegramBusTransportTimeoutError(
+            "Timed out waiting for Telegram bus response",
+          ),
+        ),
       );
     }, timeoutMs);
     timeout.unref?.();
@@ -598,6 +665,39 @@ export function sendTelegramBusLocalEnvelope(
   });
 }
 
+export async function sendTelegramBusLocalEnvelope(
+  options: TelegramBusLocalClientOptions,
+): Promise<TelegramBusEnvelope | undefined> {
+  const attempts = Math.max(1, options.retry?.attempts ?? 1);
+  const delayMs = Math.max(0, options.retry?.delayMs ?? 0);
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return await sendTelegramBusLocalEnvelopeOnce(options);
+    } catch (error) {
+      const info = classifyTelegramBusTransportError(error);
+      options.recordTransportEvent?.("client-failed", {
+        ...getTelegramBusEndpointDiagnostics(options.socketPath),
+        ...getTelegramBusEnvelopeDiagnostics(options.envelope),
+        attempt,
+        attempts,
+        ...info,
+      });
+      if (attempt >= attempts || !isRetryableTelegramBusTransportError(error)) {
+        throw error;
+      }
+      options.recordTransportEvent?.("client-retry", {
+        ...getTelegramBusEndpointDiagnostics(options.socketPath),
+        ...getTelegramBusEnvelopeDiagnostics(options.envelope),
+        attempt,
+        attempts,
+        delayMs,
+        ...info,
+      });
+      await delayTelegramBusTransportRetry(delayMs);
+    }
+  }
+}
+
 export interface TelegramBusFollowerRegistry {
   register: (
     registration: TelegramBusInstanceRegistration,
@@ -610,6 +710,7 @@ export interface TelegramBusFollowerRegistry {
   getByTarget: (target: TelegramTarget) => TelegramBusFollowerView | undefined;
   list: () => TelegramBusFollowerView[];
   remove: (instanceId: string) => boolean;
+  clear: () => void;
   pruneStale: (
     nowMs: number,
     staleAfterMs: number,
@@ -660,6 +761,7 @@ export function createTelegramBusFollowerRegistry(): TelegramBusFollowerRegistry
     },
     list: () => [...followers.values()].map(clone),
     remove: (instanceId) => followers.delete(instanceId),
+    clear: () => followers.clear(),
     pruneStale: (nowMs, staleAfterMs) => {
       const removed: TelegramBusFollowerView[] = [];
       for (const [instanceId, follower] of followers.entries()) {
@@ -676,9 +778,15 @@ async function handleTelegramBusSocketLine(
   line: string,
   socket: Socket,
   handleEnvelope: TelegramBusLocalServerDeps["handleEnvelope"],
+  recordTransportEvent: TelegramBusTransportEventRecorder | undefined,
+  socketPath: string,
 ): Promise<void> {
   const envelope = parseTelegramBusEnvelope(line);
   if (!envelope) {
+    recordTransportEvent?.("server-invalid-envelope", {
+      ...getTelegramBusEndpointDiagnostics(socketPath),
+      byteLength: Buffer.byteLength(line),
+    });
     socket.write(
       encodeTelegramBusEnvelope({
         kind: "bus.ack",
@@ -689,8 +797,24 @@ async function handleTelegramBusSocketLine(
     );
     return;
   }
-  const response = await handleEnvelope(envelope);
-  if (response) socket.write(encodeTelegramBusEnvelope(response));
+  try {
+    const response = await handleEnvelope(envelope);
+    if (response) socket.write(encodeTelegramBusEnvelope(response));
+  } catch (error) {
+    recordTransportEvent?.("server-handler-failed", {
+      ...getTelegramBusEndpointDiagnostics(socketPath),
+      ...getTelegramBusEnvelopeDiagnostics(envelope),
+      ...classifyTelegramBusTransportError(error),
+    });
+    socket.write(
+      encodeTelegramBusEnvelope({
+        kind: "bus.ack",
+        requestId: envelope.requestId,
+        ok: false,
+        message: "Telegram bus handler failed.",
+      }),
+    );
+  }
 }
 
 function parseRegisterEnvelope(

package/lib/polling.ts

@@ -20,7 +20,7 @@ const TELEGRAM_INITIAL_SYNC_LIMIT = 1;
 const TELEGRAM_INITIAL_SYNC_TIMEOUT_SECONDS = 0;
 const TELEGRAM_LONG_POLL_LIMIT = 10;
 const TELEGRAM_LONG_POLL_TIMEOUT_SECONDS = 30;
-const TELEGRAM_THREAD_CAPABILITY_MONITOR_INTERVAL_MS = 5_000;
+const TELEGRAM_THREAD_CAPABILITY_MONITOR_INTERVAL_MS = 2_500;
 const TELEGRAM_THREAD_CAPABILITY_DISABLED_CONFIRMATION_PROBES = 2;
 const TELEGRAM_POLLING_DEFAULT_MAX_UPDATE_FAILURES = 3;
 const TELEGRAM_GET_UPDATES_CONFLICT_FAST_RETRY_LIMIT = 3;
@@ -426,6 +426,12 @@ export async function probeTelegramStartupThreadCapability(
   return threadModeEnabled;
 }
 
+function hasTelegramClassicRestoreFailure(
+  state: TelegramThreadCapabilityState,
+): boolean {
+  return state.lastReconcileAction?.endsWith("-classic-restore-failed") ?? false;
+}
+
 function hasTelegramThreadCapabilityBindings(
   store: TelegramThreadCapabilityStore,
 ): boolean {
@@ -451,6 +457,7 @@ export async function applyTelegramThreadCapability<TContext>(
   await deps.topicTargetStore.load();
   if (!deps.isBusConfigured()) return;
   const nowMs = (deps.getNowMs ?? Date.now)();
+  const previousBotState = deps.topicTargetStore.getBotState();
   if (!threadModeEnabled) {
     if (
       hasTelegramThreadCapabilityBindings(deps.topicTargetStore) &&
@@ -470,11 +477,26 @@ export async function applyTelegramThreadCapability<TContext>(
     await deps.topicTargetStore.persist();
     deps.setTopicModeUnavailable(true);
     deps.stopFollowerRegistration();
-    if (deps.getPollingStartedWithTelegramBus()) {
+    if (
+      deps.getPollingStartedWithTelegramBus() ||
+      hasTelegramClassicRestoreFailure(previousBotState)
+    ) {
       deps.stopLeaderHealth();
       await deps.stopBusPolling();
       deps.setPollingStartedWithTelegramBus(false);
-      await deps.startClassicPolling(ctx);
+      try {
+        await deps.startClassicPolling(ctx);
+      } catch (classicError) {
+        deps.topicTargetStore.setBotState({
+          threadMode: "disabled",
+          updatedAtMs: (deps.getNowMs ?? Date.now)(),
+          lastReconcileAction: `${phase}-classic-restore-failed`,
+        });
+        await deps.topicTargetStore.persist();
+        deps.recordEvent("bus", classicError, {
+          phase: `${phase}-classic-restore`,
+        });
+      }
     }
     deps.updateStatus(ctx);
     return;
@@ -509,6 +531,12 @@ export async function applyTelegramThreadCapability<TContext>(
       try {
         await deps.startClassicPolling(ctx);
       } catch (classicError) {
+        deps.topicTargetStore.setBotState({
+          threadMode: "disabled",
+          updatedAtMs: (deps.getNowMs ?? Date.now)(),
+          lastReconcileAction: `${phase}-classic-restore-failed`,
+        });
+        await deps.topicTargetStore.persist();
         deps.recordEvent("bus", classicError, {
           phase: `${phase}-classic-restore`,
         });
@@ -583,6 +611,19 @@ export function createTelegramThreadAwarePollingPorts<TContext, TOwner>(
   ): Promise<boolean | undefined> => {
     await deps.topicTargetStore.load();
     if (deps.topicTargetStore.getBotState().threadMode !== "enabled") {
+      if (hasTelegramThreadCapabilityBindings(deps.topicTargetStore)) {
+        deps.recordEvent(
+          "bus",
+          "Telegram Threaded Mode disabled; follower takeover blocked",
+          {
+            phase: "follower-register-thread-mode-disabled",
+            reason: "active-thread-bindings-present",
+          },
+        );
+        throw new Error(
+          "Telegram Threaded Mode is disabled; the current leader remains the classic polling owner.",
+        );
+      }
       return undefined;
     }
     if (!deps.isBusRuntimeEnabled()) return undefined;
@@ -653,9 +694,21 @@ export function createTelegramThreadCapabilityMonitor<TContext>(
           return;
         }
         if (threadModeEnabled) consecutiveDisabledProbes = 0;
-        const current = deps.topicTargetStore.getBotState().threadMode;
+        const botState = deps.topicTargetStore.getBotState();
+        const current = botState.threadMode;
         if (threadModeEnabled && current === "enabled") return;
-        if (!threadModeEnabled && current === "disabled") return;
+        if (!threadModeEnabled && current === "disabled") {
+          if (!deps.ownsLock(ctx) || !hasTelegramClassicRestoreFailure(botState)) {
+            return;
+          }
+          await applyTelegramThreadCapability(
+            ctx,
+            false,
+            "capability-monitor-disabled-confirmed",
+            deps,
+          );
+          return;
+        }
         if (
           !threadModeEnabled &&
           hasTelegramThreadCapabilityBindings(deps.topicTargetStore)

package/lib/preview.ts

@@ -12,7 +12,6 @@ import {
 } from "./target.ts";
 import { shouldSuppressPreviewForVoice } from "./voice.ts";
 
-const TELEGRAM_PREVIEW_THROTTLE_MS = 0;
 const TELEGRAM_DRAFT_ID_MAX = 2_147_483_647;
 const TELEGRAM_DRAFT_PREVIEW_MAX_CHARS = 4096;
 
@@ -26,7 +25,6 @@ export interface TelegramPreviewState {
 }
 
 export interface TelegramPreviewRuntimeState extends TelegramPreviewState {
-  flushTimer?: ReturnType<typeof setTimeout>;
   flushPromise?: Promise<void>;
   flushRequested?: boolean;
 }
@@ -36,7 +34,6 @@ export type TelegramPreviewReplyMarkup = unknown;
 export interface TelegramPreviewRuntimeDeps {
   getState: () => TelegramPreviewRuntimeState | undefined;
   setState: (state: TelegramPreviewRuntimeState | undefined) => void;
-  clearScheduledFlush: (state: TelegramPreviewRuntimeState) => void;
   maxMessageLength: number;
   getDraftSupport: () => TelegramDraftSupport;
   setDraftSupport: (support: TelegramDraftSupport) => void;
@@ -132,13 +129,7 @@ export interface TelegramPreviewControllerDeps {
     },
   ) => Promise<unknown>;
   canSend?: () => boolean;
-  throttleMs?: number;
   maxDraftId?: number;
-  setTimer?: (
-    callback: () => void,
-    ms: number,
-  ) => ReturnType<typeof setTimeout>;
-  clearTimer?: (timer: ReturnType<typeof setTimeout>) => void;
   recordRuntimeEvent?: (
     category: string,
     error: unknown,
@@ -154,7 +145,7 @@ export interface TelegramPreviewController {
   resetState: () => void;
   clear: (
     chatId: number,
-    options?: { target?: TelegramTarget },
+    options?: { awaitFlush?: boolean; target?: TelegramTarget },
   ) => Promise<void>;
   flush: (
     chatId: number,
@@ -171,7 +162,8 @@ export interface TelegramPreviewController {
   ) => Promise<boolean>;
 }
 
-export type TelegramPreviewControllerRuntimeDeps = TelegramPreviewControllerDeps;
+export type TelegramPreviewControllerRuntimeDeps =
+  TelegramPreviewControllerDeps;
 
 export function createTelegramPreviewControllerRuntime(
   deps: TelegramPreviewControllerRuntimeDeps,
@@ -181,10 +173,7 @@ export function createTelegramPreviewControllerRuntime(
     maxMessageLength: deps.maxMessageLength,
     initialDraftSupport: deps.initialDraftSupport,
     sendDraft: deps.sendDraft,
-    throttleMs: deps.throttleMs,
     maxDraftId: deps.maxDraftId,
-    setTimer: deps.setTimer,
-    clearTimer: deps.clearTimer,
     recordRuntimeEvent: deps.recordRuntimeEvent,
   });
 }
@@ -223,7 +212,7 @@ export function createTelegramNativeMarkdownPreviewFinalizer<
   getState: () => TelegramPreviewRuntimeState | undefined;
   clear: (
     chatId: number,
-    options?: { target?: TelegramTarget },
+    options?: { awaitFlush?: boolean; target?: TelegramTarget },
   ) => Promise<void>;
   discard?: () => void;
   sendMarkdownReply: (
@@ -283,12 +272,6 @@ export function createTelegramPreviewController(
   deps: TelegramPreviewControllerDeps,
 ): TelegramPreviewController {
   let state: TelegramPreviewRuntimeState | undefined;
-  const clearTimer = deps.clearTimer ?? clearTimeout;
-  const setTimer =
-    deps.setTimer ??
-    ((callback: () => void, ms: number): ReturnType<typeof setTimeout> =>
-      setTimeout(callback, ms));
-  const throttleMs = deps.throttleMs ?? TELEGRAM_PREVIEW_THROTTLE_MS;
   const maxDraftId = deps.maxDraftId ?? TELEGRAM_DRAFT_ID_MAX;
   const maxMessageLength =
     deps.maxMessageLength ?? TELEGRAM_DRAFT_PREVIEW_MAX_CHARS;
@@ -299,11 +282,6 @@ export function createTelegramPreviewController(
     setState: (nextState) => {
       state = nextState;
     },
-    clearScheduledFlush: (nextState) => {
-      if (!nextState.flushTimer) return;
-      clearTimer(nextState.flushTimer);
-      nextState.flushTimer = undefined;
-    },
     maxMessageLength,
     getDraftSupport: () => draftSupport,
     setDraftSupport: (support) => {
@@ -334,15 +312,8 @@ export function createTelegramPreviewController(
     flush: (chatId, options) =>
       flushTelegramPreview(chatId, getRuntimeDeps(), options),
     scheduleFlush: (chatId, options) => {
-      if (!state || state.flushTimer) return;
-      if (throttleMs <= 0) {
-        void flushTelegramPreview(chatId, getRuntimeDeps(), options);
-        return;
-      }
-      state.flushTimer = setTimer(() => {
-        void flushTelegramPreview(chatId, getRuntimeDeps(), options);
-      }, throttleMs);
-      state.flushTimer.unref?.();
+      if (!state) return;
+      void flushTelegramPreview(chatId, getRuntimeDeps(), options);
     },
     finalize: (chatId, _replyToMessageId, options) =>
       finalizeTelegramPreview(chatId, getRuntimeDeps(), options),
@@ -464,7 +435,6 @@ export async function clearTelegramPreview(
 ): Promise<void> {
   const state = deps.getState();
   if (!state) return;
-  deps.clearScheduledFlush(state);
   if (state.flushPromise && options.awaitFlush !== false) {
     state.flushRequested = false;
     await state.flushPromise.catch(() => {});
@@ -699,6 +669,10 @@ function findSafeTelegramRichMarkdownDraftEnd(markdown: string): number {
   return safeEnd;
 }
 
+function hasTelegramPreviewVisibleContent(markdown: string): boolean {
+  return /[\p{L}\p{N}]/u.test(markdown);
+}
+
 export function getSafeTelegramRichMarkdownDraftPrefix(
   markdown: string,
   maxMessageLength: number,
@@ -710,13 +684,21 @@ export function getSafeTelegramRichMarkdownDraftPrefix(
       ? source.slice(0, maxMessageLength)
       : source;
   const safeEnd = findSafeTelegramRichMarkdownDraftEnd(limited);
-  if (safeEnd > 0) return limited.slice(0, safeEnd).trimEnd() || undefined;
+  if (safeEnd > 0) {
+    const safePrefix = limited.slice(0, safeEnd).trimEnd();
+    return hasTelegramPreviewVisibleContent(safePrefix)
+      ? safePrefix
+      : undefined;
+  }
   let candidateEnd = limited.length;
   while (candidateEnd > 0) {
     candidateEnd = limited.lastIndexOf(" ", candidateEnd - 1);
     if (candidateEnd <= 0) return undefined;
     const candidate = limited.slice(0, candidateEnd).trimEnd();
-    if (findSafeTelegramRichMarkdownDraftEnd(candidate) === candidate.length) {
+    if (
+      hasTelegramPreviewVisibleContent(candidate) &&
+      findSafeTelegramRichMarkdownDraftEnd(candidate) === candidate.length
+    ) {
       return candidate || undefined;
     }
   }
@@ -795,7 +777,6 @@ export async function flushTelegramPreview(
     await state.flushPromise;
     return;
   }
-  state.flushTimer = undefined;
   state.flushPromise = (async () => {
     do {
       state.flushRequested = false;

package/lib/runtime-log.ts

@@ -4,7 +4,14 @@
  * Owns session-local append-only runtime evidence for debugging without becoming routing state
  */
 
-import { existsSync, mkdirSync, statSync, writeFileSync, appendFile } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  statSync,
+  writeFileSync,
+  appendFile,
+} from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 
@@ -17,6 +24,7 @@ export interface TelegramRuntimeJsonlEvent {
 
 export interface TelegramRuntimeJsonlLogOptions {
   path?: string;
+  previousPath?: string;
   maxBytes?: number;
   getNowMs?: () => number;
 }
@@ -57,6 +65,8 @@ export function createTelegramRuntimeJsonlLog(
   options: TelegramRuntimeJsonlLogOptions = {},
 ): TelegramRuntimeJsonlLog {
   const path = options.path ?? getTelegramRuntimeLogPath();
+  const previousPath =
+    options.previousPath ?? path.replace(/\.jsonl$/u, ".previous.jsonl");
   const maxBytes = options.maxBytes ?? DEFAULT_MAX_LOG_BYTES;
   const getNowMs = options.getNowMs ?? Date.now;
   let scopeKey: string | undefined;
@@ -66,8 +76,15 @@ export function createTelegramRuntimeJsonlLog(
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
   };
 
+  const preserveCurrentLog = () => {
+    if (!existsSync(path)) return;
+    mkdirSync(dirname(previousPath), { recursive: true, mode: 0o700 });
+    copyFileSync(path, previousPath);
+  };
+
   const writeReset = (reason: string, scope?: Record<string, unknown>) => {
     ensureParent();
+    preserveCurrentLog();
     writeFileSync(
       path,
       safeJsonLine({
@@ -75,6 +92,7 @@ export function createTelegramRuntimeJsonlLog(
         kind: "reset",
         reason,
         scope,
+        previousPath,
       }) + "\n",
       { mode: 0o600 },
     );