diff --git a/Core/Const.cs b/Core/Const.cs
index db6b319..411b43c 100644
--- a/Core/Const.cs
+++ b/Core/Const.cs
@@ -14,5 +14,6 @@ namespace Core
         public const string rKeyConfig = $"{redisBaseAddr}:Cache";
         public const string ENRL_MSG_PIPE = $"{redisBaseAddr}:MPipe:Enroll";
         public const string TASK_MSG_PIPE = $"{redisBaseAddr}:MPipe:Tasks";
+        public const string UPDT_MSG_PIPE = $"{redisBaseAddr}:MPipe:Update";
     }
 }
diff --git a/LiMan.Api/Controllers/AppTaskController.cs b/LiMan.Api/Controllers/AppTaskController.cs
index 0003c1e..17e210c 100644
--- a/LiMan.Api/Controllers/AppTaskController.cs
+++ b/LiMan.Api/Controllers/AppTaskController.cs
@@ -44,18 +44,21 @@ namespace LiMan.APi.Controllers
         /// Elimina tutte le registrazioni req/run/done x device
         /// </summary>
         /// <param name="dev">dev richiedente</param>
-        /// <param name="CurrRequest">Obj AuthDataDTO con chiavi (master o app)</param>
+        /// <param name="CurrReq">Obj AuthDataDTO con chiavi (master o app)</param>
         [HttpDelete("cleanup/{dev}")]
-        public async Task<Dictionary<string, string>> TaskClearAll(string dev, [FromBody] TaskResultDTO CurrRequest)
+        public async Task<Dictionary<string, string>> TaskClearAll(string dev, [FromBody] TaskResultDTO CurrReq)
         {
             Dictionary<string, string> result = new Dictionary<string, string>();
             // verifica validità richiesta...
-            if (CurrRequest.IsValid)
+            if (CurrReq.IsValid)
             {
                 // FixMe ToDo !!! effettuare verifica valori chiavi/imp/device...
 
                 // elimina tutte le richieste x la macchina...
-                var rawData = dataService.TaskListReset(CurrRequest.CodImp);
+                var rawData = dataService.TaskListReset(CurrReq.CodImp);
+
+                // registro updater...
+                dataService.UpdaterRecordAction(CurrReq.CodImp);
 
                 if (rawData != null)
                 {
@@ -64,7 +67,7 @@ namespace LiMan.APi.Controllers
                 // salva in redis e toglie dai task da eseguire la richiesta relativa...
 
                 // registro infine chiamata
-                await dataService.recordCall(dev, CurrRequest.CodImp, $"POST:api/apptask/clear/ | {CurrRequest.MastKey} | {CurrRequest.CodImp}");
+                await dataService.recordCall(dev, CurrReq.CodImp, $"POST:api/apptask/clear/ | {CurrReq.MastKey} | {CurrReq.CodImp}");
             }
             return result;
         }
@@ -87,6 +90,10 @@ namespace LiMan.APi.Controllers
 
                 // recupero da REDIS le richieste pending x la macchina...
                 result = dataService.TaskListGet(CodImp);
+
+                // registro updater...
+                dataService.UpdaterRecordAction(CodImp);
+
                 // registro infine chiamata
                 await dataService.recordCall(dev, CodImp, $"POST:api/apptask/pending/ | {dev} | {CodImp} | {AppKey}");
             }
@@ -97,24 +104,27 @@ namespace LiMan.APi.Controllers
         /// Registra risultato esecuzione task richiesti al device
         /// </summary>
         /// <param name="dev">dev richiedente</param>
-        /// <param name="CurrRequest">Obj AuthDataDTO con chiavi (master o app)</param>
+        /// <param name="CurrReq">Obj AuthDataDTO con chiavi (master o app)</param>
         [HttpPost("done/{dev}")]
