aiden-shared-calculations-unified 1.0.148 → 1.0.150

package/calculations/alerts/Behaviour.js

@@ -3,8 +3,6 @@
  * Uses Mahalanobis Distance to detect complex deviations in investor behavior.
  * Features: Concentration (HHI), Martingale Propensity, Capacity Strain, Risk Score.
  */
-
-
 class BehavioralAnomaly {
     constructor() {
         this.results = {};
@@ -17,9 +15,8 @@ class BehavioralAnomaly {
             type: 'standard',
             isHistorical: true, 
             
-            // We request 60 days to build a strong baseline.
-            // [UPDATED] The system now intelligently checks the Root Data Index 
-            // and only fetches dates that actually exist, saving reads automatically.
+            // RESTORED: Request full 60-day history for both Portfolio and Rankings.
+            // CachedDataLoader handles this efficiently via reference pointers.
             rootDataSeries: {
                 portfolio: 60,
                 rankings: 60 
@@ -28,7 +25,6 @@ class BehavioralAnomaly {
             rootDataDependencies: ['portfolio', 'rankings', 'history'],
             userType: 'POPULAR_INVESTOR',
             
-            // Allows the computation to run even if today's specific root data is missing
             canHaveMissingRoots: true,
             isAlertComputation: true,
             mandatoryRoots: ['portfolio', 'history'],
@@ -39,14 +35,21 @@ class BehavioralAnomaly {
 
     // --- Helpers ---
 
-    /**
-     * Helper: Calculates the Herfindahl-Hirschman Index (Concentration)
-     * [FIX] Updated to accept 'math' context instead of 'layers'
-     */
+    findClosestData(dateStr, seriesMap, maxLookback = 5) {
+        if (!seriesMap) return null;
+        if (seriesMap[dateStr]) return seriesMap[dateStr];
+
+        let current = new Date(dateStr);
+        for (let i = 0; i < maxLookback; i++) {
+            current.setUTCDate(current.getUTCDate() - 1);
+            const dString = current.toISOString().slice(0, 10);
+            if (seriesMap[dString]) return seriesMap[dString];
+        }
+        return null;
+    }
+
     calculateHHI(portfolio, math) {
         if (!portfolio) return 0;
-        
-        // [FIX] DataExtractor is available directly on the flattened math object
         const { DataExtractor } = math;
         const positions = DataExtractor.getPositions(portfolio, 'POPULAR_INVESTOR');
         
@@ -55,29 +58,22 @@ class BehavioralAnomaly {
         let sumSquares = 0;
         let totalValue = 0;
 
-        positions.forEach(p => {
-            const val = DataExtractor.getPositionValue(p);
-            totalValue += val;
-        });
+        positions.forEach(p => totalValue += DataExtractor.getPositionValue(p));
 
         if (totalValue === 0) return 0;
 
         positions.forEach(p => {
-            const val = DataExtractor.getPositionValue(p);
-            const weight = val / totalValue;
+            const weight = DataExtractor.getPositionValue(p) / totalValue;
             sumSquares += (weight * weight);
         });
 
         return sumSquares;
     }
 
-    /**
-     * Helper: Calculates Martingale Score (Doubling down after loss)
-     */
     calculateMartingaleScore(tradeHistory) {
         if (!tradeHistory || tradeHistory.length < 2) return 0;
         
-        // Sort ascending
+        // Trades are already filtered by date in the main loop logic
         const sorted = [...tradeHistory].sort((a, b) => new Date(a.CloseDateTime) - new Date(b.CloseDateTime));
         const recentTrades = sorted.slice(-30);
         
@@ -100,27 +96,7 @@ class BehavioralAnomaly {
         return lossEvents > 0 ? (martingaleResponses / lossEvents) : 0;
     }
 
-    /**
-     * "Use Closest" Logic: Looks for recent valid data point
-     */
-    findClosestData(dateStr, seriesMap, maxLookback = 5) {
-        if (!seriesMap) return null;
-        if (seriesMap[dateStr]) return seriesMap[dateStr];
-
-        let current = new Date(dateStr);
-        for (let i = 0; i < maxLookback; i++) {
-            current.setUTCDate(current.getUTCDate() - 1);
-            const dString = current.toISOString().slice(0, 10);
-            if (seriesMap[dString]) return seriesMap[dString];
-        }
-        return null;
-    }
-
-    /**
-     * [FIX] Updated to accept 'math' context instead of 'layers'
-     */
     getDailyVector(portfolio, rankings, history, math) {
-        // [FIX] RankingsExtractor is available directly on the flattened math object
         const { RankingsExtractor } = math;
 
         const hhi = this.calculateHHI(portfolio, math);
@@ -140,79 +116,79 @@ class BehavioralAnomaly {
     }
 
     process(context) {
-        // [FIX] Use 'math' from context (ContextFactory flattens layers into 'math')
-        // [FIX] Access 'globalData' to retrieve series
         const { math, globalData } = context; 
         const { LinearAlgebra } = math;
         const userId = context.user.id;
         
-        // [FIX] Series data is located in globalData.series
         const seriesData = globalData?.series?.root || {};
         const portfolioSeries = seriesData.portfolio || {};
         const rankingsSeries = seriesData.rankings || {};
         
-        // The Loader now provides only existing data, so Object.keys(portfolioSeries)
-        // is already the "clean" list of available dates.
+        // Full Trade History (Contains ALL time, so we must filter it)
+        const fullHistory = context.user.history || [];
+
         const availableDates = Object.keys(portfolioSeries).sort();
         const trainingVectors = [];
 
-        // 1. Build Baseline from Available Series Data
+        // 1. Build Baseline
         for (const date of availableDates) {
             const datePortfolio = portfolioSeries[date][userId];
             if (!datePortfolio) continue;
 
+            // CRITICAL FIX: Filter History to avoid "Time Travel"
+            // We only look at trades that had closed ON or BEFORE this specific loop date.
+            const loopDateObj = new Date(date);
+            const historyAsOfDate = fullHistory.filter(t => new Date(t.CloseDateTime) <= loopDateObj);
+
+            // Robust Lookup: Find ranking for this date (or closest recent date)
             const rankingsSnapshot = this.findClosestData(date, rankingsSeries);
             const userRanking = rankingsSnapshot ? rankingsSnapshot.find(r => String(r.CustomerId) === String(userId)) : null;
 
             const vec = this.getDailyVector(
                 datePortfolio, 
                 userRanking, 
-                context.user.history, 
-                math // [FIX] Pass math object
+                historyAsOfDate, // Pass filtered history
+                math
             );
             trainingVectors.push(vec);
         }
 
-        // 2. Minimum Viable Baseline Constraint
-        // We requested 60 days, but we accept as few as 15 (approx 3 weeks) 
-        // to avoid "2 month" delay for new users while ensuring statistical fairness.
+        // 2. Minimum Viable Baseline
         const MIN_DATAPOINTS = 15;
-        
         if (trainingVectors.length < MIN_DATAPOINTS) {
             this.results[userId] = { 
                 status: 'INSUFFICIENT_BASELINE', 
-                dataPoints: trainingVectors.length,
-                required: MIN_DATAPOINTS,
-                info: 'Waiting for more history to generate fair alerts' 
+                dataPoints: trainingVectors.length 
             };
             return;
         }
 
-        // 3. Compute Statistics
+        // 3. Compute Statistics (Covariance Matrix)
         const stats = LinearAlgebra.covarianceMatrix(trainingVectors);
         const inverseCov = LinearAlgebra.invertMatrix(stats.matrix);
 
-        // Singular Matrix Check
+        // Singular Matrix Check (If behavior is perfectly identical every day)
         if (!inverseCov) {
-            this.results[userId] = { status: 'STABLE_STATE', info: 'Variance too low to detect anomalies' };
+            this.results[userId] = { status: 'STABLE_STATE', info: 'Variance too low' };
             return;
         }
 
         // 4. Compute Today's Vector
+        // We use the explicit 'today' injection, or fallback to the series
         const todayRanking = context.user.rankEntry || 
                              (this.findClosestData(context.date.today, rankingsSeries) || [])
                              .find(r => String(r.CustomerId) === String(userId));
 
         const todayVector = this.getDailyVector(
-            context.user.portfolio,
+            context.user.portfolio.today, 
             todayRanking,
-            context.user.history,
-            math // [FIX] Pass math object
+            fullHistory, // Today includes all history
+            math
         );
 
         // 5. Calculate Distance
         const distance = LinearAlgebra.mahalanobisDistance(todayVector, stats.means, inverseCov);
-        const IS_ANOMALY = distance > 3.5; // Slightly higher threshold for safety with smaller baselines
+        const IS_ANOMALY = distance > 3.5;
 
         if (IS_ANOMALY) {
             const featureNames = ['Concentration (HHI)', 'Martingale Behavior', 'Capacity Strain', 'Risk Score'];
@@ -240,6 +216,7 @@ class BehavioralAnomaly {
                 }
             };
             
+            // Add CID to index for downstream alert handlers
             if (!this.results.cids) this.results.cids = [];
             this.results.cids.push(userId);
         } else {
@@ -249,8 +226,6 @@ class BehavioralAnomaly {
             };
         }
     }
-
-    async getResult() { return this.results; }
 }
 
 module.exports = BehavioralAnomaly;

package/calculations/popular-investor/AumLeaderboard.js

@@ -5,7 +5,7 @@ class AumLeaderboard {
     static getMetadata() {
         return {
             type: 'meta',
-            category: 'popular-investor',
+            category: 'analytics',
             // We only need the rankings root data
             rootDataDependencies: ['rankings'],
             mandatoryRoots: ['rankings'],
@@ -58,9 +58,8 @@ class AumLeaderboard {
 
         // 4. Output Global Result
         this.results = rankedResult;
-    }
-
-    async getResult() {
+        
+        // CRITICAL FIX: MetaExecutor requires the data to be returned
         return this.results;
     }
 }

package/calculations/popular-investor/GlobalAumPerAsset30D.js

@@ -1,42 +1,51 @@
-class GlobalAumAggregator {
+/**
+ * @fileoverview Aggregates PI Asset AUM over the last 30 days.
+ */
+class GlobalAumPerAsset30D {
     static getMetadata() {
         return {
             type: 'meta',
             category: 'analytics',
             rootDataDependencies: [],
-            // No dependencySeries needed! We just need Today's results.
+            // No dependencySeries needed! We just need Today's results via getDependencies.
             schedule: { type: 'DAILY' }
         };
     }
 
     static getDependencies() { 
         // Force running AFTER the Standard comp
-        return ['PIDailyRollingAUM']; 
+        // CRITICAL: Must match the File Name of the standard computation
+        return ['PIDailyAssetAUM']; 
     }
 
     async process(context) {
-        // We access the STANDARD dependencies (Today's snapshot)
-        // Because of getDependencies(), system injected this into context.dependencies
-        const allUserResults = context.computed['PIDailyRollingAUM']; 
+        // Access the results injected by getDependencies()
+        // CRITICAL: Must match the File Name
+        const allUserResults = context.computed['PIDailyAssetAUM']; 
 
         const globalAverages = {};
         let userCount = 0;
 
-        Object.values(allUserResults).forEach(userOutput => {
-            // userOutput is the object we saved above: { dailyMap, averageMap }
-            const avgMap = userOutput.averageMap;
-            if (!avgMap) return;
+        if (allUserResults) {
+            Object.values(allUserResults).forEach(userOutput => {
+                // userOutput is: { dailyMap, averageMap }
+                const avgMap = userOutput.averageMap;
+                if (!avgMap) return;
 
-            userCount++;
-            Object.entries(avgMap).forEach(([ticker, avgVal]) => {
-                if (!globalAverages[ticker]) globalAverages[ticker] = 0;
-                globalAverages[ticker] += avgVal;
+                userCount++;
+                Object.entries(avgMap).forEach(([ticker, avgVal]) => {
+                    if (!globalAverages[ticker]) globalAverages[ticker] = 0;
+                    globalAverages[ticker] += avgVal;
+                });
             });
-        });
+        }
 
         // Result: The Sum of everyone's 30-Day Average Allocations
         this.results = globalAverages;
+        
+        // CRITICAL FIX: MetaExecutor requires the data to be returned
+        return this.results;
     }
+}
 
-    async getResult() { return this.results; }
-}
+module.exports = GlobalAumPerAsset30D;

package/calculations/popular-investor/PIDailyAssetAUM.js

@@ -1,26 +1,30 @@
-class PIDailyRollingAUM {
+/**
+ * @fileoverview Calculates the $ AUM allocated to each asset for a single PI using a Rolling 30-Day Window.
+ */
+class PIDailyAssetAUM {
     static getMetadata() {
         return {
             type: 'standard',
             category: 'analytics',
             userType: 'POPULAR_INVESTOR',
             
-            // 1. Load TODAY'S raw data (Cheap)
+            // 1. Core Data
             rootDataDependencies: ['portfolio', 'rankings'],
             mandatoryRoots: ['portfolio', 'rankings'],
 
-            // 2. Load MY OWN history (Last 29 days of results)
-            // This reads small result docs, not heavy portfolios
+            // 2. History: Load MY OWN results from the last 29 days
+            // CRITICAL: Name must match the File Name (PIDailyAssetAUM)
             dependencySeries: {
-                'PIDailyRollingAUM': 29 
-            }
+                'PIDailyAssetAUM': 29 
+            },
+
+            // 3. Bootstrap Flag: Allows running even if history is empty (First Run)
+            canHaveMissingSeries: true
         };
     }
 
     static getDependencies() { return []; }
 
-    // 
-
     async process(context) {
         const { extract, RankingsExtractor } = context.math;
         const userId = context.user.id;
@@ -47,55 +51,52 @@ class PIDailyRollingAUM {
         }
 
         // --- STEP B: Load History (T-1 to T-29) ---
-        // Context: context.seriesData.results['PIDailyRollingAUM'][date][userId]
-        const historyMap = context.globalData.series?.results?.['PIDailyRollingAUM'] || {};
+        // Access using the FILE NAME key
+        const historyMap = context.globalData.series?.results?.['PIDailyAssetAUM'] || {};
         
-        // Collect all daily maps (History + Today)
         const rollingWindow = [];
         
-        // 1. Add History
-        Object.values(historyMap).forEach(dayResult => {
-            // Depending on how you stored it, extract the 'dailyMap'
-            // In this logic, we store { dailyMap: {...}, averageMap: {...} }
-            const userResult = dayResult[userId];
-            if (userResult && userResult.dailyMap) {
-                rollingWindow.push(userResult.dailyMap);
-            }
-        });
+        if (historyMap) {
+            Object.values(historyMap).forEach(dayResult => {
+                const userResult = dayResult[userId];
+                if (userResult && userResult.dailyMap) {
+                    rollingWindow.push(userResult.dailyMap);
+                }
+            });
+        }
 
-        // 2. Add Today
+        // Always add Today
         rollingWindow.push(todayAllocation);
 
         // --- STEP C: Compute Rolling Average ---
-        const summedStats = {}; // { AAPL: { total: 5000, count: 5 } }
+        const summedStats = {};
         
         rollingWindow.forEach(dayAllocations => {
             Object.entries(dayAllocations).forEach(([ticker, val]) => {
                 if (!summedStats[ticker]) summedStats[ticker] = { total: 0, count: 0 };
                 summedStats[ticker].total += val;
-                summedStats[ticker].count += 1; // It existed on this day
+                summedStats[ticker].count += 1; 
             });
         });
 
         const rollingAverage = {};
-        const validDays = rollingWindow.length; // Denominator is number of valid days captured
+        const validDays = rollingWindow.length;
 
-        Object.entries(summedStats).forEach(([ticker, stat]) => {
-            // Average = Total Value / Number of Days in the Window
-            // Note: If you want "Average Allocation when held", divide by stat.count
-            // If you want "Average Portfolio Weight over 30 days", divide by validDays
-            rollingAverage[ticker] = stat.total / validDays;
-        });
+        if (validDays > 0) {
+            Object.entries(summedStats).forEach(([ticker, stat]) => {
+                rollingAverage[ticker] = stat.total / validDays;
+            });
+        }
 
-        // --- STEP D: Save Hybrid Result ---
-        // We save Today's values (for future history) AND the pre-calculated Average (for Meta)
+        // --- STEP D: Output Results ---
+        // StandardExecutor reads 'this.results', it does NOT use the return value.
         this.results = {
             [userId]: {
-                dailyMap: todayAllocation, // Saved for tomorrow's history lookup
-                averageMap: rollingAverage // Saved for today's Meta aggregator
+                dailyMap: todayAllocation,
+                averageMap: rollingAverage
             }
         };
     }
+}
 
-    async getResult() { return this.results; }
-}
+module.exports = PIDailyAssetAUM;

package/calculations/popular-investor/RecommendedPopularInvestors.js

@@ -1,19 +1,25 @@
 /**
- * @fileoverview Recommends PIs to Signed-In Users based on views, holdings, and sector alignment.
+ * @fileoverview Recommends PIs to Signed-In Users using concrete ID matching.
+ * MATCHING STRATEGY:
+ * 1. Exclusion: Filter PIs the user already copies (ParentCID).
+ * 2. Interest: Page Views (30D History) using 'viewsByUser' schema.
+ * 3. Asset Class: Match User's holdings (InstrumentTypeID) vs PI's TopTradedAssetClassId.
+ * 4. Instrument: Match User's holdings (InstrumentID) vs PI's TopTradedInstrumentId.
  */
 class RecommendedPopularInvestors {
     static getMetadata() {
         return {
             type: 'standard',
             category: 'recommendations',
-            userType: 'SIGNED_IN_USER', // Targeted audience
+            userType: 'SIGNED_IN_USER',
             
-            // We need Portfolio (for mirrors/sectors) and Rankings (for PI metadata)
+            // We need User Portfolio (Deep) and Global Rankings (Summary)
             rootDataDependencies: ['portfolio', 'rankings'],
             mandatoryRoots: ['portfolio', 'rankings'],
-            canHaveMissingRoots: true, // Allow running even if pageViews are incomplete
+            canHaveMissingRoots: true, // Allow running even if pageViews/ratings missing
 
             // 30-Day History of Page Views for Interest Graph
+            // System loads the global daily docs: { [PiCID]: { viewsByUser: { [UserCID]: { viewCount: N } } } }
             rootDataSeries: {
                 pageViews: 30
             }
@@ -26,7 +32,7 @@ class RecommendedPopularInvestors {
         return {
             type: 'object',
             patternProperties: {
-                '^[0-9]+$': { // Keyed by User ID
+                '^[0-9]+$': { 
                     type: 'array',
                     items: {
                         type: 'object',
@@ -43,90 +49,124 @@ class RecommendedPopularInvestors {
     }
 
     async process(context) {
-        const { extract, RankingsExtractor, CopyTradingExtractor, PageViewsExtractor } = context.math;
+        const { RankingsExtractor, CopyTradingExtractor, PageViewsExtractor, DataExtractor } = context.math;
         const userPortfolio = context.user.portfolio.today;
         const allRankings = context.globalData.rankings || [];
         const pageViewSeries = context.globalData.series.root.pageViews || {};
 
-        // 1. Identify Already Copied PIs (Exclusion List)
+        // --- STEP 1: USER PROFILE EXTRACTION ---
+        
+        // A. Who do I copy? (Exclusion List)
+        // Schema: AggregatedMirrors -> ParentCID (e.g., 5125148)
         const mirrors = CopyTradingExtractor.getAggregatedMirrors(userPortfolio);
         const copiedCids = new Set(mirrors.map(m => String(CopyTradingExtractor.getParentCID(m))));
         copiedCids.add(String(context.user.id)); // Exclude self
 
-        // 2. Build Interest Score from Page Views (30 Day Lookback)
-        // We traverse the global map: Series -> Date -> PI -> ViewsByUser -> ThisUser
-        const piInterestScore = new Map(); // CID -> Score
-        
-        Object.values(pageViewSeries).forEach(dailyGlobalData => {
-            // Optimization: We must iterate PIs to find our user
-            // In a real high-scale scenario, we might want an inverted index, 
-            // but for <5000 PIs this is acceptable O(N).
-            const allPiCids = PageViewsExtractor.getAllPIs(dailyGlobalData);
-            
-            for (const piCid of allPiCids) {
-                if (copiedCids.has(piCid)) continue;
-
-                // Check if *this* user viewed *this* PI
-                const userViews = PageViewsExtractor.getUserViewCount(dailyGlobalData, piCid, context.user.id);
-                if (userViews > 0) {
-                    const current = piInterestScore.get(piCid) || 0;
-                    piInterestScore.set(piCid, current + (userViews * 2)); // 2 points per view
-                }
-            }
+        // B. What Asset Classes do I hold?
+        // Schema: AggregatedPositionsByInstrumentTypeID -> InstrumentTypeID (e.g., 5=Crypto, 4=Stocks)
+        const userAssetClasses = new Set();
+        if (userPortfolio && Array.isArray(userPortfolio.AggregatedPositionsByInstrumentTypeID)) {
+            userPortfolio.AggregatedPositionsByInstrumentTypeID.forEach(grp => {
+                if (grp.InstrumentTypeID) userAssetClasses.add(Number(grp.InstrumentTypeID));
+            });
+        }
+
+        // C. What Instruments do I hold?
+        // Schema: AggregatedPositions -> InstrumentID (e.g., 1353)
+        const userInstruments = new Set();
+        const positions = DataExtractor.getPositions(userPortfolio, context.user.type);
+        positions.forEach(pos => {
+            const id = DataExtractor.getInstrumentId(pos);
+            if (id) userInstruments.add(Number(id));
         });
 
-        // 3. Analyze User Sectors
-        const userSectors = new Set(extract.getCurrentSectors(userPortfolio, context.mappings, context.user.type));
+        // --- STEP 2: INTEREST GRAPH (Page Views) ---
+        // Iterate through 30 days of global page view maps
+        const piInterestScore = new Map();
+        if (pageViewSeries) {
+            Object.values(pageViewSeries).forEach(dailyGlobalData => {
+                // dailyGlobalData matches your schema: { "31075566": { viewsByUser: { ... } } }
+                
+                // Extractor handles filtering 'lastUpdated' and iterating PIs
+                const allPiCids = PageViewsExtractor.getAllPIs(dailyGlobalData);
+                
+                for (const piCid of allPiCids) {
+                    if (copiedCids.has(piCid)) continue;
+                    
+                    // Extractor looks inside 'viewsByUser' -> [UserCID] -> 'viewCount'
+                    const userViews = PageViewsExtractor.getUserViewCount(dailyGlobalData, piCid, context.user.id);
+                    
+                    if (userViews > 0) {
+                        const current = piInterestScore.get(piCid) || 0;
+                        // Score logic: 2 points per view
+                        piInterestScore.set(piCid, current + (userViews * 2)); 
+                    }
+                }
+            });
+        }
 
-        // 4. Score Candidates
+        // --- STEP 3: MATCHING LOGIC ---
         const recommendations = [];
 
         for (const piEntry of allRankings) {
             const piCid = String(piEntry.CustomerId || piEntry.cid);
+            
+            // 1. Exclusion
             if (copiedCids.has(piCid)) continue;
 
             let score = 0;
             const reasons = [];
 
-            // A. Page View Interest
+            // 2. Interest (Page Views)
             const viewScore = piInterestScore.get(piCid) || 0;
             if (viewScore > 0) {
-                score += Math.min(20, viewScore); // Cap at 20 points
+                score += Math.min(20, viewScore);
                 reasons.push('Recently Viewed');
             }
 
-            // B. Sector Match
-            const piTags = RankingsExtractor.getTags(piEntry);
-            const hasSectorMatch = piTags.some(tag => userSectors.has(tag));
-            if (hasSectorMatch) {
+            // 3. Asset Class Match (Hard ID Match)
+            // Schema: Rankings -> TopTradedAssetClassId (e.g., 5)
+            const piAssetClass = piEntry.TopTradedAssetClassId;
+            if (piAssetClass && userAssetClasses.has(piAssetClass)) {
                 score += 15;
-                reasons.push('Matches Your Sectors');
+                reasons.push('Trades Your Asset Classes');
+            }
+
+            // 4. Top Instrument Match (Hard ID Match)
+            // Schema: Rankings -> TopTradedInstrumentId (e.g., 1155)
+            const piTopInst = piEntry.TopTradedInstrumentId;
+            if (piTopInst && userInstruments.has(piTopInst)) {
+                score += 10;
+                reasons.push('Trades Your Top Assets');
             }
 
-            // C. Base Quality (Risk/AUM)
+            // 5. Risk Filter (Baseline Quality)
+            // Schema: Rankings -> RiskScore
             const risk = RankingsExtractor.getRiskScore(piEntry);
-            if (risk <= 6) score += 5; // Prefer stable PIs
-            
-            // Only recommend if there is some signal
+            if (risk <= 6) {
+                score += 5;
+                reasons.push('Stable Risk Score');
+            }
+
+            // Push if there is a signal
             if (score > 0) {
                 recommendations.push({
                     cid: piCid,
                     username: piEntry.UserName || "Unknown",
                     matchScore: score,
-                    reason: reasons[0]
+                    // Ensure a default reason exists
+                    reason: reasons[0] || 'Recommended Strategy' 
                 });
             }
         }
 
-        // 5. Sort and Limit
+        // --- STEP 4: SORT & LIMIT ---
         recommendations.sort((a, b) => b.matchScore - a.matchScore);
         
         this.results = {
             [context.user.id]: recommendations.slice(0, 5)
         };
     }
-
-    async getResult() { return this.results; }
 }
 
 module.exports = RecommendedPopularInvestors;

package/calculations/popular-investor/RiskLeaderboard.js

@@ -54,9 +54,8 @@ class RiskLeaderboard {
         }));
 
         this.results = rankedResult;
-    }
-
-    async getResult() {
+        
+        // CRITICAL FIX: MetaExecutor requires the data to be returned
         return this.results;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-shared-calculations-unified",
-  "version": "1.0.148",
+  "version": "1.0.150",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [

package/calculations/popular-investor/AggregateAssetAUM.js

@@ -1,70 +0,0 @@
-/**
- * @fileoverview Aggregate AUM per Asset Across All Users.
- * Returns the AUM invested into each asset total across all users.
- */
-
-class AggregateAssetAUM {
-    constructor() {
-        this.results = {};
-    }
-
-    static getMetadata() {
-        return {
-            type: 'meta',
-            category: 'popular_investor',
-            userType: 'POPULAR_INVESTOR',
-            // [FIX] Enforce strict availability check. 
-            // Prevents execution if PI data is missing, even if upstream calc exists.
-            rootDataDependencies: ['portfolio'] 
-        };
-    }
-
-    static getDependencies() { return ['UserAUMPerAsset']; }
-
-    static getSchema() {
-        return {
-            type: 'object',
-            additionalProperties: { type: 'number' },
-            description: 'Map of instrumentId -> total AUM across all users'
-        };
-    }
-
-    process(context) {
-        // Input: Map of { userId: { instrumentId: aum } }
-        const aumPerAssetData = context.computed['UserAUMPerAsset'];
-
-        if (!aumPerAssetData) {
-            return {}; 
-        }
-
-        // Aggregate AUM per instrument across all users
-        const instrumentAUM = new Map();
-
-        for (const [userId, userAssets] of Object.entries(aumPerAssetData)) {
-            if (!userAssets || typeof userAssets !== 'object') continue;
-
-            for (const [instrumentIdStr, aum] of Object.entries(userAssets)) {
-                const instrumentId = Number(instrumentIdStr);
-                // Validate AUM is a number and valid instrument ID
-                if (isNaN(instrumentId) || typeof aum !== 'number' || aum <= 0) continue;
-
-                const current = instrumentAUM.get(instrumentId) || 0;
-                instrumentAUM.set(instrumentId, current + aum);
-            }
-        }
-
-        // Convert Map to output Object
-        const result = {};
-        for (const [instrumentId, totalAUM] of instrumentAUM.entries()) {
-            result[instrumentId] = Number(totalAUM.toFixed(2));
-        }
-
-        return result;
-    }
-
-    async getResult() {
-        return this.results;
-    }
-}
-
-module.exports = AggregateAssetAUM;

package/calculations/popular-investor/AggregateDailyAUM.js

@@ -1,72 +0,0 @@
-/**
- * @fileoverview Aggregate Daily AUM Across All Users.
- * Returns the overall AUM values each day total across all users.
- */
-
-class AggregateDailyAUM {
-    constructor() {
-        this.results = {};
-    }
-
-    static getMetadata() {
-        return {
-            type: 'meta',
-            category: 'popular_investor',
-            userType: 'POPULAR_INVESTOR'
-        };
-    }
-
-    static getDependencies() { return ['UserAUM30Day']; }
-
-    static getSchema() {
-        return {
-            type: 'object',
-            additionalProperties: { type: 'number' },
-            description: 'Map of date -> total AUM across all users'
-        };
-    }
-
-    process(context) {
-        const aumData = context.computed['UserAUM30Day'];
-        
-        // [FIX] Defensive check
-        if (!aumData) {
-            return {};
-        }
-
-        // Aggregate AUM by date
-        const dateMap = {};
-
-        for (const [userId, userHistory] of Object.entries(aumData)) {
-            // [FIX] Validate userHistory exists
-            if (!userHistory) continue;
-
-            // [FIX] "30Day" data is an Array of daily entries. 
-            // We must iterate the array. We also handle the edge case where it might be a single object.
-            const entries = Array.isArray(userHistory) ? userHistory : [userHistory];
-
-            for (const entry of entries) {
-                if (entry && typeof entry === 'object' && entry.date && typeof entry.aum === 'number') {
-                    const date = entry.date;
-                    // Sum the AUM for this specific date
-                    dateMap[date] = (dateMap[date] || 0) + entry.aum;
-                }
-            }
-        }
-
-        // Round values to 2 decimals
-        const rounded = {};
-        for (const [date, total] of Object.entries(dateMap)) {
-            rounded[date] = Number(total.toFixed(2));
-        }
-
-        // [FIX] Must RETURN the result for MetaExecutor
-        return rounded;
-    }
-
-    async getResult() {
-        return this.results;
-    }
-}
-
-module.exports = AggregateDailyAUM;

package/calculations/popular-investor/UserAUM30Day.js

@@ -1,67 +0,0 @@
-/**
- * @fileoverview AUM Value Over Last 30 Days for Users.
- * Returns the AUM value for the current day.
- * (Historical aggregation handled by Database/API or 'isHistorical' mechanisms in Meta scripts).
- */
-
-class UserAUM30Day {
-    constructor() {
-        this.results = {};
-    }
-
-    static getMetadata() {
-        return {
-            type: 'standard',
-            category: 'popular_investor',
-            rootDataDependencies: ['portfolio', 'rankings'],
-            userType: 'POPULAR_INVESTOR'
-        };
-    }
-
-    static getDependencies() { return []; }
-
-    static getSchema() {
-        return {
-            type: 'object',
-            properties: {
-                date: { type: 'string', format: 'date' },
-                aum: { type: 'number' }
-            }
-        };
-    }
-
-    process(context) {
-        const { RankingsExtractor, PopularInvestorExtractor } = context.math;
-        const userId = context.user.id;
-        const portfolio = context.user.portfolio.today;
-        const rankEntry = context.user.rankEntry;
-        const dateStr = context.date.today;
-
-        let aum = 0;
-
-        // 1. Priority: Official Rankings Data
-        if (rankEntry) {
-            aum = RankingsExtractor.getAUMValue(rankEntry) || 0;
-        }
-
-        // 2. Fallback: Portfolio Snapshot Data
-        if ((!aum || aum === 0) && portfolio) {
-            if (typeof portfolio.AUMValue === 'number') {
-                aum = portfolio.AUMValue;
-            } else {
-                aum = PopularInvestorExtractor.getEquity(portfolio);
-            }
-        }
-
-        this.results[userId] = {
-            date: dateStr,
-            aum: Number(aum.toFixed(2))
-        };
-    }
-
-    async getResult() {
-        return this.results;
-    }
-}
-
-module.exports = UserAUM30Day;

package/calculations/popular-investor/UserAUMPerAsset.js

@@ -1,67 +0,0 @@
-/**
- * @fileoverview AUM per Asset for Users.
- * Returns the AUM invested into each asset per user.
- */
-
-class UserAUMPerAsset {
-    constructor() {
-        this.results = {};
-    }
-
-    static getMetadata() {
-        return {
-            type: 'standard',
-            category: 'popular_investor',
-            rootDataDependencies: ['portfolio'],
-            userType: 'POPULAR_INVESTOR'
-        };
-    }
-
-    static getDependencies() { return []; }
-
-    static getSchema() {
-        return {
-            type: 'object',
-            additionalProperties: { type: 'number' },
-            description: 'Map of instrumentId -> AUM value invested'
-        };
-    }
-
-    process(context) {
-        const { DataExtractor } = context.math;
-        const userId = context.user.id;
-        const portfolio = context.user.portfolio.today;
-
-        if (!portfolio) {
-            this.results[userId] = {};
-            return;
-        }
-
-        // [FIX] Inline aggregation logic
-        const positions = DataExtractor.getPositions(portfolio, 'POPULAR_INVESTOR');
-        const aumMap = {};
-
-        for (const pos of positions) {
-            const instId = DataExtractor.getInstrumentId(pos);
-            const value = DataExtractor.getPositionValue(pos); // Value in USD
-            
-            if (instId && value > 0) {
-                // Ensure key is numeric or string consistent with consumption
-                aumMap[instId] = (aumMap[instId] || 0) + value;
-            }
-        }
-        
-        // Round values
-        for (const key in aumMap) {
-            aumMap[key] = Number(aumMap[key].toFixed(2));
-        }
-
-        this.results[userId] = aumMap;
-    }
-
-    async getResult() {
-        return this.results;
-    }
-}
-
-module.exports = UserAUMPerAsset;