aiden-shared-calculations-unified 1.0.44 → 1.0.46

package/calculations/behavioural/historical/smart_money_flow.js

@@ -1,64 +1,128 @@
 /**
  * @fileoverview Tracks the investment flow of "smart money".
  *
- * --- FIX ---
- * The core logic (identifySmartMoney) has been moved from process() to
- * getResult(). This is critical to prevent a race condition where
- * this calculation tries to *read* the profitability shards
- * before user_profitability_tracker has *written* them.
- * --- END FIX ---
+ * --- META REFACTOR (v2) ---
+ * This is a streaming meta-calc. It reads historical shards (a side-effect
+ * from Pass 1) and streams root portfolio data to calculate its result.
+ * It has no direct computational dependencies passed to `process`.
  */
 
 const { Firestore } = require('@google-cloud/firestore');
 const firestore = new Firestore();
-// CORRECTED PATH: ../utils/ instead of ../../utils/
 const { getInstrumentSectorMap } = require('../../../utils/sector_mapping_provider');
+// NOTE: Corrected relative path for data_loader
+const { loadDataByRefs, getPortfolioPartRefs, loadFullDayMap } = require('../../../../bulltrackers-module/functions/computation-system/utils/data_loader');
+
 
 class SmartMoneyFlow {
+    
+    /**
+     * (NEW) Statically declare dependencies.
+     * This calc reads shards from Pass 1, but doesn't take a computed
+     * result as an argument. The manifest ensures it runs in Pass 2.
+     */
+    static getDependencies() {
+        return ['user-profitability-tracker']; // This is just for ordering, not for `fetchedDependencies`
+    }
+    
     constructor() {
         this.smartMoneyUsers = new Set();
-        this.sectorMap = null; // Cache for the sector map
-
-        // --- NEW ---
+        this.sectorMap = null; 
+        
         // We now store the portfolio data during process()
+        // (This state is reset for each date by the runner)
         this.todayPortfolios = {};
         this.yesterdayPortfolios = {};
-        // --- END NEW ---
     }
 
-    async process(todayPortfolio, yesterdayPortfolio, userId) {
-        // --- FIX: process() NO LONGER calls identifySmartMoney ---
-        // It just caches the portfolios we need for getResult()
-
-        // Load sector map if not already loaded
+    /**
+     * REFACTORED PROCESS METHOD
+     * This is now the *first* method called by the runner.
+     * It caches the portfolios.
+     */
+    async process(dateStr, dependencies, config, fetchedDependencies) {
+        const { logger, db, rootData } = dependencies;
+        const { portfolioRefs } = rootData;
+        logger.log('INFO', '[SmartMoneyFlow] Starting meta-process...');
+        
+        // 1. Load external dependencies (sectors)
         if (!this.sectorMap) {
              try {
                  this.sectorMap = await getInstrumentSectorMap();
-                 if (!this.sectorMap || Object.keys(this.sectorMap).length === 0) {
-                     console.warn('Sector map loaded but is empty.');
-                 }
             } catch (error) {
-                console.error('Failed to load sector map:', error);
-                return; // Stop processing if sector map fails to load
+                logger.log('ERROR', '[SmartMoneyFlow] Failed to load sector map.', { err: error.message });
+                return null; // Abort
             }
         }
-
-        if (todayPortfolio) {
-            this.todayPortfolios[userId] = todayPortfolio;
+        
+        // 2. Load "yesterday's" portfolio data for comparison
+        const yesterdayDate = new Date(dateStr + 'T00:00:00Z');
+        yesterdayDate.setUTCDate(yesterdayDate.getUTCDate() - 1);
+        const yesterdayStr = yesterdayDate.toISOString().slice(0, 10);
+        const yesterdayRefs = await getPortfolioPartRefs(config, dependencies, yesterdayStr);
+        const yesterdayPortfolios = await loadFullDayMap(config, dependencies, yesterdayRefs);
+        logger.log('INFO', `[SmartMoneyFlow] Loaded ${yesterdayRefs.length} part refs for yesterday.`);
+
+        // 3. Identify smart money users by reading Pass 1 shards
+        // This is the dependency.
+        await this.identifySmartMoney(dependencies);
+        if (this.smartMoneyUsers.size === 0) {
+            logger.log('WARN', '[SmartMoneyFlow] No smart money users identified. Aborting.');
+            return { smart_money_flow: {} };
         }
-        if (yesterdayPortfolio) {
-            this.yesterdayPortfolios[userId] = yesterdayPortfolio;
+
+        // 4. Stream "today's" portfolio data and process *only smart users*
+        const batchSize = config.partRefBatchSize || 10;
+        const sectorFlow = {};
+
+        for (let i = 0; i < portfolioRefs.length; i += batchSize) {
+            const batchRefs = portfolioRefs.slice(i, i + batchSize);
+            const todayPortfoliosChunk = await loadDataByRefs(config, dependencies, batchRefs);
+
+            for (const uid in todayPortfoliosChunk) {
+                // --- Filter user ---
+                if (!this.smartMoneyUsers.has(uid)) {
+                    continue;
+                }
+                
+                const pToday = todayPortfoliosChunk[uid];
+                const pYesterday = yesterdayPortfolios[uid];
+                
+                if (!pToday || !pYesterday) continue;
+
+                // --- User is in cohort, run logic ---
+                const todaySectorInvestment = this.calculateSectorInvestment(pToday);
+                const yesterdaySectorInvestment = this.calculateSectorInvestment(pYesterday);
+
+                const allSectors = new Set([...Object.keys(todaySectorInvestment), ...Object.keys(yesterdaySectorInvestment)]);
+                for (const sector of allSectors) {
+                    const todayAmount = todaySectorInvestment[sector] || 0;
+                    const yesterdayAmount = yesterdaySectorInvestment[sector] || 0;
+                    const change = todayAmount - yesterdayAmount;
+
+                    if (change !== 0) {
+                         if (!sectorFlow[sector]) {
+                            sectorFlow[sector] = 0;
+                        }
+                        sectorFlow[sector] += change;
+                    }
+                }
+            }
         }
+        
+        logger.log('INFO', `[SmartMoneyFlow] Processed ${this.smartMoneyUsers.size} smart users.`);
+
+        // 5. Return final result
+        return { smart_money_flow: sectorFlow };
     }
 
-     async identifySmartMoney() {
-        console.log("Attempting to identify smart money users...");
+     async identifySmartMoney(dependencies) {
+         const { logger } = dependencies;
+        logger.log('INFO', "[SmartMoneyFlow] Attempting to identify smart money users by reading shards...");
         try {
-            // Fetching sharded profitability data
             const shardPromises = [];
-            const NUM_SHARDS = 50; // Ensure this matches the value used in user_profitability_tracker
+            const NUM_SHARDS = 50; 
             for (let i = 0; i < NUM_SHARDS; i++) {
-                // Corrected document path for shards
                 const docRef = firestore.collection('historical_insights').doc(`user_profitability_shard_${i}`);
                 shardPromises.push(docRef.get());
             }
@@ -70,10 +134,7 @@ class SmartMoneyFlow {
                     const shardData = snap.data() || {};
                     for (const userId in shardData) {
                         const history = shardData[userId];
-                        // Check if history is an array and has enough entries
                         if (Array.isArray(history) && history.length >= 5) {
-                             // "Smart money" definition: profitable for at least 5 of the last 7 days
-                             // Filter based on the 'pnl' property of each history entry
                              const profitableDays = history.slice(-7).filter(d => d && typeof d.pnl === 'number' && d.pnl > 0).length;
                              if (profitableDays >= 5) {
                                 this.smartMoneyUsers.add(userId);
@@ -82,32 +143,25 @@ class SmartMoneyFlow {
                         }
                     }
                 } else {
-                     console.warn(`Profitability shard user_profitability_shard_${index} does not exist.`);
+                     logger.log('WARN', `[SmartMoneyFlow] Profitability shard user_profitability_shard_${index} does not exist.`);
                 }
             });
-             console.log(`Found ${profitableUsersFound} potentially smart money users across all shards.`);
+             logger.log('INFO', `[SmartMoneyFlow] Found ${profitableUsersFound} smart money users across all shards.`);
 
         } catch (error) {
-            console.error('Error identifying smart money users:', error);
-            // Decide how to handle error: maybe retry, or proceed without smart money data
-            this.smartMoneyUsers.clear(); // Ensure set is empty on error
-        }
-         // Final check after attempt
-         if (this.smartMoneyUsers.size === 0) {
-            console.warn("No smart money users identified. Smart money flow calculation might be empty.");
+            logger.log('ERROR', '[SmartMoneyFlow] Error identifying smart money users', { err: error.message });
+            this.smartMoneyUsers.clear();
         }
     }
 
 
     calculateSectorInvestment(portfolio) {
         const sectorInvestment = {};
-         // Ensure sectorMap is loaded
          if (!this.sectorMap) {
-             console.warn("Cannot calculate sector investment: Sector map not loaded.");
-             return sectorInvestment; // Return empty object
+             console.warn("[SmartMoneyFlow] Cannot calculate sector investment: Sector map not loaded.");
+             return sectorInvestment; 
          }
 
-        // Use AggregatedPositions as it contains 'Invested' amount
         if (portfolio && portfolio.AggregatedPositions && Array.isArray(portfolio.AggregatedPositions)) {
             for (const pos of portfolio.AggregatedPositions) {
                  if (pos && typeof pos.InstrumentID !== 'undefined' && typeof pos.Invested === 'number') {
@@ -116,70 +170,20 @@ class SmartMoneyFlow {
                         sectorInvestment[sector] = 0;
                     }
                     sectorInvestment[sector] += pos.Invested;
-                } else {
-                     // Log potentially malformed position data
-                     // console.warn('Skipping position due to missing InstrumentID or Invested amount:', pos);
                 }
             }
-        } else {
-             // Log if AggregatedPositions are missing or not an array
-             // console.warn('AggregatedPositions missing or invalid in portfolio for sector investment calculation.');
         }
         return sectorInvestment;
     }
 
 
-    async getResult() {
-        // --- FIX: MOVED FROM process() ---
-        // 1. Identify smart money *now*, after Pass 1's getResult() has run
-        await this.identifySmartMoney();
-
-        // 2. Ensure sector map is loaded (it should be from process())
-        if (!this.sectorMap) {
-            console.error('SmartMoneyFlow: Sector map not loaded, cannot get result.');
-            return { smart_money_flow: {} };
-        }
-        // --- END FIX ---
-
-        const sectorFlow = {};
-
-        // 3. Loop through the cached portfolios
-        for (const userId of this.smartMoneyUsers) {
-            const todayPortfolio = this.todayPortfolios[userId];
-            const yesterdayPortfolio = this.yesterdayPortfolios[userId];
-
-            if (todayPortfolio && yesterdayPortfolio) {
-                const todaySectorInvestment = this.calculateSectorInvestment(todayPortfolio);
-                const yesterdaySectorInvestment = this.calculateSectorInvestment(yesterdayPortfolio);
-
-                // Calculate change in investment per sector
-                const allSectors = new Set([...Object.keys(todaySectorInvestment), ...Object.keys(yesterdaySectorInvestment)]);
-                for (const sector of allSectors) {
-                    const todayAmount = todaySectorInvestment[sector] || 0;
-                    const yesterdayAmount = yesterdaySectorInvestment[sector] || 0;
-                    const change = todayAmount - yesterdayAmount;
-
-                    // Only record if there is a change
-                    if (change !== 0) {
-                         if (!sectorFlow[sector]) {
-                            sectorFlow[sector] = 0;
-                        }
-                        sectorFlow[sector] += change;
-                    }
-                }
-            }
-        }
-
-        // Return only sectors with non-zero flow if desired, or the full object
-         const filteredFlow = {};
-         for (const sector in sectorFlow) {
-             if (sectorFlow[sector] !== 0) {
-                 filteredFlow[sector] = sectorFlow[sector];
-             }
-         }
-         console.log("Final Smart Money Flow:", filteredFlow);
-        return { smart_money_flow: filteredFlow };
+    async getResult() { return null; }
+    reset() {
+        this.smartMoneyUsers.clear();
+        this.sectorMap = null;
+        this.todayPortfolios = {};
+        this.yesterdayPortfolios = {};
     }
 }
 
-module.exports = SmartMoneyFlow;
+module.exports = SmartMoneyFlow;

package/calculations/behavioural/historical/user-investment-profile.js

@@ -1,23 +1,25 @@
 /**
  * @fileoverview Calculates a rolling 90-day "Investor Score" (IS) for each normal user.
  *
- * --- META REFACTOR ---
- * This calculation is now `type: "meta"` to consume in-memory dependencies.
- * It runs ONCE per day, receives the in-memory cache, and must
- * perform its own user data streaming.
+ * --- META REFACTOR (v2) ---
+ * This calculation is now `type: "meta"` and expects its dependencies
+ * to be fetched by the pass runner and provided to its `process` method.
+ * It also dynamically fetches its own historical user data.
  */
 
 const { Firestore } = require('@google-cloud/firestore');
 const firestore = new Firestore();
-const { loadAllPriceData, getDailyPriceChange } = require('../../../utils/price_data_provider');
-const { loadInstrumentMappings, getInstrumentSectorMap } = require('../../../utils/sector_mapping_provider');
-const { loadDataByRefs, getPortfolioPartRefs, loadFullDayMap } = require('../../../../bulltrackers-module/functions/computation-system/utils/data_loader');// Config
-const NUM_SHARDS = 50; // Must match the number of shards to read/write
+// NOTE: Corrected relative path for data_loader
+const { loadDataByRefs, getPortfolioPartRefs, loadFullDayMap } = require('../../../../bulltrackers-module/functions/computation-system/utils/data_loader');
+const { loadAllPriceData, getInstrumentSectorMap } = require('../../../utils/price_data_provider');
+
+// Config
+const NUM_SHARDS = 50;
 const ROLLING_DAYS = 90;
-const SHARD_COLLECTION_NAME = 'user_profile_history'; // The collection to store sharded history
-const PNL_TRACKER_CALC_ID = 'user-profitability-tracker'; // The calc to read PNL from
+const SHARD_COLLECTION_NAME = 'user_profile_history';
+const PNL_TRACKER_CALC_ID = 'user-profitability-tracker';
 
-// Helper: stable shard index for numeric or string IDs
+// Helper: stable shard index
 function getShardIndex(id) {
     const n = parseInt(id, 10);
     if (!Number.isNaN(n)) return Math.abs(n) % NUM_SHARDS;
@@ -30,16 +32,15 @@ function getShardIndex(id) {
 }
 
 class UserInvestmentProfile {
-    constructor() {
-        // --- META REFACTOR ---
-        // All state is now managed inside the `process` function.
-        // The constructor, getResult, and reset methods are no longer used
-        // by the meta-runner, but we leave them for compatibility.
-        // --- END REFACTOR ---
-    }
 
-    // ... [Heuristic calculation functions _calculateRiskAndDivScore, _calculateDisciplineScore, _calculateMarketTimingScore] ...
-    // These helper functions remain identical to your original file.
+    /**
+     * (NEW) Statically declare dependencies.
+     * The runner will fetch these results for the *current date*
+     * and pass them to `process`.
+     */
+    static getDependencies() {
+        return [PNL_TRACKER_CALC_ID];
+    }
 
     /**
      * HEURISTIC 1: Risk & Diversification Score (0-10).
@@ -59,7 +60,7 @@ class UserInvestmentProfile {
         for (const pos of positions) {
             const invested = pos.InvestedAmount || pos.Amount || 0;
             const netProfit = ('NetProfit' in pos) ? pos.NetProfit : (pos.ProfitAndLoss || 0); // decimal % return
-            const ret = invested > 0 ? (netProfit) : netProfit; // if invested==0 we still include ret but weight 0
+            const ret = invested > 0 ? (netProfit) : netProfit; 
 
             weightedRetSum += ret * invested;
             weightedRetSqSum += (ret * ret) * invested;
@@ -69,29 +70,19 @@ class UserInvestmentProfile {
             sectors.add(sectorMap[pos.InstrumentID] || 'N/A');
         }
 
-        // Weighted mean & variance of returns
         const meanReturn = totalInvested > 0 ? (weightedRetSum / totalInvested) : 0;
         const meanReturnSq = totalInvested > 0 ? (weightedRetSqSum / totalInvested) : (meanReturn * meanReturn);
         const variance = Math.max(0, meanReturnSq - (meanReturn * meanReturn));
         const stdReturn = Math.sqrt(variance);
-
-        // dispersion proxy: mean / std (if std is zero we treat as neutral 0)
         let dispersionRiskProxy = stdReturn > 0 ? meanReturn / stdReturn : 0;
-
-        // cap and map dispersion proxy to [0..10].
-        // dispersionRiskProxy can be outside [-2..4], clamp to reasonable bounds first.
         const capped = Math.max(-2, Math.min(4, dispersionRiskProxy));
-        const scoreSharpe = ((capped + 2) / 6) * 10; // maps [-2..4] -> [0..10]
-
-        // Sector diversification (monotonic - diminishing returns)
+        const scoreSharpe = ((capped + 2) / 6) * 10; 
         const sectorCount = sectors.size;
         let scoreDiversification = 0;
         if (sectorCount === 1) scoreDiversification = 0;
         else if (sectorCount <= 4) scoreDiversification = 5;
         else if (sectorCount <= 7) scoreDiversification = 8;
         else scoreDiversification = 10;
-
-        // Position sizing / concentration penalty
         const concentrationRatio = totalInvested > 0 ? (maxPosition / totalInvested) : 0;
         let scoreSizing = 0;
         if (concentrationRatio > 0.8) scoreSizing = 0;
@@ -99,7 +90,6 @@ class UserInvestmentProfile {
         else if (concentrationRatio > 0.3) scoreSizing = 5;
         else if (concentrationRatio > 0.15) scoreSizing = 8;
         else scoreSizing = 10;
-
         const final = (scoreSharpe * 0.4) + (scoreDiversification * 0.3) + (scoreSizing * 0.3);
         return Math.max(0, Math.min(10, final));
     }
@@ -110,42 +100,34 @@ class UserInvestmentProfile {
     _calculateDisciplineScore(yesterdayPortfolio = {}, todayPortfolio = {}) {
         const yPositions = yesterdayPortfolio.AggregatedPositions || [];
         const tPositions = new Map((todayPortfolio.AggregatedPositions || []).map(p => [p.PositionID, p]));
-
         if (yPositions.length === 0) {
-            return 5; // neutral if nothing to judge
+            return 5; // neutral
         }
-
         let eventPoints = 0;
         let eventCount = 0;
-
         for (const yPos of yPositions) {
             const profitAndLoss = ('ProfitAndLoss' in yPos) ? yPos.ProfitAndLoss : (yPos.NetProfit || 0);
             const invested = yPos.InvestedAmount || yPos.Amount || 0;
-            const pnlPercent = profitAndLoss; // This is already the decimal % return
-
+            const pnlPercent = profitAndLoss;
             const tPos = tPositions.get(yPos.PositionID);
-
             if (!tPos) {
-                // Closed position
                 eventCount++;
-                if (pnlPercent < -0.05) eventPoints += 10;         // cut loser (good)
-                else if (pnlPercent > 0.20) eventPoints += 8;     // took big profit (good)
-                else if (pnlPercent > 0 && pnlPercent < 0.05) eventPoints += 2; // paper hands (bad)
-                else eventPoints += 5; // neutral close
+                if (pnlPercent < -0.05) eventPoints += 10;
+                else if (pnlPercent > 0.20) eventPoints += 8;
+                else if (pnlPercent > 0 && pnlPercent < 0.05) eventPoints += 2;
+                else eventPoints += 5;
             } else {
-                // Held or modified
                 if (pnlPercent < -0.10) {
                     eventCount++;
                     const tInvested = tPos.InvestedAmount || tPos.Amount || 0;
-                    if (tInvested > invested) eventPoints += 0; // averaged down (very poor)
-                    else eventPoints += 3; // held loser (poor)
+                    if (tInvested > invested) eventPoints += 0;
+                    else eventPoints += 3;
                 } else if (pnlPercent > 0.15) {
                     eventCount++;
-                    eventPoints += 10; // held/added to winner (good)
+                    eventPoints += 10;
                 }
             }
         }
-
         const avg = (eventCount > 0) ? (eventPoints / eventCount) : 5;
         return Math.max(0, Math.min(10, avg));
     }
@@ -156,44 +138,33 @@ class UserInvestmentProfile {
     _calculateMarketTimingScore(yesterdayPortfolio = {}, todayPortfolio = {}, priceMap) {
         const yIds = new Set((yesterdayPortfolio.AggregatedPositions || []).map(p => p.PositionID));
         const newPositions = (todayPortfolio.AggregatedPositions || []).filter(p => !yIds.has(p.PositionID));
-
         if (newPositions.length === 0) return 5;
-
         let timingPoints = 0;
         let timingCount = 0;
-
         for (const tPos of newPositions) {
             const prices = priceMap[tPos.InstrumentID];
             if (!prices) continue;
-
-            // Accept prices as either array or {date:price} map; build sorted array of prices
             let historyPrices = [];
             if (Array.isArray(prices)) {
-                // assume array of numbers or objects with .price/.close
                 historyPrices = prices
                     .map(p => (typeof p === 'number' ? p : (p.price || p.close || null)))
                     .filter(v => v != null);
             } else {
-                // object keyed by date -> price
                 const entries = Object.keys(prices)
                     .map(d => ({ d, p: prices[d] }))
                     .filter(e => e.p != null)
                     .sort((a, b) => new Date(a.d) - new Date(b.d));
                 historyPrices = entries.map(e => e.p);
             }
-
             const last30 = historyPrices.slice(-30);
             if (last30.length < 2) continue;
-
             const minPrice = Math.min(...last30);
             const maxPrice = Math.max(...last30);
             const openRate = tPos.OpenRate;
             const range = maxPrice - minPrice;
             if (!isFinite(range) || range === 0) continue;
-
-            let proximity = (openRate - minPrice) / range; // 0 = at low, 1 = at high
-            proximity = Math.max(0, Math.min(1, proximity)); // clamp to [0,1]
-
+            let proximity = (openRate - minPrice) / range;
+            proximity = Math.max(0, Math.min(1, proximity));
             timingCount++;
             if (proximity < 0.2) timingPoints += 10;
             else if (proximity < 0.4) timingPoints += 8;
@@ -201,30 +172,32 @@ class UserInvestmentProfile {
             else if (proximity > 0.7) timingPoints += 3;
             else timingPoints += 5;
         }
-
         const avg = (timingCount > 0) ? (timingPoints / timingCount) : 5;
         return Math.max(0, Math.min(10, avg));
     }
-
-
+    
     /**
-     * PROCESS: META REFACTOR
-     * This now runs ONCE, loads all data, streams users, and returns one big result.
+     * REFACTORED PROCESS METHOD
+     * @param {string} dateStr - The date being processed (YYYY-MM-DD).
+     * @param {object} dependencies - Shared dependencies (db, logger, rootData, etc.).
+     * @param {object} config - The computation system configuration.
+     * @param {object} fetchedDependencies - An object containing the results of this
+     * calc's dependencies (e.g., { 'user-profitability-tracker': ... }).
      */
-    async process(dateStr, dependencies, config, computedDependencies) {
-        const { logger, db, rootData, calculationUtils } = dependencies;
+    async process(dateStr, dependencies, config, fetchedDependencies) {
+        const { logger, db, rootData } = dependencies;
         const { portfolioRefs } = rootData;
 
         logger.log('INFO', '[UserInvestmentProfile] Starting meta-process...');
 
-        // 1. Get Pass 1 dependency from in-memory cache
-        const pnlTrackerResult = computedDependencies[PNL_TRACKER_CALC_ID];
+        // 1. Get Pass 1 dependency from the `fetchedDependencies` argument
+        const pnlTrackerResult = fetchedDependencies[PNL_TRACKER_CALC_ID];
         if (!pnlTrackerResult || !pnlTrackerResult.daily_pnl_map) {
-            logger.log('WARN', `[UserInvestmentProfile] Missing in-memory dependency '${PNL_TRACKER_CALC_ID}'. Aborting.`);
+            logger.log('WARN', `[UserInvestmentProfile] Dependency '${PNL_TRACKER_CALC_ID}' not found in fetchedDependencies. Aborting.`);
             return null; // Return null to signal failure
         }
         const pnlScores = pnlTrackerResult.daily_pnl_map;
-        logger.log('INFO', `[UserInvestmentProfile] Received ${Object.keys(pnlScores).length} PNL scores in-memory.`);
+        logger.log('INFO', `[UserInvestmentProfile] Received ${Object.keys(pnlScores).length} PNL scores from dependency.`);
 
         // 2. Load external dependencies (prices, sectors)
         const [priceMap, sectorMap] = await Promise.all([
@@ -254,11 +227,10 @@ class UserInvestmentProfile {
 
             for (const uid in todayPortfoliosChunk) {
                 const pToday = todayPortfoliosChunk[uid];
-                if (!pToday || !pToday.AggregatedPositions) continue; // Skip speculators or empty
+                if (!pToday || !pToday.AggregatedPositions) continue; // Skip
 
                 const pYesterday = yesterdayPortfolios[uid] || {};
 
-                // Run the heuristic calculations
                 const score_rd = this._calculateRiskAndDivScore(pToday, sectorMap);
                 const score_disc = this._calculateDisciplineScore(pYesterday, pToday);
                 const score_time = this._calculateMarketTimingScore(pYesterday, pToday, priceMap);
@@ -272,15 +244,12 @@ class UserInvestmentProfile {
         }
         logger.log('INFO', `[UserInvestmentProfile] Calculated daily scores for ${Object.keys(dailyUserScores).length} users.`);
         
-        // --- 5. GETRESULT LOGIC IS NOW INSIDE PROCESS ---
-        // (This is the logic from your original getResult())
-
+        // 5. GETRESULT LOGIC (Final aggregation)
         const shardedResults = {};
         for (let i = 0; i < NUM_SHARDS; i++) {
             const shardKey = `${SHARD_COLLECTION_NAME}_shard_${i}`;
             shardedResults[shardKey] = { profiles: {}, lastUpdated: dateStr };
         }
-
         const dailyInvestorScoreMap = {};
 
         // Fetch existing shards in parallel
@@ -296,16 +265,13 @@ class UserInvestmentProfile {
         for (const userId of Object.keys(dailyUserScores)) {
             const shardIndex = getShardIndex(userId);
             const scores = dailyUserScores[userId];
-
             const existingProfiles = existingShards[shardIndex] || {};
             const history = (existingProfiles[userId] || []).slice(); // clone
-
             history.push({
                 date: dateStr,
                 ...scores,
                 pnl: (pnlScores[userId] || 0)
             });
-
             const newHistory = history.slice(-ROLLING_DAYS);
 
             // compute rolling averages
@@ -340,18 +306,8 @@ class UserInvestmentProfile {
         };
     }
 
-    /**
-     * getResult is no longer used by the meta-runner.
-     */
-    async getResult() { 
-        return null;
-    }
-
-    /**
-     * reset is no longer used by the meta-runner.
-     */
-    reset() {
-    }
+    async getResult() { return null; }
+    reset() {}
 }
 
 module.exports = UserInvestmentProfile;