@llblab/pi-telegram 0.18.4 → 0.18.6

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/routing.ts

@@ -217,21 +217,13 @@ function formatTelegramAllTabMenuChooserText(command: string): string {
 function buildTelegramUnboundRerouteChooserMarkup(
   rerouteId: string,
   records: readonly Threads.TelegramTopicTargetRecord[],
-  options: {
+  _options: {
     currentLeaderProfileKey?: string;
     currentInstanceId?: string;
   } = {},
 ): Menu.TelegramReplyMarkup {
   const activeRecords = records.filter((record) => record.status === "active");
-  const canRestoreCurrentLeader = activeRecords.some(
-    (record) =>
-      typeof record.rerouteConfirmedAtMs === "number" &&
-      isCurrentLeaderTopicRecord(
-        record,
-        options.currentLeaderProfileKey,
-        options.currentInstanceId,
-      ),
-  );
+  const canRestoreAnyLiveThread = activeRecords.length > 0;
   const rows = activeRecords.map((record) => [
     {
       text: getTelegramRouteThreadButtonLabel(record),
@@ -242,7 +234,7 @@ function buildTelegramUnboundRerouteChooserMarkup(
     },
   ]);
   return {
-    inline_keyboard: canRestoreCurrentLeader
+    inline_keyboard: canRestoreAnyLiveThread
       ? [
           ...rows,
           [
@@ -414,6 +406,7 @@ export interface TelegramInboundRouteRuntimeDeps<
   getCurrentInstanceId?: () => string | undefined;
   getMessageOwnership?: Updates.TelegramMessageOwnershipLookup;
   getTargetOwnership?: Updates.TelegramTargetOwnershipLookup;
+  recordMessageOwnership?: Updates.TelegramMessageOwnershipRecorder;
   getLiveThreadTargets?: () => Queue.TelegramQueueTarget[];
   getLocalThreadLabelForTarget?: (
     target: Queue.TelegramQueueTarget,
@@ -1861,6 +1854,7 @@ export function createTelegramInboundRouteRuntime<
     getCurrentInstanceId: deps.getCurrentInstanceId,
     getMessageOwnership: deps.getMessageOwnership,
     getTargetOwnership: deps.getTargetOwnership,
+    recordMessageOwnership: deps.recordMessageOwnership,
     handleTelegramTopicLifecycleUpdate,
     foreignOwnedUpdateForwarder: deps.foreignOwnedUpdateForwarder,
     setAllowedUserId: deps.configStore.setAllowedUserId,

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 },
     );

package/lib/runtime.ts

@@ -4,7 +4,7 @@
  * Owns small session-local runtime primitives that are shared by orchestration but are not specific to queueing, rendering, polling, or Telegram transport
  */
 
-const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 1500;
+const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 2500;
 const TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS = 250;
 
 export interface TelegramRuntimeQueueCounters {
@@ -398,13 +398,9 @@ export function createTelegramTypingLoopStarter<TContext>(
       chatId: chatId ?? deps.getDefaultChatId(),
       target: options?.target,
       intervalMs: deps.intervalMs ?? TELEGRAM_TYPING_ACTION_INTERVAL_MS,
-      sendTypingAction: async (targetChatId) => {
+      sendTypingAction: async (targetChatId, actionOptions) => {
         try {
-          const threadParams = getTelegramTypingLoopThreadParams(options?.target);
-          await deps.sendTypingAction(targetChatId, threadParams);
-          if (threadParams?.message_thread_id !== undefined) {
-            await deps.sendAggregateTypingAction?.(targetChatId);
-          }
+          await deps.sendTypingAction(targetChatId, actionOptions);
         } catch (error) {
           const message =
             error instanceof Error ? error.message : String(error);
@@ -419,6 +415,26 @@ export function createTelegramTypingLoopStarter<TContext>(
           });
         }
       },
+      sendAggregateTypingAction: deps.sendAggregateTypingAction
+        ? async (targetChatId) => {
+            try {
+              await deps.sendAggregateTypingAction?.(targetChatId);
+            } catch (error) {
+              const message =
+                error instanceof Error ? error.message : String(error);
+              updateTelegramRuntimeStatusSafely(deps.updateStatus, ctx, {
+                error: message,
+                category: "typing",
+                phase: "status-update",
+                recordRuntimeEvent: deps.recordRuntimeEvent,
+              });
+              deps.recordRuntimeEvent?.("typing", error, {
+                chatId: targetChatId,
+                aggregate: true,
+              });
+            }
+          }
+        : undefined,
     });
   };
 }

package/lib/status.ts

@@ -113,6 +113,17 @@ export interface TelegramBridgeStatusBusFollower {
   status?: string;
 }
 
+export interface TelegramBridgeStatusLocalBus {
+  leaderSocketPath?: string;
+  leaderTransport?: "pipe" | "socket";
+  followerSocketPath?: string;
+  followerTransport?: "pipe" | "socket";
+  followerRegistered?: boolean;
+  followerTarget?: { chatId: number; threadId?: number };
+  followerSlot?: string;
+  followerThreadName?: string;
+}
+
 export interface TelegramBridgeStatusTopicTarget {
   instanceId?: string;
   status?: string;
@@ -187,6 +198,7 @@ export interface TelegramBridgeStatusLineState {
   pendingModelSwitch: boolean;
   queuedItems: Array<{ queueLane: TelegramStatusQueueLane }>;
   busFollowers?: TelegramBridgeStatusBusFollower[];
+  localBus?: TelegramBridgeStatusLocalBus;
   topicTargets?: TelegramBridgeStatusTopicTarget[];
   threadReservations?: TelegramBridgeStatusThreadReservation[];
   topicSyncObservations?: TelegramBridgeStatusSyncObservation[];
@@ -266,6 +278,7 @@ export interface TelegramBridgeStatusRuntimeDeps<
       }
     | undefined;
   getBusFollowers?: () => TelegramBridgeStatusBusFollower[];
+  getLocalBus?: () => TelegramBridgeStatusLocalBus | undefined;
   getTopicTargets?: () => TelegramBridgeStatusTopicTarget[];
   getThreadReservations?: () => TelegramBridgeStatusThreadReservation[];
   getTopicSyncObservations?: () => TelegramBridgeStatusSyncObservation[];
@@ -626,6 +639,7 @@ export function createTelegramBridgeStatusRuntime<
         pendingModelSwitch: deps.hasPendingModelSwitch(),
         queuedItems: deps.getQueuedItems(),
         busFollowers: deps.getBusFollowers?.(),
+        localBus: deps.getLocalBus?.(),
         topicTargets: deps.getTopicTargets?.(),
         threadReservations: deps.getThreadReservations?.(),
         topicSyncObservations: deps.getTopicSyncObservations?.(),
@@ -682,6 +696,7 @@ export function createTelegramStatusSnapshot(
     },
     liveRoster: {
       busFollowers: state.busFollowers ?? [],
+      ...(state.localBus ? { localBus: state.localBus } : {}),
       topicTargets: state.topicTargets ?? [],
       reservations: state.threadReservations ?? [],
       syncObservations: state.topicSyncObservations ?? [],
@@ -756,8 +771,6 @@ export function buildTelegramStatusBarText(
     return `${label} ${theme.fg("warning", "electing")}${queued}`;
   if (!state.pollingActive && state.busRole !== "follower")
     return `${label} ${theme.fg("muted", "disconnected")}${queued}`;
-  if (state.busRole === "follower")
-    return `${label} ${theme.fg("success", "follower")}${queued}`;
   if (state.compactionInProgress) {
     return `${label} ${theme.fg("warning", "compacting")}${queued}`;
   }
@@ -769,6 +782,8 @@ export function buildTelegramStatusBarText(
       processingStatus === "active" ? "warning" : "accent";
     return `${label} ${theme.fg(processingToken, processingStatus)}${queued}`;
   }
+  if (state.busRole === "follower")
+    return `${label} ${theme.fg("success", "follower")}${queued}`;
   if (state.busRole === "leader")
     return `${label} ${theme.fg("success", "leader")}`;
   return `${label} ${theme.fg("success", "connected")}`;
@@ -824,6 +839,38 @@ function buildTelegramBusFollowerLines(
   ];
 }
 
+function buildTelegramLocalBusLines(
+  state: Pick<TelegramBridgeStatusLineState, "localBus">,
+  options: { verbose?: boolean } = {},
+): string[] {
+  const localBus = state.localBus;
+  if (!localBus) return [];
+  const target = formatTelegramStatusTarget(localBus.followerTarget);
+  const label = formatTelegramThreadStatusLabel({
+    slot: localBus.followerSlot,
+    threadName: localBus.followerThreadName,
+  });
+  const followerLine = `- follower registered: ${localBus.followerRegistered ? "yes" : "no"}${label ? ` ${label}` : ""}${target}`;
+  const lines = ["", "local bus:", followerLine];
+  if (options.verbose) {
+    if (localBus.leaderSocketPath) {
+      const transport = localBus.leaderTransport
+        ? ` [${localBus.leaderTransport}]`
+        : "";
+      lines.push(`- leader endpoint${transport}: ${localBus.leaderSocketPath}`);
+    }
+    if (localBus.followerSocketPath) {
+      const transport = localBus.followerTransport
+        ? ` [${localBus.followerTransport}]`
+        : "";
+      lines.push(
+        `- follower endpoint${transport}: ${localBus.followerSocketPath}`,
+      );
+    }
+  }
+  return lines;
+}
+
 function buildTelegramSyncSliceLines(
   state: Pick<TelegramBridgeStatusLineState, "syncState">,
 ): string[] {
@@ -1038,6 +1085,8 @@ function buildTelegramBridgeCompactStatusLines(
       : []),
     ...(state.pendingModelSwitch ? ["- pending model switch: yes"] : []),
     ...buildTelegramBridgeCompactThreadLines(state),
+    ...buildTelegramBusFollowerLines(state),
+    ...buildTelegramLocalBusLines(state),
     ...buildTelegramThreadReconciliationLines(state),
     "",
     "diagnostics:",
@@ -1100,6 +1149,7 @@ export function buildTelegramBridgeDiagnosticStatusLines(
     `- queued turns: ${state.queuedItems.length}`,
     `- lanes: control=${controlQueueCount}, priority=${priorityQueueCount}, default=${defaultQueueCount}`,
     ...buildTelegramBusFollowerLines(state),
+    ...buildTelegramLocalBusLines(state, { verbose: true }),
     ...buildTelegramTopicTargetDiagnosticLines(state),
     ...buildTelegramThreadReconciliationLines(state),
     ...buildTelegramSyncSliceLines(state),

package/lib/threads.ts

@@ -1438,7 +1438,7 @@ function getTelegramThreadNameEntropyIndex(
 
 export function getTelegramTopicThreadNameValidationError(
   threadName: string,
-  slot: string | undefined,
+  _slot: string | undefined,
 ): string | undefined {
   const identity = getTelegramTopicIdentityName(threadName);
   const reasons: string[] = [];
@@ -1501,6 +1501,60 @@ function asInteger(value: unknown): number | undefined {
   return Number.isInteger(parsed) ? parsed : undefined;
 }
 
+export interface TelegramPromoteFollowerBindingToLeaderDeps {
+  store: TelegramTopicTargetStore;
+  instanceId: string;
+  cwd?: string;
+  target?: TelegramTarget;
+  slot?: string;
+  threadName?: string;
+  nowMs?: number;
+}
+
+export async function promoteTelegramFollowerBindingToLeader(
+  deps: TelegramPromoteFollowerBindingToLeaderDeps,
+): Promise<TelegramTopicTargetRecord | undefined> {
+  const target = deps.target;
+  if (typeof target?.threadId !== "number") return undefined;
+  await deps.store.load();
+  const nowMs = deps.nowMs ?? Date.now();
+  const existing = deps.store
+    .list()
+    .find(
+      (record) =>
+        record.target.chatId === target.chatId &&
+        record.target.threadId === target.threadId,
+    );
+  const owner: TelegramThreadOwner = {
+    kind: "leader",
+    cwd: deps.cwd,
+    instanceId: deps.instanceId,
+  };
+  const record = deps.store.upsert({
+    profileKey: getTelegramThreadOwnerKey(owner),
+    owner,
+    target: { chatId: target.chatId, threadId: target.threadId },
+    status: "active",
+    createdAtMs: existing?.createdAtMs ?? nowMs,
+    updatedAtMs: nowMs,
+    ...(existing?.threadName ?? deps.threadName
+      ? { threadName: existing?.threadName ?? deps.threadName }
+      : {}),
+    instanceId: deps.instanceId,
+    ...(existing?.slot ?? deps.slot ? { slot: existing?.slot ?? deps.slot } : {}),
+    ...(existing?.syncStatus ? { syncStatus: existing.syncStatus } : {}),
+    ...(existing?.lastSyncObservedAtMs !== undefined
+      ? { lastSyncObservedAtMs: existing.lastSyncObservedAtMs }
+      : {}),
+    lastReconcileAction: "follower-promoted-to-leader",
+    ...(existing?.rerouteConfirmedAtMs !== undefined
+      ? { rerouteConfirmedAtMs: existing.rerouteConfirmedAtMs }
+      : {}),
+  });
+  await deps.store.persist();
+  return record;
+}
+
 export interface TelegramOwnTopicProvisionDeps {
   getAllowedUserId: () => number | undefined;
   instanceId: string;
@@ -2077,7 +2131,7 @@ export function createTelegramTopicTargetProvisioner(
           existing.threadName ?? identityThreadName ?? bakedThreadName,
         instanceId: request.instanceId,
         slot,
-        owner: existing.owner ?? request.owner,
+        owner: request.owner ?? existing.owner,
         lastError: undefined,
       });
       return { target: record.target, reused: true, record };