bulltrackers-module 1.0.472 → 1.0.474

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

@@ -16,7 +16,8 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     const piUsername = await getPIUsername(db, piCid);
     
     // 2. Find all users subscribed to this PI and alert type
-    const subscriptions = await findSubscriptionsForPI(db, piCid, alertType.id);
+    // Use computationName (e.g., 'RiskScoreIncrease') to map to alertConfig keys
+    const subscriptions = await findSubscriptionsForPI(db, logger, piCid, alertType.computationName);
     
     if (subscriptions.length === 0) {
       logger.log('INFO', `[processAlertForPI] No subscriptions found for PI ${piCid}, alert type ${alertType.id}`);
@@ -28,37 +29,41 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
     // 3. Generate alert message
     const alertMessage = generateAlertMessage(alertType, piUsername, computationMetadata);
     
-    // 4. Create alerts for each subscribed user
+    // 4. Create notifications for each subscribed user (using user_notifications collection)
     const batch = db.batch();
-    const alertRefs = [];
+    const notificationRefs = [];
     const counterUpdates = {};
     
     for (const subscription of subscriptions) {
-      const alertId = `alert_${Date.now()}_${subscription.userCid}_${piCid}`;
-      const alertRef = db.collection('user_alerts')
+      const notificationId = `alert_${Date.now()}_${subscription.userCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
+      const notificationRef = db.collection('user_notifications')
         .doc(String(subscription.userCid))
-        .collection('alerts')
-        .doc(alertId);
+        .collection('notifications')
+        .doc(notificationId);
       
-      const alertData = {
-        id: alertId,
-        userCid: subscription.userCid,
-        piCid: piCid,
-        piUsername: piUsername,
-        alertType: alertType.id,
-        alertTypeName: alertType.name,
-        computationName: alertType.computationName,
-        computationDate: computationDate,
+      const notificationData = {
+        id: notificationId,
+        type: 'alert',
+        title: alertType.name,
         message: alertMessage,
-        severity: alertType.severity,
         read: false,
-        readAt: null,
         createdAt: FieldValue.serverTimestamp(),
-        metadata: computationMetadata || {}
+        metadata: {
+          piCid: Number(piCid),
+          piUsername: piUsername,
+          alertType: alertType.id,
+          alertTypeName: alertType.name,
+          computationName: alertType.computationName,
+          computationDate: computationDate,
+          severity: alertType.severity,
+          watchlistId: subscription.watchlistId,
+          watchlistName: subscription.watchlistName,
+          ...(computationMetadata || {})
+        }
       };
       
-      batch.set(alertRef, alertData);
-      alertRefs.push(alertRef);
+      batch.set(notificationRef, notificationData);
+      notificationRefs.push(notificationRef);
       
       // Track counter updates
       const dateKey = computationDate || new Date().toISOString().split('T')[0];
@@ -76,9 +81,9 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
         (counterUpdates[subscription.userCid].byType[alertType.id] || 0) + 1;
     }
     
-    // 5. Update alert counters
+    // 5. Update notification counters
     for (const [userCid, counter] of Object.entries(counterUpdates)) {
-      const counterRef = db.collection('user_alerts')
+      const counterRef = db.collection('user_notifications')
         .doc(String(userCid))
         .collection('counters')
         .doc(counter.date);
@@ -92,25 +97,10 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
       }, { merge: true });
     }
     
-    // 6. Update subscription lastAlertAt
-    for (const subscription of subscriptions) {
-      const subscriptionRef = db.collection('watchlist_subscriptions')
-        .doc(String(subscription.userCid))
-        .collection('alerts')
-        .doc(String(piCid));
-      
-      batch.update(subscriptionRef, {
-        lastAlertAt: FieldValue.serverTimestamp()
-      });
-    }
-    
-    // 7. Commit batch
+    // 6. Commit batch
     await batch.commit();
     
-    logger.log('SUCCESS', `[processAlertForPI] Created ${alertRefs.length} alerts for PI ${piCid}, alert type ${alertType.id}`);
-    
-    // 8. Optionally notify the PI if they're a signed-in user
-    await notifyPIIfSignedIn(db, logger, piCid, alertType, subscriptions.length);
+    logger.log('SUCCESS', `[processAlertForPI] Created ${notificationRefs.length} notifications for PI ${piCid}, alert type ${alertType.id}`);
     
   } catch (error) {
     logger.log('ERROR', `[processAlertForPI] Error processing alert for PI ${piCid}`, error);
@@ -119,35 +109,67 @@ async function processAlertForPI(db, logger, piCid, alertType, computationMetada
 }
 
 /**
- * Find all subscriptions for a PI and alert type
+ * Find all users who should receive alerts for a PI and alert type
+ * Reads from actual watchlist structure: watchlists/{userCid}/lists/{watchlistId}
  */
-async function findSubscriptionsForPI(db, piCid, alertTypeId) {
+async function findSubscriptionsForPI(db, logger, piCid, alertTypeId) {
   const subscriptions = [];
   
-  // Query all users who have subscriptions
-  const subscriptionsCollection = db.collection('watchlist_subscriptions');
-  const snapshot = await subscriptionsCollection
-    .where('piCid', '==', Number(piCid))
-    .get();
+  // Map computation names to watchlist alertConfig keys
+  // The alertTypeId is actually the computation name (e.g., 'RiskScoreIncrease')
+  const computationToConfigKey = {
+    'RiskScoreIncrease': 'increasedRisk',
+    'SignificantVolatility': 'volatilityChanges',
+    'NewSectorExposure': 'newSector',
+    'PositionInvestedIncrease': 'increasedPositionSize',
+    'NewSocialPost': 'newSocialPost',
+    'NewPositions': 'newPositions' // If this computation exists
+  };
   
-  for (const doc of snapshot.docs) {
-    const data = doc.data();
-    const userCid = data.userCid;
+  const configKey = computationToConfigKey[alertTypeId];
+  if (!configKey) {
+    logger.log('WARN', `[findSubscriptionsForPI] No mapping found for alert type: ${alertTypeId}`);
+    return subscriptions;
+  }
+  
+  // Get all watchlists
+  const watchlistsCollection = db.collection('watchlists');
+  const watchlistsSnapshot = await watchlistsCollection.get();
+  
+  for (const userDoc of watchlistsSnapshot.docs) {
+    const userCid = Number(userDoc.id);
+    const userListsSnapshot = await userDoc.ref.collection('lists').get();
     
-    // Check if this user is subscribed to this alert type
-    if (data.alertTypes && data.alertTypes[alertTypeId] === true) {
-      // Check thresholds if applicable
-      if (shouldTriggerAlert(data, alertTypeId)) {
-        subscriptions.push({
-          userCid: userCid,
-          piCid: piCid,
-          alertTypes: data.alertTypes,
-          thresholds: data.thresholds || {}
-        });
+    for (const listDoc of userListsSnapshot.docs) {
+      const listData = listDoc.data();
+      
+      // Check static watchlists
+      if (listData.type === 'static' && listData.items && Array.isArray(listData.items)) {
+        for (const item of listData.items) {
+          if (Number(item.cid) === Number(piCid)) {
+            // Check if this alert type is enabled for this PI in this watchlist
+            if (item.alertConfig && item.alertConfig[configKey] === true) {
+              subscriptions.push({
+                userCid: userCid,
+                piCid: piCid,
+                piUsername: item.username || `PI-${piCid}`,
+                watchlistId: listDoc.id,
+                watchlistName: listData.name || 'Unnamed Watchlist',
+                alertConfig: item.alertConfig
+              });
+              break; // Found in this watchlist, no need to check other items
+            }
+          }
+        }
       }
+      
+      // Check dynamic watchlists - if the PI matches the computation result, check alertConfig
+      // Note: Dynamic watchlists are handled separately as they're based on computation results
+      // For now, we only process static watchlists here
     }
   }
   
+  logger.log('INFO', `[findSubscriptionsForPI] Found ${subscriptions.length} subscriptions for PI ${piCid}, alert type ${alertTypeId}`);
   return subscriptions;
 }
 
@@ -336,10 +358,41 @@ function readComputationResults(docData) {
   }
 }
 
+/**
+ * Read computation results, handling sharded data
+ */
+async function readComputationResultsWithShards(db, docData, docRef) {
+  try {
+    // Check if data is sharded
+    if (docData._sharded === true && docData._shardCount) {
+      // Data is stored in shards - read all shards and merge
+      const shardsCol = docRef.collection('_shards');
+      const shardsSnapshot = await shardsCol.get();
+      
+      if (!shardsSnapshot.empty) {
+        let mergedData = {};
+        for (const shardDoc of shardsSnapshot.docs) {
+          const shardData = shardDoc.data();
+          const decompressed = tryDecompress(shardData);
+          Object.assign(mergedData, decompressed);
+        }
+        return readComputationResults(mergedData);
+      }
+    }
+    
+    // Data is in the main document (compressed or not)
+    return readComputationResults(docData);
+  } catch (error) {
+    console.error('[readComputationResultsWithShards] Error reading sharded results', error);
+    return { cids: [], metadata: {}, perUserData: {} };
+  }
+}
+
 module.exports = {
   processAlertForPI,
   findSubscriptionsForPI,
   getPIUsername,
-  readComputationResults
+  readComputationResults,
+  readComputationResultsWithShards
 };
 

package/functions/alert-system/index.js

@@ -4,7 +4,7 @@
  */
 
 const { getAlertTypeByComputation, isAlertComputation } = require('./helpers/alert_type_registry');
-const { processAlertForPI, readComputationResults } = require('./helpers/alert_helpers');
+const { processAlertForPI, readComputationResults, readComputationResultsWithShards } = require('./helpers/alert_helpers');
 
 /**
  * Pub/Sub trigger handler for alert generation
@@ -126,13 +126,33 @@ async function handleAlertTrigger(message, context, config, dependencies) {
 }
 
 /**
- * Firestore trigger function for alert generation (if using Firestore triggers)
+ * Firestore trigger function for alert generation
  * Triggered when computation results are written to:
- * unified_insights/{date}/results/popular-investor/computations/{computationName}
+ * unified_insights/{date}/results/{category}/computations/{computationName}
+ * 
+ * Handles sharded data by checking _shards subcollection if _sharded === true
  */
 async function handleComputationResultWrite(change, context, config, dependencies) {
   const { db, logger } = dependencies;
-  const { date, computationName } = context.params;
+  
+  // Extract path parameters from the document path
+  // Path format: unified_insights/{date}/results/{category}/computations/{computationName}
+  const resource = context.resource || change.after.ref.path;
+  const pathParts = resource.split('/');
+  
+  // Find indices of key path segments
+  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) {
+    logger.log('WARN', `[AlertTrigger] Invalid document path format: ${resource}`);
+    return;
+  }
+  
+  const date = pathParts[dateIndex];
+  const category = pathParts[categoryIndex];
+  const computationName = pathParts[computationIndex];
   
   // Only process if document was created or updated (not deleted)
   if (!change.after.exists) {
@@ -148,10 +168,16 @@ async function handleComputationResultWrite(change, context, config, dependencie
       return;
     }
     
+    // Only process popular-investor category computations
+    if (category !== 'popular-investor') {
+      logger.log('DEBUG', `[AlertTrigger] Not popular-investor category: ${category}`);
+      return;
+    }
+    
     // If it's PopularInvestorProfileMetrics, check for all-clear notifications only
     if (isProfileMetrics) {
       const docData = change.after.data();
-      const results = readComputationResults(docData);
+      const results = await readComputationResultsWithShards(db, docData, change.after.ref);
       if (results.cids && results.cids.length > 0) {
         await checkAndSendAllClearNotifications(db, logger, results.cids, date, config);
       }
@@ -166,9 +192,9 @@ async function handleComputationResultWrite(change, context, config, dependencie
     
     logger.log('INFO', `[AlertTrigger] Processing alert computation: ${computationName} for date ${date}`);
     
-    // 2. Read and decompress computation results
+    // 2. Read and decompress computation results (handling shards)
     const docData = change.after.data();
-    const results = readComputationResults(docData);
+    const results = await readComputationResultsWithShards(db, docData, change.after.ref);
     
     if (!results.cids || results.cids.length === 0) {
       logger.log('INFO', `[AlertTrigger] No PIs found in computation results for ${computationName}`);
@@ -178,6 +204,7 @@ async function handleComputationResultWrite(change, context, config, dependencie
     logger.log('INFO', `[AlertTrigger] Found ${results.cids.length} PIs in ${computationName} results`);
     
     // 3. Process alerts for each PI
+    // Use computationName as the alertTypeId (it maps to alertConfig keys)
     let processedCount = 0;
     let errorCount = 0;
     
@@ -186,7 +213,7 @@ async function handleComputationResultWrite(change, context, config, dependencie
         // Extract PI-specific metadata if available, otherwise use global metadata
         const piMetadata = results.perUserData && results.perUserData[piCid] 
           ? results.perUserData[piCid]
-          : results.metadata || {};
+          : results.metadata || results.globalMetadata || {};
         
         await processAlertForPI(
           db,
@@ -206,12 +233,6 @@ async function handleComputationResultWrite(change, context, config, dependencie
     
     logger.log('SUCCESS', `[AlertTrigger] Completed processing ${computationName}: ${processedCount} successful, ${errorCount} errors`);
     
-    // After processing alerts, check for "all clear" notifications for static watchlists
-    if (processedCount > 0 || results.cids.length > 0) {
-      // Check if any PIs were processed but didn't trigger alerts
-      await checkAndSendAllClearNotifications(db, logger, results.cids, date, config);
-    }
-    
   } catch (error) {
     logger.log('ERROR', `[AlertTrigger] Fatal error processing ${computationName}`, error);
     // Don't throw - we don't want to retry the entire computation write
@@ -238,7 +259,7 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
     const usersToNotify = new Map(); // userCid -> Map of piCid -> {username, ...}
     
     for (const userDoc of watchlistsSnapshot.docs) {
-      const userCid = userDoc.id;
+      const userCid = Number(userDoc.id);
       const userListsSnapshot = await userDoc.ref.collection('lists').get();
       
       for (const listDoc of userListsSnapshot.docs) {
@@ -253,8 +274,8 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
         for (const item of listData.items) {
           const piCid = Number(item.cid);
           if (processedPICids.includes(piCid)) {
-            // Check if this PI triggered any alerts today
-            const hasAlerts = await checkIfPIHasAlertsToday(db, userCid, piCid, today);
+            // Check if this PI triggered any alerts today for this user
+            const hasAlerts = await checkIfPIHasAlertsToday(db, logger, userCid, piCid, today);
             
             if (!hasAlerts) {
               // No alerts triggered - send "all clear" notification
@@ -292,28 +313,28 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
 
 /**
  * Check if a PI has any alerts for a user today
+ * Checks user_notifications collection for alert-type notifications
  */
-async function checkIfPIHasAlertsToday(db, userCid, piCid, date) {
+async function checkIfPIHasAlertsToday(db, logger, userCid, piCid, date) {
   try {
-    const alertsRef = db.collection('user_alerts')
+    const notificationsRef = db.collection('user_notifications')
       .doc(String(userCid))
-      .collection('alerts');
-    
-    // Check if there are any alerts for this PI today
-    const todayStart = new Date(date);
-    todayStart.setHours(0, 0, 0, 0);
-    const todayEnd = new Date(date);
-    todayEnd.setHours(23, 59, 59, 999);
+      .collection('notifications');
     
-    const snapshot = await alertsRef
-      .where('piCid', '==', Number(piCid))
-      .where('computationDate', '==', date)
+    // Check if there are any alert notifications for this PI today
+    const snapshot = await notificationsRef
+      .where('type', '==', 'alert')
+      .where('metadata.piCid', '==', Number(piCid))
+      .where('metadata.computationDate', '==', date)
       .limit(1)
       .get();
     
     return !snapshot.empty;
   } catch (error) {
-    // If we can't check, assume there are alerts (safer)
+    if (logger) {
+      logger.log('WARN', `[checkIfPIHasAlertsToday] Error checking alerts for user ${userCid}, PI ${piCid}: ${error.message}`);
+    }
+    // If we can't check, assume there are alerts (safer - won't send false all-clear)
     return true;
   }
 }

package/functions/computation-system/persistence/ResultCommitter.js

@@ -202,15 +202,10 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
         await updateComputationStatus(dStr, successUpdates, config, deps); 
     }
 
-    // Flush Alert Triggers to Pub/Sub
+    // Alert triggers are now handled via Firestore triggers
+    // No need to publish Pub/Sub messages - the Firestore write itself triggers the alert system
     if (alertTriggers.length > 0) {
-        const topicName = config.alertTopicName || 'alert-trigger';
-        try {
-            await pubSubUtils.publishMessageBatch(topicName, alertTriggers);
-            logger.log('INFO', `[Alert System] Triggered ${alertTriggers.length} alerts to ${topicName}`);
-        } catch (alertErr) {
-            logger.log('ERROR', `[Alert System] Failed to publish alerts: ${alertErr.message}`);
-        }
+        logger.log('INFO', `[Alert System] ${alertTriggers.length} alert computations written to Firestore - triggers will fire automatically`);
     }
     
     return { successUpdates, failureReport, shardIndexes: nextShardIndexes };

package/functions/computation-system/workflows/data_feeder_pipeline.yaml

@@ -1,5 +1,6 @@
-# Data Feeder Pipeline (V2.3 - Try/Retry Syntax Fixed)
-# Orchestrates data fetching with UTC-alignment, Test Mode, and Reliability.
+# Data Feeder Pipeline (V3.1 - Syntax Fixed)
+# Starts at 22:00 UTC via Cloud Scheduler.
+# Fixes: Split assign/call steps and corrected assign syntax.
 
 main:
   params: [input]
@@ -8,17 +9,8 @@ main:
         assign:
           - project: '${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}'
           - location: "europe-west1"
-          - market_date: '${text.split(time.format(sys.now()), "T")[0]}'
-          # Define a central retry policy to reuse across all HTTP calls
-          - default_retry:
-              predicate: ${http.default_retry_predicate}
-              max_retries: 5
-              backoff:
-                initial_delay: 2
-                max_delay: 60
-                multiplier: 2
-
-    # --- TEST MODE / SELECTIVE EXECUTION ---
+
+    # --- TEST MODE ---
     - check_test_mode:
         switch:
           - condition: '${input != null and "target_step" in input}'
@@ -26,130 +18,164 @@ main:
               - route_test:
                   switch:
                     - condition: '${input.target_step == "market"}'
-                      next: run_market_close_tasks
-                    - condition: '${input.target_step == "rankings"}'
-                      next: run_rankings_fetch
+                      next: phase_2200_price
+                    - condition: '${input.target_step == "midnight"}'
+                      next: phase_0000_rankings
                     - condition: '${input.target_step == "social"}'
-                      next: run_social_midnight
-                    - condition: '${input.target_step == "global"}'
-                      next: run_global_indexer
-
-    # --- PHASE 1: MARKET CLOSE (22:00 UTC) ---
-    - run_market_close_tasks:
-        parallel:
-          branches:
-            - price_fetch:
-                steps:
-                  - call_price_fetcher:
-                      try:
-                        call: http.post
-                        args:
-                          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/price-fetcher"}'
-                          auth: { type: OIDC }
-                          timeout: 300
-                      retry: ${default_retry} # Fixed: Moved retry to a Try Step
-            - insights_fetch:
-                steps:
-                  - call_insights_fetcher:
-                      try:
-                        call: http.post
-                        args:
-                          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/insights-fetcher"}'
-                          auth: { type: OIDC }
-                          timeout: 300
-                      retry: ${default_retry} # Fixed: Moved retry to a Try Step
-
-    - index_market_data:
+                      next: social_loop_start
+
+    # ==========================================
+    # PHASE 1: MARKET CLOSE (Starts 22:00 UTC)
+    # ==========================================
+
+    - phase_2200_price:
         try:
           call: http.post
           args:
-            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
-            body:
-              targetDate: '${market_date}'
+            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/price-fetcher"}'
             auth: { type: OIDC }
             timeout: 300
-        retry: ${default_retry}
+        except:
+          as: e
+          steps:
+            - log_price_error:
+                call: sys.log
+                args: { severity: "WARNING", text: "Price fetch timed out/failed. Proceeding." }
+    
+    - wait_10_after_price:
+        call: sys.sleep
+        args: { seconds: 600 } # 10 Minutes
 
-    # --- PHASE 2: ALIGN TO MIDNIGHT ---
-    - wait_for_midnight:
+    # FIX 1: Split assign and call
+    - prepare_index_price:
         assign:
-          - now_sec: '${int(sys.now())}'
-          - day_sec: 86400
-          - sleep_midnight: '${day_sec - (now_sec % day_sec)}'
-    - do_midnight_sleep:
-        call: sys.sleep
+          - today: '${text.split(time.format(sys.now()), "T")[0]}'
+    - index_today_after_price:
+        call: http.post
         args:
-          seconds: '${sleep_midnight}'
+          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+          body: { targetDate: '${today}' }
+          auth: { type: OIDC }
 
-    # --- PHASE 3: RANKINGS & INITIAL SOCIAL (00:00 UTC) ---
-    - run_rankings_fetch:
+    - wait_10_before_insights:
+        call: sys.sleep
+        args: { seconds: 600 }
+
+    - phase_2200_insights:
         try:
           call: http.post
           args:
-            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/fetch-popular-investors"}'
+            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/insights-fetcher"}'
             auth: { type: OIDC }
             timeout: 300
-        retry: ${default_retry}
         except:
           as: e
           steps:
-            - log_rankings_error:
+            - log_insights_error:
                 call: sys.log
-                args:
-                  severity: "ERROR"
-                  text: '${"Rankings Fetch Failed: " + json.encode(e)}'
+                args: { severity: "WARNING", text: "Insights fetch timed out/failed. Proceeding." }
 
-    - run_social_midnight:
-        try:
-          call: http.post
-          args:
-            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/social-orchestrator"}'
-            auth: { type: OIDC }
-            timeout: 300
-        retry: ${default_retry}
+    - wait_10_after_insights:
+        call: sys.sleep
+        args: { seconds: 600 }
 
-    - prepare_midnight_index:
+    # FIX 2: Split assign and call
+    - prepare_index_insights:
         assign:
-            - current_date: '${text.split(time.format(sys.now()), "T")[0]}'
-    - index_midnight_data:
+          - today: '${text.split(time.format(sys.now()), "T")[0]}'
+    - index_today_after_insights:
+        call: http.post
+        args:
+          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+          body: { targetDate: '${today}' }
+          auth: { type: OIDC }
+
+    # ==========================================
+    # PHASE 2: WAIT FOR MIDNIGHT
+    # ==========================================
+
+    - align_to_midnight:
+        assign:
+          - now_sec: '${int(sys.now())}'
+          - day_sec: 86400
+          - sleep_midnight: '${day_sec - (now_sec % day_sec)}'
+    - wait_for_midnight:
+        call: sys.sleep
+        args: { seconds: '${sleep_midnight}' }
+
+    # ==========================================
+    # PHASE 3: MIDNIGHT TASKS (00:00 UTC)
+    # ==========================================
+
+    - phase_0000_rankings:
         try:
           call: http.post
           args:
-            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
-            body:
-               targetDate: '${current_date}'
+            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/fetch-popular-investors"}'
             auth: { type: OIDC }
             timeout: 300
-        retry: ${default_retry}
+        except:
+          as: e
+          steps:
+            - log_ranking_error:
+                call: sys.log
+                args: { severity: "WARNING", text: "Rankings failed. Proceeding to Social (risky)." }
 
-    - run_global_indexer:
+    - wait_10_after_rankings:
+        call: sys.sleep
+        args: { seconds: 600 }
+
+    # FIX 3: Split assign and call
+    - prepare_index_rankings:
+        assign:
+          - today: '${text.split(time.format(sys.now()), "T")[0]}'
+    - index_today_after_rankings:
+        call: http.post
+        args:
+          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+          body: { targetDate: '${today}' }
+          auth: { type: OIDC }
+
+    - phase_0000_social:
         try:
           call: http.post
           args:
-            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/social-orchestrator"}'
             auth: { type: OIDC }
             timeout: 300
-        retry: ${default_retry}
+        except:
+          as: e
+          steps:
+            - log_social_error:
+                call: sys.log
+                args: { severity: "WARNING", text: "Social failed. Proceeding." }
+
+    - wait_10_after_social:
+        call: sys.sleep
+        args: { seconds: 600 }
+
+    - global_index_midnight:
+        call: http.post
+        args:
+          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+          # No targetDate = Global Run
+          auth: { type: OIDC }
+
+    # ==========================================
+    # PHASE 4: SOCIAL LOOP (Every 3 Hours)
+    # ==========================================
 
-    # --- PHASE 4: RECURRING SOCIAL FETCH (UTC Aligned 3hr) ---
     - init_social_loop:
         assign:
           - i: 0
     
-    - social_loop:
+    - social_loop_start:
         switch:
-          - condition: ${i < 7}
+          - condition: ${i < 7} # Covers the remainder of the 24h cycle
             steps:
-              - calculate_next_window:
-                  assign:
-                    - now_sec_loop: '${int(sys.now())}'
-                    - window_size: 10800 
-                    - sleep_loop: '${window_size - (now_sec_loop % window_size)}'
-              
-              - wait_for_3hr_window:
+              - wait_3_hours:
                   call: sys.sleep
-                  args:
-                    seconds: '${sleep_loop}'
+                  args: { seconds: 10800 }
               
               - run_social_recurring:
                   try:
@@ -158,27 +184,34 @@ main:
                       url: '${"https://" + location + "-" + project + ".cloudfunctions.net/social-orchestrator"}'
                       auth: { type: OIDC }
                       timeout: 300
-                  retry: ${default_retry}
+                  except:
+                    as: e
+                    steps:
+                      - log_loop_social_warn:
+                          call: sys.log
+                          args: { severity: "WARNING", text: "Loop Social timed out. Proceeding." }
 
-              - prepare_recurring_index:
+              - wait_10_in_loop:
+                  call: sys.sleep
+                  args: { seconds: 600 }
+              
+              # FIX 4: Split assign and call
+              - prepare_index_loop:
                    assign:
-                     - cur_date_rec: '${text.split(time.format(sys.now()), "T")[0]}'
-              - index_recurring:
-                   try:
-                     call: http.post
-                     args:
-                       url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
-                       body:
-                         targetDate: '${cur_date_rec}'
-                       auth: { type: OIDC }
-                       timeout: 300
-                   retry: ${default_retry}
+                     - today: '${text.split(time.format(sys.now()), "T")[0]}'
+              - index_today_in_loop:
+                   call: http.post
+                   args:
+                     url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+                     body: { targetDate: '${today}' }
+                     auth: { type: OIDC }
               
-              - increment:
-                  assign:
-                    - i: ${i + 1}
+              # FIX 5: Correct assign syntax (must be a list)
+              - increment_loop:
+                  assign: 
+                    - i: '${i + 1}'
               - next_iteration:
-                  next: social_loop
+                  next: social_loop_start
 
     - finish:
-        return: "Daily Data Pipeline Completed"
+        return: "Complete 24h Cycle Finished"

package/index.js

@@ -57,7 +57,7 @@ const { runRootDataIndexer }                              = require('./functions
 const { runPopularInvestorFetch }                         = require('./functions/fetch-popular-investors/index');
 
 // Alert System
-const { handleAlertTrigger, handleComputationResultWrite } = require('./functions/alert-system/index');
+const { handleAlertTrigger, handleComputationResultWrite, checkAndSendAllClearNotifications } = require('./functions/alert-system/index');
 
 // Proxy
 const { handlePost }                                      = require('./functions/appscript-api/index');
@@ -126,8 +126,9 @@ const maintenance = {
 const proxy = { handlePost };
 
 const alertSystem = {
-  handleAlertTrigger,
-  handleComputationResultWrite
+  handleAlertTrigger, // Pub/Sub handler (kept for backward compatibility, but not used)
+  handleComputationResultWrite, // Firestore trigger handler - main entry point
+  checkAndSendAllClearNotifications
 };
 
 module.exports = {

package/package.json

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