bulltrackers-module 1.0.678 → 1.0.680

package/functions/alert-system/helpers/alert_helpers.js

@@ -6,8 +6,8 @@
 const { FieldValue } = require('@google-cloud/firestore');
 const zlib = require('zlib');
 const { Storage } = require('@google-cloud/storage');
-const { getAlertTypeByComputation, generateAlertMessage } = require('./alert_type_registry');
-// Migration helpers removed - write directly to new path
+const { generateAlertMessage } = require('./alert_manifest_loader');
+// [UPDATED] Now uses dynamic manifest loading instead of hardcoded registry
 
 const storage = new Storage(); // Singleton GCS Client
 
@@ -16,12 +16,53 @@ const storage = new Storage(); // Singleton GCS Client
  */
 async function processAlertForPI(db, logger, piCid, alertType, computationMetadata, computationDate, dependencies = {}) {
   try {
+    // [FIX] Check if computation date is earlier than today (backfill protection)
+    const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD format
+    const isHistoricalData = computationDate < today;
+    
+    // If it's historical data, check if this alert already exists
+    if (isHistoricalData) {
+      // Check if we've already created alerts for this PI/date/alertType combination
+      const existingAlertsSnapshot = await db.collection('SignedInUsers')
+        .doc('_metadata') // Use metadata doc to track processed alerts
+        .collection('processed_alerts')
+        .where('piCid', '==', Number(piCid))
+        .where('computationDate', '==', computationDate)
+        .where('alertType', '==', alertType.id)
+        .limit(1)
+        .get();
+      
+      if (!existingAlertsSnapshot.empty) {
+        logger.log('INFO', `[processAlertForPI] Skipping duplicate alert for historical data: PI ${piCid}, date ${computationDate}, alert type ${alertType.id}`);
+        return;
+      }
+      
+      logger.log('WARN', `[processAlertForPI] Processing alert for historical data (backfill): PI ${piCid}, date ${computationDate}, alert type ${alertType.id}. This alert will only be sent to developers.`);
+    }
+    
     // 1. Get PI username from rankings or subscriptions
     const piUsername = await getPIUsername(db, piCid);
     
     // 2. Find all users subscribed to this PI and alert type
     // Use computationName (e.g., 'RiskScoreIncrease') to map to alertConfig keys
-    const subscriptions = await findSubscriptionsForPI(db, logger, piCid, alertType.computationName, computationDate, dependencies);
+    let subscriptions = await findSubscriptionsForPI(db, logger, piCid, alertType.computationName, computationDate, dependencies);
+    
+    // [FIX] If it's historical data, only send to developer accounts
+    if (isHistoricalData) {
+      const { isDeveloper } = require('../../api-v2/helpers/data-fetchers/firestore.js');
+      
+      // Filter subscriptions to only include developers
+      const devSubscriptions = [];
+      for (const subscription of subscriptions) {
+        const isDev = await isDeveloper(db, String(subscription.userCid));
+        if (isDev) {
+          devSubscriptions.push(subscription);
+        }
+      }
+      
+      subscriptions = devSubscriptions;
+      logger.log('INFO', `[processAlertForPI] Historical data: Filtered to ${subscriptions.length} developer subscriptions for PI ${piCid}, alert type ${alertType.id}`);
+    }
     
     if (subscriptions.length === 0) {
       logger.log('INFO', `[processAlertForPI] No subscriptions found for PI ${piCid}, alert type ${alertType.id}`);
@@ -38,8 +79,24 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     const config = dependencies.config || {};
     const notificationPromises = [];
     
+    // Check watchlistAlerts preference for each user
+    const { manageNotificationPreferences } = require('../../api-v2/helpers/data-fetchers/firestore.js');
+    
     for (const subscription of subscriptions) {
       const userCid = subscription.userCid;
+      
+      // [FIX] Check user's watchlistAlerts preference before creating alert
+      try {
+        const prefs = await manageNotificationPreferences(db, userCid, 'get');
+        if (!prefs.watchlistAlerts) {
+          logger.log('DEBUG', `[processAlertForPI] User ${userCid} has watchlistAlerts disabled, skipping alert`);
+          continue; // Skip this user
+        }
+      } catch (prefError) {
+        logger.log('WARN', `[processAlertForPI] Error checking watchlistAlerts preference for user ${userCid}: ${prefError.message}`);
+        // Continue anyway - fail open for important alerts
+      }
+      
       const notificationId = `alert_${Date.now()}_${userCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
       
       const notificationData = {
@@ -129,6 +186,28 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     
     logger.log('SUCCESS', `[processAlertForPI] Created ${notificationPromises.length} notifications for PI ${piCid}, alert type ${alertType.id}`);
     
+    // [FIX] Mark alert as processed to prevent duplicates on backfill
+    if (isHistoricalData) {
+      try {
+        await db.collection('SignedInUsers')
+          .doc('_metadata')
+          .collection('processed_alerts')
+          .doc(`${piCid}_${computationDate}_${alertType.id}`)
+          .set({
+            piCid: Number(piCid),
+            computationDate: computationDate,
+            alertType: alertType.id,
+            alertTypeName: alertType.name,
+            processedAt: FieldValue.serverTimestamp(),
+            notificationsSent: notificationPromises.length
+          });
+        logger.log('INFO', `[processAlertForPI] Marked historical alert as processed: PI ${piCid}, date ${computationDate}, alert type ${alertType.id}`);
+      } catch (markError) {
+        logger.log('WARN', `[processAlertForPI] Failed to mark alert as processed: ${markError.message}`);
+        // Don't throw - this is non-critical
+      }
+    }
+    
   } catch (error) {
     logger.log('ERROR', `[processAlertForPI] Error processing alert for PI ${piCid}`, error);
     throw error;
@@ -285,8 +364,33 @@ async function findSubscriptionsForPI(db, logger, piCid, alertTypeId, computatio
               const isTestProbe = alertTypeId === 'TestSystemProbe';
               const isEnabled = item.alertConfig && item.alertConfig[configKey] === true;
               
-              // If it's the probe OR the user explicitly enabled it
-              if (isTestProbe || isEnabled) {
+              // [FIX] Check if this is a test alert (respect testAlerts preference)
+              // Load alert type from dependencies to check isTest flag
+              const alertType = dependencies.alertType;
+              const isTestAlert = alertType && alertType.isTest === true;
+              
+              let shouldSendAlert = false;
+              if (isTestAlert) {
+                // Check if user has testAlerts enabled in their notification preferences
+                try {
+                  const { manageNotificationPreferences } = require('../../api-v2/helpers/data-fetchers/firestore.js');
+                  const prefs = await manageNotificationPreferences(db, userCid, 'get');
+                  shouldSendAlert = prefs.testAlerts === true;
+                  
+                  if (!shouldSendAlert) {
+                    logger.log('DEBUG', `[findSubscriptionsForPI] User ${userCid} has testAlerts disabled, skipping test alert ${alertTypeId}`);
+                  }
+                } catch (prefError) {
+                  logger.log('WARN', `[findSubscriptionsForPI] Error checking testAlerts preference for user ${userCid}: ${prefError.message}`);
+                  // Default to not sending test alerts if we can't check preferences
+                  shouldSendAlert = false;
+                }
+              } else {
+                // For non-test alerts, use normal alert config check
+                shouldSendAlert = isEnabled;
+              }
+              
+              if (shouldSendAlert) {
                 subscriptions.push({
                   userCid: userCid,
                   piCid: piCid,

package/functions/alert-system/helpers/alert_manifest_loader.js

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview Dynamic Alert Manifest Loader
+ * Loads alert types from computation classes instead of hardcoded registry
+ */
+
+/**
+ * Flatten nested calculations object (same logic as index.js)
+ * @param {Object} obj - Nested calculations object
+ * @returns {Array<Function>} Flat array of computation classes
+ */
+const flattenCalculations = (obj) => {
+  let result = [];
+  for (const key in obj) {
+    if (typeof obj[key] === 'function') {
+      result.push(obj[key]);
+    } else if (typeof obj[key] === 'object' && obj[key] !== null) {
+      result = result.concat(flattenCalculations(obj[key]));
+    }
+  }
+  return result;
+};
+
+/**
+ * Load all alert computations from calculations package
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Array>} Array of alert type objects with metadata
+ */
+async function loadAlertTypesFromManifest(logger) {
+  try {
+    // Import calculations the same way index.js does
+    const { calculations } = require('aiden-shared-calculations-unified');
+    const calculationsArray = flattenCalculations(calculations);
+    
+    const alertTypes = [];
+    
+    // Iterate through all computation classes (same logic as index.js alert trigger registration)
+    for (const CalcClass of calculationsArray) {
+      if (!CalcClass || typeof CalcClass.getMetadata !== 'function') {
+        continue;
+      }
+      
+      const metadata = CalcClass.getMetadata();
+      
+      // Check if this is an alert computation
+      if (metadata.isAlertComputation !== true) {
+        continue;
+      }
+      
+      // Check if alert metadata exists
+      if (!metadata.alert) {
+        logger?.log('WARN', `[AlertManifestLoader] Computation ${metadata.name} has isAlertComputation=true but no alert metadata`);
+        continue;
+      }
+      
+      // Build alert type object
+      const alertType = {
+        id: metadata.alert.id,
+        name: metadata.alert.frontendName,
+        description: metadata.alert.description,
+        computationName: metadata.name,
+        category: metadata.category || 'alerts',
+        messageTemplate: metadata.alert.messageTemplate,
+        severity: metadata.alert.severity || 'medium',
+        configKey: metadata.alert.configKey,
+        isTest: metadata.isTest === true,
+        enabled: true
+      };
+      
+      alertTypes.push(alertType);
+      
+      logger?.log('DEBUG', `[AlertManifestLoader] Loaded alert type: ${alertType.id} from ${metadata.name}`);
+    }
+    
+    logger?.log('INFO', `[AlertManifestLoader] Successfully loaded ${alertTypes.length} alert types from calculations`);
+    
+    return alertTypes;
+  } catch (error) {
+    logger?.log('ERROR', `[AlertManifestLoader] Failed to load alert types: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Get alert type by computation name
+ * @param {Array} alertTypes - Array of alert types from loadAlertTypesFromManifest
+ * @param {string} computationName - Name of computation
+ * @returns {Object|null} Alert type object or null
+ */
+function getAlertTypeByComputation(alertTypes, computationName) {
+  return alertTypes.find(type => type.computationName === computationName) || null;
+}
+
+/**
+ * Check if a computation is an alert computation
+ * @param {Array} alertTypes - Array of alert types from loadAlertTypesFromManifest
+ * @param {string} computationName - Name of computation
+ * @returns {boolean} True if computation is an alert
+ */
+function isAlertComputation(alertTypes, computationName) {
+  return getAlertTypeByComputation(alertTypes, computationName) !== null;
+}
+
+/**
+ * Generate alert message from template and metadata
+ * @param {Object} alertType - Alert type object
+ * @param {string} piUsername - PI username
+ * @param {Object} metadata - Metadata from computation results
+ * @returns {string} Generated alert message
+ */
+function generateAlertMessage(alertType, piUsername, metadata = {}) {
+  let message = alertType.messageTemplate;
+  
+  // Replace placeholders
+  message = message.replace(/{piUsername}/g, piUsername || 'Unknown');
+  message = message.replace(/{count}/g, metadata.count || metadata.positions?.length || metadata.moveCount || 0);
+  message = message.replace(/{change}/g, metadata.change || metadata.changePercent || metadata.diff || 'N/A');
+  message = message.replace(/{previous}/g, metadata.previous || metadata.previousValue || metadata.prev || metadata.previousRisk || 'N/A');
+  message = message.replace(/{current}/g, metadata.current || metadata.currentValue || metadata.curr || metadata.currentRisk || 'N/A');
+  message = message.replace(/{sectorName}/g, metadata.sectorName || (metadata.newExposures && metadata.newExposures.length > 0 ? metadata.newExposures.join(', ') : 'Unknown'));
+  message = message.replace(/{ticker}/g, metadata.ticker || metadata.symbol || 'Unknown');
+  
+  // Format numeric values
+  message = message.replace(/{volatility}/g, metadata.volatility ? `${(metadata.volatility * 100).toFixed(1)}` : 'N/A');
+  message = message.replace(/{threshold}/g, metadata.threshold ? `${(metadata.threshold * 100).toFixed(0)}` : 'N/A');
+  message = message.replace(/{diff}/g, metadata.diff ? `${metadata.diff.toFixed(1)}` : 'N/A');
+  message = message.replace(/{prev}/g, metadata.prev ? `${metadata.prev.toFixed(1)}` : 'N/A');
+  message = message.replace(/{curr}/g, metadata.curr ? `${metadata.curr.toFixed(1)}` : 'N/A');
+  message = message.replace(/{title}/g, metadata.title || 'New Update');
+  
+  // Probe placeholders
+  message = message.replace(/{status}/g, metadata.status || 'Unknown Status');
+  message = message.replace(/{timestamp}/g, metadata.timestamp || new Date().toISOString());
+
+  // Behavioral Anomaly placeholders
+  message = message.replace(/{primaryDriver}/g, metadata.primaryDriver || 'Unknown Factor');
+  message = message.replace(/{driverSignificance}/g, metadata.driverSignificance || 'N/A');
+  message = message.replace(/{anomalyScore}/g, metadata.anomalyScore || 'N/A');
+  
+  // Handle positions list if available
+  if (metadata.positions && Array.isArray(metadata.positions) && metadata.positions.length > 0) {
+    const positionsList = metadata.positions
+      .slice(0, 3)
+      .map(p => p.ticker || p.instrumentId)
+      .join(', ');
+    message = message.replace(/{positions}/g, positionsList);
+  }
+  
+  // Handle moves array for PositionInvestedIncrease
+  if (metadata.moves && Array.isArray(metadata.moves) && metadata.moves.length > 0) {
+    const firstMove = metadata.moves[0];
+    message = message.replace(/{symbol}/g, firstMove.symbol || 'Unknown');
+    message = message.replace(/{diff}/g, firstMove.diff ? `${firstMove.diff.toFixed(1)}` : 'N/A');
+    message = message.replace(/{prev}/g, firstMove.prev ? `${firstMove.prev.toFixed(1)}` : 'N/A');
+    message = message.replace(/{curr}/g, firstMove.curr ? `${firstMove.curr.toFixed(1)}` : 'N/A');
+  }
+  
+  return message;
+}
+
+module.exports = {
+  loadAlertTypesFromManifest,
+  getAlertTypeByComputation,
+  isAlertComputation,
+  generateAlertMessage
+};

package/functions/alert-system/index.js

@@ -1,11 +1,15 @@
 /**
  * @fileoverview Alert System Trigger Handler
  * Can be triggered via Pub/Sub when computation results are written
+ * [UPDATED] Now uses dynamic manifest loading instead of hardcoded registry
  */
 
-const { getAlertTypeByComputation, isAlertComputation } = require('./helpers/alert_type_registry');
+const { loadAlertTypesFromManifest, getAlertTypeByComputation, isAlertComputation } = require('./helpers/alert_manifest_loader');
 const { processAlertForPI, readComputationResults, readComputationResultsWithShards } = require('./helpers/alert_helpers');
 
+// Cache for loaded alert types (loaded once per function instance)
+let cachedAlertTypes = null;
+
 /**
  * Pub/Sub trigger handler for alert generation
  * Expected message format:
@@ -19,6 +23,11 @@ async function handleAlertTrigger(message, context, config, dependencies) {
   const { db, logger } = dependencies;
   
   try {
+    // [NEW] Load alert types from manifest (cached)
+    if (!cachedAlertTypes) {
+      cachedAlertTypes = await loadAlertTypesFromManifest(logger);
+    }
+    
     // Parse Pub/Sub message
     let payload;
     if (message.data) {
@@ -35,13 +44,13 @@ async function handleAlertTrigger(message, context, config, dependencies) {
       return;
     }
     
-    // 1. Check if this is an alert computation
-    if (!isAlertComputation(computationName)) {
+    // 1. Check if this is an alert computation (using dynamic manifest)
+    if (!isAlertComputation(cachedAlertTypes, computationName)) {
       logger.log('DEBUG', `[AlertTrigger] Not an alert computation: ${computationName}`);
       return;
     }
     
-    const alertType = getAlertTypeByComputation(computationName);
+    const alertType = getAlertTypeByComputation(cachedAlertTypes, computationName);
     if (!alertType) {
       logger.log('WARN', `[AlertTrigger] Alert type not found for computation: ${computationName}`);
       return;
@@ -101,7 +110,7 @@ async function handleAlertTrigger(message, context, config, dependencies) {
           alertType,
           piMetadata,
           date,
-          dependencies
+          { ...dependencies, alertType } // Pass alertType in dependencies for isTest check
         );
         processedCount++;
       } catch (error) {
@@ -134,47 +143,55 @@ async function handleAlertTrigger(message, context, config, dependencies) {
  */
 async function handleComputationResultWrite(change, context, config, dependencies) {
   const { db, logger } = dependencies;
+  
+  // Declare variables outside try block for error logging
+  let date, category, computationName;
 
-  // --- PATH RESOLUTION LOGIC ---
-  // 1. Try to use context.params (Preferred for Gen 2 & Wildcards)
-  // The 'contextShim' in your root index.js passes 'event.params' into here.
-  let { date, category, computationName } = context.params || {};
+  try {
+    // [NEW] Load alert types from manifest (cached)
+    if (!cachedAlertTypes) {
+      cachedAlertTypes = await loadAlertTypesFromManifest(logger);
+    }
 
-  // 2. Fallback: Parse from resource string (Legacy / Backup)
-  if (!date || !computationName) {
-      const resource = context.resource || (change.after && change.after.ref.path) || '';
-      
-      // Simple split logic can fail on full resource URIs (e.g. //firestore.googleapis.com/...)
-      // so we look for specific keywords to anchor the split.
-      const pathParts = resource.split('/');
-      
-      const dateIndex = pathParts.indexOf('unified_insights') + 1;
-      const categoryIndex = pathParts.indexOf('results') + 1;
-      const computationIndex = pathParts.indexOf('computations') + 1;
-      
-      if (dateIndex > 0 && categoryIndex > 0 && computationIndex > 0) {
-          date = pathParts[dateIndex];
-          category = pathParts[categoryIndex];
-          computationName = pathParts[computationIndex];
-      }
-  }
+    // --- PATH RESOLUTION LOGIC ---
+    // 1. Try to use context.params (Preferred for Gen 2 & Wildcards)
+    // The 'contextShim' in your root index.js passes 'event.params' into here.
+    ({ date, category, computationName } = context.params || {});
+
+    // 2. Fallback: Parse from resource string (Legacy / Backup)
+    if (!date || !computationName) {
+        const resource = context.resource || (change.after && change.after.ref.path) || '';
+        
+        // Simple split logic can fail on full resource URIs (e.g. //firestore.googleapis.com/...)
+        // so we look for specific keywords to anchor the split.
+        const pathParts = resource.split('/');
+        
+        const dateIndex = pathParts.indexOf('unified_insights') + 1;
+        const categoryIndex = pathParts.indexOf('results') + 1;
+        const computationIndex = pathParts.indexOf('computations') + 1;
+        
+        if (dateIndex > 0 && categoryIndex > 0 && computationIndex > 0) {
+            date = pathParts[dateIndex];
+            category = pathParts[categoryIndex];
+            computationName = pathParts[computationIndex];
+        }
+    }
 
-  // 3. Validation
-  if (!date || !category || !computationName) {
-      logger.log('WARN', `[AlertTrigger] Could not resolve path params. Resource: ${context.resource}`);
+    // 3. Validation
+    if (!date || !category || !computationName) {
+        logger.log('WARN', `[AlertTrigger] Could not resolve path params. Resource: ${context.resource}`);
+        return;
+    }
+    
+    // Only process if document was created or updated (not deleted)
+    if (!change.after.exists) {
+      logger.log('INFO', `[AlertTrigger] Document deleted, skipping: ${computationName} for ${date}`);
       return;
-  }
-  
-  // Only process if document was created or updated (not deleted)
-  if (!change.after.exists) {
-    logger.log('INFO', `[AlertTrigger] Document deleted, skipping: ${computationName} for ${date}`);
-    return;
-  }
-  
-  try {
-    // 1. Check if this is an alert computation OR PopularInvestorProfileMetrics
+    }
+    
+    // 1. Check if this is an alert computation OR PopularInvestorProfileMetrics (using dynamic manifest)
     const isProfileMetrics = computationName === 'PopularInvestorProfileMetrics';
-    if (!isAlertComputation(computationName) && !isProfileMetrics) {
+    if (!isAlertComputation(cachedAlertTypes, computationName) && !isProfileMetrics) {
       logger.log('DEBUG', `[AlertTrigger] Not an alert computation or profile metrics: ${computationName}`);
       return;
     }
@@ -195,13 +212,18 @@ async function handleComputationResultWrite(change, context, config, dependencie
       return; // Don't process as alert computation
     }
     
-    const alertType = getAlertTypeByComputation(computationName);
+    const alertType = getAlertTypeByComputation(cachedAlertTypes, computationName);
     if (!alertType) {
       logger.log('WARN', `[AlertTrigger] Alert type not found for computation: ${computationName}`);
       return;
     }
     
-    logger.log('INFO', `[AlertTrigger] Processing alert computation: ${computationName} for date ${date}`);
+    // [NEW] Filter test alerts - only send to developers if isTest === true
+    if (alertType.isTest) {
+      logger.log('INFO', `[AlertTrigger] Processing TEST alert computation: ${computationName} for date ${date} (will only send to developers)`);
+    } else {
+      logger.log('INFO', `[AlertTrigger] Processing alert computation: ${computationName} for date ${date}`);
+    }
     
     // 2. Read and decompress computation results (handling GCS, shards, and compression)
     const docData = change.after.data();
@@ -233,7 +255,7 @@ async function handleComputationResultWrite(change, context, config, dependencie
           alertType,
           piMetadata,
           date,
-          dependencies
+          { ...dependencies, alertType } // Pass alertType in dependencies for isTest check
         );
         processedCount++;
       } catch (error) {

package/functions/api-v2/helpers/notification_helpers.js

@@ -18,6 +18,15 @@ const { FieldValue } = require('@google-cloud/firestore');
  */
 async function notifyTaskEngineComplete(db, logger, userCid, requestId, username, success, errorMessage, options = {}) {
     try {
+        // [FIX] Check user's notification preferences before sending
+        const { manageNotificationPreferences } = require('./data-fetchers/firestore.js');
+        const prefs = await manageNotificationPreferences(db, userCid, 'get');
+        
+        if (!prefs.syncProcesses) {
+            logger?.log('DEBUG', `[notifyTaskEngineComplete] User ${userCid} has syncProcesses disabled, skipping notification`);
+            return;
+        }
+        
         const notificationData = {
             type: 'sync',
             subType: 'complete',
@@ -42,6 +51,29 @@ async function notifyTaskEngineComplete(db, logger, userCid, requestId, username
             .doc(requestId)
             .set(notificationData);
 
+        // [FIX] Clean up progress notifications for this sync to stop showing loading icons
+        try {
+            const progressNotificationsQuery = await db.collection('SignedInUsers')
+                .doc(String(userCid))
+                .collection('notifications')
+                .where('metadata.requestId', '==', requestId)
+                .where('subType', '==', 'progress')
+                .get();
+            
+            const batch = db.batch();
+            progressNotificationsQuery.docs.forEach(doc => {
+                batch.delete(doc.ref);
+            });
+            
+            if (progressNotificationsQuery.size > 0) {
+                await batch.commit();
+                logger?.log('INFO', `[notifyTaskEngineComplete] Cleaned up ${progressNotificationsQuery.size} progress notifications for request ${requestId}`);
+            }
+        } catch (cleanupError) {
+            logger?.log('WARN', `[notifyTaskEngineComplete] Failed to clean up progress notifications: ${cleanupError.message}`);
+            // Don't throw - cleanup is non-critical
+        }
+
         logger?.log('INFO', `[notifyTaskEngineComplete] Notification sent for user ${userCid}, request ${requestId}`);
     } catch (error) {
         logger?.log('WARN', `[notifyTaskEngineComplete] Failed to send notification: ${error.message}`);
@@ -61,6 +93,15 @@ async function notifyTaskEngineComplete(db, logger, userCid, requestId, username
  */
 async function notifyTaskEngineProgress(db, logger, userCid, requestId, username, stage, dataType, options = {}) {
     try {
+        // [FIX] Check user's notification preferences before sending
+        const { manageNotificationPreferences } = require('./data-fetchers/firestore.js');
+        const prefs = await manageNotificationPreferences(db, userCid, 'get');
+        
+        if (!prefs.syncProcesses) {
+            logger?.log('DEBUG', `[notifyTaskEngineProgress] User ${userCid} has syncProcesses disabled, skipping notification`);
+            return;
+        }
+        
         const stageMessages = {
             'started': 'Data sync started',
             'portfolio_complete': 'Portfolio data fetched',
@@ -130,6 +171,15 @@ async function notifyPIDataRefreshed(db, logger, collectionRegistry, piCid, user
  */
 async function notifyComputationComplete(db, logger, userCid, requestId, computation, displayName, success, errorMessage, options = {}) {
     try {
+        // [FIX] Check user's notification preferences before sending
+        const { manageNotificationPreferences } = require('./data-fetchers/firestore.js');
+        const prefs = await manageNotificationPreferences(db, userCid, 'get');
+        
+        if (!prefs.userActionCompletions) {
+            logger?.log('DEBUG', `[notifyComputationComplete] User ${userCid} has userActionCompletions disabled, skipping notification`);
+            return;
+        }
+        
         const notificationData = {
             type: 'computation',
             subType: 'complete',

package/functions/api-v2/routes/alerts.js

@@ -6,9 +6,11 @@ const {
     fetchAlertTypes,
     getUserSubscriptions,
     updateSubscription,
-    unsubscribeFromAlerts
+    unsubscribeFromAlerts,
+    isDeveloper
 } = require('../helpers/data-fetchers/firestore.js');
 const { sanitizeCid, sanitizeDocId, validateBatchSize } = require('../helpers/security_utils.js');
+const { loadAlertTypesFromManifest } = require('../../alert-system/helpers/alert_manifest_loader');
 
 const router = express.Router();
 
@@ -34,6 +36,43 @@ const updateSubscriptionSchema = z.object({
     thresholds: z.record(z.any()).optional()
 });
 
+// [NEW] GET /alerts/types - Dynamically load available alert types from manifest
+router.get('/types', async (req, res, next) => {
+    try {
+        const { db, logger } = req.dependencies;
+        
+        // Load alert types from manifest
+        const alertTypes = await loadAlertTypesFromManifest(logger);
+        
+        // Check if user is a developer
+        const isDev = await isDeveloper(db, String(req.targetUserId));
+        
+        // Filter out test alerts for non-developers
+        const filteredAlertTypes = isDev 
+            ? alertTypes 
+            : alertTypes.filter(type => !type.isTest);
+        
+        // Format response for frontend
+        const formattedTypes = filteredAlertTypes.map(type => ({
+            id: type.id,
+            name: type.name,
+            description: type.description,
+            severity: type.severity,
+            configKey: type.configKey,
+            isTest: type.isTest || false
+        }));
+        
+        res.json({ 
+            success: true, 
+            alertTypes: formattedTypes,
+            count: formattedTypes.length 
+        });
+    } catch (error) {
+        logger?.log('ERROR', `[GET /alerts/types] Error loading alert types: ${error.message}`);
+        next(error);
+    }
+});
+
 // GET /alerts/history
 router.get('/history', async (req, res, next) => {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.678",
+  "version": "1.0.680",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [