bulltrackers-module 1.0.778 → 1.0.779

package/functions/alert-system/index.js

@@ -23,13 +23,13 @@ let cachedAlertTypes = null;
  */
 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) {
@@ -38,28 +38,28 @@ async function handleAlertTrigger(message, context, config, dependencies) {
     } else {
       payload = message;
     }
-    
+
     const { date, computationName, documentPath } = payload;
-    
+
     if (!date || !computationName) {
       logger.log('WARN', '[AlertTrigger] Missing required fields: date or computationName');
       return;
     }
-    
+
     // 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(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}`);
-    
+
     // 2. Read computation results from Firestore
     let docRef;
     if (documentPath) {
@@ -75,36 +75,36 @@ async function handleAlertTrigger(message, context, config, dependencies) {
         .collection('computations')
         .doc(computationName);
     }
-    
+
     const docSnapshot = await docRef.get();
-    
+
     if (!docSnapshot.exists) {
       logger.log('WARN', `[AlertTrigger] Document not found: ${docRef.path}`);
       return;
     }
-    
+
     // 3. Read and decompress computation results (handling GCS, shards, and compression)
     const docData = docSnapshot.data();
     const results = await readComputationResultsWithShards(db, docData, docRef, logger);
-    
+
     if (!results.cids || results.cids.length === 0) {
       logger.log('INFO', `[AlertTrigger] No PIs found in computation results for ${computationName}`);
       return;
     }
-    
+
     logger.log('INFO', `[AlertTrigger] Found ${results.cids.length} PIs in ${computationName} results`);
-    
+
     // 4. Process alerts for each PI
     let processedCount = 0;
     let errorCount = 0;
-    
+
     for (const piCid of results.cids) {
       try {
         // Extract PI-specific metadata if available, otherwise use global metadata
-        const piMetadata = results.perUserData && results.perUserData[piCid] 
+        const piMetadata = results.perUserData && results.perUserData[piCid]
           ? results.perUserData[piCid]
           : results.metadata || {};
-        
+
         await processAlertForPI(
           db,
           logger,
@@ -121,16 +121,16 @@ async function handleAlertTrigger(message, context, config, dependencies) {
         // Continue processing other PIs even if one fails
       }
     }
-    
+
     logger.log('SUCCESS', `[AlertTrigger] Completed processing ${computationName}: ${processedCount} successful, ${errorCount} errors`);
-    
+
     // After processing alerts, check for "all clear" notifications for static watchlists
     // This runs after all alert computations are processed
     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, dependencies);
     }
-    
+
   } catch (error) {
     logger.log('ERROR', '[AlertTrigger] Fatal error processing alert trigger', error);
     throw error; // Re-throw for Pub/Sub retry
@@ -138,140 +138,83 @@ async function handleAlertTrigger(message, context, config, dependencies) {
 }
 
 /**
- * Firestore trigger function for alert generation
+ * Firestore trigger function for alert generation (V2 paths only).
  * Triggered when computation results are written to:
- * unified_insights/{date}/results/{category}/computations/{computationName}
- * * Handles sharded data by checking _shards subcollection if _sharded === true
+ * - Per-entity: alerts/{date}/{computationName}/{entityId}
+ * - Single-doc: alerts/{date}/{computationName} (doc contains cids and per-entity data)
+ * context.params must include date, computationName; entityId present only for per-entity path.
  */
 async function handleComputationResultWrite(change, context, config, dependencies) {
   const { db, logger } = dependencies;
-  
-  // Declare variables outside try block for error logging
-  let date, category, computationName;
+
+  let date, computationName, entityId;
 
   try {
-    // [NEW] Load alert types from manifest (cached)
     if (!cachedAlertTypes) {
       cachedAlertTypes = await loadAlertTypesFromManifest(logger);
     }
 
-    // --- 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 || {});
+    ({ date, computationName, entityId } = 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];
-        }
+      logger.log('WARN', `[AlertTrigger] Missing path params. Params: ${JSON.stringify(context.params)}`);
+      return;
     }
 
-    // 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;
     }
-    
-    // 1. Check if this is an alert computation OR PopularInvestorProfileMetrics (using dynamic manifest)
-    const isProfileMetrics = computationName === 'PopularInvestorProfileMetrics';
-    if (!isAlertComputation(cachedAlertTypes, computationName) && !isProfileMetrics) {
-      logger.log('DEBUG', `[AlertTrigger] Not an alert computation or profile metrics: ${computationName}`);
-      return;
-    }
-    
-    // [FIX] Allow both 'popular-investor' (for profile metrics) AND 'alerts' (for actual alerts)
-    if (category !== 'popular-investor' && category !== 'alerts') {
-      logger.log('DEBUG', `[AlertTrigger] Skipping irrelevant category: ${category}`);
+
+    if (!isAlertComputation(cachedAlertTypes, computationName)) {
+      logger.log('DEBUG', `[AlertTrigger] Not an alert computation: ${computationName}`);
       return;
     }
-    
-    // If it's PopularInvestorProfileMetrics, check for all-clear notifications only
-    if (isProfileMetrics) {
-      const docData = change.after.data();
-      const results = await readComputationResultsWithShards(db, docData, change.after.ref, logger);
-      if (results.cids && results.cids.length > 0) {
-        await checkAndSendAllClearNotifications(db, logger, results.cids, date, config, dependencies);
-      }
-      return; // Don't process as alert computation
-    }
-    
+
     const alertType = getAlertTypeByComputation(cachedAlertTypes, computationName);
     if (!alertType) {
       logger.log('WARN', `[AlertTrigger] Alert type not found for computation: ${computationName}`);
       return;
     }
-    
-    // [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)`);
+      logger.log('INFO', `[AlertTrigger] Processing TEST alert: ${computationName} for date ${date}`);
     } else {
-      logger.log('INFO', `[AlertTrigger] Processing alert computation: ${computationName} for date ${date}`);
+      logger.log('INFO', `[AlertTrigger] Processing alert: ${computationName} for date ${date}`);
     }
-    
-    // 2. Read and decompress computation results (handling GCS, shards, and compression)
+
     const docData = change.after.data();
-    const results = await readComputationResultsWithShards(db, docData, change.after.ref, logger);
-    
-    if (!results.cids || results.cids.length === 0) {
-      logger.log('INFO', `[AlertTrigger] No PIs found in computation results for ${computationName}`);
+    const deps = { ...dependencies, alertType };
+
+    if (entityId != null && entityId !== '') {
+      // Per-entity path: one doc per PI; doc body is the single PI result
+      await processAlertForPI(db, logger, entityId, alertType, docData, date, deps);
+      logger.log('SUCCESS', `[AlertTrigger] Completed ${computationName} for PI ${entityId}`);
       return;
     }
-    
-    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)
+
+    // Single-doc path: doc contains cids and per-entity keys
+    const cids = Array.isArray(docData.cids) ? docData.cids : Object.keys(docData).filter(k => /^\d+$/.test(k)).map(Number);
+    if (!cids.length) {
+      logger.log('INFO', `[AlertTrigger] No PIs in document for ${computationName}`);
+      return;
+    }
+
     let processedCount = 0;
     let errorCount = 0;
-    
-    for (const piCid of results.cids) {
+    for (const piCid of cids) {
       try {
-        // Extract PI-specific metadata if available, otherwise use global metadata
-        const piMetadata = results.perUserData && results.perUserData[piCid] 
-          ? results.perUserData[piCid]
-          : results.metadata || results.globalMetadata || {};
-        
-        await processAlertForPI(
-          db,
-          logger,
-          piCid,
-          alertType,
-          piMetadata,
-          date,
-          { ...dependencies, alertType } // Pass alertType in dependencies for isTest check
-        );
+        const piMetadata = docData[String(piCid)] ?? docData[piCid] ?? {};
+        await processAlertForPI(db, logger, piCid, alertType, piMetadata, date, deps);
         processedCount++;
       } catch (error) {
         errorCount++;
         logger.log('ERROR', `[AlertTrigger] Error processing alert for PI ${piCid}`, error);
-        // Continue processing other PIs even if one fails
       }
     }
-    
-    logger.log('SUCCESS', `[AlertTrigger] Completed processing ${computationName}: ${processedCount} successful, ${errorCount} errors`);
-    
+    logger.log('SUCCESS', `[AlertTrigger] Completed ${computationName}: ${processedCount} successful, ${errorCount} errors`);
   } catch (error) {
     logger.log('ERROR', `[AlertTrigger] Fatal error processing ${computationName}`, error);
-    // Don't throw - we don't want to retry the entire computation write
   }
 }
 
