bulltrackers-module 1.0.263 → 1.0.264

package/functions/computation-system/executors/StandardExecutor.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Executor for "Standard" (per-user) calculations.
- * UPDATED: Handles lazy loading of data references (accepts null refs from Indexer).
+ * UPDATED: Handles lazy loading of data references.
+ * UPDATED: Supports Multi-Date Fan-Out Aggregation (Time Machine Mode).
  */
 const { normalizeName }                                                = require('../utils/utils');
 const { streamPortfolioData, streamHistoryData, getPortfolioPartRefs } = require('../utils/data_loader');
@@ -39,8 +40,46 @@ class StandardExecutor {
         // 3. Stream & Process
         await StandardExecutor.streamAndProcess(dStr, state, passName, config, deps, fullRoot, rootData.portfolioRefs, rootData.historyRefs, fetchedDeps, previousFetchedDeps);
         
-        // 4. Commit
-        return await commitResults(state, dStr, passName, config, deps, skipStatusWrite);
+        // 4. Pre-Commit Transformation for Fan-Out
+        // If a calc produced multi-date output per user, we must transpose it:
+        // FROM: UserA -> { "2024-01-01": data, "2024-01-02": data }
+        // TO:   "2024-01-01" -> { UserA: data }, "2024-01-02" -> { UserA: data }
+        
+        const transformedState = {};
+        for (const [name, inst] of Object.entries(state)) {
+            const result = await inst.getResult(); // { userId: { date: data } } or { userId: data }
+            const firstUser = Object.keys(result)[0];
+            
+            // Check if the inner value is a Date Map
+            // Only checks the first user as heuristic; implies uniform return type
+            if (firstUser && result[firstUser] && typeof result[firstUser] === 'object') {
+                const innerKeys = Object.keys(result[firstUser]);
+                // Check if keys look like YYYY-MM-DD
+                const isDateMap = innerKeys.length > 0 && innerKeys.every(k => /^\d{4}-\d{2}-\d{2}$/.test(k));
+                
+                if (isDateMap) {
+                    const transposed = {};
+                    for (const [userId, dateMap] of Object.entries(result)) {
+                        for (const [dateKey, dailyData] of Object.entries(dateMap)) {
+                            if (!transposed[dateKey]) transposed[dateKey] = {};
+                            transposed[dateKey][userId] = dailyData;
+                        }
+                    }
+                    
+                    // Mock a "getResult" for the committer that returns the Transposed Map
+                    transformedState[name] = {
+                        manifest: inst.manifest,
+                        getResult: async () => transposed
+                    };
+                    continue;
+                }
+            }
+            // Normal behavior
+            transformedState[name] = inst;
+        }
+
+        // 5. Commit
+        return await commitResults(transformedState, dStr, passName, config, deps, skipStatusWrite);
     }
 
     static async streamAndProcess(dateStr, state, passName, config, deps, rootData, portfolioRefs, historyRefs, fetchedDeps, previousFetchedDeps) {
@@ -58,20 +97,16 @@ class StandardExecutor {
         const prevDate    = new Date(dateStr + 'T00:00:00Z'); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
         const prevDateStr = prevDate.toISOString().slice(0, 10);
         
-        // [FIX] pass null if portfolioRefs is null; streamPortfolioData handles the fetch
         const tP_iter = streamPortfolioData(config, deps, dateStr, portfolioRefs);
         
         const needsYesterdayPortfolio = streamingCalcs.some(c => c.manifest.isHistorical);
-        // yesterdayPortfolioRefs are manually fetched in run(), so they are usually populated
         const yP_iter = (needsYesterdayPortfolio && rootData.yesterdayPortfolioRefs)  ? streamPortfolioData(config, deps, prevDateStr, rootData.yesterdayPortfolioRefs) : null;
         
         const needsTradingHistory = streamingCalcs.some(c => c.manifest.rootDataDependencies.includes('history'));
-        // [FIX] Removed '&& historyRefs' check. We pass null to streamHistoryData if refs are missing, allowing it to fetch them.
         const tH_iter = (needsTradingHistory) ? streamHistoryData(config, deps, dateStr, historyRefs) : null;
 
         let yP_chunk = {}, tH_chunk = {};
         
-        // [FIX] Ensure manual iterators are closed if loop fails
         try {
             for await (const tP_chunk of tP_iter) {
                 if (yP_iter) yP_chunk = (await yP_iter.next()).value || {};

package/functions/computation-system/layers/profiling.js

@@ -1,6 +1,7 @@
 /**
- * @fileoverview Profiling Layer - Intelligence Engine (V5)
+ * @fileoverview Profiling Layer - Intelligence Engine (V6)
  * Encapsulates advanced behavioral profiling, psychological scoring, and classification schemas.
+ * UPDATED: Added SmartMoneyScorer for advanced multi-factor user classification.
  */
 
 const SCHEMAS = {
@@ -21,118 +22,332 @@ const SCHEMAS = {
 };
 
 // ========================================================================
-// 1. BEHAVIORAL ANALYTICS ENGINES
+// 1. SMART MONEY SCORING ENGINE (NEW)
 // ========================================================================
 
-class CognitiveBiases {
+class SmartMoneyScorer {
+
     /**
-     * Anchoring Bias Detector.
-     * Checks if the user holds "dead money" positions that are hovering near breakeven
-     * for extended periods, refusing to close them.
-     * @param {Array} openPositions - Current holdings. Needs OpenDateTime (Speculators).
-     * @param {number} thresholdPct - +/- % range around 0 PnL (e.g. 2%).
-     * @param {number} minDaysHeld - Minimum days held to qualify as "Anchored".
+     * Internal Helper: Calculate Pearson Correlation
      */
-    static calculateAnchoringScore(openPositions, thresholdPct = 2.0, minDaysHeld = 14) {
-        if (!openPositions || openPositions.length === 0) return 0;
+    static _correlation(x, y) {
+        if (!x || !y || x.length !== y.length || x.length < 2) return 0;
+        const n = x.length;
+        let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
+        for (let i = 0; i < n; i++) {
+            sumX += x[i]; sumY += y[i];
+            sumXY += x[i] * y[i];
+            sumX2 += x[i] * x[i]; sumY2 += y[i] * y[i];
+        }
+        const numerator = (n * sumXY) - (sumX * sumY);
+        const denominator = Math.sqrt(((n * sumX2) - (sumX * sumX)) * ((n * sumY2) - (sumY * sumY)));
+        return (denominator === 0) ? 0 : numerator / denominator;
+    }
+
+    /**
+     * Mode 1: Portfolio-Based Scoring
+     * Heuristics:
+     * 1. Diversification (Sector/Asset count)
+     * 2. Allocation Efficiency (Correlation of Size vs Profit)
+     * 3. Shorting Competence
+     * 4. Concentration Risk (HHI)
+     */
+    static scorePortfolio(portfolio, userType, prices, mappings, math) {
+        const positions = math.extract.getPositions(portfolio, userType);
+        if (!positions || positions.length === 0) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
+
+        let totalInvested = 0;
+        let weightedPnL = 0;
+        let shortInvested = 0;
+        let shortPnL = 0;
         
-        let anchoredCount = 0;
-        let validPositions = 0;
-        const now = Date.now();
-        const msPerDay = 86400000;
+        const weights = [];
+        const pnls = [];
+        const sectors = new Set();
+        const tickers = new Set();
 
-        for (const pos of openPositions) {
-            // Only applicable if we have OpenDateTime (Speculator Schema)
-            if (pos.OpenDateTime) {
-                validPositions++;
-                const ageDays = (now - new Date(pos.OpenDateTime).getTime()) / msPerDay;
+        // 1. Data Aggregation
+        for (const pos of positions) {
+            const invested = math.extract.getPositionWeight(pos, userType);
+            const pnl = math.extract.getNetProfit(pos); // %
+            const instId = math.extract.getInstrumentId(pos);
+            const isShort = math.extract.getDirection(pos) === 'Sell';
+            
+            const sector = mappings.instrumentToSector[instId];
+            const ticker = mappings.instrumentToTicker[instId];
+
+            if (invested > 0) {
+                totalInvested += invested;
+                weightedPnL += (pnl * invested);
+                weights.push(invested);
+                pnls.push(pnl);
                 
-                // Is the trade old AND hovering near 0% PnL?
-                if (ageDays > minDaysHeld && Math.abs(pos.NetProfit) < thresholdPct) {
-                    anchoredCount++;
+                if (sector) sectors.add(sector);
+                if (ticker) tickers.add(ticker);
+
+                if (isShort) {
+                    shortInvested += invested;
+                    shortPnL += (pnl * invested);
                 }
             }
         }
+
+        if (totalInvested === 0) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
+
+        // 2. Metrics Calculation
+        const avgPnL = weightedPnL / totalInvested;
         
-        return validPositions > 0 ? (anchoredCount / validPositions) : 0;
+        // A. Allocation Efficiency (Do they bet big on winners?)
+        // Correlation between Invested Amount and PnL %
+        const allocEfficiency = this._correlation(weights, pnls); // -1 to 1
+
+        // B. Diversification & Concentration (HHI)
+        // Sum of squared market shares. 1.0 = Monopoly. 0.0 = Infinite.
+        let hhi = 0;
+        for (const w of weights) {
+            const share = w / totalInvested;
+            hhi += (share * share);
+        }
+        
+        // C. Shorting Competence
+        const shortRatio = shortInvested / totalInvested;
+        const avgShortPnL = shortInvested > 0 ? shortPnL / shortInvested : 0;
+
+        // 3. Scoring Logic
+        let score = 50; 
+
+        // Efficiency Bonus: If > 0.5, they size winners up. (+20)
+        // If < -0.3, they are bagholding losers with large size (-15)
+        if (allocEfficiency > 0.5) score += 20;
+        else if (allocEfficiency < -0.3) score -= 15;
+
+        // Profitability (The ultimate metric)
+        if (avgPnL > 5) score += 10;
+        if (avgPnL > 20) score += 10;
+        if (avgPnL < -10) score -= 10;
+        if (avgPnL < -25) score -= 15;
+
+        // Concentration Logic
+        // High Concentration (HHI > 0.3) is "Smart" ONLY if profitable (Sniper)
+        // High Concentration and unprofitable is "Dumb" (Bagholder/Gambler)
+        if (hhi > 0.3) {
+            if (avgPnL > 5) score += 10; // Sniper
+            else if (avgPnL < -5) score -= 10; // Reckless
+        }
+
+        // Diversification Logic
+        // High Sector count (>3) reduces risk penalty
+        if (sectors.size >= 4) score += 5;
+
+        // Shorting Logic
+        // Penalize speculation unless they are actually good at it
+        if (shortRatio > 0.1) {
+            if (avgShortPnL > 0) score += 10; // Smart Short
+            else score -= 10; // Failed Speculation
+        }
+
+        return {
+            score: Math.max(0, Math.min(100, score)),
+            metrics: { allocEfficiency, hhi, avgPnL, shortRatio, sectorCount: sectors.size }
+        };
     }
 
     /**
-     * Disposition Effect (Loss Aversion in Time Domain).
-     * Calculates ratio of Avg Hold Time (Losers) / Avg Hold Time (Winners).
-     * Value > 1.0 means they hold losers longer than winners (Bad).
+     * Mode 2: History-Based Scoring
+     * Heuristics:
+     * 1. Win/Loss Ratio & Profit Factor
+     * 2. Asset Consistency (Revenge trading vs Specialist)
+     * 3. Entry Efficiency (Buying Lows)
+     * 4. Exit Efficiency (Selling Highs - Opportunity Cost)
+     * 5. Churn (Overtrading)
+     * 6. DCA/Entry Patterns
      */
-    static calculateDispositionEffect(historyTrades) {
-        let winDur = 0, winCount = 0;
-        let lossDur = 0, lossCount = 0;
+    static scoreHistory(historyDoc, prices, mappings, math) {
+        // Handle V2 Schema (PublicHistoryPositions)
+        const trades = historyDoc?.PublicHistoryPositions || [];
+        // Handle V1 Schema fallback if needed (though prompt implies V2)
+        
+        if (trades.length < 5) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
 
-        for (const t of historyTrades) {
-            if (!t.OpenDateTime || !t.CloseDateTime) continue;
-            
-            const dur = (new Date(t.CloseDateTime) - new Date(t.OpenDateTime)) / 3600000; // Hours
+        // Filter valid trades
+        const validTrades = trades.filter(t => t.OpenDateTime && t.CloseDateTime && t.InstrumentID);
+        if (validTrades.length < 5) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
+
+        let wins = 0, losses = 0;
+        let totalWinPct = 0, totalLossPct = 0;
+        let entryScores = [];
+        const assetsTraded = new Map(); // ID -> { count, pnl }
+
+        // Time sorting for Churn analysis
+        validTrades.sort((a, b) => new Date(a.OpenDateTime) - new Date(b.OpenDateTime));
+        const firstDate = new Date(validTrades[0].OpenDateTime);
+        const lastDate = new Date(validTrades[validTrades.length-1].OpenDateTime);
+        const daysActive = Math.max(1, (lastDate - firstDate) / 86400000);
+
+        for (const t of validTrades) {
+            const ticker = mappings.instrumentToTicker[t.InstrumentID];
             
-            if (t.NetProfit > 0) {
-                winDur += dur;
-                winCount++;
-            } else if (t.NetProfit < 0) {
-                lossDur += dur;
-                lossCount++;
+            // Asset Consistency
+            if (!assetsTraded.has(t.InstrumentID)) assetsTraded.set(t.InstrumentID, { count: 0, pnl: 0 });
+            const assetStat = assetsTraded.get(t.InstrumentID);
+            assetStat.count++;
+            assetStat.pnl += t.NetProfit;
+
+            // A. Win/Loss Stats
+            if (t.NetProfit > 0) { wins++; totalWinPct += t.NetProfit; }
+            else { losses++; totalLossPct += Math.abs(t.NetProfit); }
+
+            // B. Entry Timing (Requires Price History)
+            if (ticker && prices) {
+                const priceHist = math.priceExtractor.getHistory(prices, ticker);
+                if (priceHist && priceHist.length > 0) {
+                    // 1.0 = Perfect Low, 0.0 = Bought High
+                    const eff = ExecutionAnalytics.calculateEfficiency(t.OpenRate, priceHist, t.OpenDateTime, t.IsBuy ? 'Buy' : 'Sell');
+                    entryScores.push(eff);
+                }
             }
         }
 
-        const avgWinHold = winCount > 0 ? winDur / winCount : 0;
-        const avgLossHold = lossCount > 0 ? lossDur / lossCount : 0;
+        const avgWin = wins > 0 ? totalWinPct / wins : 0;
+        const avgLoss = losses > 0 ? totalLossPct / losses : 1;
+        const profitFactor = (wins * avgWin) / Math.max(1, (losses * avgLoss));
+        
+        // C. Entry Skill
+        const avgEntrySkill = entryScores.length > 0 ? math.compute.average(entryScores) : 0.5;
 
-        if (avgWinHold === 0) return 2.0; // Infinite bias if they never hold winners
-        return avgLossHold / avgWinHold;
+        // D. Consistency / Specialization
+        // Do they trade 100 tickers once (Gambler) or 5 tickers 20 times (Specialist)?
+        const totalTrades = validTrades.length;
+        const uniqueAssets = assetsTraded.size;
+        const specializationRatio = 1 - (uniqueAssets / totalTrades); // Higher = More specialized
+
+        // E. Overtrading (Churn)
+        const tradesPerDay = totalTrades / daysActive;
+
+        // F. Revenge Trading Check
+        // High count on a specific asset with negative total PnL
+        let revengeScore = 0;
+        for (const [id, stat] of assetsTraded.entries()) {
+            if (stat.pnl < -20 && stat.count > 5) revengeScore += 1;
+        }
+
+        // Scoring Logic
+        let score = 50;
+
+        // Profit Factor (Primary Driver)
+        if (profitFactor > 1.2) score += 10;
+        if (profitFactor > 2.0) score += 15;
+        if (profitFactor < 0.8) score -= 15;
+
+        // Entry Efficiency
+        if (avgEntrySkill > 0.7) score += 10; // Sniper
+        if (avgEntrySkill < 0.3) score -= 10; // FOMO
+
+        // Specialization
+        if (specializationRatio > 0.6) score += 5; // Specialist bonus
+        if (specializationRatio < 0.1 && totalTrades > 20) score -= 5; // Scattergun penalty
+
+        // Churn Penalty
+        if (tradesPerDay > 10 && profitFactor < 1.0) score -= 10; // Brokerage Cash Cow
+
+        // Revenge Penalty
+        if (revengeScore > 0) score -= (revengeScore * 5);
+
+        return {
+            score: Math.max(0, Math.min(100, score)),
+            metrics: { profitFactor, avgEntrySkill, specializationRatio, tradesPerDay, revengeScore }
+        };
     }
 
     /**
-     * Prospect Theory Utility Function (Kahneman/Tversky).
-     * Models the psychological "utility" (pain/pleasure) of a return.
-     * Losses hurt approx 2.25x more than gains feel good.
-     * @param {number} pnl - Net Profit %.
+     * Mode 3: Hybrid Scoring
+     * Merges Portfolio (Unrealized/Current) and History (Realized/Past).
      */
-    static prospectUtility(pnl, lambda = 2.25, alpha = 0.88) {
-        if (pnl >= 0) {
-            return Math.pow(pnl, alpha);
-        } else {
-            return -lambda * Math.pow(Math.abs(pnl), alpha);
+    static scoreHybrid(context) {
+        const { user, prices, mappings, math } = context;
+        
+        // Get Sub-Scores
+        const pScore = this.scorePortfolio(user.portfolio.today, user.type, prices, mappings, math);
+        const hScore = this.scoreHistory(user.history.today, prices, mappings, math);
+
+        let finalScore = 50;
+        let method = 'Neutral';
+
+        const hasHistory = hScore && hScore.score > 0;
+        const hasPortfolio = pScore && pScore.score > 0;
+
+        if (hasHistory && hasPortfolio) {
+            // Weighted: 60% Track Record (History), 40% Current Positioning (Portfolio)
+            finalScore = (hScore.score * 0.6) + (pScore.score * 0.4);
+            method = 'Hybrid';
+        } else if (hasHistory) {
+            finalScore = hScore.score;
+            method = 'HistoryOnly';
+        } else if (hasPortfolio) {
+            finalScore = pScore.score;
+            method = 'PortfolioOnly';
+        }
+
+        // Classification Label
+        let label = SCHEMAS.LABELS.NEUTRAL;
+        if (finalScore >= 80) label = SCHEMAS.LABELS.ELITE;
+        else if (finalScore >= 65) label = SCHEMAS.LABELS.SMART;
+        else if (finalScore <= 35) label = SCHEMAS.LABELS.GAMBLER;
+        else if (finalScore <= 50) label = SCHEMAS.LABELS.DUMB;
+
+        return {
+            totalScore: Math.round(finalScore),
+            label: label,
+            method: method,
+            components: {
+                portfolio: pScore,
+                history: hScore
+            }
+        };
+    }
+}
+
+// ========================================================================
+// 2. SUPPORTING ANALYTICS ENGINES
+// ========================================================================
+
+class CognitiveBiases {
+    static calculateAnchoringScore(openPositions, thresholdPct = 2.0, minDaysHeld = 14) {
+        if (!openPositions || openPositions.length === 0) return 0;
+        let anchoredCount = 0, validPositions = 0;
+        const now = Date.now(), msPerDay = 86400000;
+        for (const pos of openPositions) {
+            if (pos.OpenDateTime) {
+                validPositions++;
+                const ageDays = (now - new Date(pos.OpenDateTime).getTime()) / msPerDay;
+                if (ageDays > minDaysHeld && Math.abs(pos.NetProfit) < thresholdPct) { anchoredCount++; }
+            }
+        }
+        return validPositions > 0 ? (anchoredCount / validPositions) : 0;
+    }
+
+    static calculateDispositionEffect(historyTrades) {
+        let winDur = 0, winCount = 0, lossDur = 0, lossCount = 0;
+        for (const t of historyTrades) {
+            if (!t.OpenDateTime || !t.CloseDateTime) continue;
+            const dur = (new Date(t.CloseDateTime) - new Date(t.OpenDateTime)) / 3600000; 
+            if (t.NetProfit > 0) { winDur += dur; winCount++; } else if (t.NetProfit < 0) { lossDur += dur; lossCount++; }
         }
+        const avgWinHold = winCount > 0 ? winDur / winCount : 0;
+        const avgLossHold = lossCount > 0 ? lossDur / lossCount : 0;
+        if (avgWinHold === 0) return 2.0; 
+        return avgLossHold / avgWinHold;
     }
 }
 
 class SkillAttribution {
-    /**
-     * Calculates Selection Skill (Alpha) by comparing User PnL vs Asset Benchmark.
-     * Note: Since we don't have individual asset performance histories easily available
-     * in the user context, we use the 'Insights' global growth as a daily benchmark proxy.
-     * @param {Array} userPositions - Current open positions.
-     * @param {Object} dailyInsights - Map of InstrumentID -> Insight Data (which contains 'growth').
-     */
     static calculateSelectionAlpha(userPositions, dailyInsights) {
-        let totalAlpha = 0;
-        let count = 0;
-
+        let totalAlpha = 0, count = 0;
         for (const pos of userPositions) {
             const instrumentId = pos.InstrumentID;
-            // Note: Schema 5 (Insights) is an array, we assume it's converted to a map or we find it.
-            // If passed as array, we find the item.
-            let insight = null;
-            if (Array.isArray(dailyInsights)) {
-                insight = dailyInsights.find(i => i.instrumentId === instrumentId);
-            }
-
+            let insight = Array.isArray(dailyInsights) ? dailyInsights.find(i => i.instrumentId === instrumentId) : null;
             if (insight && typeof insight.growth === 'number') {
-                // User PnL for today isn't explicitly stored, but Total PnL is.
-                // We use NetProfit as a proxy for "Performance" state.
-                // A Better proxy: Is their NetProfit > The Asset's Weekly Growth?
-                // This is a rough heuristic given schema limitations.
-                
-                // If the user is long and PnL > 0, and Growth is negative, that's high alpha (Bucking the trend).
-                // Simplified: Just returning the difference.
-                const diff = pos.NetProfit - insight.growth;
-                totalAlpha += diff;
+                totalAlpha += (pos.NetProfit - insight.growth);
                 count++;
             }
         }
@@ -198,90 +413,35 @@ class AdaptiveAnalytics {
     }
 }
 
+// Legacy Wrapper for backward compatibility with older calculations
 class UserClassifier {
     static classify(context) {
-        const { user, math, prices } = context;
-        const history = user.history.today?.PublicHistoryPositions || [];
-        const validHistory = history.filter(t => t.OpenDateTime);
-        validHistory.sort((a, b) => new Date(a.OpenDateTime) - new Date(b.OpenDateTime));
-        const portfolio = math.extract.getPositions(user.portfolio.today, user.type);
-        const summary = math.history.getSummary(user.history.today);
-        if (!summary) return { intelligence: { label: SCHEMAS.LABELS.NEUTRAL, score: 0 }, style: { primary: SCHEMAS.STYLES.INVESTOR } };
-
-        let entryScores = [];
-        const recentTrades = validHistory.slice(-20); 
-        for (const t of recentTrades) {
-            const ticker = context.mappings.instrumentToTicker[t.InstrumentID];
-            const priceData = math.priceExtractor.getHistory(prices, ticker);
-            if (priceData && priceData.length > 0) { entryScores.push(ExecutionAnalytics.calculateEfficiency(t.OpenRate, priceData, t.OpenDateTime, 'Buy')); }
-        }
-        const avgEntryEff = math.compute.average(entryScores) || 0.5;
-        const dispositionSkew = Psychometrics.computeDispositionSkew(validHistory, portfolio);
-        const revengeScore = Psychometrics.detectRevengeTrading(validHistory);
-        const adaptationScore = AdaptiveAnalytics.analyzeDrawdownAdaptation(validHistory);
-        
-        // New Cognitive Bias Checks
-        const anchoring = CognitiveBiases.calculateAnchoringScore(portfolio);
-        const dispositionTime = CognitiveBiases.calculateDispositionEffect(validHistory);
-
-        const riskAdjustedReturn = summary.avgLossPct === 0 ? 10 : (summary.avgProfitPct / Math.abs(summary.avgLossPct));
-        let smartScore = 50; 
-        if (riskAdjustedReturn > 1.5) smartScore += 10;
-        if (riskAdjustedReturn > 3.0) smartScore += 10;
-        if (summary.winRatio > 60) smartScore += 10;
-        if (avgEntryEff > 0.7) smartScore += 10; 
-        if (avgEntryEff < 0.3) smartScore -= 5;  
-        if (dispositionSkew > 15) smartScore -= 20; else if (dispositionSkew < 5) smartScore += 10; 
-        if (revengeScore > 0.3) smartScore -= 25; 
-        if (adaptationScore > 0.5) smartScore += 5; if (adaptationScore < -0.5) smartScore -= 10; 
+        // Delegate to the new robust Hybrid Scorer
+        const result = SmartMoneyScorer.scoreHybrid(context);
         
-        // Penalty for biases
-        if (anchoring > 0.3) smartScore -= 10;
-        if (dispositionTime > 1.5) smartScore -= 10;
-
-        let label = SCHEMAS.LABELS.NEUTRAL;
-        if (smartScore >= 80) label = SCHEMAS.LABELS.ELITE;
-        else if (smartScore >= 65) label = SCHEMAS.LABELS.SMART;
-        else if (smartScore <= 30) label = SCHEMAS.LABELS.GAMBLER;
-        else if (smartScore <= 45) label = SCHEMAS.LABELS.DUMB;
-
-        const styleProfile = this.classifyStyle(validHistory, portfolio);
+        // Map new result structure to legacy structure expected by V1 calcs
         return {
-            intelligence: { label: label, score: Math.max(0, Math.min(100, smartScore)), isSmart: smartScore >= 65 },
-            style: styleProfile,
+            intelligence: { 
+                label: result.label, 
+                score: result.totalScore, 
+                isSmart: result.totalScore >= 65 
+            },
+            style: { primary: SCHEMAS.STYLES.INVESTOR }, // Placeholder
             metrics: {
-                entryEfficiency: avgEntryEff,
-                dispositionSkew: dispositionSkew,
-                revengeTendency: revengeScore,
-                riskRewardRatio: riskAdjustedReturn,
-                drawdownAdaptation: adaptationScore,
-                biasAnchoring: anchoring,
-                biasDispositionTime: dispositionTime
+                profitFactor: result.components.history?.metrics?.profitFactor || 0,
+                allocEfficiency: result.components.portfolio?.metrics?.allocEfficiency || 0
             }
         };
     }
-
-    static classifyStyle(history, portfolio) {
-        let totalMinutes = 0; let validTrades = 0;
-        history.forEach(t => { if (t.OpenDateTime && t.CloseDateTime) { const open = new Date(t.OpenDateTime); const close = new Date(t.CloseDateTime); totalMinutes += (close - open) / 60000; validTrades++; } });
-        const avgHoldTime = validTrades > 0 ? totalMinutes / validTrades : 0;
-        let baseStyle = SCHEMAS.STYLES.INVESTOR;
-        if (validTrades > 0) { if (avgHoldTime < 60) baseStyle = SCHEMAS.STYLES.SCALPER; else if (avgHoldTime < 60 * 24) baseStyle = SCHEMAS.STYLES.DAY_TRADER; else if (avgHoldTime < 60 * 24 * 7) baseStyle = SCHEMAS.STYLES.SWING_TRADER; }
-        const subStyles = new Set();
-        const assets = [...history, ...portfolio]; let leverageCount = 0;
-        assets.forEach(p => { if ((p.Leverage || 1) > 1) leverageCount++; });
-        const tradeCount = assets.length || 1;
-        if ((leverageCount / tradeCount) > 0.3) subStyles.add("Speculative"); if ((leverageCount / tradeCount) > 0.8) subStyles.add("High-Leverage");
-        return { primary: baseStyle, tags: Array.from(subStyles), avgHoldTimeMinutes: avgHoldTime };
-    }
 }
 
 module.exports = { 
     SCHEMAS, 
     UserClassifier,
+    SmartMoneyScorer, // <-- Exporting the new engine
     ExecutionAnalytics,
     Psychometrics,
     AdaptiveAnalytics,
-    CognitiveBiases, // New
-    SkillAttribution // New
+    CognitiveBiases,
+    SkillAttribution
 };

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

@@ -42,18 +42,10 @@ async function commitBatchInChunks(config, deps, writes, operationName) {
     for (const write of writes) {
         let docSize = 100;
         try { if (write.data) docSize = JSON.stringify(write.data).length; } catch (e) { }
-
-        if (docSize > 900 * 1024) {
-            logger.log('WARN', `[${operationName}] Large document detected (~${(docSize / 1024).toFixed(2)} KB).`);
-        }
-
-        if ((currentOpsCount + 1 > MAX_BATCH_OPS) || (currentBytesEst + docSize > MAX_BATCH_BYTES)) {
-            await commitAndReset();
-        }
-
+        if (docSize > 900 * 1024) { logger.log('WARN', `[${operationName}] Large document detected (~${(docSize / 1024).toFixed(2)} KB).`); }
+        if ((currentOpsCount + 1 > MAX_BATCH_OPS) || (currentBytesEst + docSize > MAX_BATCH_BYTES)) { await commitAndReset(); }
         const options = write.options || { merge: true };
         currentBatch.set(write.ref, write.data, options);
-        
         currentOpsCount++;
         currentBytesEst += docSize;
     }

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

@@ -2,14 +2,15 @@
  * @fileoverview Handles saving computation results with observability and Smart Cleanup.
  * UPDATED: Returns detailed failure reports AND metrics for the Audit Logger.
  * UPDATED: Stops retrying on non-transient errors.
+ * UPDATED: Supports Multi-Date Fan-Out (Time Machine Mode) with CONCURRENCY THROTTLING.
  */
 const { commitBatchInChunks }              = require('./FirestoreUtils');
 const { updateComputationStatus }          = require('./StatusRepository');
 const { batchStoreSchemas }                = require('../utils/schema_capture');
 const { generateProcessId, PROCESS_TYPES } = require('../logger/logger');
-
 const { HeuristicValidator }               = require('./ResultsValidator');
 const validationOverrides                  = require('../config/validation_overrides'); 
+const pLimit                               = require('p-limit'); // <--- CRITICAL IMPORT
 
 const NON_RETRYABLE_ERRORS = [
     'INVALID_ARGUMENT',      // Schema/Type mismatch
@@ -26,7 +27,8 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     const { logger, db } = deps;
     const pid            = generateProcessId(PROCESS_TYPES.STORAGE, passName, dStr);
     
-    const passNum = passName.replace(/[^0-9]/g, '');
+    // SAFETY LIMIT: Only allow 10 concurrent daily writes to prevent network saturation during Fan-Out
+    const fanOutLimit = pLimit(10); 
 
     for (const name in stateObj) {
         const calc = stateObj[name];
@@ -44,144 +46,88 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
             const healthCheck = HeuristicValidator.analyze(calc.manifest.name, result, overrides);
 
             if (!healthCheck.valid) {
-                // If validation failed, we consider it an anomaly but we BLOCK the write (throw error)
                 runMetrics.validation.isValid = false;
                 runMetrics.validation.anomalies.push(healthCheck.reason);
                 throw { message: healthCheck.reason, stage: 'QUALITY_CIRCUIT_BREAKER' };
             }
             
-            // Check for minor anomalies (validation warnings that didn't fail) - optional implementation
-            // For now, we assume if valid=true, anomalies are empty unless we add warning logic later.
-
             const isEmpty = !result || (typeof result === 'object' && Object.keys(result).length === 0) || (typeof result === 'number' && result === 0);
             if (isEmpty) { 
-                // Log empty success
                 if (calc.manifest.hash) { 
-                    successUpdates[name] = {  
-                        hash: false,  
-                        category: calc.manifest.category,
-                        metrics: runMetrics // Return empty metrics
-                    }; 
+                    successUpdates[name] = { hash: false, category: calc.manifest.category, metrics: runMetrics }; 
                 } 
                 continue; 
             }
             
-            // Calculate Key Count rough estimate
             if (typeof result === 'object') runMetrics.storage.keys = Object.keys(result).length;
 
-            const mainDocRef = db.collection(config.resultsCollection)
-                .doc(dStr)
-                .collection(config.resultsSubcollection)
-                .doc(calc.manifest.category)
-                .collection(config.computationsSubcollection)
-                .doc(name);
-
-            // --- REACTIVE SELF-HEALING LOOP ---
-            let committed = false;
-            // Strategy: 1=Normal, 2=Safe (Halved), 3=Aggressive (Quartered + Key Limit)
-            const strategies = [
-                { bytes: 900 * 1024, keys: null },      // Attempt 1: Standard
-                { bytes: 450 * 1024, keys: 10000 },     // Attempt 2: High Index usage
-                { bytes: 200 * 1024, keys: 2000 }       // Attempt 3: Extreme fragmentation
-            ];
-
-            let lastError = null;
-
-            for (let attempt = 0; attempt < strategies.length; attempt++) {
-                if (committed) break;
+            // --- MULTI-DATE FAN-OUT DETECTION ---
+            // If the result keys are ALL date strings (YYYY-MM-DD), we split the writes.
+            const resultKeys = Object.keys(result || {});
+            const isMultiDate = resultKeys.length > 0 && resultKeys.every(k => /^\d{4}-\d{2}-\d{2}$/.test(k));
+
+            if (isMultiDate) {
+                logger.log('INFO', `[ResultCommitter] 🕰️ Multi-Date Output detected for ${name} (${resultKeys.length} days). Throttled Fan-Out...`);
                 
-                const constraints = strategies[attempt];
+                // Group updates by DATE. result is { "2024-01-01": { user1: ... }, "2024-01-02": { user1: ... } }
+                // We execute a fan-out commit for each date using p-limit.
                 
-                try {
-                    // 1. Prepare Shards with current constraints
-                    // This function now needs to help us determine sharding info
-                    const updates = await prepareAutoShardedWrites(result, mainDocRef, logger, constraints.bytes, constraints.keys);
-                    
-                    // METRICS CALCULATION
-                    const pointer = updates.find(u => u.data._completed === true);
-                    const isSharded = pointer && pointer.data._sharded === true;
-                    const shardCount = isSharded ? (pointer.data._shardCount || 1) : 1;
-                    const totalSize = updates.reduce((acc, u) => acc + (u.data ? JSON.stringify(u.data).length : 0), 0);
-                    
-                    runMetrics.storage.sizeBytes = totalSize;
-                    runMetrics.storage.isSharded = isSharded;
-                    runMetrics.storage.shardCount = shardCount;
-
-                    // 2. Audit Ledger (Only add to the first update batch)
-                    if (passNum && calc.manifest) {
-                        const ledgerRef = db.collection(`computation_audit_ledger/${dStr}/passes/${passNum}/tasks`).doc(name);
-                        updates.push({
-                            ref: ledgerRef,
-                            data: {
-                                status: 'COMPLETED',
-                                completedAt: new Date(),
-                                actualHash: calc.manifest.hash,
-                                _verified: true,
-                                _shardingStrategy: attempt + 1
-                            },
-                            options: { merge: true }
-                        });
-                    }
-
-                    // 3. Attempt Commit
-                    await commitBatchInChunks(config, deps, updates, `${name} Results (Att ${attempt+1})`);
-                    
-                    // Log Success
-                    if (logger && logger.logStorage) { 
-                        logger.logStorage(pid, name, dStr, mainDocRef.path, totalSize, isSharded); 
-                    }
-                    
-                    committed = true; // Exit loop
-
-                } catch (commitErr) {
-                    lastError = commitErr;
-                    const msg = commitErr.message || '';
-                    
-                    const isNonRetryable = NON_RETRYABLE_ERRORS.includes(commitErr.code);
-                    if (isNonRetryable) {
-                        logger.log('ERROR', `[SelfHealing] ${name} encountered FATAL error (Attempt ${attempt + 1}): ${msg}. Aborting.`);
-                        throw commitErr; 
-                    }
-
-                    const isSizeError  = msg.includes('Transaction too big')    || msg.includes('payload is too large');
-                    const isIndexError = msg.includes('too many index entries') || msg.includes('INVALID_ARGUMENT'); 
-
-                    if (isSizeError || isIndexError) {
-                        logger.log('WARN', `[SelfHealing] ${name} failed write attempt ${attempt + 1}. Retrying with tighter constraints...`, { error: msg });
-                        continue; // Try next strategy
-                    } else {
-                        logger.log('WARN', `[SelfHealing] ${name} unknown error (Attempt ${attempt + 1}). Retrying...`, { error: msg });
-                    }
+                const datePromises = resultKeys.map((historicalDate) => fanOutLimit(async () => {
+                    const dailyData = result[historicalDate];
+                    if (!dailyData || Object.keys(dailyData).length === 0) return;
+
+                    const historicalDocRef = db.collection(config.resultsCollection)
+                        .doc(historicalDate) // Use the HISTORICAL date, not dStr
+                        .collection(config.resultsSubcollection)
+                        .doc(calc.manifest.category)
+                        .collection(config.computationsSubcollection)
+                        .doc(name);
+
+                    // Re-use the existing sharding logic for this specific date payload
+                    await writeSingleResult(dailyData, historicalDocRef, name, historicalDate, logger, config, deps);
+                }));
+                
+                await Promise.all(datePromises);
+                
+                // Mark success for the Target Date (dStr) so the workflow continues
+                if (calc.manifest.hash) { 
+                    successUpdates[name] = {  
+                        hash: calc.manifest.hash, 
+                        category: calc.manifest.category, 
+                        metrics: runMetrics // Pass metrics up
+                    }; 
                 }
-            }
 
-            if (!committed) {
-                throw { 
-                    message: `Exhausted sharding strategies. Last error: ${lastError?.message}`, 
-                    stack: lastError?.stack, 
-                    stage: 'SHARDING_LIMIT_EXCEEDED' 
-                };
-            }
-            // ----------------------------------
-
-            // Mark Success & Pass Metrics
-            if (calc.manifest.hash) { 
-                successUpdates[name] = {  
-                    hash: calc.manifest.hash, 
-                    category: calc.manifest.category,
-                    metrics: runMetrics // Pass metrics up
-                }; 
+            } else {
+                // --- STANDARD MODE (Single Date) ---
+                const mainDocRef = db.collection(config.resultsCollection)
+                    .doc(dStr)
+                    .collection(config.resultsSubcollection)
+                    .doc(calc.manifest.category)
+                    .collection(config.computationsSubcollection)
+                    .doc(name);
+
+                // Use the encapsulated write function
+                const writeStats = await writeSingleResult(result, mainDocRef, name, dStr, logger, config, deps);
+                
+                runMetrics.storage.sizeBytes = writeStats.totalSize;
+                runMetrics.storage.isSharded = writeStats.isSharded;
+                runMetrics.storage.shardCount = writeStats.shardCount;
+
+                // Mark Success & Pass Metrics
+                if (calc.manifest.hash) { 
+                    successUpdates[name] = {  
+                        hash: calc.manifest.hash, 
+                        category: calc.manifest.category,
+                        metrics: runMetrics 
+                    }; 
+                }
             }
 
             // Capture Schema
             if (calc.manifest.class.getSchema) {
                 const { class: _cls, ...safeMetadata } = calc.manifest;
-                schemas.push({ 
-                    name, 
-                    category: calc.manifest.category, 
-                    schema: calc.manifest.class.getSchema(), 
-                    metadata: safeMetadata 
-                });
+                schemas.push({ name, category: calc.manifest.category, schema: calc.manifest.class.getSchema(), metadata: safeMetadata });
             }
 
             // Cleanup Migration
@@ -210,6 +156,80 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     return { successUpdates, failureReport };
 }
 
+/**
+ * Encapsulated write logic for reuse in Fan-Out.
+ * Handles sharding strategy and retries.
+ */
+async function writeSingleResult(result, docRef, name, dateContext, logger, config, deps) {
+    // Strategy: 1=Normal, 2=Safe (Halved), 3=Aggressive (Quartered + Key Limit)
+    const strategies = [
+        { bytes: 900 * 1024, keys: null },      // Attempt 1: Standard
+        { bytes: 450 * 1024, keys: 10000 },     // Attempt 2: High Index usage
+        { bytes: 200 * 1024, keys: 2000 }       // Attempt 3: Extreme fragmentation
+    ];
+
+    let committed = false;
+    let lastError = null;
+    let finalStats = { totalSize: 0, isSharded: false, shardCount: 1 };
+
+    for (let attempt = 0; attempt < strategies.length; attempt++) {
+        if (committed) break;
+        
+        const constraints = strategies[attempt];
+        
+        try {
+            // 1. Prepare Shards with current constraints
+            const updates = await prepareAutoShardedWrites(result, docRef, logger, constraints.bytes, constraints.keys);
+            
+            // Stats
+            const pointer = updates.find(u => u.data._completed === true);
+            finalStats.isSharded = pointer && pointer.data._sharded === true;
+            finalStats.shardCount = finalStats.isSharded ? (pointer.data._shardCount || 1) : 1;
+            finalStats.totalSize = updates.reduce((acc, u) => acc + (u.data ? JSON.stringify(u.data).length : 0), 0);
+
+            // 2. Attempt Commit
+            await commitBatchInChunks(config, deps, updates, `${name}::${dateContext} (Att ${attempt+1})`);
+            
+            // Log Success
+            if (logger && logger.logStorage) { 
+                logger.logStorage(null, name, dateContext, docRef.path, finalStats.totalSize, finalStats.isSharded); 
+            }
+            
+            committed = true; // Exit loop
+
+        } catch (commitErr) {
+            lastError = commitErr;
+            const msg = commitErr.message || '';
+            
+            const isNonRetryable = NON_RETRYABLE_ERRORS.includes(commitErr.code);
+            if (isNonRetryable) {
+                logger.log('ERROR', `[SelfHealing] ${name} encountered FATAL error (Attempt ${attempt + 1}): ${msg}. Aborting.`);
+                throw commitErr; 
+            }
+
+            const isSizeError  = msg.includes('Transaction too big')    || msg.includes('payload is too large');
+            const isIndexError = msg.includes('too many index entries') || msg.includes('INVALID_ARGUMENT'); 
+
+            if (isSizeError || isIndexError) {
+                logger.log('WARN', `[SelfHealing] ${name} on ${dateContext} failed write attempt ${attempt + 1}. Retrying with tighter constraints...`, { error: msg });
+                continue; // Try next strategy
+            } else {
+                logger.log('WARN', `[SelfHealing] ${name} on ${dateContext} unknown error (Attempt ${attempt + 1}). Retrying...`, { error: msg });
+            }
+        }
+    }
+
+    if (!committed) {
+        throw { 
+            message: `Exhausted sharding strategies for ${name} on ${dateContext}. Last error: ${lastError?.message}`, 
+            stack: lastError?.stack, 
+            stage: 'SHARDING_LIMIT_EXCEEDED' 
+        };
+    }
+
+    return finalStats;
+}
+
 /**
  * Deletes result documents from a previous category location.
  */

package/functions/computation-system/tools/BuildReporter.js

@@ -38,9 +38,6 @@ async function ensureBuildReport(config, dependencies, manifest) {
         
         // Run generation. This function handles writing the 'latest' document with FULL data.
         await generateBuildReport(config, dependencies, manifest, 90, buildId);
-        
-        // [FIX] REMOVED: The redundant write that was overwriting the full report with just metadata.
-        // The generateBuildReport function now serves as the single source of truth for writing 'latest'.
 
     } catch (e) {
         logger.log('ERROR', `[BuildReporter] Auto-run check failed: ${e.message}`);
@@ -57,23 +54,23 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
     logger.log('INFO', `[BuildReporter] Generating Build Report: ${buildId} (Scope: ${daysBack} days)...`);
 
     // 1. Determine Date Range
-    const today = new Date();
+    const today     = new Date();
     const startDate = new Date();
     startDate.setDate(today.getDate() - daysBack);
     
     const datesToCheck = getExpectedDateStrings(startDate, today);
-    const manifestMap = new Map(manifest.map(c => [normalizeName(c.name), c]));
+    const manifestMap  = new Map(manifest.map(c => [normalizeName(c.name), c]));
     
     const reportData = {
         buildId,
-        packageVersion: packageVersion, // [FIX] Renamed 'version' to 'packageVersion' for consistency with ensureBuildReport check
+        packageVersion: packageVersion, 
         generatedAt: new Date().toISOString(),
         summary: {},
         dates: {}
     };
 
     let totalReRuns = 0;
-    let totalNew = 0;
+    let totalNew    = 0;
 
     // 2. PARALLEL PROCESSING
     const limit = pLimit(20);
@@ -106,17 +103,13 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
             // If we fetched prevStatus, it's at index 2
             const prevDailyStatus = (prevDateStr && results[2]) ? results[2] : (prevDateStr ? {} : null);
 
-            const rootDataStatus = availability ? availability.status : {
-                hasPortfolio: false, hasHistory: false, hasSocial: false, hasInsights: false, hasPrices: false
-            };
+            const rootDataStatus = availability ? availability.status : { hasPortfolio: false, hasHistory: false, hasSocial: false, hasInsights: false, hasPrices: false };
 
             // D. Run Logic Analysis
             const analysis = analyzeDateExecution(dateStr, manifest, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus);
 
             // E. Format Findings
-            const dateSummary = {
-                willRun: [], willReRun: [], blocked: [], impossible: [] 
-            };
+            const dateSummary = { willRun: [], willReRun: [], blocked: [], impossible: [] };
 
             analysis.runnable.forEach   (item => dateSummary.willRun.push    ({ name: item.name, reason: "New / No Previous Record" }));
             analysis.reRuns.forEach     (item => dateSummary.willReRun.push  ({ name: item.name, reason: item.previousCategory ? "Migration" : "Hash Mismatch" }));
@@ -156,11 +149,7 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
     await reportRef.set(reportData);
 
     // 5. Update 'latest' pointer
-    // This now writes the FULL reportData, making 'latest' a cache of the actual report.
-    await db.collection('computation_build_records').doc('latest').set({
-        ...reportData,
-        note: "Latest build report pointer."
-    });
+    await db.collection('computation_build_records').doc('latest').set({ ...reportData, note: "Latest build report pointer." });
 
     logger.log('SUCCESS', `[BuildReporter] Report ${buildId} saved. Re-runs: ${totalReRuns}, New: ${totalNew}.`);
     

package/functions/root-data-indexer/index.js

@@ -5,14 +5,12 @@
  */
 
 const { FieldValue } = require('@google-cloud/firestore');
-const pLimit = require('p-limit');
+const pLimit         = require('p-limit');
 
 // Hardcoded verification blocks as per logic requirements
 const CANARY_BLOCK_ID = '19M';
-const CANARY_PART_ID = 'part_0';
-
-// [FIX] Hardcoded to 'shard_0' based on your confirmed data path (/asset_prices/shard_0)
-const PRICE_SHARD_ID = 'shard_0'; 
+const CANARY_PART_ID  = 'part_0';
+const PRICE_SHARD_ID  = 'shard_0'; 
 
 /**
  * Main pipe: pipe.maintenance.runRootDataIndexer
@@ -25,36 +23,21 @@ exports.runRootDataIndexer = async (config, dependencies) => {
         collections 
     } = config;
 
-    // [FIX] Hardcode the collection name to ignore any incorrect config values
     const PRICE_COLLECTION_NAME = 'asset_prices';
-
     logger.log('INFO', '[RootDataIndexer] Starting Root Data Availability Scan...');
-
-    // 1. Pre-fetch Price Data Availability (Optimization)
     const priceAvailabilitySet = new Set();
-    
-    // --- DEBUGGING START ---
     logger.log('INFO', `[RootDataIndexer] DEBUG: Attempting to fetch price shard. Collection: "${PRICE_COLLECTION_NAME}", Doc ID: "${PRICE_SHARD_ID}"`);
-    // --- DEBUGGING END ---
-
     try {
-        // [FIX] Use the hardcoded collection name
         const priceShardRef = db.collection(PRICE_COLLECTION_NAME).doc(PRICE_SHARD_ID);
         const priceSnap = await priceShardRef.get();
-        
         if (priceSnap.exists) {
-            const data = priceSnap.data();
+            const data        = priceSnap.data();
             const instruments = Object.values(data);
-            
-            // --- DEBUGGING START ---
             logger.log('INFO', `[RootDataIndexer] DEBUG: Shard document found. Contains ${instruments.length} instrument entries.`);
-            
             if (instruments.length > 0) {
-                // Log the structure of the first instrument found to verify schema match
                 const sampleKey = Object.keys(data)[0];
                 const sampleVal = data[sampleKey];
                 logger.log('INFO', `[RootDataIndexer] DEBUG: Sample Instrument Data (ID: ${sampleKey}):`, sampleVal);
-                
                 if (!sampleVal.prices) {
                     logger.log('WARN', `[RootDataIndexer] DEBUG: ⚠️ Sample instrument is MISSING the 'prices' field! Available fields: ${Object.keys(sampleVal).join(', ')}`);
                 } else {
@@ -64,23 +47,10 @@ exports.runRootDataIndexer = async (config, dependencies) => {
             } else {
                 logger.log('WARN', '[RootDataIndexer] DEBUG: Shard document exists but appears empty (0 instruments found).');
             }
-            // --- DEBUGGING END ---
-
-            // Iterate over all instruments in this shard to find any available dates
-            Object.values(data).forEach(instrument => {
-                if (instrument.prices) {
-                    Object.keys(instrument.prices).forEach(dateKey => {
-                        // Validate format YYYY-MM-DD
-                        if (/^\d{4}-\d{2}-\d{2}$/.test(dateKey)) {
-                            priceAvailabilitySet.add(dateKey);
-                        }
-                    });
-                }
-            });
+
+            Object.values(data).forEach(instrument => { if (instrument.prices) { Object.keys(instrument.prices).forEach(dateKey => { if (/^\d{4}-\d{2}-\d{2}$/.test(dateKey)) { priceAvailabilitySet.add(dateKey); } }); } });
         } else {
-            // --- DEBUGGING START ---
             logger.log('ERROR', `[RootDataIndexer] DEBUG: 🛑 FATAL: Document "${PRICE_SHARD_ID}" does NOT exist in collection "${PRICE_COLLECTION_NAME}". Price availability will be false for all dates.`);
-            // --- DEBUGGING END ---
         }
         logger.log('INFO', `[RootDataIndexer] Loaded price availability map. Found prices for ${priceAvailabilitySet.size} unique dates.`);
     } catch (e) {
@@ -89,18 +59,16 @@ exports.runRootDataIndexer = async (config, dependencies) => {
 
     // 2. Determine Date Range (Earliest -> Tomorrow)
     const start = new Date(earliestDate || '2023-01-01');
-    const end = new Date();
+    const end   = new Date();
     end.setDate(end.getDate() + 1); // Look ahead 1 day
 
     const datesToScan = [];
-    for (let d = new Date(start); d <= end; d.setDate(d.getDate() + 1)) {
-        datesToScan.push(d.toISOString().slice(0, 10));
-    }
+    for (let d = new Date(start); d <= end; d.setDate(d.getDate() + 1)) { datesToScan.push(d.toISOString().slice(0, 10)); }
 
     logger.log('INFO', `[RootDataIndexer] Scanning ${datesToScan.length} dates from ${datesToScan[0]} to ${datesToScan[datesToScan.length-1]}`);
 
     // 3. Scan in Parallel
-    const limit = pLimit(20); // Concurrent date checks
+    const limit      = pLimit(20); // Concurrent date checks
     let updatesCount = 0;
 
     const promises = datesToScan.map(dateStr => limit(async () => {
@@ -111,17 +79,17 @@ exports.runRootDataIndexer = async (config, dependencies) => {
                 
                 // Defaults
                 hasPortfolio: false,
-                hasHistory: false,
-                hasSocial: false,
-                hasInsights: false,
-                hasPrices: false,
+                hasHistory:   false,
+                hasSocial:    false,
+                hasInsights:  false,
+                hasPrices:    false,
                 
                 // Detailed breakdown
                 details: {
-                    normalPortfolio: false,
+                    normalPortfolio:     false,
                     speculatorPortfolio: false,
-                    normalHistory: false,
-                    speculatorHistory: false
+                    normalHistory:       false,
+                    speculatorHistory:   false
                 }
             };
 
@@ -165,32 +133,35 @@ exports.runRootDataIndexer = async (config, dependencies) => {
 
             // --- EXECUTE CHECKS ---
             const [
-                normPortSnap, specPortSnap,
-                normHistSnap, specHistSnap,
-                insightsSnap, socialQuerySnap
+                normPortSnap, 
+                specPortSnap,
+                normHistSnap, 
+                specHistSnap,
+                insightsSnap, 
+                socialQuerySnap
             ] = await Promise.all([
-                normPortRef.get(), specPortRef.get(),
-                normHistRef.get(), specHistRef.get(),
+                normPortRef.get(), 
+                specPortRef.get(),
+                normHistRef.get(), 
+                specHistRef.get(),
                 insightsRef.get(), 
                 socialPostsRef.limit(1).get()
             ]);
 
             // Evaluate Findings
-            availability.details.normalPortfolio = normPortSnap.exists;
+            availability.details.normalPortfolio     = normPortSnap.exists;
             availability.details.speculatorPortfolio = specPortSnap.exists;
-            availability.hasPortfolio = normPortSnap.exists || specPortSnap.exists;
+            availability.hasPortfolio                = normPortSnap.exists || specPortSnap.exists;
 
-            availability.details.normalHistory = normHistSnap.exists;
-            availability.details.speculatorHistory = specHistSnap.exists;
-            availability.hasHistory = normHistSnap.exists || specHistSnap.exists;
+            availability.details.normalHistory       = normHistSnap.exists;
+            availability.details.speculatorHistory   = specHistSnap.exists;
+            availability.hasHistory                  = normHistSnap.exists || specHistSnap.exists;
 
-            availability.hasInsights = insightsSnap.exists;
-            availability.hasSocial = !socialQuerySnap.empty;
+            availability.hasInsights                 = insightsSnap.exists;
+            availability.hasSocial                   = !socialQuerySnap.empty;
 
-            // G. Prices (From pre-loaded set)
-            availability.hasPrices = priceAvailabilitySet.has(dateStr);
+            availability.hasPrices                   = priceAvailabilitySet.has(dateStr);
 
-            // Write to Index
             await db.collection(availabilityCollection).doc(dateStr).set(availability);
             updatesCount++;
 

package/package.json

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