-        public async Task<string> TaskSetDone(string dev, [FromBody] TaskResultDTO CurrRequest)
+        public async Task<string> TaskSetDone(string dev, [FromBody] TaskResultDTO CurrReq)
         {
             string result = "NA";
             // verifica validità richiesta...
-            if (CurrRequest.IsValid)
+            if (CurrReq.IsValid)
             {
                 // FixMe ToDo !!! effettuare verifica valori chiavi/imp/device...
 
                 // recupero da REDIS le richieste pending x la macchina...
-                int numDone = dataService.TaskSetDone(CurrRequest.CodImp, CurrRequest.DataPayload);
+                int numDone = dataService.TaskSetDone(CurrReq.CodImp, CurrReq.DataPayload);
 
-                result = $"saved {numDone}/{CurrRequest.DataPayload.Count}";
+                // registro updater...
+                dataService.UpdaterRecordAction(CurrReq.CodImp);
+
+                result = $"saved {numDone}/{CurrReq.DataPayload.Count}";
                 // salva in redis e toglie dai task da eseguire la richiesta relativa...
 
                 // registro infine chiamata
-                await dataService.recordCall(CurrRequest.CodImp, CurrRequest.CodImp, $"POST:api/apptask/done/ | {CurrRequest.MastKey} | {CurrRequest.CodImp}");
+                await dataService.recordCall(CurrReq.CodImp, CurrReq.CodImp, $"POST:api/apptask/done/ | {CurrReq.MastKey} | {CurrReq.CodImp}");
             }
             return result;
         }
@@ -123,24 +133,26 @@ namespace LiMan.APi.Controllers
         /// Registra in esecuzione itask richiesti al device
         /// </summary>
         /// <param name="dev">dev richiedente</param>
-        /// <param name="CurrRequest">Obj AuthDataDTO con chiavi (master o app)</param>
+        /// <param name="CurrReq">Obj AuthDataDTO con chiavi (master o app)</param>
         [HttpPost("running/{dev}")]
-        public async Task<string> TaskSetRunning(string dev, [FromBody] TaskResultDTO CurrRequest)
+        public async Task<string> TaskSetRunning(string dev, [FromBody] TaskResultDTO CurrReq)
         {
             string result = "NA";
             // verifica validità richiesta...
-            if (CurrRequest.IsValid)
+            if (CurrReq.IsValid)
             {
                 // FixMe ToDo !!! effettuare verifica valori chiavi/imp/device...
 
                 // recupero da REDIS le richieste pending x la macchina...
-                int numDone = dataService.TaskSetRunning(CurrRequest.CodImp, CurrRequest.DataPayload);
+                int numDone = dataService.TaskSetRunning(CurrReq.CodImp, CurrReq.DataPayload);
 
-                result = $"saved {numDone}/{CurrRequest.DataPayload.Count}";
-                // salva in redis e toglie dai task da eseguire la richiesta relativa...
+                // registro updater...
+                dataService.UpdaterRecordAction(CurrReq.CodImp);
+
+                result = $"saved {numDone}/{CurrReq.DataPayload.Count}";
 
                 // registro infine chiamata
-                await dataService.recordCall(dev, CurrRequest.CodImp, $"POST:api/apptask/running/ | {CurrRequest.MastKey} | {CurrRequest.CodImp}");
+                await dataService.recordCall(dev, CurrReq.CodImp, $"POST:api/apptask/running/ | {CurrReq.MastKey} | {CurrReq.CodImp}");
             }
             return result;
         }
@@ -281,6 +293,10 @@ namespace LiMan.APi.Controllers
                 }
             }
             uploadResults.Add(uploadResult);
+
+            // registro updater...
+            dataService.UpdaterRecordAction(CodImp);
+
             return new CreatedResult(resourcePath, uploadResult);
         }
 
diff --git a/LiMan.Api/Controllers/ReleaseController.cs b/LiMan.Api/Controllers/ReleaseController.cs
index 6ed74d5..418d4ef 100644
--- a/LiMan.Api/Controllers/ReleaseController.cs
+++ b/LiMan.Api/Controllers/ReleaseController.cs
@@ -87,18 +87,22 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Recupera elenco dati Release (rilasciate) POST api/release/getall
         /// </summary>
-        /// <param name="CurrRequest">Obj ReleaseReqDTO con chiavi (master o app)</param>
+        /// <param name="CurrReq">Obj ReleaseReqDTO con chiavi (master o app)</param>
         [HttpPost("getall")]
-        public async Task<List<ReleaseDTO>> GetReleases([FromBody] ReleaseReqDTO CurrRequest)
+        public async Task<List<ReleaseDTO>> GetReleases([FromBody] ReleaseReqDTO CurrReq)
         {
             List<ReleaseDTO> result = new List<ReleaseDTO>();
             // verifica validità richiesta...
-            if (CheckReqKeys(CurrRequest))
+            if (CheckReqKeys(CurrReq))
             {
-                result = await dataService.ReleaseGetByApp(CurrRequest.CodApp);
+                result = await dataService.ReleaseGetByApp(CurrReq.CodApp);
                 // invio notifica x app...
-                dataService.TaskMessPipe.sendMessage(CurrRequest.CodImp);
-                await dataService.recordCall(CurrRequest.CodApp, CurrRequest.CodApp, $"POST:api/release/getall/ | {CurrRequest.MastKey} | {CurrRequest.CodImp} | {CurrRequest.CodApp}");
+                dataService.TaskMessPipe.sendMessage(CurrReq.CodImp);
+
+                // registro updater...
+                dataService.UpdaterRecordAction(CurrReq.CodImp);
+
+                await dataService.recordCall(CurrReq.CodApp, CurrReq.CodApp, $"POST:api/release/getall/ | {CurrReq.MastKey} | {CurrReq.CodImp} | {CurrReq.CodApp}");
             }
             return result;
         }
@@ -107,18 +111,22 @@ namespace LiMan.APi.Controllers
         /// Recupera elenco dati Release CRITICHE rilasciate (se sono ultima per singola CodApp)
         /// POST api/release/get-critical
         /// </summary>
-        /// <param name="CurrRequest">Obj ReleaseReqDTO con chiavi (master o app)</param>
+        /// <param name="CurrReq">Obj ReleaseReqDTO con chiavi (master o app)</param>
         [HttpPost("getcritical")]
-        public async Task<Dictionary<string, ReleaseDTO>> GetReleasesCritical([FromBody] ReleaseReqDTO CurrRequest)
+        public async Task<Dictionary<string, ReleaseDTO>> GetReleasesCritical([FromBody] ReleaseReqDTO CurrReq)
         {
             Dictionary<string, ReleaseDTO> result = new Dictionary<string, ReleaseDTO>();
             // verifica validità richiesta...
-            if (CheckReqKeys(CurrRequest))
+            if (CheckReqKeys(CurrReq))
             {
                 result = await dataService.ReleaseGetCritical();
                 // invio notifica x app...
-                dataService.TaskMessPipe.sendMessage(CurrRequest.CodImp);
-                await dataService.recordCall(CurrRequest.CodApp, CurrRequest.CodApp, $"POST:api/release/getcritical/ | {CurrRequest.MastKey} | {CurrRequest.CodImp} | {CurrRequest.CodApp}");
+                dataService.TaskMessPipe.sendMessage(CurrReq.CodImp);
+
+                // registro updater...
+                dataService.UpdaterRecordAction(CurrReq.CodImp);
+
+                await dataService.recordCall(CurrReq.CodApp, CurrReq.CodApp, $"POST:api/release/getcritical/ | {CurrReq.MastKey} | {CurrReq.CodImp} | {CurrReq.CodApp}");
             }
             return result;
         }
@@ -126,33 +134,37 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Recupera elenco dati Release (rilasciate) data versione minima POST api/release/getfilt
         /// </summary>
-        /// <param name="CurrRequest">Obj ReleaseReqDTO con chiavi (master o app)</param>
+        /// <param name="CurrReq">Obj ReleaseReqDTO con chiavi (master o app)</param>
         [HttpPost("getfilt")]
