@llblab/pi-telegram 0.20.0 → 0.20.2

package/lib/bus-follower.ts

@@ -16,8 +16,10 @@ import {
   createTelegramBusLocalServer,
   createUnauthorizedBusAck,
   getTelegramBusSocketPath,
+  resolveTelegramBusSocketPath,
   sendTelegramBusLocalEnvelope,
   type TelegramBusEnvelope,
+  type TelegramBusSocketPathSource,
 } from "./bus.ts";
 import {
   getTelegramBusTransportRetryPolicy,
@@ -133,7 +135,7 @@ export interface TelegramBusForwardedUpdateReceiverRuntime {
 }
 
 export interface TelegramBusFollowerApiCallerDeps {
-  socketPath: string;
+  socketPath: TelegramBusSocketPathSource;
   instanceId: string;
   createRequestId: () => string;
   getAuthSecret?: () => string | undefined;
@@ -149,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;
@@ -170,6 +173,63 @@ export interface TelegramBusFollowerRegistrationRuntimeDeps<
   onHeartbeatFailure?: (error: unknown, ctx: TContext) => Promise<void> | void;
 }
 
+export function createTelegramManualFollowerProfileKeyResolver(input: {
+  getActiveProfileName: () => string | undefined;
+  manualFollowerOwnerId: string;
+}): () => string {
+  return () =>
+    Threads.getTelegramThreadOwnerKey({
+      kind: "manual-follower",
+      instanceId: input.manualFollowerOwnerId,
+      telegramProfile: input.getActiveProfileName(),
+    });
+}
+
+export type TelegramBusFollowerPromotionHandler<TContext> = (
+  ctx: TContext,
+  binding: TelegramBusFollowerPromotedBinding,
+) => Promise<void>;
+
+export function createTelegramBusFollowerPromotionHandler<
+  TContext extends { cwd: string },
+>(input: {
+  topicTargetStore: Threads.TelegramTopicTargetStore;
+  instanceId: string;
+  getActiveProfileName: () => string | undefined;
+  startLeader: (ctx: TContext) => Promise<unknown> | unknown;
+  recordRuntimeEvent: (
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ) => void;
+}): TelegramBusFollowerPromotionHandler<TContext> {
+  return async (ctx, binding) => {
+    const promotedRecord = await Threads.promoteTelegramFollowerBindingToLeader({
+      store: input.topicTargetStore,
+      instanceId: input.instanceId,
+      cwd: ctx.cwd,
+      telegramProfile: input.getActiveProfileName(),
+      target: binding.target,
+      slot: binding.slot,
+      threadName: binding.threadName,
+    });
+    if (promotedRecord) {
+      input.recordRuntimeEvent(
+        "bus",
+        "Follower thread binding promoted to leader",
+        {
+          phase: "follower-promoted-binding",
+          chatId: promotedRecord.target.chatId,
+          threadId: promotedRecord.target.threadId,
+          slot: promotedRecord.slot,
+          threadName: promotedRecord.threadName,
+        },
+      );
+    }
+    await input.startLeader(ctx);
+  };
+}
+
 export interface TelegramBusFollowerTargetReplacementHandlerDeps<TContext> {
   topicTargetStore: Pick<
     Threads.TelegramTopicTargetStore,
@@ -180,7 +240,7 @@ export interface TelegramBusFollowerTargetReplacementHandlerDeps<TContext> {
     "getTarget" | "setRegistered"
   >;
   instanceId: string;
-  manualFollowerProfileKey: string;
+  getManualFollowerProfileKey: () => string;
   manualFollowerOwnerId: string;
   getSyncState: () => Sync.TelegramSyncState;
   setSyncState: (state: Sync.TelegramSyncState) => void;
@@ -238,7 +298,7 @@ export interface TelegramBusForwardedUpdateReceiverRuntimeDeps<
   TCallbackQuery,
   TMessage = unknown,
 > {
-  socketPath: string;
+  socketPath: TelegramBusSocketPathSource;
   instanceId: string;
   getAuthSecret?: () => string | undefined;
   getContext: () => TContext | undefined;
@@ -273,6 +333,71 @@ export interface TelegramBusForwardedUpdateReceiverRuntimeDeps<
   ) => void;
 }
 
+export interface TelegramBusFollowerRuntimeAssemblyDeps<
+  TContext extends { cwd?: string },
+  TReactionUpdate,
+  TCallbackQuery,
+  TMessage = unknown,
+> {
+  receiver: Omit<
+    TelegramBusForwardedUpdateReceiverRuntimeDeps<
+      TContext,
+      TReactionUpdate,
+      TCallbackQuery,
+      TMessage
+    >,
+    "handleReplaceTarget"
+  >;
+  targetReplacement: TelegramBusFollowerTargetReplacementHandlerDeps<TContext>;
+  recovery: Omit<
+    TelegramBusFollowerHeartbeatRecoveryHandlerDeps<TContext>,
+    "getRegistrationRuntime"
+  >;
+  registration: Omit<
+    TelegramBusFollowerRegistrationRuntimeDeps<TContext>,
+    "startReceiving" | "stopReceiving" | "onHeartbeatFailure"
+  >;
+}
+
+export interface TelegramBusFollowerRuntimeAssembly<TContext> {
+  receiver: TelegramBusForwardedUpdateReceiverRuntime;
+  registration: TelegramBusFollowerRegistrationRuntime<TContext>;
+}
+
+export function createTelegramBusFollowerRuntimeAssembly<
+  TContext extends { cwd?: string },
+  TReactionUpdate,
+  TCallbackQuery,
+  TMessage = unknown,
+>(
+  deps: TelegramBusFollowerRuntimeAssemblyDeps<
+    TContext,
+    TReactionUpdate,
+    TCallbackQuery,
+    TMessage
+  >,
+): TelegramBusFollowerRuntimeAssembly<TContext> {
+  const receiver = createTelegramBusForwardedUpdateReceiverRuntime({
+    ...deps.receiver,
+    handleReplaceTarget:
+      createTelegramBusFollowerTargetReplacementHandler(
+        deps.targetReplacement,
+      ),
+  });
+  let registration: TelegramBusFollowerRegistrationRuntime<TContext>;
+  const recovery = createTelegramBusFollowerHeartbeatRecoveryHandler({
+    ...deps.recovery,
+    getRegistrationRuntime: () => registration,
+  });
+  registration = createTelegramBusFollowerRegistrationRuntime({
+    ...deps.registration,
+    startReceiving: receiver.start,
+    stopReceiving: receiver.stop,
+    onHeartbeatFailure: recovery,
+  });
+  return { receiver, registration };
+}
+
 export function createTelegramBusFollowerTargetReplacementHandler<TContext>(
   deps: TelegramBusFollowerTargetReplacementHandlerDeps<TContext>,
 ): NonNullable<
@@ -305,7 +430,7 @@ export function createTelegramBusFollowerTargetReplacementHandler<TContext>(
       );
     }
     const profileKey =
-      currentRecord?.profileKey ?? deps.manualFollowerProfileKey;
+      currentRecord?.profileKey ?? deps.getManualFollowerProfileKey();
     deps.topicTargetStore.upsert({
       profileKey,
       owner: {
@@ -354,11 +479,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: {
@@ -650,6 +776,7 @@ export function createTelegramBusFollowerRegistrationRuntime<
   let activeLeaderSocketPath: string | undefined;
   let activeAuthSecret: string | undefined;
   let activeContext: TContext | undefined;
+  let lastKnownTarget: TelegramTarget | undefined;
   const stopHeartbeat = () => {
     if (!heartbeatInterval) return;
     clearInterval(heartbeatInterval);
@@ -660,6 +787,7 @@ export function createTelegramBusFollowerRegistrationRuntime<
     activeAuthSecret = undefined;
     deps.setActiveAuthSecret?.(undefined);
     deps.registrationState?.setRegistered(false);
+    lastKnownTarget = undefined;
     activeContext = undefined;
     void deps.stopReceiving?.();
   };
@@ -725,7 +853,9 @@ export function createTelegramBusFollowerRegistrationRuntime<
             (ctx.cwd ? basename(ctx.cwd) : undefined),
           cwd: ctx.cwd,
           pid: getPid(),
-          busSocketPath: deps.followerBusSocketPath,
+          target: deps.registrationState?.getTarget() ?? lastKnownTarget,
+          busSocketPath:
+            deps.getFollowerBusSocketPath?.() ?? deps.followerBusSocketPath,
           connectedAtMs: getNowMs(),
         },
       });
@@ -778,6 +908,7 @@ export function createTelegramBusFollowerRegistrationRuntime<
           registrationResult.target,
           registrationResult,
         );
+        lastKnownTarget = registrationResult.target;
         activeLeaderSocketPath = leaderSocketPath;
         activeContext = ctx;
         await sendHeartbeat();

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";
 
@@ -153,15 +154,105 @@ export interface TelegramBusLeaderApiProxyDeps {
   ) => Promise<unknown> | unknown;
 }
 
