@llblab/pi-telegram 0.19.3 → 0.20.1

package/index.ts

@@ -32,7 +32,7 @@ import * as Queue from "./lib/queue.ts";
 import * as Replies from "./lib/replies.ts";
 import * as Routing from "./lib/routing.ts";
 import * as Runtime from "./lib/runtime.ts";
-import * as RuntimeLog from "./lib/runtime-log.ts";
+import * as Logs from "./lib/logs.ts";
 import * as Sections from "./lib/sections.ts";
 import * as Status from "./lib/status.ts";
 import * as Sync from "./lib/sync.ts";
@@ -58,16 +58,40 @@ export default function (pi: Pi.ExtensionAPI) {
   } = piRuntime;
   const bridgeRuntime = Runtime.createTelegramBridgeRuntime();
   const telegramInstanceId = `${process.pid}:${Date.now()}`;
-  const telegramManualFollowerOwnerId = String(process.pid);
-  const telegramManualFollowerProfileKey = `manual:${telegramManualFollowerOwnerId}`;
+  // Manual follower identity must survive a Pi process reload in the same
+  // terminal. The process id changes on reload, but the parent shell/terminal id
+  // is stable enough to keep the follower bound to its existing Telegram thread.
+  const telegramManualFollowerOwnerId = String(process.ppid || process.pid);
+  const getActiveTelegramThreadProfile = function (): string | undefined {
+    return configStore.getActiveProfileName();
+  };
+  const getTelegramManualFollowerProfileKey = function (): string {
+    return Threads.getTelegramThreadOwnerKey({
+      kind: "manual-follower",
+      instanceId: telegramManualFollowerOwnerId,
+      telegramProfile: getActiveTelegramThreadProfile(),
+    });
+  };
   const telegramBusAuthSecret = Bus.createTelegramBusAuthSecret();
   let telegramActiveBusAuthSecret: string | undefined;
   let telegramBusLifecycleOverridePhase:
     | Status.TelegramBridgeBusLifecyclePhase
     | undefined;
-  const telegramBusSocketPath = Bus.getTelegramBusSocketPath();
-  const telegramBusFollowerSocketPath =
-    Bus.getTelegramBusFollowerSocketPath(telegramInstanceId);
+  const getTelegramBusSocketPath = function (): string {
+    return Bus.getTelegramBusSocketPath(
+      undefined,
+      undefined,
+      getActiveTelegramThreadProfile(),
+    );
+  };
+  const getTelegramBusFollowerSocketPath = function (): string {
+    return Bus.getTelegramBusFollowerSocketPath(
+      telegramInstanceId,
+      undefined,
+      undefined,
+      getActiveTelegramThreadProfile(),
+    );
+  };
   let telegramBusRequestSequence = 0;
   const telegramBusFollowerRegistry = Bus.createTelegramBusFollowerRegistry();
   const telegramBusFollowerRegistrationState =
@@ -85,7 +109,23 @@ export default function (pi: Pi.ExtensionAPI) {
       return configStoreForRedaction?.getBotToken();
     },
   });