@@ -283,36 +226,36 @@ async function handleComputationResultWrite(change, context, config, dependencie
 async function checkAndSendAllClearNotifications(db, logger, processedPICids, computationDate, config, dependencies = {}) {
   try {
     const today = computationDate || new Date().toISOString().split('T')[0];
-    
+
     if (!processedPICids || processedPICids.length === 0) {
       return; // No PIs to check
     }
-    
+
     // Get all static watchlists that contain any of the processed PIs
     const watchlistsCollection = config.watchlistsCollection || 'watchlists';
     const watchlistsSnapshot = await db.collection(watchlistsCollection).get();
-    
+
     const usersToNotify = new Map(); // userCid -> Map of piCid -> {username, ...}
-    
+
     for (const userDoc of watchlistsSnapshot.docs) {
       const userCid = Number(userDoc.id);
       const userListsSnapshot = await userDoc.ref.collection('lists').get();
-      
+
       for (const listDoc of userListsSnapshot.docs) {
         const listData = listDoc.data();
-        
+
         // Only check static watchlists
         if (listData.type !== 'static' || !listData.items || !Array.isArray(listData.items)) {
           continue;
         }
-        
+
         // Check if any processed PI is in this watchlist
         for (const item of listData.items) {
           const piCid = Number(item.cid);
           if (processedPICids.includes(piCid)) {
             // Check if this PI triggered any alerts today for this user
             const hasAlerts = await checkIfPIHasAlertsToday(db, logger, userCid, piCid, today, dependencies);
-            
+
             if (!hasAlerts) {
               // No alerts triggered - send "all clear" notification
               if (!usersToNotify.has(userCid)) {
@@ -327,7 +270,7 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
         }
       }
     }
-    
+
     // Send notifications to all users
     let totalNotifications = 0;
     for (const [userCid, pisMap] of usersToNotify.entries()) {
@@ -336,11 +279,11 @@ async function checkAndSendAllClearNotifications(db, logger, processedPICids, co
         totalNotifications++;
       }
     }
-    
+
     if (totalNotifications > 0) {
       logger.log('INFO', `[checkAndSendAllClearNotifications] Sent ${totalNotifications} all-clear notifications to ${usersToNotify.size} users`);
     }
-    
+
   } catch (error) {
     logger.log('ERROR', `[checkAndSendAllClearNotifications] Error checking all-clear notifications`, error);
     // Don't throw - this is a non-critical feature
@@ -355,7 +298,7 @@ async function checkIfPIHasAlertsToday(db, logger, userCid, piCid, date, depende
   try {
     const { collectionRegistry } = dependencies;
     const config = dependencies.config || {};
-    
+
     // Use collection registry to get notifications path
     let notificationsPath;
     if (collectionRegistry && collectionRegistry.getCollectionPath) {
@@ -364,9 +307,9 @@ async function checkIfPIHasAlertsToday(db, logger, userCid, piCid, date, depende
       // Fallback to legacy path
       notificationsPath = `user_notifications/${userCid}/notifications`;
     }
-    
+
     const notificationsRef = db.collection(notificationsPath);
-    
+
     // Check alerts collection instead of notifications
     // Use collection registry to get alerts path
     let alertsPath;
@@ -376,16 +319,16 @@ async function checkIfPIHasAlertsToday(db, logger, userCid, piCid, date, depende
       // Fallback to legacy path
       alertsPath = `user_alerts/${userCid}/alerts`;
     }
-    
+
     const alertsRef = db.collection(alertsPath);
-    
+
     // Check if there are any alerts for this PI today
     const snapshot = await alertsRef
       .where('piCid', '==', Number(piCid))
       .where('computationDate', '==', date)
       .limit(1)
       .get();
-    
+
     return !snapshot.empty;
   } catch (error) {
     if (logger) {
@@ -404,7 +347,7 @@ async function sendAllClearNotification(db, logger, userCid, piCid, piUsername,
     const { FieldValue } = require('@google-cloud/firestore');
     const { collectionRegistry } = dependencies;
     const config = dependencies.config || {};
-    
+
     // Use collection registry to get notifications path
     let notificationsPath;
     if (collectionRegistry && collectionRegistry.getCollectionPath) {
@@ -413,7 +356,7 @@ async function sendAllClearNotification(db, logger, userCid, piCid, piUsername,
       // Fallback to legacy path
       notificationsPath = `user_notifications/${userCid}/notifications`;
     }
-    
+
     // Check if we already sent an all-clear notification for this PI today
     const existingSnapshot = await db.collection(notificationsPath)
       .where('type', '==', 'watchlistAlerts')
@@ -422,12 +365,12 @@ async function sendAllClearNotification(db, logger, userCid, piCid, piUsername,
       .where('metadata.computationDate', '==', date)
       .limit(1)
       .get();
-    
+
     if (!existingSnapshot.empty) {
       // Already sent notification for this PI today
       return;
     }
-    
+
     // Create the notification using writeWithMigration
     const notificationId = `all_clear_${Date.now()}_${userCid}_${piCid}_${Math.random().toString(36).substring(2, 9)}`;
     const notificationData = {
@@ -449,7 +392,7 @@ async function sendAllClearNotification(db, logger, userCid, piCid, piUsername,
         message: 'User was processed, all clear today!'
       }
     };
-    
+
     // Write to alerts collection (not notifications) - alerts are separate from system notifications
     // Write directly to new path: SignedInUsers/{userCid}/alerts/{alertId}
     const alertData = {
@@ -464,14 +407,14 @@ async function sendAllClearNotification(db, logger, userCid, piCid, piUsername,
       createdAt: FieldValue.serverTimestamp(),
       computationDate: date
     };
-    
+
     // 1. Write to Firestore (source of truth)
     await db.collection('SignedInUsers')
       .doc(String(userCid))
       .collection('alerts')
       .doc(notificationId)
       .set(alertData);
-    
+
     // 2. Send FCM push notification (non-blocking)
     try {
       await sendAlertPushNotification(db, userCid, alertData, logger);
@@ -479,9 +422,9 @@ async function sendAllClearNotification(db, logger, userCid, piCid, piUsername,
       // Log but don't throw - FCM failure shouldn't fail the alert
       logger.log('WARN', `[sendAllClearNotification] FCM push failed for user ${userCid}: ${fcmError.message}`);
     }
-    
+
     logger.log('INFO', `[sendAllClearNotification] Sent all-clear notification to user ${userCid} for PI ${piCid}`);
-    
+
   } catch (error) {
     logger.log('ERROR', `[sendAllClearNotification] Error sending all-clear notification`, error);
     // Don't throw - this is non-critical

package/functions/alert-system/tests/stage1-alert-manifest.test.js

@@ -0,0 +1,94 @@
+/**
+ * @fileoverview Stage 1 unit test: Mark alert computations and derive triggers from V2 config.
+ * Uses real config/computations (read-only). Retained for inspection and debugging.
+ */
+
+const path = require('path');
+const assert = require('assert');
+
+const EXPECTED_ALERT_COMPUTATIONS = [
+  'RiskScoreIncrease',
+  'BehavioralAnomaly',
+  'NewSectorExposure',
+  'NewSocialPost',
+  'PositionInvestedIncrease'
+];
+
+async function runStage1Tests() {
+  let passed = 0;
+  let failed = 0;
+
+  // (a) Manifest: exactly the five alert computations have alert in manifest
+  try {
+    const v2ConfigPath = path.join(__dirname, '../../computation-system-v2/config/bulltrackers.config.js');
+    const v2Config = require(v2ConfigPath);
+    const { ManifestBuilder } = require('../../computation-system-v2/framework/core/Manifest.js');
+    const builder = new ManifestBuilder(v2Config, null);
+    const manifest = builder.build(v2Config.computations);
+    const withAlert = manifest.filter(e => e.alert != null);
+    const namesWithAlert = withAlert.map(e => e.originalName).sort();
+    const expectedSorted = [...EXPECTED_ALERT_COMPUTATIONS].sort();
+    assert.deepStrictEqual(
+      namesWithAlert,
+      expectedSorted,
+      `Manifest alert computations: expected ${expectedSorted.join(', ')}, got ${namesWithAlert.join(', ')}`
+    );
+    passed++;
+    console.log('[Stage1] (a) Manifest: exactly five alert computations have alert');
+  } catch (e) {
+    failed++;
+    console.error('[Stage1] (a) FAIL:', e.message);
+  }
+
+  // (b) loadAlertTypesFromManifest returns five alert types with correct computationName and configKey
+  try {
+    const { loadAlertTypesFromManifest } = require('../helpers/alert_manifest_loader.js');
+    const logger = { log: () => {} };
+    const alertTypes = await loadAlertTypesFromManifest(logger);
+    assert.strictEqual(alertTypes.length, 5, `Expected 5 alert types, got ${alertTypes.length}`);
+    const computationNames = alertTypes.map(t => t.computationName).sort();
+    assert.deepStrictEqual(
+      computationNames,
+      [...EXPECTED_ALERT_COMPUTATIONS].sort(),
+      `Alert types computationName: expected ${EXPECTED_ALERT_COMPUTATIONS.join(', ')}, got ${computationNames.join(', ')}`
+    );
+    for (const t of alertTypes) {
+      assert(t.configKey != null && t.configKey !== '', `Alert type ${t.computationName} must have configKey`);
+    }
+    passed++;
+    console.log('[Stage1] (b) loadAlertTypesFromManifest returns five alert types with computationName and configKey');
+  } catch (e) {
+    failed++;
+    console.error('[Stage1] (b) FAIL:', e.message);
+  }
+
+  // (c) Derived alertComputations list matches entries with storage.firestore.enabled and alert
+  try {
+    const v2ConfigPath = path.join(__dirname, '../../computation-system-v2/config/bulltrackers.config.js');
+    const v2Config = require(v2ConfigPath);
+    const { ManifestBuilder } = require('../../computation-system-v2/framework/core/Manifest.js');
+    const builder = new ManifestBuilder(v2Config, null);
+    const manifest = builder.build(v2Config.computations);
+    const alertComputations = manifest.filter(e => e.storage?.firestore?.enabled && e.alert);
+    const alertNames = alertComputations.map(e => e.originalName).sort();
+    assert.deepStrictEqual(
+      alertNames,
+      [...EXPECTED_ALERT_COMPUTATIONS].sort(),
+      `Derived alertComputations: expected ${EXPECTED_ALERT_COMPUTATIONS.join(', ')}, got ${alertNames.join(', ')}`
+    );
+    passed++;
+    console.log('[Stage1] (c) Derived alertComputations matches storage.firestore.enabled && alert');
+  } catch (e) {
+    failed++;
+    console.error('[Stage1] (c) FAIL:', e.message);
+  }
+
+  console.log(`[Stage1] Done: ${passed} passed, ${failed} failed`);
+  return failed === 0;
+}
+
+// Allow async test (b)
+(async () => {
+  const ok = await runStage1Tests();
+  process.exit(ok ? 0 : 1);
+})();

package/functions/alert-system/tests/stage2-alert-metadata.test.js

@@ -0,0 +1,93 @@
+/**
+ * @fileoverview Stage 2 unit test: Complete alert metadata on all five alert computations.
+ * Asserts each computation has full alert metadata and generateAlertMessage uses only messageTemplate + metadata.
+ * Retained for inspection and debugging.
+ */
+
+const path = require('path');
+const assert = require('assert');
+
+const EXPECTED_ALERT_COMPUTATIONS = [
+  'RiskScoreIncrease',
+  'BehavioralAnomaly',
+  'NewSectorExposure',
+  'NewSocialPost',
+  'PositionInvestedIncrease'
+];
+
+async function runStage2Tests() {
+  let passed = 0;
+  let failed = 0;
+
+  const v2ConfigPath = path.join(__dirname, '../../computation-system-v2/config/bulltrackers.config.js');
+  const v2Config = require(v2ConfigPath);
+  const computations = v2Config.computations || [];
+  const { generateAlertMessage, loadAlertTypesFromManifest } = require('../helpers/alert_manifest_loader.js');
+  const logger = { log: () => {} };
+  const alertTypes = await loadAlertTypesFromManifest(logger);
+
+  for (const ComputationClass of computations) {
+    if (!ComputationClass?.getConfig) continue;
+    const config = ComputationClass.getConfig();
+    if (!config?.alert) continue;
+
+    const name = config.name;
+    const alert = config.alert;
+
+    try {
+      assert(alert.id != null && alert.id !== '', `${name}: alert.id required`);
+      assert(alert.frontendName != null && alert.frontendName !== '', `${name}: alert.frontendName required`);
+      assert(alert.description != null, `${name}: alert.description required`);
+      assert(alert.messageTemplate != null && alert.messageTemplate !== '', `${name}: alert.messageTemplate required`);
+      assert(alert.configKey != null && alert.configKey !== '', `${name}: alert.configKey required`);
+
+      if (alert.isDynamic && alert.dynamicConfig) {
+        const hasThresholds = Array.isArray(alert.dynamicConfig.thresholds) && alert.dynamicConfig.thresholds.length > 0;
+        const hasConditions = Array.isArray(alert.dynamicConfig.conditions) && alert.dynamicConfig.conditions.length > 0;
+        assert(hasThresholds || hasConditions, `${name}: dynamic alert should have thresholds or conditions`);
+        if (alert.dynamicConfig.resultFields) {
+          assert(typeof alert.dynamicConfig.resultFields === 'object', `${name}: resultFields should be object`);
+        }
+      }
+
+      const alertType = alertTypes.find(t => t.computationName === name);
+      assert(alertType != null, `${name}: should be in loaded alert types`);
+
+      const sampleResult = name === 'RiskScoreIncrease'
+        ? { change: 1.5, previousRisk: 3, currentRisk: 4.5 }
+        : name === 'BehavioralAnomaly'
+          ? { driver: 'Sector HHI', score: 4.2, driverValue: 'elevated' }
+          : name === 'NewSocialPost'
+            ? { title: 'Market update' }
+            : name === 'NewSectorExposure'
+              ? { newExposures: ['Technology'] }
+              : { moves: [{ symbol: 'AAPL', diff: 5, prev: 10, curr: 15 }] };
+
+      const msg = generateAlertMessage(alertType, 'TestPI', sampleResult);
+      assert(typeof msg === 'string' && msg.length > 0, `${name}: generateAlertMessage must return non-empty string`);
+      assert(msg.includes('TestPI') || msg.includes('Unknown'), `${name}: message should include piUsername or fallback`);
+
+      passed++;
+      console.log(`[Stage2] ${name}: alert metadata and generateAlertMessage OK`);
+    } catch (e) {
+      failed++;
+      console.error(`[Stage2] ${name} FAIL:`, e.message);
+    }
+  }
+
+  assert.strictEqual(
+    passed,
+    EXPECTED_ALERT_COMPUTATIONS.length,
+    `Expected ${EXPECTED_ALERT_COMPUTATIONS.length} alert computations to pass, got ${passed} passed, ${failed} failed`
+  );
+
+  console.log(`[Stage2] Done: ${passed} passed, ${failed} failed`);
+  return failed === 0;
+}
+
+runStage2Tests()
+  .then(ok => process.exit(ok ? 0 : 1))
+  .catch(err => {
+    console.error(err);
+    process.exit(1);
+  });