-        public async Task<List<ReleaseDTO>> GetReleasesFilt([FromBody] ReleaseReqDTO CurrRequest)
+        public async Task<List<ReleaseDTO>> GetReleasesFilt([FromBody] ReleaseReqDTO CurrReq)
         {
             List<ReleaseDTO> result = new List<ReleaseDTO>();
             // verifica validità richiesta...
-            if (CheckReqKeys(CurrRequest))
+            if (CheckReqKeys(CurrReq))
             {
-                result = await dataService.ReleaseGetByAppVers(CurrRequest.CodApp, CurrRequest.VersMin);
+                result = await dataService.ReleaseGetByAppVers(CurrReq.CodApp, CurrReq.VersMin);
                 // registro stato applicativi (da richiesta...)
                 InstalledReleasesModel checkRec = new InstalledReleasesModel()
                 {
-                    AppKey = CurrRequest.AppKey,
-                    CodApp = CurrRequest.CodApp,
-                    CodImp = CurrRequest.CodImp,
+                    AppKey = CurrReq.AppKey,
+                    CodApp = CurrReq.CodApp,
+                    CodImp = CurrReq.CodImp,
                     DtCheck = DateTime.Now,
-                    MastKey = CurrRequest.MastKey,
-                    NumImp = CurrRequest.NumImp,
-                    VersNum = CurrRequest.VersMin
+                    MastKey = CurrReq.MastKey,
+                    NumImp = CurrReq.NumImp,
+                    VersNum = CurrReq.VersMin
                 };
                 dataService.InstallRelUpsert(checkRec);
                 // chiamata x effettuare eventuale snapshot sulle installazioni attive
                 await dataService.InstallRelHistSnapshot(false);
                 // invio notifica x app...
-                dataService.TaskMessPipe.sendMessage(CurrRequest.CodImp);
+                dataService.TaskMessPipe.sendMessage(CurrReq.CodImp);
+
+                // registro updater...
+                dataService.UpdaterRecordAction(CurrReq.CodImp);
+
                 // registro infine chiamata
-                await dataService.recordCall(CurrRequest.CodApp, CurrRequest.CodApp, $"POST:api/release/getfilt/ | {CurrRequest.MastKey} | {CurrRequest.CodImp} | {CurrRequest.CodApp}");
+                await dataService.recordCall(CurrReq.CodApp, CurrReq.CodApp, $"POST:api/release/getfilt/ | {CurrReq.MastKey} | {CurrReq.CodImp} | {CurrReq.CodApp}");
             }
             return result;
         }
@@ -160,18 +172,22 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Recupera elenco dati Release (rilasciate) data versione minima e massima POST api/release/getlimit
         /// </summary>
-        /// <param name="CurrRequest">Obj ReleaseReqDTO con chiavi (master o app)</param>
+        /// <param name="CurrReq">Obj ReleaseReqDTO con chiavi (master o app)</param>
         [HttpPost("getlimit")]
-        public async Task<List<ReleaseDTO>> GetReleasesLimit([FromBody] ReleaseReqDTO CurrRequest)
+        public async Task<List<ReleaseDTO>> GetReleasesLimit([FromBody] ReleaseReqDTO CurrReq)
         {
             List<ReleaseDTO> result = new List<ReleaseDTO>();
             // verifica validità richiesta...
-            if (CheckReqKeys(CurrRequest))
+            if (CheckReqKeys(CurrReq))
             {
-                result = await dataService.ReleaseGetByAppVersLimit(CurrRequest.CodApp, CurrRequest.VersMin, CurrRequest.VersMax);
+                result = await dataService.ReleaseGetByAppVersLimit(CurrReq.CodApp, CurrReq.VersMin, CurrReq.VersMax);
                 // invio notifica x app...
-                dataService.TaskMessPipe.sendMessage(CurrRequest.CodImp);
-                await dataService.recordCall(CurrRequest.CodApp, CurrRequest.CodApp, $"POST:api/release/getlimit/ | {CurrRequest.MastKey} | {CurrRequest.CodImp} | {CurrRequest.CodApp}");
+                dataService.TaskMessPipe.sendMessage(CurrReq.CodImp);
+
+                // registro updater...
+                dataService.UpdaterRecordAction(CurrReq.CodImp);
+
+                await dataService.recordCall(CurrReq.CodApp, CurrReq.CodApp, $"POST:api/release/getlimit/ | {CurrReq.MastKey} | {CurrReq.CodImp} | {CurrReq.CodApp}");
             }
             return result;
         }
@@ -179,23 +195,23 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Salva una nuova release dell'applicativo (eventualmente sovrascrivendo) POST api/release/save
         /// </summary>
-        /// <param name="CurrRequest">Obj Richiesta</param>
+        /// <param name="CurrReq">Obj Richiesta</param>
         [HttpPost("save")]