-export interface TelegramBusFollowerRegistryRestoreDeps {
-  topicTargetStore: Pick<Threads.TelegramTopicTargetStore, "load" | "list">;
-  followerRegistry: TelegramBusFollowerRegistry;
+export interface TelegramBusLeaderRuntimeAssemblyDeps<TContext> {
+  runtime: Omit<
+    TelegramBusLeaderRuntimeDeps<TContext>,
+    | "callApi"
+    | "onFollowerPruned"
+    | "provisionFollowerTarget"
+    | "provisionLeaderTarget"
+    | "reconcileFollowerBindings"
+    | "recordRuntimeEvent"
+  >;
+  getAllowedUserId: () => number | undefined;
+  instanceId: string;
+  getCwd?: (ctx: TContext) => string | undefined;
+  getTelegramProfile?: () => string | undefined;
+  shouldForceFreshUnnamed?: () => boolean;
+  topicTargetStore: Threads.TelegramTopicTargetStore;
+  callApi: TelegramBusLeaderTargetProvisionerDeps<TContext>["callApi"];
+  callMultipart: TelegramBusLeaderApiProxyDeps["callMultipart"];
+  downloadFile: TelegramBusLeaderApiProxyDeps["downloadFile"];
+  recoverStaleTargetError?: TelegramBusLeaderApiProxyDeps["recoverStaleTargetError"];
+  getCurrentLeaderEpoch?: () => number | string | undefined;
+  getThreadReconciliationMachineState?: TelegramBusLeaderTargetProvisionerDeps<TContext>["getThreadReconciliationMachineState"];
+  recordThreadReconciliationPlan?: TelegramBusLeaderTargetProvisionerDeps<TContext>["recordThreadReconciliationPlan"];
+  getSyncState: () => Sync.TelegramSyncState;
+  setSyncState: (state: Sync.TelegramSyncState) => void;
+  setLeaderTarget: TelegramBusLeaderTargetProvisionerDeps<TContext>["setLeaderTarget"];
+  onProvisioningStart?: () => void;
+  onProvisioningEnd?: () => void;
+  recordRuntimeEvent: NonNullable<
+    TelegramBusLeaderRuntimeDeps<TContext>["recordRuntimeEvent"]
+  >;
+}
+
+export function createTelegramBusLeaderRuntimeAssembly<TContext>(
+  deps: TelegramBusLeaderRuntimeAssemblyDeps<TContext>,
+): TelegramBusLeaderRuntime<TContext> {
+  const provisionerPorts = {
+    getAllowedUserId: deps.getAllowedUserId,
+    topicTargetStore: deps.topicTargetStore,
+    callApi: deps.callApi,
+    getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,
+    getSyncState: deps.getSyncState,
+    setSyncState: deps.setSyncState,
+    onProvisioningStart: deps.onProvisioningStart,
+    onProvisioningEnd: deps.onProvisioningEnd,
+    recordRuntimeEvent: deps.recordRuntimeEvent,
+  };
+  return createTelegramBusLeaderRuntime({
+    ...deps.runtime,
+    provisionLeaderTarget: createTelegramBusLeaderTargetProvisioner({
+      ...provisionerPorts,
+      instanceId: deps.instanceId,
+      getCwd: deps.getCwd,
+      getTelegramProfile: deps.getTelegramProfile,
+      shouldForceFreshUnnamed: deps.shouldForceFreshUnnamed,
+      getThreadReconciliationMachineState:
+        deps.getThreadReconciliationMachineState,
+      recordThreadReconciliationPlan: deps.recordThreadReconciliationPlan,
+      setLeaderTarget: deps.setLeaderTarget,
+    }),
+    onFollowerPruned: createTelegramBusFollowerPruneHandler({
+      ...provisionerPorts,
+    }),
+    provisionFollowerTarget: createTelegramBusFollowerTargetProvisioner({
+      ...provisionerPorts,
+    }),
+    reconcileFollowerBindings:
+      createTelegramBusFollowerBindingRealityReconciler({
+        topicTargetStore: deps.topicTargetStore,
+        followerRegistry: deps.runtime.followerRegistry,
+        recordRuntimeEvent: deps.recordRuntimeEvent,
+      }),
+    callApi: createTelegramBusLeaderApiProxy({
+      call: deps.callApi,
+      callMultipart: deps.callMultipart,
+      downloadFile: deps.downloadFile,
+      recoverStaleTargetError: deps.recoverStaleTargetError,
+    }),
+    recordRuntimeEvent: deps.recordRuntimeEvent,
+  });
+}
+
+export interface TelegramBusFollowerBindingRealityDeps {
+  topicTargetStore: Pick<
+    Threads.TelegramTopicTargetStore,
+    | "load"
+    | "list"
+    | "markOfflineByInstanceId"
+    | "forgetIdentityByProfileKey"
+    | "getBotState"
+    | "persist"
+    | "setBotState"
+  >;
+  followerRegistry: Pick<TelegramBusFollowerRegistry, "list">;
   recordRuntimeEvent: (
     category: string,
     error: unknown,
     details?: Record<string, unknown>,
   ) => void;
-  getNowMs?: () => number;
 }
 
 export interface TelegramBusFollowerMessageOwnershipRecord {
@@ -176,7 +267,7 @@ export type TelegramBusFollowerMessageOwnershipRecorder = (
 ) => void;
 
 export interface TelegramBusLeaderRuntimeDeps<TContext> {
-  socketPath: string;
+  socketPath: TelegramBusSocketPathSource;
   followerRegistry: TelegramBusFollowerRegistry;
   authSecret?: string;
   startPolling: (ctx: TContext) => void | Promise<void>;
@@ -191,11 +282,12 @@ export interface TelegramBusLeaderRuntimeDeps<TContext> {
   provisionFollowerTarget?: (
     registration: TelegramBusInstanceRegistration,
   ) => Promise<TelegramTarget | undefined> | TelegramTarget | undefined;
-  restoreFollowerRegistry?: () => Promise<void> | void;
+  reconcileFollowerBindings?: () => Promise<unknown> | unknown;
   provisionLeaderTarget?: (ctx: TContext) => Promise<void> | void;
   getNowMs?: () => number;
   followerPruneIntervalMs?: number;
   followerStaleAfterMs?: number;
+  followerRecoveryGraceMs?: number;
   onFollowerPruned?: (
     follower: TelegramBusFollowerView,
   ) => Promise<void> | void;
@@ -206,39 +298,61 @@ export interface TelegramBusLeaderRuntimeDeps<TContext> {
   ) => void;
 }
 
-export function createTelegramBusFollowerRegistryRestoreHandler(
-  deps: TelegramBusFollowerRegistryRestoreDeps,
-): () => Promise<void> {
+export function createTelegramBusFollowerBindingRealityReconciler(
+  deps: TelegramBusFollowerBindingRealityDeps,
+): () => Promise<number> {
   return async () => {
     await deps.topicTargetStore.load();
-    const nowMs = (deps.getNowMs ?? Date.now)();
-    let restored = 0;
-    for (const record of deps.topicTargetStore.list()) {
-      if (record.owner?.kind !== "manual-follower") continue;
-      if (!record.instanceId) continue;
-      if (
-        record.status !== "active" &&
-        record.status !== "starting" &&
-        record.status !== "pending"
-      ) {
-        continue;
-      }
-      deps.followerRegistry.register({
-        instanceId: record.instanceId,
-        profileKey: record.profileKey,
-        threadName: record.threadName,
-        target: record.target,
-        busSocketPath: getTelegramBusFollowerSocketPath(record.instanceId),
-        connectedAtMs: nowMs,
-      });
-      restored += 1;
+    const liveInstanceIds = new Set(
+      deps.followerRegistry.list().map((follower) => follower.instanceId),
+    );
+    const staleRecords = deps.topicTargetStore.list().filter((record) => {
+      return (
+        record.owner?.kind === "manual-follower" &&
+        !!record.instanceId &&
+        !liveInstanceIds.has(record.instanceId)
+      );
+    });
+    const staleInstanceIds = new Set(
+      staleRecords.flatMap((record) =>
+        record.instanceId ? [record.instanceId] : [],
+      ),
+    );
+    let removed = 0;
+    for (const instanceId of staleInstanceIds) {
+      removed += deps.topicTargetStore.markOfflineByInstanceId(instanceId);
     }
-    if (restored > 0) {
-      deps.recordRuntimeEvent("bus", "Telegram follower registry restored", {
-        phase: "follower-registry-restore",
-        followers: restored,
-      });
+    for (const record of staleRecords) {
+      const profileKey =
+        record.profileKey ??
+        (record.owner
+          ? Threads.getTelegramThreadOwnerKey(record.owner)
+          : undefined);
+      if (profileKey) deps.topicTargetStore.forgetIdentityByProfileKey(profileKey);
+    }
+    if (removed === 0) return 0;
+    const cursorRealigned =
+      Threads.reconcileTelegramFreshAllocationCursor(deps.topicTargetStore);
+    await deps.topicTargetStore.persist();
+    deps.recordRuntimeEvent(
+      "bus",
+      "Historical follower bindings removed from live state",
+      {
+        phase: "follower-binding-reality",
+        removed,
+      },
+    );
+    if (cursorRealigned) {
+      deps.recordRuntimeEvent(
+        "bus",
+        "Fresh allocation cursor realigned after live-state compaction",
+        {
+          phase: "follower-binding-reality-cursor",
+          lastSlot: deps.topicTargetStore.getBotState().lastSlot,
+        },
+      );
     }
+    return removed;
   };
 }
 
@@ -338,6 +452,16 @@ export function createTelegramBusFollowerTargetProvisioner(
       claimPendingTargets: false,
     });
     const recordsBeforeProvision = deps.topicTargetStore.list();
+    const reconnectRecord = registration.target
+      ? recordsBeforeProvision.find((record) => {
+          return (
+            record.owner?.kind === "manual-follower" &&
+            record.instanceId === registration.instanceId &&
+            record.target.chatId === registration.target?.chatId &&
+            record.target.threadId === registration.target.threadId
+          );
+        })
+      : undefined;
     const followerProfileKey =
       registration.profileKey ?? `manual:${registration.instanceId}`;
     const followerOwner =
@@ -367,7 +491,9 @@ export function createTelegramBusFollowerTargetProvisioner(
     const runRegistration = async (): Promise<
       (TelegramTarget & { slot?: string; threadName?: string }) | undefined
     > => {
-    let result = await provisionTarget();
+    let result = reconnectRecord
+      ? { target: reconnectRecord.target, reused: true, record: reconnectRecord }
+      : await provisionTarget();
     deps.setSyncState(
       Sync.markTelegramSyncSliceFresh(deps.getSyncState(), "target-bindings", {
         nowMs: getNowMs(),
@@ -943,12 +1069,32 @@ export function createTelegramBusLeaderRuntime<TContext>(
   const getNowMs = deps.getNowMs ?? Date.now;
   const followerPruneIntervalMs = deps.followerPruneIntervalMs ?? 1000;
   const followerStaleAfterMs = deps.followerStaleAfterMs ?? 5000;
+  const followerRecoveryGraceMs = deps.followerRecoveryGraceMs ?? 5000;
   let pruneInterval: ReturnType<typeof setInterval> | undefined;
+  let followerRealityTimer: ReturnType<typeof setTimeout> | undefined;
   const stopPruning = () => {
     if (!pruneInterval) return;
     clearInterval(pruneInterval);
     pruneInterval = undefined;
   };
+  const stopFollowerRealityTimer = () => {
+    if (!followerRealityTimer) return;
+    clearTimeout(followerRealityTimer);
+    followerRealityTimer = undefined;
+  };
+  const scheduleFollowerBindingReality = () => {
+    stopFollowerRealityTimer();
+    if (!deps.reconcileFollowerBindings) return;
+    followerRealityTimer = setTimeout(() => {
+      followerRealityTimer = undefined;
+      void Promise.resolve(deps.reconcileFollowerBindings?.()).catch((error) =>
+        deps.recordRuntimeEvent?.("bus", error, {
+          phase: "follower-binding-reality",
+        }),
+      );
+    }, followerRecoveryGraceMs);
+    followerRealityTimer.unref?.();
+  };
   const pruneFollowers = async () => {
     const removed = deps.followerRegistry.pruneStale(
       getNowMs(),
@@ -997,25 +1143,21 @@ export function createTelegramBusLeaderRuntime<TContext>(
   return {
     startPolling: async (ctx) => {
       await localServer.start();
-      try {
-        await deps.restoreFollowerRegistry?.();
-      } catch (error) {
-        deps.recordRuntimeEvent?.("bus", error, {
-          phase: "follower-registry-restore",
-        });
-      }
+      scheduleFollowerBindingReality();
       startPruning();
       try {
         await deps.provisionLeaderTarget?.(ctx);
         await deps.startPolling(ctx);
       } catch (error) {
         stopPruning();
+        stopFollowerRealityTimer();
         await localServer.stop();
         throw error;
       }
     },
     stopPolling: async () => {
       stopPruning();
+      stopFollowerRealityTimer();
       try {
         await deps.stopPolling();
       } finally {

package/lib/bus-transport.ts

@@ -99,31 +99,55 @@ export function getTelegramBusTransportRetryPolicy(input: {
   };
 }
 
+function normalizeTelegramBusEndpointScope(value: string): string {
+  return value.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 80);
+}
+
 export function getTelegramBusLeaderEndpoint(input: {
   agentDir: string;
   platform: NodeJS.Platform | string;
+  profileName?: string;
 }): string {
+  const profileScope = input.profileName
+    ? normalizeTelegramBusEndpointScope(input.profileName)
+    : undefined;
   return input.platform === "win32"
-    ? getTelegramBusPipePath({ agentDir: input.agentDir, scope: "bus" })
-    : join(input.agentDir, "tmp", "telegram", "bus.sock");
+    ? getTelegramBusPipePath({
+        agentDir: input.agentDir,
+        scope: profileScope ? `bus-${profileScope}` : "bus",
+      })
+    : join(
+        input.agentDir,
+        "tmp",
+        "telegram",
+        profileScope ? `bus.${profileScope}.sock` : "bus.sock",
+      );
 }
 
 export function getTelegramBusFollowerEndpoint(input: {
   agentDir: string;
   platform: NodeJS.Platform | string;
   instanceId: string;
+  profileName?: string;
 }): string {
+  const instanceScope = normalizeTelegramBusEndpointScope(input.instanceId);
+  const profileScope = input.profileName
+    ? normalizeTelegramBusEndpointScope(input.profileName)
+    : undefined;
   return input.platform === "win32"
     ? getTelegramBusPipePath({
         agentDir: input.agentDir,
-        scope: `follower-${input.instanceId}`,
+        scope: profileScope
+          ? `follower-${profileScope}-${instanceScope}`
+          : `follower-${instanceScope}`,
       })
     : join(
         input.agentDir,
         "tmp",
         "telegram",
         "followers",
-        `${input.instanceId.replace(/[^a-zA-Z0-9_.-]/g, "_")}.sock`,
+        ...(profileScope ? [profileScope] : []),
+        `${instanceScope}.sock`,
       );
 }