-  const runtimeJsonlLog = RuntimeLog.createTelegramRuntimeJsonlLog();
+  let getRuntimeLogProfileName = function (): string | undefined {
+    return undefined;
+  };
+  const runtimeJsonlLog = Logs.createTelegramRuntimeJsonlLog({
+    path: function () {
+      return Logs.getTelegramRuntimeLogPath(
+        undefined,
+        getRuntimeLogProfileName(),
+      );
+    },
+    previousPath: function () {
+      return Logs.getTelegramPreviousRuntimeLogPath(
+        undefined,
+        getRuntimeLogProfileName(),
+      );
+    },
+  });
   runtimeJsonlLog.reset("extension-start", {
     instanceId: telegramInstanceId,
     pid: process.pid,
@@ -103,6 +143,7 @@ export default function (pi: Pi.ExtensionAPI) {
   };
   const configStore = Config.createTelegramConfigStore({ recordRuntimeEvent });
   configStoreForRedaction = configStore;
+  getRuntimeLogProfileName = configStore.getActiveProfileName;
   const isTelegramBusConfigured = function (): boolean {
     return true;
   };
@@ -112,9 +153,15 @@ export default function (pi: Pi.ExtensionAPI) {
   Config.bindGlobalTelegramConfigRuntime(configStore);
   const configControls = Config.createTelegramConfigControls(configStore);
   const threadStore = Threads.createTelegramTopicTargetStore({
-    path: Threads.getTelegramTopicTargetsPath(),
+    path: function () {
+      return Threads.getTelegramTopicTargetsPath(
+        undefined,
+        configStore.getActiveProfileName(),
+      );
+    },
   });
   const lockRuntime = Locks.createTelegramLockRuntime<Pi.ExtensionContext>({
+    key: Locks.createTelegramLockKeyResolver(configStore),
     instanceId: telegramInstanceId,
     busSecret: telegramBusAuthSecret,
     staleHeartbeatMs: Locks.TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS,
@@ -201,7 +248,7 @@ export default function (pi: Pi.ExtensionAPI) {
     await configStore.persist();
     markTelegramConfigSyncChange("config-persist");
   };
-  const getCurrentThreadRecord = function ():
+  const findCurrentThreadRecord = function ():
     | Threads.TelegramTopicTargetRecord
     | undefined {
     return Threads.findCurrentTelegramInstanceThreadRecord({
@@ -213,11 +260,24 @@ export default function (pi: Pi.ExtensionAPI) {
         telegramBusLeaderTarget,
     });
   };
+  const getCurrentThreadRecord = function ():
+    | Threads.TelegramTopicTargetRecord
+    | undefined {
+    const record = findCurrentThreadRecord();
+    if (
+      record?.owner?.kind === "manual-follower" &&
+      !telegramBusFollowerRegistrationState.isRegistered()
+    ) {
+      return undefined;
+    }
+    return record;
+  };
   const statusRuntime = Status.createTelegramBridgeStatusRuntime<
     Pi.ExtensionContext,
     Queue.TelegramQueueItem<Pi.ExtensionContext>
   >({
     getConfig: configStore.get,
+    getActiveProfileName: configStore.getActiveProfileName,
     isPollingActive: Polling.createTelegramPollingActivityReader(
       pollingControllerState,
     ),
@@ -252,12 +312,13 @@ export default function (pi: Pi.ExtensionAPI) {
     },
     getLocalBus() {
       return {
-        leaderSocketPath: telegramBusSocketPath,
-        leaderTransport:
-          BusTransport.getTelegramBusTransportKind(telegramBusSocketPath),
-        followerSocketPath: telegramBusFollowerSocketPath,
+        leaderSocketPath: getTelegramBusSocketPath(),
+        leaderTransport: BusTransport.getTelegramBusTransportKind(
+          getTelegramBusSocketPath(),
+        ),
+        followerSocketPath: getTelegramBusFollowerSocketPath(),
         followerTransport: BusTransport.getTelegramBusTransportKind(
-          telegramBusFollowerSocketPath,
+          getTelegramBusFollowerSocketPath(),
         ),
         followerRegistered: telegramBusFollowerRegistrationState.isRegistered(),
         followerTarget: telegramBusFollowerRegistrationState.getTarget(),
@@ -302,15 +363,12 @@ export default function (pi: Pi.ExtensionAPI) {
     },
   });
   const { updateStatus: updateStatusLine } = statusRuntime;
-  let lastRuntimeLogScopeKey: string | undefined;
   const updateRuntimeLogScope = function (reason: string) {
     const scope = Status.createTelegramRuntimeLogScope({
       state: statusRuntime.getStatusState(),
       instanceId: telegramInstanceId,
     });
     const scopeKey = JSON.stringify(scope);
-    if (scopeKey === lastRuntimeLogScopeKey) return;
-    lastRuntimeLogScopeKey = scopeKey;
     runtimeJsonlLog.resetIfScopeChanged(scopeKey, reason, scope);
   };
   const updateStatus = function (ctx: Pi.ExtensionContext) {
@@ -367,7 +425,7 @@ export default function (pi: Pi.ExtensionAPI) {
     },
     getDefaultTarget: proactivePushTargetGetter,
     callFollowerApi: BusFollower.createTelegramBusFollowerApiCaller({
-      socketPath: telegramBusSocketPath,
+      socketPath: getTelegramBusSocketPath,
       instanceId: telegramInstanceId,
       createRequestId() {
         telegramBusRequestSequence += 1;
@@ -596,7 +654,7 @@ export default function (pi: Pi.ExtensionAPI) {
       Routing.TelegramRoutedCallbackQuery,
       Routing.TelegramRoutedMessage
     >({
-      socketPath: telegramBusSocketPath,
+      socketPath: getTelegramBusSocketPath,
       createRequestId() {
         telegramBusRequestSequence += 1;
         return Bus.createTelegramBusRequestId({
@@ -611,7 +669,7 @@ export default function (pi: Pi.ExtensionAPI) {
     });
   const followerTargetController =
     Bus.createTelegramBusFollowerTargetController({
-      socketPath: telegramBusSocketPath,
+      socketPath: getTelegramBusSocketPath,
       createRequestId() {
         telegramBusRequestSequence += 1;
         return Bus.createTelegramBusRequestId({
@@ -766,7 +824,7 @@ export default function (pi: Pi.ExtensionAPI) {
       Routing.TelegramRoutedCallbackQuery,
       Routing.TelegramRoutedMessage
     >({
-      socketPath: telegramBusFollowerSocketPath,
+      socketPath: getTelegramBusFollowerSocketPath,
       instanceId: telegramInstanceId,
       getContext() {
         return telegramSessionContextStore.get();
@@ -800,7 +858,7 @@ export default function (pi: Pi.ExtensionAPI) {
           topicTargetStore: threadStore,
           registrationState: telegramBusFollowerRegistrationState,
           instanceId: telegramInstanceId,
-          manualFollowerProfileKey: telegramManualFollowerProfileKey,
+          manualFollowerProfileKey: getTelegramManualFollowerProfileKey(),
           manualFollowerOwnerId: telegramManualFollowerOwnerId,
           getSyncState() {
             return telegramSyncState;
@@ -834,6 +892,7 @@ export default function (pi: Pi.ExtensionAPI) {
               store: threadStore,
               instanceId: telegramInstanceId,
               cwd: ctx.cwd,
+              telegramProfile: getActiveTelegramThreadProfile(),
               target: binding.target,
               slot: binding.slot,
               threadName: binding.threadName,
@@ -864,7 +923,8 @@ export default function (pi: Pi.ExtensionAPI) {
     BusFollower.createTelegramBusFollowerRegistrationRuntime<Pi.ExtensionContext>(
       {
         instanceId: telegramInstanceId,
-        followerBusSocketPath: telegramBusFollowerSocketPath,
+        getFollowerBusSocketPath: getTelegramBusFollowerSocketPath,
+        getLeaderSocketPath: getTelegramBusSocketPath,
         startReceiving: telegramBusForwardedUpdateReceiver.start,
         stopReceiving: telegramBusForwardedUpdateReceiver.stop,
         registrationState: telegramBusFollowerRegistrationState,
@@ -885,7 +945,7 @@ export default function (pi: Pi.ExtensionAPI) {
           return undefined;
         },
         getProfileKey() {
-          return telegramManualFollowerProfileKey;
+          return getTelegramManualFollowerProfileKey();
         },
         onHeartbeatFailure: telegramFollowerHeartbeatRecovery,
         recordRuntimeEvent,
@@ -921,7 +981,7 @@ export default function (pi: Pi.ExtensionAPI) {
     });
   };
   const telegramBusLeaderRuntime = BusLeader.createTelegramBusLeaderRuntime({
-    socketPath: telegramBusSocketPath,
+    socketPath: getTelegramBusSocketPath,
     followerRegistry: telegramBusFollowerRegistry,
     authSecret: telegramBusAuthSecret,
     startPolling: pollingRuntime.start,
@@ -942,6 +1002,7 @@ export default function (pi: Pi.ExtensionAPI) {
         getCwd(ctx) {
           return typeof ctx.cwd === "string" ? ctx.cwd : undefined;
         },
+        getTelegramProfile: getActiveTelegramThreadProfile,
         shouldForceFreshUnnamed() {
           return forceFreshLeaderThreadOnNextStart;
         },
@@ -1174,7 +1235,7 @@ export default function (pi: Pi.ExtensionAPI) {
   const disconnectTelegramAndDeleteCurrentThread =
     Sync.createTelegramManualThreadDisconnectHandler({
       instanceId: telegramInstanceId,
-      getCurrentThreadRecord,
+      getCurrentThreadRecord: findCurrentThreadRecord,
       topicTargetStore: threadStore,
       callApi: callTelegramApi,
       getLeaderTarget() {
@@ -1199,6 +1260,14 @@ export default function (pi: Pi.ExtensionAPI) {
       registrationState: telegramBusFollowerRegistrationState,
       instanceId: telegramInstanceId,
       suspendPolling: lockedPollingRuntime.suspend,
+      onFollowerSessionDisconnect() {
+        const target = telegramBusFollowerRegistrationState.getTarget();
+        if (!target) return undefined;
+        return BusFollower.markTelegramFollowerThreadStaleForSessionDisconnect({
+          topicTargetStore: threadStore,
+          target,
+        });
+      },
       recordRuntimeEvent,
     });
   const queueSessionLifecycle = Queue.createTelegramSessionLifecycleRuntime({

package/lib/bindings.ts

@@ -73,8 +73,8 @@ export function registerTelegramCommandsAndTools({
   getDefaultChatId,
   getDefaultTarget,
   canSendDirect,
-  updateStatus,
   recordRuntimeEvent,
+  updateStatus,
 }: TelegramCommandsAndToolsBindingDeps): void {
   OutboundAttachments.registerTelegramOutboundAttachmentTool(pi, {
     getActiveTurn: activeTurnRuntime.get,
@@ -96,22 +96,72 @@ export function registerTelegramCommandsAndTools({
   });
   Prompts.registerTelegramHelpTool(pi);
   Commands.registerTelegramBridgeCommands(pi, {
-    promptForConfig: Setup.createTelegramSetupPromptRuntime({
-      getConfig: configStore.get,
-      setConfig: configStore.set,
-      setupGuard: setup,
-      getMe: TelegramApi.fetchTelegramBotIdentity,
-      persistConfig,
-      startPolling: lockedPollingRuntime.start,
-      updateStatus,
-      recordRuntimeEvent,
-    }),
+    promptForConfig: async (ctx, profileName) => {
+      const nextProfileName = profileName ?? undefined;
+      if (profileName && !Config.isValidTelegramProfileName(profileName)) {
+        ctx.ui.notify(`Invalid Telegram profile name: ${profileName}`, "error");
+        return;
+      }
+      const previousProfileName = configStore.getActiveProfileName();
+      if (previousProfileName !== nextProfileName) {
+        await (stopPolling ?? lockedPollingRuntime.stop)();
+      }
+      if (!profileName) {
+        configStore.activateProfile(undefined);
+      } else {
+        const storedConfig = configStore.getStoredConfig();
+        if (!storedConfig.profiles?.[profileName]) {
+          configStore.set({
+            ...storedConfig,
+            profiles: {
+              ...(storedConfig.profiles ?? {}),
+              [profileName]: { botToken: "" },
+            },
+          });
+        }
+        configStore.activateProfile(profileName);
+      }
+      const runSetup = Setup.createTelegramSetupPromptRuntime({
+        getConfig: configStore.get,
+        setConfig: configStore.set,
+        setupGuard: setup,
+        getMe: TelegramApi.fetchTelegramBotIdentity,
+        persistConfig,
+        startPolling: lockedPollingRuntime.start,
+        updateStatus,
+        recordRuntimeEvent,
+      });
+      await runSetup(ctx);
+      if (profileName) {
+        ctx.ui.notify(`Profile "${profileName}" saved and connected.`, "info");
+      }
+    },
     getStatusLines,
     reloadConfig: configStore.load,
     hasBotToken: configStore.hasBotToken,
     startPolling: lockedPollingRuntime.start,
     stopPolling: stopPolling ?? lockedPollingRuntime.stop,
     updateStatus,
+    getProfileNames: () =>
+      Config.getTelegramProfileNames(configStore.getStoredConfig()),
+    activateDefaultProfileConfig: async () => {
+      await configStore.load();
+      const previousProfileName = configStore.getActiveProfileName();
+      if (previousProfileName) {
+        await (stopPolling ?? lockedPollingRuntime.stop)();
+      }
+      configStore.activateProfile(undefined);
+    },
+    activateProfileConfig: async (_ctx, profileName) => {
+      await configStore.load();
+      if (!Config.isValidTelegramProfileName(profileName)) return false;
+      const previousProfileName = configStore.getActiveProfileName();
+      if (previousProfileName !== profileName) {
+        await (stopPolling ?? lockedPollingRuntime.stop)();
+      }
+      if (!configStore.activateProfile(profileName)) return false;
+      return true;
+    },
   });
 }
 

package/lib/bus-follower.ts

@@ -16,8 +16,10 @@ import {
   createTelegramBusLocalServer,
   createUnauthorizedBusAck,
   getTelegramBusSocketPath,
+  resolveTelegramBusSocketPath,
   sendTelegramBusLocalEnvelope,
   type TelegramBusEnvelope,
+  type TelegramBusSocketPathSource,
 } from "./bus.ts";
 import {
   getTelegramBusTransportRetryPolicy,
@@ -90,6 +92,7 @@ export interface TelegramBusFollowerSessionReplacementSuspenderDeps {
   registrationState: Pick<TelegramBusFollowerRegistrationState, "isRegistered">;
   instanceId: string;
   suspendPolling: () => Promise<void>;
+  onFollowerSessionDisconnect?: () => Promise<void> | void;
   recordRuntimeEvent: (
     category: string,
     error: unknown,
@@ -132,7 +135,7 @@ export interface TelegramBusForwardedUpdateReceiverRuntime {
 }
 
 export interface TelegramBusFollowerApiCallerDeps {
-  socketPath: string;
+  socketPath: TelegramBusSocketPathSource;
   instanceId: string;
   createRequestId: () => string;
   getAuthSecret?: () => string | undefined;
@@ -148,6 +151,7 @@ export interface TelegramBusFollowerRegistrationRuntimeDeps<
   getLeaderAuthSecret?: (leader: { busSecret?: string }) => string | undefined;
   setActiveAuthSecret?: (secret: string | undefined) => void;
   followerBusSocketPath?: string;
+  getFollowerBusSocketPath?: () => string;
   getLeaderSocketPath?: () => string;
   startReceiving?: () => Promise<void>;
   stopReceiving?: () => Promise<void> | void;
@@ -237,7 +241,7 @@ export interface TelegramBusForwardedUpdateReceiverRuntimeDeps<
   TCallbackQuery,
   TMessage = unknown,
 > {
-  socketPath: string;
+  socketPath: TelegramBusSocketPathSource;
   instanceId: string;
   getAuthSecret?: () => string | undefined;
   getContext: () => TContext | undefined;
@@ -353,11 +357,12 @@ export function createTelegramBusFollowerApiCaller(
   const getNowMs = deps.getNowMs ?? Date.now;
   const timeoutMs = deps.timeoutMs ?? 30000;
   return async (method, args) => {
+    const socketPath = resolveTelegramBusSocketPath(deps.socketPath);
     const response = await sendTelegramBusLocalEnvelope({
-      socketPath: deps.socketPath,
+      socketPath,
       timeoutMs,
       retry: getTelegramBusTransportRetryPolicy({
-        endpoint: deps.socketPath,
+        endpoint: socketPath,
         operation: "operation",
       }),
       envelope: {
@@ -387,24 +392,42 @@ function isTelegramStaleContextError(error: unknown): boolean {
   );
 }
 
+export async function markTelegramFollowerThreadStaleForSessionDisconnect(input: {
+  topicTargetStore: Threads.TelegramTopicTargetStore;
+  target: TelegramTarget;
+}): Promise<void> {
+  await input.topicTargetStore.load();
+  const record = input.topicTargetStore.list().find(
+    (candidate) =>
+      candidate.target.chatId === input.target.chatId &&
+      candidate.target.threadId === input.target.threadId,
+  );
+  const marked = input.topicTargetStore.markStaleByTarget(
+    input.target,
+    "unknown",
+    "Follower session reloaded before reconnect.",
+  );
+  const forgotIdentity = record?.profileKey
+    ? input.topicTargetStore.forgetIdentityByProfileKey(record.profileKey)
+    : false;
+  if (marked || forgotIdentity) await input.topicTargetStore.persist();
+}
+
 export function createTelegramBusFollowerSessionReplacementSuspender(
   deps: TelegramBusFollowerSessionReplacementSuspenderDeps,
 ): () => Promise<void> {
   return async () => {
     if (deps.registrationState.isRegistered()) {
-      setTelegramFollowerSessionHandoff({
-        pid: (deps.getPid ?? (() => process.pid))(),
-        instanceId: deps.instanceId,
-        createdAtMs: (deps.getNowMs ?? Date.now)(),
-      });
+      setTelegramFollowerSessionHandoff(undefined);
+      await deps.onFollowerSessionDisconnect?.();
       deps.recordRuntimeEvent(
         "bus",
-        "Telegram follower registration preserved",
+        "Telegram follower registration stopped for session replacement",
         {
-          phase: "follower-session-preserve",
+          phase: "follower-session-disconnect",
+          instanceId: deps.instanceId,
         },
       );
-      return;
     }
     await deps.suspendPolling();
   };
@@ -706,7 +729,8 @@ export function createTelegramBusFollowerRegistrationRuntime<
             (ctx.cwd ? basename(ctx.cwd) : undefined),
           cwd: ctx.cwd,
           pid: getPid(),
-          busSocketPath: deps.followerBusSocketPath,
+          busSocketPath:
+            deps.getFollowerBusSocketPath?.() ?? deps.followerBusSocketPath,
           connectedAtMs: getNowMs(),
         },
       });

package/lib/bus-leader.ts

@@ -20,6 +20,7 @@ import {
   type TelegramBusFollowerRegistry,
   type TelegramBusFollowerView,
   type TelegramBusInstanceRegistration,
+  type TelegramBusSocketPathSource,
 } from "./bus.ts";
 import { getTelegramBusTransportRetryPolicy } from "./bus-transport.ts";
 
@@ -54,6 +55,7 @@ export interface TelegramBusLeaderTargetProvisionerDeps<TContext> {
   getAllowedUserId: () => number | undefined;
   instanceId: string;
   getCwd?: (ctx: TContext) => string | undefined;
+  getTelegramProfile?: () => string | undefined;
   shouldForceFreshUnnamed?: () => boolean;
   topicTargetStore: Threads.TelegramTopicTargetStore;
   callApi: <TResponse>(
@@ -175,7 +177,7 @@ export type TelegramBusFollowerMessageOwnershipRecorder = (
 ) => void;
 
 export interface TelegramBusLeaderRuntimeDeps<TContext> {
-  socketPath: string;
+  socketPath: TelegramBusSocketPathSource;
   followerRegistry: TelegramBusFollowerRegistry;
   authSecret?: string;
   startPolling: (ctx: TContext) => void | Promise<void>;
@@ -315,6 +317,10 @@ export function createTelegramBusFollowerTargetProvisioner(
   (TelegramTarget & { slot?: string; threadName?: string }) | undefined
 > {
   const getNowMs = deps.getNowMs ?? Date.now;
+  const pendingRegistrations = new Map<
+    string,
+    Promise<(TelegramTarget & { slot?: string; threadName?: string }) | undefined>
+  >();
   return async (registration) => {
     const registrationStartedAtMs = Date.now();
     const chatId = deps.getAllowedUserId();
@@ -337,6 +343,9 @@ export function createTelegramBusFollowerTargetProvisioner(
       registration.profileKey ?? `manual:${registration.instanceId}`;
     const followerOwner =
       Threads.getTelegramThreadOwnerFromProfileKey(followerProfileKey);
+    const registrationKey = followerProfileKey || registration.instanceId;
+    const pendingRegistration = pendingRegistrations.get(registrationKey);
+    if (pendingRegistration) return pendingRegistration;
     const provisionTarget = async () => {
       deps.onProvisioningStart?.();
       try {
@@ -356,6 +365,9 @@ export function createTelegramBusFollowerTargetProvisioner(
         deps.onProvisioningEnd?.();
       }
     };
+    const runRegistration = async (): Promise<
+      (TelegramTarget & { slot?: string; threadName?: string }) | undefined
+    > => {
     let result = await provisionTarget();
     deps.setSyncState(
       Sync.markTelegramSyncSliceFresh(deps.getSyncState(), "target-bindings", {
@@ -363,48 +375,14 @@ export function createTelegramBusFollowerTargetProvisioner(
         action: "follower-register",
       }),
     );
-    let connectedAnnouncement =
-      createTelegramBusInstanceLifecycleAnnouncement({
-        target: result.target,
-        threadName: result.record.threadName,
-        slot: result.record.slot,
-        state: "connected",
-      });
-    let connectedAnnouncementSent = false;
-    if (result.reused && connectedAnnouncement) {
-      try {
-        await deps.callApi("sendMessage", {
-          chat_id: connectedAnnouncement.target.chatId,
-          message_thread_id: connectedAnnouncement.target.threadId,
-          text: connectedAnnouncement.text,
-          parse_mode: connectedAnnouncement.parseMode,
-        });
-        connectedAnnouncementSent = true;
-      } catch (error) {
-        deps.recordRuntimeEvent("telegram", error, {
-          phase: "follower-topic-reuse-probe",
-          instanceId: registration.instanceId,
-          chatId: result.target.chatId,
-          threadId: result.target.threadId,
+    const connectedAnnouncement = result.reused
+      ? undefined
+      : createTelegramBusInstanceLifecycleAnnouncement({
+          target: result.target,
+          threadName: result.record.threadName,
+          slot: result.record.slot,
+          state: "connected",
         });
-        if (Threads.isTelegramTopicTargetStaleError(error)) {
-          deps.topicTargetStore.markStaleByTarget(
-            result.target,
-            "deleted",
-            "Follower registration found the reusable thread target stale.",
-          );
-          await deps.topicTargetStore.persist();
-          result = await provisionTarget();
-          connectedAnnouncement = createTelegramBusInstanceLifecycleAnnouncement({
-            target: result.target,
-            threadName: result.record.threadName,
-            slot: result.record.slot,
-            state: "connected",
-          });
-          connectedAnnouncementSent = false;
-        }
-      }
-    }
     recordSlowTelegramBusFollowerRegistrationStep(deps, {
       phase: "follower-register-critical",
       elapsedMs: Date.now() - registrationStartedAtMs,
@@ -414,7 +392,7 @@ export function createTelegramBusFollowerTargetProvisioner(
     });
     scheduleTelegramBusLeaderBackgroundTask(async () => {
       const backgroundStartedAtMs = Date.now();
-      if (connectedAnnouncement && !connectedAnnouncementSent) {
+      if (connectedAnnouncement) {
         try {
           await deps.callApi("sendMessage", {
             chat_id: connectedAnnouncement.target.chatId,
@@ -486,6 +464,12 @@ export function createTelegramBusFollowerTargetProvisioner(
       slot: result.record.slot,
       threadName: result.record.threadName,
     };
+    };
+    const registrationPromise = runRegistration().finally(() => {
+      pendingRegistrations.delete(registrationKey);
+    });
+    pendingRegistrations.set(registrationKey, registrationPromise);
+    return registrationPromise;
   };
 }
 
@@ -516,6 +500,7 @@ export function createTelegramBusLeaderTargetProvisioner<TContext>(
         getAllowedUserId: deps.getAllowedUserId,
         instanceId: deps.instanceId,
         cwd: deps.getCwd?.(ctx),
+        telegramProfile: deps.getTelegramProfile?.(),
         forceFreshUnnamed: deps.shouldForceFreshUnnamed?.(),
         getNowMs,
         getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,