-        public async Task<ReleaseDTO> SaveRelease([FromBody] AppRelVersion CurrRequest)
+        public async Task<ReleaseDTO> SaveRelease([FromBody] AppRelVersion CurrReq)
         {
             ReleaseDTO result = new ReleaseDTO()
             {
-                CodApp = CurrRequest.CodApp,
-                ReleaseDate = CurrRequest.ReleaseDate,
-                VersNum = CurrRequest.VersNum,
-                VersText = CurrRequest.VersText,
-                RelTags = CurrRequest.RelTags.ToUpper()
+                CodApp = CurrReq.CodApp,
+                ReleaseDate = CurrReq.ReleaseDate,
+                VersNum = CurrReq.VersNum,
+                VersText = CurrReq.VersText,
+                RelTags = CurrReq.RelTags.ToUpper()
             };
             // controllo valori
-            if (CurrRequest.IsValid)
+            if (CurrReq.IsValid)
             {
                 // verifica preliminare licenza x upload
-                var licUploader = await dataService.LicenzeSearch(CurrRequest.CodInst, CurrRequest.UplAppID, CurrRequest.MasterKey, false);
+                var licUploader = await dataService.LicenzeSearch(CurrReq.CodInst, CurrReq.UplAppID, CurrReq.MasterKey, false);
                 if (licUploader != null && licUploader.Count > 0)
                 {
                     // in primis cerco app...
@@ -203,54 +219,55 @@ namespace LiMan.APi.Controllers
                     ApplicativoModel recApp = new ApplicativoModel();
                     if (appList != null)
                     {
-                        recApp = appList.FirstOrDefault(x => x.CodApp == CurrRequest.CodApp);
+                        recApp = appList.FirstOrDefault(x => x.CodApp == CurrReq.CodApp);
                     }
                     // nel caso mancasse la aggiungo
-                    if (recApp == null || string.IsNullOrEmpty(recApp.CodApp) || recApp.CodApp != CurrRequest.CodApp)
+                    if (recApp == null || string.IsNullOrEmpty(recApp.CodApp) || recApp.CodApp != CurrReq.CodApp)
                     {
                         recApp = new ApplicativoModel()
                         {
-                            CodApp = CurrRequest.CodApp,
+                            CodApp = CurrReq.CodApp,
                             Descrizione = "Nuova APP da POST api/release/save",
                             TplConnString = "",
-                            Tipo = CurrRequest.Tipo
+                            Tipo = CurrReq.Tipo
                         };
                         await dataService.ApplicativoUpsert(recApp);
                     }
                     //converto in una release...
                     ReleaseModel newRec = new ReleaseModel()
                     {
-                        CodApp = CurrRequest.CodApp,
-                        ReleaseDate = CurrRequest.ReleaseDate,
-                        RelTags = CurrRequest.RelTags.ToUpper(),
-                        VersNum = CurrRequest.VersNum,
-                        VersText = CurrRequest.VersText
+                        CodApp = CurrReq.CodApp,
+                        ReleaseDate = CurrReq.ReleaseDate,
+                        RelTags = CurrReq.RelTags.ToUpper(),
+                        VersNum = CurrReq.VersNum,
+                        VersText = CurrReq.VersText
                     };
                     // registro versione eventualmente gestendo nuovo applicativo
                     var insRes = await dataService.ReleaseUpsert(newRec);
                     if (insRes)
                     {
-                        Log.Info($"Release recorded | {CurrRequest.CodApp} | {CurrRequest.VersNum} | {CurrRequest.VersText} | {CurrRequest.ReleaseDate} | {CurrRequest.RelTags}");
+                        Log.Info($"Release recorded | {CurrReq.CodApp} | {CurrReq.VersNum} | {CurrReq.VersText} | {CurrReq.ReleaseDate} | {CurrReq.RelTags}");
                     }
                 }
                 else
                 {
-                    Log.Error($"Errore: licenza UpdateManager non TROVATA | {CurrRequest.MasterKey}");
-                    await dataService.recordCall(CurrRequest.CodInst, CurrRequest.CodApp, $"ERROR POST:api/release/save:{CurrRequest.CodApp} | {CurrRequest.MasterKey}");
+                    Log.Error($"Errore: licenza UpdateManager non TROVATA | {CurrReq.MasterKey}");
+                    await dataService.recordCall(CurrReq.CodInst, CurrReq.CodApp, $"ERROR POST:api/release/save:{CurrReq.CodApp} | {CurrReq.MasterKey}");
                 }
                 // recupero vers applicativo...
-                var rawResult = await dataService.ReleaseGetByApp(CurrRequest.CodApp);
+                var rawResult = await dataService.ReleaseGetByApp(CurrReq.CodApp);
                 if (rawResult != null && rawResult.Count > 0)
                 {
-                    result = rawResult.Where(x => x.VersText == CurrRequest.VersText).FirstOrDefault();
+                    result = rawResult.Where(x => x.VersText == CurrReq.VersText).FirstOrDefault();
                 }
+
                 // fisso nostra install
-                await dataService.recordCall(CurrRequest.CodInst, CurrRequest.CodApp, $"POST:api/release/save:{CurrRequest.CodApp}");
+                await dataService.recordCall(CurrReq.CodInst, CurrReq.CodApp, $"POST:api/release/save:{CurrReq.CodApp}");
             }
             else
             {
-                Log.Error($"Errore: licenza UpdateManager non VALIDA | {CurrRequest.MasterKey}");
-                await dataService.recordCall(CurrRequest.CodInst, CurrRequest.CodApp, $"ERROR POST:api/release/save:{CurrRequest.CodApp} | {CurrRequest.MasterKey}");
+                Log.Error($"Errore: licenza UpdateManager non VALIDA | {CurrReq.MasterKey}");
+                await dataService.recordCall(CurrReq.CodInst, CurrReq.CodApp, $"ERROR POST:api/release/save:{CurrReq.CodApp} | {CurrReq.MasterKey}");
             }
             return result;
         }
