@llblab/pi-telegram 0.27.11 → 0.28.0

package/lib/sync.ts

@@ -4,7 +4,7 @@
  * Owns pure contracts for deciding when local Telegram mirror state should be refreshed without querying Telegram on every action
  */
 
-import type { TelegramTarget } from "./target.ts";
+import { getTelegramTargetKey, type TelegramTarget } from "./target.ts";
 import * as ThreadReconciler from "./thread-reconciler.ts";
 import {
   getTelegramTargetFromApiBody,
@@ -70,6 +70,7 @@ export interface TelegramTopicLifecycleSyncDeps {
   recordThreadReconciliationPlan?: (
     plan: ThreadReconciler.ThreadReconciliationPlan,
   ) => void;
+  assertExecutionCurrent?: (message: unknown) => void;
   recordEvent?: (
     category: string,
     message: unknown,
@@ -162,6 +163,52 @@ export function markTelegramConfigSyncChange<
   return nextState;
 }
 
+export interface TelegramSessionRestartThreadCleanupDeps<
+  TSyncState extends TelegramSyncState,
+> extends Omit<TelegramManualThreadDisconnectDeps<TSyncState>, "stopPolling"> {
+  suspendPolling: () => Promise<void>;
+}
+
+export function createTelegramSessionRestartThreadCleanupHandler<
+  TSyncState extends TelegramSyncState,
+>(
+  deps: TelegramSessionRestartThreadCleanupDeps<TSyncState>,
+): () => Promise<string> {
+  return createTelegramManualThreadDisconnectHandler({
+    ...deps,
+    async stopPolling() {
+      await deps.suspendPolling();
+      return "Telegram bridge suspended for session restart.";
+    },
+  });
+}
+
+export interface TelegramThreadDisconnectAssembly {
+  disconnect: () => Promise<string>;
+  cleanupForSessionRestart: () => Promise<string>;
+}
+
+export function createTelegramThreadDisconnectAssembly<
+  TSyncState extends TelegramSyncState,
+>(
+  deps: Omit<TelegramManualThreadDisconnectDeps<TSyncState>, "stopPolling"> & {
+    stopPolling: () => Promise<string>;
+    suspendPolling: () => Promise<void>;
+  },
+): TelegramThreadDisconnectAssembly {
+  return {
+    disconnect: createTelegramManualThreadDisconnectHandler({
+      ...deps,
+      stopPolling: deps.stopPolling,
+    }),
+    cleanupForSessionRestart:
+      createTelegramSessionRestartThreadCleanupHandler({
+        ...deps,
+        suspendPolling: deps.suspendPolling,
+      }),
+  };
+}
+
 export function createTelegramManualThreadDisconnectHandler<
   TSyncState extends TelegramSyncState,
 >(deps: TelegramManualThreadDisconnectDeps<TSyncState>): () => Promise<string> {
@@ -260,6 +307,8 @@ export function createTelegramLeaderHealthRuntime<
   const intervalMs = deps.intervalMs ?? 60_000;
   const getNowMs = deps.getNowMs ?? Date.now;
   let interval: ReturnType<typeof setInterval> | undefined;
+  let generation = 0;
+  let tickPromise: Promise<void> | undefined;
 
   const markFresh = (): void => {
     let state = markTelegramSyncSliceFresh(
@@ -282,20 +331,67 @@ export function createTelegramLeaderHealthRuntime<
         action: "leader-health-tick",
       }) as TSyncState,
     );
-    deps.recordEvent("telegram", error, { phase: "leader-health-tick" });
+    try {
+      deps.recordEvent("telegram", error, { phase: "leader-health-tick" });
+    } catch {
+      // Health diagnostics cannot create an unhandled timer rejection.
+    }
   };
 
   const stop = (): void => {
-    if (!interval) return;
-    clearInterval(interval);
+    generation += 1;
+    if (interval) clearInterval(interval);
     interval = undefined;
+    tickPromise = undefined;
+  };
+  const requestTick = (): Promise<void> => {
+    if (tickPromise) return tickPromise;
+    const expectedGeneration = generation;
+    let tracked: Promise<void>;
+    tracked = Promise.resolve()
+      .then(deps.callGetMe)
+      .then(
+        () => {
+          if (generation !== expectedGeneration) return;
+          try {
+            markFresh();
+          } catch (stateError) {
+            try {
+              deps.recordEvent("telegram", stateError, {
+                phase: "leader-health-state",
+              });
+            } catch {
+              // State and diagnostic failure remain contained by this owner.
+            }
+          }
+        },
+        (error) => {
+          if (generation !== expectedGeneration) return;
+          try {
+            markSuspect(error);
+          } catch (stateError) {
+            try {
+              deps.recordEvent("telegram", stateError, {
+                phase: "leader-health-state",
+              });
+            } catch {
+              // State and diagnostic failure remain contained by this owner.
+            }
+          }
+        },
+      )
+      .finally(() => {
+        if (tickPromise === tracked) tickPromise = undefined;
+      });
+    tickPromise = tracked;
+    return tracked;
   };
 
   return {
     start() {
       stop();
       interval = setInterval(() => {
-        void deps.callGetMe().then(markFresh).catch(markSuspect);
+        void requestTick();
       }, intervalMs);
       interval.unref?.();
     },
@@ -381,6 +477,32 @@ export async function ensureTelegramLeaderThreadBinding(
   assertLeaderEpoch("start");
   await deps.topicTargetStore.load();
   assertLeaderEpoch("after-load");
+  const unavailableTargetKeys = new Set([
+    ...deps.topicTargetStore
+      .listSyncObservations()
+      .filter((observation) => observation.syncStatus === "deleted")
+      .map((observation) => getTelegramTargetKey(observation.target)),
+    ...deps.topicTargetStore
+      .listPendingCleanups()
+      .map((intent) => getTelegramTargetKey(intent.target)),
+  ]);
+  let invalidatedUnavailableTarget = false;
+  for (const record of deps.topicTargetStore.list()) {
+    if (
+      record.instanceId !== deps.instanceId ||
+      !unavailableTargetKeys.has(getTelegramTargetKey(record.target))
+    ) {
+      continue;
+    }
+    invalidatedUnavailableTarget =
+      deps.topicTargetStore.markStaleByTarget(record.target) ||
+      invalidatedUnavailableTarget;
+  }
+  if (invalidatedUnavailableTarget) {
+    assertLeaderEpoch("before-unavailable-persist");
+    await deps.topicTargetStore.persist();
+    assertLeaderEpoch("after-unavailable-persist");
+  }
   const priorTargets = deps.topicTargetStore.list().filter((record) => {
     return (
       record.instanceId === deps.instanceId &&
@@ -659,6 +781,7 @@ export function createTelegramObservedTopicLifecycleSyncHandler<
     createTelegramTopicLifecycleSyncHandler<TMessage>(deps);
   return async (lifecycle) => {
     const nowMs = deps.getNowMs ?? Date.now;
+    deps.assertExecutionCurrent?.(lifecycle.message);
     deps.setSyncState(
       markTelegramSyncSliceSuspect(deps.getSyncState(), "topic-state", {
         nowMs: nowMs(),
@@ -667,6 +790,7 @@ export function createTelegramObservedTopicLifecycleSyncHandler<
       }) as TSyncState,
     );
     await syncTopicLifecycle(lifecycle);
+    deps.assertExecutionCurrent?.(lifecycle.message);
     deps.setSyncState(
       markTelegramSyncSliceFresh(deps.getSyncState(), "topic-state", {
         nowMs: nowMs(),
@@ -680,7 +804,9 @@ export function createTelegramTopicLifecycleSyncHandler<TMessage = unknown>(
   deps: TelegramTopicLifecycleSyncDeps,
 ): TelegramTopicLifecycleSyncHandler<TMessage> {
   return async (lifecycle) => {
+    deps.assertExecutionCurrent?.(lifecycle.message);
     await deps.topicTargetStore.load();
+    deps.assertExecutionCurrent?.(lifecycle.message);
     const nowMs = Date.now();
     const plan = ThreadReconciler.planThreadReconciliation({
       nowMs,

package/lib/telegram-api.ts

@@ -648,8 +648,31 @@ function getTelegramRetryDelayMs(
   return Math.max(0, baseDelayMs * 2 ** attempt);
 }
 
-function sleepTelegramRetry(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function getTelegramApiAbortReason(signal: AbortSignal): unknown {
+  return signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+
+function throwIfTelegramApiCallAborted(signal: AbortSignal | undefined): void {
+  if (signal?.aborted) throw getTelegramApiAbortReason(signal);
+}
+
+function sleepTelegramRetry(
+  ms: number,
+  signal?: AbortSignal,
+): Promise<void> {
+  if (signal?.aborted) return Promise.reject(getTelegramApiAbortReason(signal));
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      reject(getTelegramApiAbortReason(signal!));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+  });
 }
 
 function assertTelegramFileSizeWithinLimit(
@@ -1030,8 +1053,13 @@ async function callTelegramWithRetry<TResponse>(
       isTelegramApiMethodRetrySafe(method));
   const maxAttempts = Math.max(1, options?.maxAttempts ?? 3);
   const retryBaseDelayMs = options?.retryBaseDelayMs ?? 500;
-  const sleep = options?.sleep ?? sleepTelegramRetry;
+  const waitBeforeRetry = async (ms: number): Promise<void> => {
+    if (options?.sleep) await options.sleep(ms);
+    else await sleepTelegramRetry(ms, options?.signal);
+    throwIfTelegramApiCallAborted(options?.signal);
+  };
   for (let attempt = 0; ; attempt += 1) {
+    throwIfTelegramApiCallAborted(options?.signal);
     try {
       return unwrapTelegramApiResult(
         method,
@@ -1042,16 +1070,16 @@ async function callTelegramWithRetry<TResponse>(
       );
     } catch (error) {
       const retryable =
-      isRetryableTelegramApiError(error) &&
-      !(
-        options?.retryRateLimit === false &&
-        error instanceof TelegramApiHttpError &&
-        error.status === 429
-      );
+        isRetryableTelegramApiError(error) &&
+        !(
+          options?.retryRateLimit === false &&
+          error instanceof TelegramApiHttpError &&
+          error.status === 429
+        );
       if (!retrySafe) {
         if (error instanceof TelegramApiHttpError && error.status === 429) {
           if (attempt >= maxAttempts - 1) throw error;
-          await sleep(
+          await waitBeforeRetry(
             getTelegramRetryDelayMs(error, attempt, retryBaseDelayMs),
           );
           continue;
@@ -1068,7 +1096,9 @@ async function callTelegramWithRetry<TResponse>(
         throw error;
       }
       if (attempt >= maxAttempts - 1 || !retryable) throw error;
-      await sleep(getTelegramRetryDelayMs(error, attempt, retryBaseDelayMs));
+      await waitBeforeRetry(
+        getTelegramRetryDelayMs(error, attempt, retryBaseDelayMs),
+      );
     }
   }
 }

package/lib/text-groups.ts

@@ -38,6 +38,8 @@ export interface TelegramTextGroupState<TMessage, TContext = unknown> {
   dispatching?: boolean;
   suspended?: boolean;
   reschedule?: (delayMs?: number) => void;
+  dispatchNow?: () => Promise<void>;
+  dispatchPromise?: Promise<void>;
   dispatchLimit?: number;
   forwardPairCandidate?: TelegramForwardCommentBatchPosition;
 }
@@ -63,6 +65,7 @@ export interface TelegramTextGroupController<TMessage, TContext = unknown> {
       ctx: TContext,
     ) => unknown | Promise<unknown>;
   }) => boolean;
+  flushMessage: (messageId: number) => Promise<boolean>;
   suspend: () => void;
   resume: (context: TContext) => void;
   clear: () => void;
@@ -193,9 +196,18 @@ export function queueTelegramTextGroupMessage<
   const key = getTelegramTextGroupKey(options.message);
   if (!key) return false;
   const existing = options.groups.get(key);
-  if (existing?.messages.some(
+  const duplicateIndex = existing?.messages.findIndex(
     (message) => message.message_id === options.message.message_id,
-  )) return true;
+  );
+  if (existing && duplicateIndex !== undefined && duplicateIndex >= 0) {
+    existing.messages[duplicateIndex] = options.message;
+    existing.context = options.context;
+    existing.forwardPairCandidate = options.forwardPairCandidate;
+    if (!existing.suspended && !existing.dispatching && !existing.flushTimer) {
+      existing.reschedule?.();
+    }
+    return true;
+  }
   if (
     !existing &&
     !options.forceStart &&
@@ -208,46 +220,52 @@ export function queueTelegramTextGroupMessage<
   state.messages.push(options.message);
   state.context = options.context;
   state.forwardPairCandidate = options.forwardPairCandidate;
-  const dispatchQueued = (): void => {
-      state.flushTimer = undefined;
-      const queued = options.groups.get(key);
-      if (!queued || queued.context === undefined) return;
-      if (queued.dispatching) {
-        scheduleDispatch();
-        return;
-      }
-      const dispatchCount = queued.dispatchLimit ?? queued.messages.length;
-      queued.dispatchLimit = undefined;
-      const dispatchedMessages = queued.messages.slice(0, dispatchCount);
-      const dispatchedIds = new Set(
-        dispatchedMessages.map((message) => message.message_id),
-      );
-      queued.dispatching = true;
-      void Promise.resolve(
-        options.dispatchMessages(dispatchedMessages, queued.context),
-      ).then(
-        () => {
-          if (options.groups.get(key) !== queued) return;
-          queued.messages = queued.messages.filter(
-            (message) => !dispatchedIds.has(message.message_id),
-          );
-          queued.dispatching = false;
-          if (queued.messages.length === 0) options.groups.delete(key);
-          else if (!queued.flushTimer) scheduleDispatch();
-        },
-        () => {
-          if (options.groups.get(key) !== queued) return;
+  const dispatchQueued = (): Promise<void> => {
+    state.flushTimer = undefined;
+    const queued = options.groups.get(key);
+    if (!queued || queued.context === undefined) return Promise.resolve();
+    if (queued.dispatching) return queued.dispatchPromise ?? Promise.resolve();
+    const dispatchCount = queued.dispatchLimit ?? queued.messages.length;
+    queued.dispatchLimit = undefined;
+    const dispatchedMessages = queued.messages.slice(0, dispatchCount);
+    const dispatchedIds = new Set(
+      dispatchedMessages.map((message) => message.message_id),
+    );
+    queued.dispatching = true;
+    const operation = Promise.resolve(
+      options.dispatchMessages(dispatchedMessages, queued.context),
+    ).then(
+      () => {
+        if (options.groups.get(key) !== queued) return;
+        queued.messages = queued.messages.filter(
+          (message) => !dispatchedIds.has(message.message_id),
+        );
+        queued.dispatching = false;
+        queued.dispatchPromise = undefined;
+        if (queued.messages.length === 0) options.groups.delete(key);
+        else if (!queued.flushTimer) scheduleDispatch();
+      },
+      (error) => {
+        if (options.groups.get(key) === queued) {
           queued.dispatching = false;
+          queued.dispatchPromise = undefined;
           if (!queued.flushTimer) scheduleDispatch();
-        },
-      );
+        }
+        throw error;
+      },
+    );
+    queued.dispatchPromise = operation;
+    return operation;
   };
   const scheduleDispatch = (delayMs = options.debounceMs): void => {
     if (state.suspended) return;
-    state.flushTimer = options.setTimer(dispatchQueued, delayMs);
+    state.flushTimer = options.setTimer(() => {
+      void dispatchQueued().catch(() => undefined);
+    }, delayMs);
     state.flushTimer.unref?.();
   };
   state.reschedule = scheduleDispatch;
+  state.dispatchNow = dispatchQueued;
   if (state.flushTimer) options.clearTimer(state.flushTimer);
   scheduleDispatch(
     options.dispatchImmediately ? 0 : (options.delayMs ?? options.debounceMs),
@@ -390,6 +408,24 @@ export function createTelegramTextGroupController<
             : undefined,
       });
     },
+    async flushMessage(messageId) {
+      for (const state of groups.values()) {
+        if (!state.messages.some((message) => message.message_id === messageId)) {
+          continue;
+        }
+        if (state.flushTimer) clearTimer(state.flushTimer);
+        state.flushTimer = undefined;
+        await state.dispatchNow?.();
+        if (
+          state.messages.some((message) => message.message_id === messageId) &&
+          !state.dispatching
+        ) {
+          await state.dispatchNow?.();
+        }
+        return true;
+      }
+      return false;
+    },
     suspend: () => {
       for (const state of groups.values()) {
         state.suspended = true;
@@ -422,6 +458,7 @@ export function createTelegramTextGroupDispatchRuntime<
   textGroups: TelegramTextGroupController<TMessage, TContext>;
   dispatchMessages: (messages: TMessage[], ctx: TContext) => Promise<void>;
   dispatchSingleMessage: (message: TMessage, ctx: TContext) => Promise<void>;
+  onDeferredMessage?: (message: TMessage) => void;
 }): TelegramTextGroupDispatchRuntime<TMessage, TContext> {
   return {
     handleMessage: async (message, ctx) => {
@@ -431,7 +468,10 @@ export function createTelegramTextGroupDispatchRuntime<
         dispatchMessages: (messages, queuedCtx) =>
           deps.dispatchMessages(messages, queuedCtx),
       });
-      if (queuedTextGroup) return;
+      if (queuedTextGroup) {
+        deps.onDeferredMessage?.(message);
+        return;
+      }
       await deps.dispatchSingleMessage(message, ctx);
     },
   };

package/lib/threads.ts

@@ -226,6 +226,8 @@ function getNextMonotonicSlot(
 
 export interface TelegramTopicTargetStore {
   load: () => Promise<void>;
+  /** Discard process-local projections and reload owner-published state. */
+  refresh?: () => Promise<void>;
   persist: () => Promise<void>;
   list: () => TelegramTopicTargetRecord[];
   getFollowerRecoveryHintByTarget?: (
@@ -1296,6 +1298,11 @@ export function createTelegramTopicTargetStore(
       if (dirty) return;
       await loadFromDisk();
     },
+    refresh() {
+      const refresh = persistQueue.then(loadFromDisk);
+      persistQueue = refresh.catch(() => undefined);
+      return refresh;
+    },
     persist() {
       const persist = persistQueue.then(async () => {
         const path = getPath();
@@ -2459,7 +2466,7 @@ export interface TelegramCurrentInstanceThreadRuntime {
   getRestorationIdentity(): TelegramInstanceThreadIdentityCandidate;
 }
 
-export function createTelegramCurrentInstanceThreadRuntime(deps: {
+export interface TelegramCurrentInstanceThreadRuntimeDeps {
   instanceId: string;
   listRecords(): readonly TelegramTopicTargetRecord[];
   getPreferredTarget(): TelegramTarget | undefined;
@@ -2467,7 +2474,11 @@ export function createTelegramCurrentInstanceThreadRuntime(deps: {
     | (TelegramInstanceThreadIdentityCandidate & { registered: boolean })
     | undefined;
   getLeader(): TelegramInstanceThreadIdentityCandidate | undefined;
-}): TelegramCurrentInstanceThreadRuntime {
+}
+
+export function createTelegramCurrentInstanceThreadRuntime(
+  deps: TelegramCurrentInstanceThreadRuntimeDeps,
+): TelegramCurrentInstanceThreadRuntime {
   const findRecord = function (): TelegramTopicTargetRecord | undefined {
     return findCurrentTelegramInstanceThreadRecord({
       records: deps.listRecords(),
@@ -2563,6 +2574,11 @@ export interface TelegramThreadStatusProjectionRuntime {
     followerTarget?: TelegramTarget;
     followerSlot?: string;
     followerThreadName?: string;
+    leaderProtocol?: {
+      protocolVersion: number;
+      runtimeBuild: string;
+      capabilities: string[];
+    };
   };
   getTopicTargets(): ReturnType<typeof listTelegramThreadStatusTargets>;
   getThreadReservations(): ReturnType<
@@ -2575,7 +2591,7 @@ export interface TelegramThreadStatusProjectionRuntime {
   getInstanceThreadName(): string | undefined;
 }
 
-export function createTelegramThreadStatusProjectionRuntime(deps: {
+export interface TelegramThreadStatusProjectionRuntimeDeps {
   getThreadMode(): "unknown" | "enabled" | "disabled";
   isBusPollingStarted(): boolean;
   isFollowerRegistered(): boolean;
@@ -2589,8 +2605,19 @@ export function createTelegramThreadStatusProjectionRuntime(deps: {
   getFollowerTarget(): TelegramTarget | undefined;
   getFollowerSlot(): string | undefined;
   getFollowerThreadName(): string | undefined;
+  getLeaderProtocol?():
+    | {
+        protocolVersion: number;
+        runtimeBuild: string;
+        capabilities: string[];
+      }
+    | undefined;
   getCurrentIdentity(): TelegramInstanceThreadIdentityCandidate;
-}): TelegramThreadStatusProjectionRuntime {
+}
+
+export function createTelegramThreadStatusProjectionRuntime(
+  deps: TelegramThreadStatusProjectionRuntimeDeps,
+): TelegramThreadStatusProjectionRuntime {
   return {
     getBusRole() {
       if (deps.getThreadMode() === "disabled") return undefined;
@@ -2606,6 +2633,7 @@ export function createTelegramThreadStatusProjectionRuntime(deps: {
     getLocalBus() {
       const leaderSocketPath = deps.getLeaderSocketPath();
       const followerSocketPath = deps.getFollowerSocketPath();
+      const leaderProtocol = deps.getLeaderProtocol?.();
       return {
         leaderSocketPath,
         leaderTransport: deps.getTransportKind(leaderSocketPath),
@@ -2615,6 +2643,7 @@ export function createTelegramThreadStatusProjectionRuntime(deps: {
         followerTarget: deps.getFollowerTarget(),
         followerSlot: deps.getFollowerSlot(),
         followerThreadName: deps.getFollowerThreadName(),
+        ...(leaderProtocol ? { leaderProtocol } : {}),
       };
     },
     getTopicTargets: () => listTelegramThreadStatusTargets(deps.listRecords()),
@@ -2633,11 +2662,84 @@ export function createTelegramThreadStatusProjectionRuntime(deps: {
   };
 }
 
+export interface TelegramCurrentThreadAssemblyDeps {
+  instanceId: string;
+  listRecords: TelegramCurrentInstanceThreadRuntimeDeps["listRecords"];
+  getActiveTurnTarget(): TelegramTarget | undefined;
+  getFollowerTarget(): TelegramTarget | undefined;
+  isFollowerRegistered(): boolean;
+  getFollowerSlot(): string | undefined;
+  getFollowerThreadName(): string | undefined;
+  getLeaderIdentity(): TelegramInstanceThreadIdentityCandidate | undefined;
+  getLeaderTarget(): TelegramTarget | undefined;
+  getLeaderProtocol?: TelegramThreadStatusProjectionRuntimeDeps["getLeaderProtocol"];
+  status: Pick<
+    TelegramThreadStatusProjectionRuntimeDeps,
+    | "getThreadMode"
+    | "isBusPollingStarted"
+    | "listFollowers"
+    | "listReservations"
+    | "listSyncObservations"
+    | "getLeaderSocketPath"
+    | "getFollowerSocketPath"
+    | "getTransportKind"
+  >;
+}
+
+export interface TelegramCurrentThreadAssembly {
+  current: TelegramCurrentInstanceThreadRuntime;
+  status: TelegramThreadStatusProjectionRuntime;
+}
+
+/** Own current-thread preference and its matching status projection. */
+export function createTelegramCurrentThreadAssembly(
+  deps: TelegramCurrentThreadAssemblyDeps,
+): TelegramCurrentThreadAssembly {
+  const getFollower = () => {
+    const target = deps.getFollowerTarget();
+    if (!target) return undefined;
+    return {
+      registered: deps.isFollowerRegistered(),
+      target,
+      slot: deps.getFollowerSlot(),
+      threadName: deps.getFollowerThreadName(),
+    };
+  };
+  const current = createTelegramCurrentInstanceThreadRuntime({
+    instanceId: deps.instanceId,
+    listRecords: deps.listRecords,
+    getPreferredTarget: () =>
+      deps.getActiveTurnTarget() ??
+      deps.getFollowerTarget() ??
+      deps.getLeaderTarget(),
+    getFollower,
+    getLeader: deps.getLeaderIdentity,
+  });
+  return {
+    current,
+    status: createTelegramThreadStatusProjectionRuntime({
+      ...deps.status,
+      isFollowerRegistered: deps.isFollowerRegistered,
+      listRecords: deps.listRecords,
+      getFollowerTarget: deps.getFollowerTarget,
+      getFollowerSlot: deps.getFollowerSlot,
+      getFollowerThreadName: deps.getFollowerThreadName,
+      getLeaderProtocol: deps.getLeaderProtocol,
+      getCurrentIdentity: current.getRestorationIdentity,
+    }),
+  };
+}
+
 export interface TelegramThreadStatusFollowerView {
   instanceId: string;
   cwd?: string;
   lastHeartbeatMs: number;
   target?: TelegramTarget;
+  protocol?: {
+    protocolVersion: number;
+    runtimeBuild: string;
+    capabilities: string[];
+  };
 }
 
 function getTelegramThreadStatusName(
@@ -2660,6 +2762,11 @@ export function listTelegramThreadStatusFollowers(options: {
   cwd?: string;
   lastHeartbeatMs: number;
   target?: TelegramTarget;
+  protocol?: {
+    protocolVersion: number;
+    runtimeBuild: string;
+    capabilities: string[];
+  };
   slot?: string;
   threadName?: string;
   status?: string;
@@ -2676,6 +2783,7 @@ export function listTelegramThreadStatusFollowers(options: {
       cwd: follower.cwd,
       lastHeartbeatMs: follower.lastHeartbeatMs,
       target: follower.target,
+      ...(follower.protocol ? { protocol: follower.protocol } : {}),
       slot: record?.slot,
       threadName: getTelegramThreadStatusName(record),
       status: record?.status,