@@ -258,18 +275,22 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Esegue tentativo salvataggio rel history
         /// </summary>
-        /// <param name="CurrRequest">Obj ReleaseReqDTO con chiavi (master o app)</param>
+        /// <param name="CurrReq">Obj ReleaseReqDTO con chiavi (master o app)</param>
         [HttpPost("save-history")]
-        public async Task<List<ReleaseDTO>> SaveRelHistory([FromBody] ReleaseReqDTO CurrRequest)
+        public async Task<List<ReleaseDTO>> SaveRelHistory([FromBody] ReleaseReqDTO CurrReq)
         {
             List<ReleaseDTO> result = new List<ReleaseDTO>();
             // verifica validità richiesta...
-            if (CheckReqKeys(CurrRequest))
+            if (CheckReqKeys(CurrReq))
             {
                 // chiamata x effettuare eventuale snapshot sulle installazioni attive
                 await dataService.InstallRelHistSnapshot(true);
+
+                // registro updater...
+                dataService.UpdaterRecordAction(CurrReq.CodImp);
+
                 // registro infine chiamata
-                await dataService.recordCall(CurrRequest.CodApp, CurrRequest.CodApp, $"POST:api/release/save-history/ | {CurrRequest.MastKey} | {CurrRequest.CodImp} | {CurrRequest.CodApp}");
+                await dataService.recordCall(CurrReq.CodApp, CurrReq.CodApp, $"POST:api/release/save-history/ | {CurrReq.MastKey} | {CurrReq.CodImp} | {CurrReq.CodApp}");
             }
             return result;
         }
@@ -277,18 +298,22 @@ namespace LiMan.APi.Controllers
         /// <summary>
         /// Conferma quale sia l'elenco delle app gestite POST api/release/setmanaged
         /// </summary>
-        /// <param name="ManagedApp">Obj ManDeclareDTO con chiavi + elenco app gestite (x eliminare altre)</param>
+        /// <param name="CurrReq">Obj ManDeclareDTO con chiavi + elenco app gestite (x eliminare altre)</param>
         /// <returns>Numero di record eliminati</returns>
         [HttpPost("setmanaged")]
-        public async Task<int> SetManaged([FromBody] ManDeclareDTO ManagedApp)
+        public async Task<int> SetManaged([FromBody] ManDeclareDTO CurrReq)
         {
             int result = 0;
             // verifica validità richiesta...
-            if (CheckReqKeys(ManagedApp))
+            if (CheckReqKeys(CurrReq))
             {
-                result = dataService.InstallRelClean(ManagedApp.CodImp, ManagedApp.AppKey, ManagedApp.ListCodApp);
+                result = dataService.InstallRelClean(CurrReq.CodImp, CurrReq.AppKey, CurrReq.ListCodApp);
+
+                // registro updater...
+                dataService.UpdaterRecordAction(CurrReq.CodImp);
+
                 // invio notifica x app...
-                dataService.TaskMessPipe.sendMessage(ManagedApp.CodImp);
+                dataService.TaskMessPipe.sendMessage(CurrReq.CodImp);
             }
             await Task.Delay(1);
             return result;
diff --git a/LiMan.Api/Data/ApiDataService.cs b/LiMan.Api/Data/ApiDataService.cs
index d30253f..a73f987 100644
--- a/LiMan.Api/Data/ApiDataService.cs
+++ b/LiMan.Api/Data/ApiDataService.cs
@@ -66,6 +66,7 @@ namespace LiMan.APi.Data
             // conf messagepipe: setup canali pub/sub
             EnrollMessPipe = new MessagePipe(redisConn, Const.ENRL_MSG_PIPE);
             TaskMessPipe = new MessagePipe(redisConn, Const.TASK_MSG_PIPE);
+            UpdActMessPipe = new MessagePipe(redisConn, Const.UPDT_MSG_PIPE);
 
             // conf DB
             string connStrDB = _configuration.GetConnectionString("LiMan.DB");
@@ -94,6 +95,11 @@ namespace LiMan.APi.Data
         /// </summary>
         public MessagePipe TaskMessPipe { get; set; } = null!;
 
+        /// <summary>
+        /// Wrapper x invio/ricezione messaggi sul canale dedicato a generico update info dai vari EgwACC
+        /// </summary>
+        public MessagePipe UpdActMessPipe { get; set; } = null!;
+
         #endregion Public Properties
 
         #region Public Methods
@@ -1238,6 +1244,23 @@ namespace LiMan.APi.Data
             return answ;
         }
 
+
+
+        /// <summary>
+        /// Salva ultima dataora di comunicazione con un updater
+        /// </summary>
+        /// <param name="CodImp"></param>
+        /// <returns></returns>
+        public int UpdaterRecordAction(string CodImp)
+        {
+            int done = 0;
+            // upsert per ogni singolo record + rimozione da running
+            redisHashKeySet((RedisKey)$"{rKeyUpdLastAct}List", CodImp, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss}");
+            // invio string in messagepipe x forzare refresh...
+            UpdActMessPipe.sendMessage(CodImp);
+            return done;
+        }
+
         /// <summary>
         /// Salva il risultato dell'esecuzione dei task effettuata
         /// </summary>
@@ -1448,6 +1471,10 @@ namespace LiMan.APi.Data
         /// Chiave degli elenchi dei Task in esecuzione
         /// </summary>
         protected const string rKeyTaskRun = $"{rKeyBaseComm}:TaskRun";
+        /// <summary>
+        /// Chiave degli elenchi delle ultime DataOra di comunicazione degli updater
+        /// </summary>
+        protected const string rKeyUpdLastAct = $"{rKeyBaseComm}:LastAction";
 
         protected static JsonSerializerSettings? JSSettings;
 
diff --git a/LiMan.Api/Resources/ChangeLog.html b/LiMan.Api/Resources/ChangeLog.html
index 3b45763..5bdadfc 100644
--- a/LiMan.Api/Resources/ChangeLog.html
+++ b/LiMan.Api/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>License Manager</i>
-    <h4>Versione: 2.1.2501.2817</h4>
+    <h4>Versione: 2.1.2501.2907</h4>
     <br /> Note di rilascio:
     <ul>
         <li>
diff --git a/LiMan.Api/Resources/VersNum.txt b/LiMan.Api/Resources/VersNum.txt
index 4136350..1e22251 100644
--- a/LiMan.Api/Resources/VersNum.txt
+++ b/LiMan.Api/Resources/VersNum.txt
@@ -1 +1 @@
-2.1.2501.2817
+2.1.2501.2907
diff --git a/LiMan.Api/Resources/manifest.xml b/LiMan.Api/Resources/manifest.xml
index 9b7ced4..8cc3a19 100644
--- a/LiMan.Api/Resources/manifest.xml
+++ b/LiMan.Api/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>2.1.2501.2817</version>
+  <version>2.1.2501.2907</version>
   <url>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/LiMan.UI.zip</url>
   <changelog>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>
diff --git a/LiMan.DB/Services/CommonDataServices.cs b/LiMan.DB/Services/CommonDataServices.cs
index 78a8a87..9c9b7cc 100644
--- a/LiMan.DB/Services/CommonDataServices.cs
+++ b/LiMan.DB/Services/CommonDataServices.cs
@@ -50,6 +50,7 @@ namespace LiMan.DB.Services
             // conf messagepipe: setup canali pub/sub
             EnrollMessPipe = new MessagePipe(redisConn, Const.ENRL_MSG_PIPE);
             TaskMessPipe = new MessagePipe(redisConn, Const.TASK_MSG_PIPE);
+            UpdActMessPipe = new MessagePipe(redisConn, Const.UPDT_MSG_PIPE);
 
             _emailSender = emailSender;
             // conf DB
@@ -79,6 +80,11 @@ namespace LiMan.DB.Services
         /// </summary>
         public MessagePipe TaskMessPipe { get; set; } = null!;
 
+        /// <summary>
+        /// Wrapper x invio/ricezione messaggi sul canale dedicato a generico update info dai vari EgwACC
+        /// </summary>
+        public MessagePipe UpdActMessPipe { get; set; } = null!;
+
         #endregion Public Properties
 
         #region Public Methods
diff --git a/LiMan.Transfer/Resources/ChangeLog.html b/LiMan.Transfer/Resources/ChangeLog.html
index 6ae380e..0d1d222 100644
--- a/LiMan.Transfer/Resources/ChangeLog.html
+++ b/LiMan.Transfer/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>License Manager</i>
-    <h4>Versione: 2.1.2501.2817</h4>
+    <h4>Versione: 2.1.2501.2907</h4>
     <br />
     Note di rilascio:
     <ul>
diff --git a/LiMan.Transfer/Resources/VersNum.txt b/LiMan.Transfer/Resources/VersNum.txt
index 4136350..1e22251 100644
--- a/LiMan.Transfer/Resources/VersNum.txt
+++ b/LiMan.Transfer/Resources/VersNum.txt
@@ -1 +1 @@
-2.1.2501.2817
+2.1.2501.2907
diff --git a/LiMan.Transfer/Resources/manifest.xml b/LiMan.Transfer/Resources/manifest.xml
index c89a144..012d1cd 100644
--- a/LiMan.Transfer/Resources/manifest.xml
+++ b/LiMan.Transfer/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>2.1.2501.2817</version>
+  <version>2.1.2501.2907</version>
   <url>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/LiMan.Transfer.zip</url>
   <changelog>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>
diff --git a/LiMan.UI/LiMan.UI.csproj b/LiMan.UI/LiMan.UI.csproj
index 9dd272a..523353c 100644
--- a/LiMan.UI/LiMan.UI.csproj
+++ b/LiMan.UI/LiMan.UI.csproj
@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net6.0</TargetFramework>
-        <Version>2.1.2501.2817</Version>
+        <Version>2.1.2501.2907</Version>
         <RootNamespace>LiMan.UI</RootNamespace>
         <AssemblyName>LiMan.UI</AssemblyName>
     </PropertyGroup>
diff --git a/LiMan.UI/Resources/ChangeLog.html b/LiMan.UI/Resources/ChangeLog.html
index 3b45763..5bdadfc 100644
--- a/LiMan.UI/Resources/ChangeLog.html
+++ b/LiMan.UI/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>License Manager</i>
-    <h4>Versione: 2.1.2501.2817</h4>
+    <h4>Versione: 2.1.2501.2907</h4>
     <br /> Note di rilascio:
     <ul>
         <li>
diff --git a/LiMan.UI/Resources/VersNum.txt b/LiMan.UI/Resources/VersNum.txt
index 4136350..1e22251 100644
--- a/LiMan.UI/Resources/VersNum.txt
+++ b/LiMan.UI/Resources/VersNum.txt
@@ -1 +1 @@
-2.1.2501.2817
+2.1.2501.2907
diff --git a/LiMan.UI/Resources/manifest.xml b/LiMan.UI/Resources/manifest.xml
index 9b7ced4..8cc3a19 100644
--- a/LiMan.UI/Resources/manifest.xml
+++ b/LiMan.UI/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>2.1.2501.2817</version>
+  <version>2.1.2501.2907</version>
   <url>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/LiMan.UI.zip</url>
   <changelog>https://nexus.steamware.net/repository/SWS/LiMan/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>