aiden-shared-calculations-unified 1.0.106 → 1.0.108

package/calculations/core/asset-pnl-status.js

@@ -4,7 +4,9 @@
  */
 class AssetPnlStatus {
     constructor() {
-        this.userStats = new Map();
+        // [FIX 1] Use 'this.results' directly. 
+        // The StandardExecutor monitors this property to perform Batch Flushing.
+        this.results = {}; 
     }
 
     static getMetadata() {
@@ -22,29 +24,26 @@ class AssetPnlStatus {
     static getSchema() {
         return {
             "type": "object",
-            "properties": {
-                "by_user": {
+            // [FIX 2] Flattened Schema (removed "by_user" wrapper)
+            "patternProperties": {
+                "^[0-9]+$": {
                     "type": "object",
-                    "patternProperties": {
-                        "^[0-9]+$": {
-                            "type": "object",
-                            "properties": {
-                                "winners": { "type": "array", "items": { "type": "string" } },
-                                "losers": { "type": "array", "items": { "type": "string" } }
-                            },
-                            "required": ["winners", "losers"]
-                        }
-                    }
+                    "properties": {
+                        "winners": { "type": "array", "items": { "type": "string" } },
+                        "losers": { "type": "array", "items": { "type": "string" } }
+                    },
+                    "required": ["winners", "losers"]
                 }
             }
         };
     }
     
     _initUser(userId) {
-        if (!this.userStats.has(userId)) {
-            this.userStats.set(userId, { winners: new Set(), losers: new Set() });
+        // [FIX 3] Direct access to this.results
+        if (!this.results[userId]) {
+            this.results[userId] = { winners: [], losers: [] };
         }
-        return this.userStats.get(userId);
+        return this.results[userId];
     }
 
     process(context) {
@@ -55,7 +54,9 @@ class AssetPnlStatus {
         const positions = extract.getPositions(user.portfolio.today, user.type);
         if (!positions || positions.length === 0) return;
 
-        let stats = null;
+        // Use temporary sets for processing to keep logic clean, then convert to array for storage
+        const winners = new Set();
+        const losers = new Set();
 
         for (const pos of positions) {
             const instId = extract.getInstrumentId(pos);
@@ -68,35 +69,26 @@ class AssetPnlStatus {
             const sector = mappings.instrumentToSector[instId];
             const isWinner = pnl > 0;
 
-            if (ticker || sector) {
-                if (!stats) stats = this._initUser(userId);
-                if (ticker) {
-                    if (isWinner) stats.winners.add(ticker); else stats.losers.add(ticker);
-                }
-                if (sector) {
-                    if (isWinner) stats.winners.add(sector); else stats.losers.add(sector);
-                }
-            }
+            if (ticker) { isWinner ? winners.add(ticker) : losers.add(ticker); }
+            if (sector) { isWinner ? winners.add(sector) : losers.add(sector); }
         }
-    }
 
-    async getResult() {
-        const byUser = {};
-
-        for (const [userId, stats] of this.userStats) {
-            if (stats.winners.size > 0 || stats.losers.size > 0) {
-                byUser[userId] = {
-                    winners: Array.from(stats.winners),
-                    losers: Array.from(stats.losers)
-                };
-            }
+        if (winners.size > 0 || losers.size > 0) {
+            this.results[userId] = {
+                winners: Array.from(winners),
+                losers: Array.from(losers)
+            };
         }
+    }
 
-        // Return flat object. Orchestrator handles 1MB limit.
-        return { by_user: byUser };
+    async getResult() {
+        // [FIX 4] Return 'this.results' directly.
+        // This is a FLAT object { "user1": {...}, "user2": {...} }
+        // The ResultCommitter can now shard this into 50-user chunks if needed.
+        return this.results;
     }
     
-    reset() { this.userStats.clear(); }
+    // [FIX 5] No manual reset needed, StandardExecutor does it.
 }
 
 module.exports = AssetPnlStatus;

package/calculations/core/crowd-cost-basis.js

@@ -7,7 +7,7 @@ class CrowdCostBasis {
             type: 'meta',
             category: 'History Reconstruction',
             userType: 'n/a',
-            isHistorical: false,
+            isHistorical: false, // Self-contained history generation
             rootDataDependencies: ['price']
         };
     }
@@ -15,7 +15,7 @@ class CrowdCostBasis {
     static getDependencies() { return ['user-history-reconstructor']; }
 
     static getSchema() {
-        const schema = {
+        const dailySchema = {
             "type": "object",
             "properties": {
                 "avgEntry": { "type": "number", "description": "Global average entry price for all holders." },
@@ -25,20 +25,48 @@ class CrowdCostBasis {
             },
             "required": ["avgEntry", "holderCount", "profitabilityPct", "state"]
         };
-        // The result is a Map of Ticker -> Schema
-        return { "type": "object", "patternProperties": { "^.*$": schema } };
+        
+        // Output: Date -> Ticker -> Schema
+        return {
+            "type": "object",
+            "patternProperties": {
+                "^\\d{4}-\\d{2}-\\d{2}$": {
+                    "type": "object",
+                    "patternProperties": { "^.*$": dailySchema }
+                }
+            }
+        };
     }
 
     async process(context) {
         const { computed, prices, math } = context;
-        const userReconstructions = computed['user-history-reconstructor'];
-        if (!userReconstructions) return;
+        const historyData = computed['user-history-reconstructor'];
+        if (!historyData) return;
+
+        // Detect Structure: Date-First (Time Machine) or User-First (Legacy)
+        // With the new StandardExecutor refactor, it should be Date -> User -> Ticker
+        const keys = Object.keys(historyData);
+        const isDateKeyed = keys.length > 0 && /^\d{4}-\d{2}-\d{2}$/.test(keys[0]);
+
+        if (isDateKeyed) {
+            // Process All Dates in the Map
+            for (const dateStr of keys) {
+                this.results[dateStr] = this.processSingleDate(dateStr, historyData[dateStr], prices, math);
+            }
+        } else {
+            // Fallback for single-date/legacy context
+            const dateStr = context.date.today;
+            this.results[dateStr] = this.processSingleDate(dateStr, historyData, prices, math);
+        }
+    }
 
+    processSingleDate(dateStr, usersMap, prices, math) {
         const aggregator = {};
+        const dailyResults = {};
 
-        // 1. Iterate Users
-        for (const userId in userReconstructions) {
-            const userPortfolio = userReconstructions[userId];
+        // 1. Iterate Users for this Date
+        for (const userId in usersMap) {
+            const userPortfolio = usersMap[userId];
 
             for (const ticker in userPortfolio) {
                 const stats = userPortfolio[ticker];
@@ -54,24 +82,29 @@ class CrowdCostBasis {
         // 2. Compute Global Cost Basis
         for (const ticker in aggregator) {
             const data = aggregator[ticker];
-            if (data.count < 5) continue; 
+            if (data.count < 3) continue; // Noise filter
 
             const globalAvgEntry = data.sumEntry / data.count;
 
-            // Get Price for Context Date
+            // Get Price for this specific date
+            // Note: prices.history might be sharded, assuming ContextFactory loaded relevant shards
             const priceHistory = math.priceExtractor.getHistory(prices, ticker);
-            const lastPriceObj = priceHistory[priceHistory.length - 1];
-            const currentPrice = lastPriceObj ? lastPriceObj.price : globalAvgEntry;
+            
+            // Find price closest to this date
+            // Optimization: In a real "Time Machine" run, priceExtractor should probably be a map lookup
+            const dayPriceObj = priceHistory.find(p => p.date === dateStr);
+            const currentPrice = dayPriceObj ? dayPriceObj.price : globalAvgEntry;
 
-            const diffPct = ((currentPrice - globalAvgEntry) / globalAvgEntry) * 100;
+            const diffPct = globalAvgEntry > 0 ? ((currentPrice - globalAvgEntry) / globalAvgEntry) * 100 : 0;
 
-            this.results[ticker] = {
+            dailyResults[ticker] = {
                 avgEntry: globalAvgEntry,
                 holderCount: data.count,
                 profitabilityPct: diffPct,
                 state: diffPct > 0 ? 'PROFIT_SUPPORT' : 'LOSS_RESISTANCE'
             };
         }
+        return dailyResults;
     }
 
     async getResult() { return this.results; }

package/calculations/core/leverage-divergence.js

@@ -7,81 +7,119 @@ class LeverageDivergence {
             type: 'meta',
             category: 'History Reconstruction',
             userType: 'n/a',
-            isHistorical: true, 
-            rootDataDependencies: []
+            isHistorical: false, // We handle history internally now
+            rootDataDependencies: ['price'] // Needed for Smart/Dumb PnL calc
         };
     }
 
     static getDependencies() { return ['user-history-reconstructor']; }
 
     static getSchema() {
-        const schema = {
+        const dailySchema = {
             "type": "object",
             "properties": {
-                "levHolders": { "type": "number", "description": "Count of holders with leverage > 1.1x." },
-                "spotHolders": { "type": "number", "description": "Count of holders with leverage <= 1.1x." },
-                "levDelta": { "type": "number", "description": "Change in leveraged holders vs yesterday." },
-                "spotDelta": { "type": "number", "description": "Change in spot holders vs yesterday." },
-                "signal": { "type": "string", "description": "Divergence signal: NEUTRAL, SMART_ACCUMULATION, SPECULATIVE_PUMP, SMART_EXIT." }
+                "smartAccumulation": { "type": "number", "description": "Buy volume from profitable users." },
+                "dumbAccumulation": { "type": "number", "description": "Buy volume from unprofitable/high-lev users." },
+                "netFlow": { "type": "number", "description": "Net buy/sell activity." },
+                "signal": { "type": "string", "description": "Divergence signal: NEUTRAL, SMART_ACCUMULATION, SPECULATIVE_PUMP, BROAD_EXIT." }
             },
-            "required": ["levHolders", "spotHolders", "levDelta", "spotDelta", "signal"]
+            "required": ["smartAccumulation", "dumbAccumulation", "netFlow", "signal"]
+        };
+        // Output: Date -> Ticker -> Schema
+        return {
+            "type": "object",
+            "patternProperties": {
+                "^\\d{4}-\\d{2}-\\d{2}$": {
+                    "type": "object",
+                    "patternProperties": { "^.*$": dailySchema }
+                }
+            }
         };
-        return { "type": "object", "patternProperties": { "^.*$": schema } };
     }
 
     async process(context) {
-        const { computed, previousComputed } = context;
-
-        const currentReconstruction = computed['user-history-reconstructor'];
-        const previousResult = previousComputed['leverage-divergence'];
+        const { computed, prices, math } = context;
+        const historyData = computed['user-history-reconstructor'];
+        if (!historyData) return;
+
+        const keys = Object.keys(historyData);
+        const isDateKeyed = keys.length > 0 && /^\d{4}-\d{2}-\d{2}$/.test(keys[0]);
+        const dateList = isDateKeyed ? keys.sort() : [context.date.today];
+
+        // Process sequentially to allow day-over-day comparison if needed (though we use raw flows here)
+        for (const dateStr of dateList) {
+            const usersMap = isDateKeyed ? historyData[dateStr] : historyData;
+            this.results[dateStr] = this.processSingleDate(dateStr, usersMap, prices, math);
+        }
+    }
 
-        const currentAgg = {};
+    processSingleDate(dateStr, usersMap, prices, math) {
+        const tickerAgg = {}; // Ticker -> { smartBuys, dumbBuys, sells }
 
-        // 1. Build Today's Aggregates
-        for (const userId in currentReconstruction) {
-            const userPortfolio = currentReconstruction[userId];
+        for (const userId in usersMap) {
+            const userPortfolio = usersMap[userId];
 
             for (const ticker in userPortfolio) {
                 const stats = userPortfolio[ticker];
+                
+                // We only care about Activity (Buys/Sells)
+                if (stats.didBuy === 0 && stats.didSell === 0) continue;
+
+                if (!tickerAgg[ticker]) tickerAgg[ticker] = { smartBuys: 0, dumbBuys: 0, sells: 0 };
+                
+                // 1. Classify User "Smartness" for this Ticker/Date
+                // Heuristic: Are they profitable on their holdings relative to TODAY's price?
+                const priceHistory = math.priceExtractor.getHistory(prices, ticker);
+                const dayPriceObj = priceHistory.find(p => p.date === dateStr);
+                const currentPrice = dayPriceObj ? dayPriceObj.price : stats.avgEntry;
+
+                let isSmart = false;
+                if (stats.avgEntry > 0 && currentPrice > 0) {
+                    const pnlPct = ((currentPrice - stats.avgEntry) / stats.avgEntry) * 100;
+                    // Smart = Profitable (>2%) OR (Small Loss > -2% AND Low Leverage < 2x)
+                    // Dumb = Unprofitable (< -5%) OR High Leverage (> 5x)
+                    if (pnlPct > 2) isSmart = true;
+                    else if (pnlPct > -2 && stats.avgLeverage < 2) isSmart = true;
+                }
 
-                if (stats.isHolder === 1) {
-                    if (!currentAgg[ticker]) currentAgg[ticker] = { levHolders: 0, spotHolders: 0 };
-
-                    if (stats.avgLeverage > 1.1) {
-                        currentAgg[ticker].levHolders++;
-                    } else {
-                        currentAgg[ticker].spotHolders++;
-                    }
+                // 2. Accumulate Flows
+                if (stats.didBuy > 0) {
+                    if (isSmart) tickerAgg[ticker].smartBuys += stats.didBuy;
+                    else tickerAgg[ticker].dumbBuys += stats.didBuy;
+                }
+                
+                if (stats.didSell > 0) {
+                    tickerAgg[ticker].sells += stats.didSell;
                 }
             }
         }
 
-        // 2. Compare with Previous Day
-        for (const ticker in currentAgg) {
-            const curr = currentAgg[ticker];
-            const prev = previousResult ? previousResult[ticker] : null;
-
-            if (!prev) {
-                this.results[ticker] = { ...curr, levDelta: 0, spotDelta: 0, signal: 'NEW' };
-                continue;
-            }
+        const dailyResult = {};
+        for (const ticker in tickerAgg) {
+            const { smartBuys, dumbBuys, sells } = tickerAgg[ticker];
+            const netFlow = (smartBuys + dumbBuys) - sells;
+            const totalActivity = smartBuys + dumbBuys + sells;
 
-            const levDelta = curr.levHolders - prev.levHolders;
-            const spotDelta = curr.spotHolders - prev.spotHolders;
+            if (totalActivity < 3) continue;
 
             let signal = 'NEUTRAL';
-            if (spotDelta > 0 && levDelta < 0) signal = 'SMART_ACCUMULATION';
-            else if (spotDelta < 0 && levDelta > 0) signal = 'SPECULATIVE_PUMP';
-            else if (spotDelta > 0 && levDelta > 0) signal = 'BROAD_ACCUMULATION';
-            else if (spotDelta < 0 && levDelta < 0) signal = 'BROAD_EXIT';
-
-            this.results[ticker] = {
-                ...curr,
-                levDelta,
-                spotDelta,
-                signal
+            
+            if (netFlow > 0) {
+                if (smartBuys > dumbBuys) signal = 'SMART_ACCUMULATION';
+                else signal = 'SPECULATIVE_PUMP'; // Mostly dumb/lev money buying
+            } else if (netFlow < 0) {
+                signal = 'BROAD_EXIT';
+            }
+
+            dailyResult[ticker] = {
+                smartAccumulation: smartBuys,
+                dumbAccumulation: dumbBuys,
+                netFlow: netFlow,
+                signal: signal
             };
         }
+
+        return dailyResult;
     }
 
     async getResult() { return this.results; }

package/calculations/core/liquidation-cascade.js

@@ -15,57 +15,89 @@ class LiquidationCascade {
     static getDependencies() { return ['user-history-reconstructor']; }
 
     static getSchema() {
-        const schema = {
+        const dailySchema = {
             "type": "object",
             "properties": {
                 "totalClosures": { "type": "number", "description": "Total number of positions closed today." },
                 "forcedClosures": { "type": "number", "description": "Number of positions closed via Stop Loss (Reason 1)." },
+                "avgClosedLeverage": { "type": "number", "description": "Average leverage of the closed positions." },
                 "painIndex": { "type": "number", "description": "Ratio of forced closures to total closures (0.0 - 1.0)." },
-                "isFlushEvent": { "type": "boolean", "description": "True if painIndex > 0.3." }
+                "isFlushEvent": { "type": "boolean", "description": "True if painIndex > 0.3 AND avgClosedLeverage > 3." }
             },
             "required": ["totalClosures", "forcedClosures", "painIndex", "isFlushEvent"]
         };
-        return { "type": "object", "patternProperties": { "^.*$": schema } };
+        // Output: Date -> Ticker -> Schema
+        return {
+            "type": "object",
+            "patternProperties": {
+                "^\\d{4}-\\d{2}-\\d{2}$": {
+                    "type": "object",
+                    "patternProperties": { "^.*$": dailySchema }
+                }
+            }
+        };
     }
 
     async process(context) {
         const { computed } = context;
-        const userReconstructions = computed['user-history-reconstructor'];
-        if (!userReconstructions) return;
+        const historyData = computed['user-history-reconstructor'];
+        if (!historyData) return;
+
+        const keys = Object.keys(historyData);
+        const isDateKeyed = keys.length > 0 && /^\d{4}-\d{2}-\d{2}$/.test(keys[0]);
 
+        if (isDateKeyed) {
+            for (const dateStr of keys) {
+                this.results[dateStr] = this.processSingleDate(historyData[dateStr]);
+            }
+        } else {
+            this.results[context.date.today] = this.processSingleDate(historyData);
+        }
+    }
+
+    processSingleDate(usersMap) {
         const aggregator = {};
+        const dailyResults = {};
 
-        for (const userId in userReconstructions) {
-            const userPortfolio = userReconstructions[userId];
+        for (const userId in usersMap) {
+            const userPortfolio = usersMap[userId];
 
             for (const ticker in userPortfolio) {
                 const stats = userPortfolio[ticker];
 
                 if (stats.didSell > 0) {
-                    if (!aggregator[ticker]) aggregator[ticker] = { totalClosed: 0, forced: 0 };
+                    if (!aggregator[ticker]) aggregator[ticker] = { totalClosed: 0, forced: 0, sumLev: 0 };
 
                     aggregator[ticker].totalClosed += stats.didSell;
                     
+                    // Reason 1 is usually Stop Loss / Liquidation in cTrader/MetaTrader schemas
                     if (stats.closeReasons && stats.closeReasons["1"]) {
                         aggregator[ticker].forced += stats.closeReasons["1"];
                     }
+
+                    // We use avgLeverage of the holding as a proxy for the closed leverage
+                    aggregator[ticker].sumLev += (stats.avgLeverage * stats.didSell);
                 }
             }
         }
 
         for (const ticker in aggregator) {
             const data = aggregator[ticker];
-            if (data.totalClosed < 5) continue;
+            if (data.totalClosed < 3) continue;
 
             const forcedRatio = data.forced / data.totalClosed;
+            const avgLev = data.sumLev / data.totalClosed;
 
-            this.results[ticker] = {
+            dailyResults[ticker] = {
                 totalClosures: data.totalClosed,
                 forcedClosures: data.forced,
+                avgClosedLeverage: avgLev,
                 painIndex: forcedRatio,
-                isFlushEvent: forcedRatio > 0.3
+                // Flush = High Pain AND Significant Leverage involved
+                isFlushEvent: forcedRatio > 0.3 && avgLev > 3
             };
         }
+        return dailyResults;
     }
 
     async getResult() { return this.results; }

package/calculations/core/user-history-reconstructor.js

@@ -1,3 +1,8 @@
+/**
+ * @fileoverview Reconstructs a user's full trading history timeline from a single snapshot.
+ * Uses a Scan-Line algorithm to replay history and generate daily stats (Holders, Buys, Sells).
+ */
+
 class UserHistoryReconstructor {
     constructor() {
         this.results = {}; 
@@ -9,7 +14,8 @@ class UserHistoryReconstructor {
             type: 'standard', 
             category: 'History Reconstruction',
             userType: 'all',
-            isHistorical: false,
+            // False because we generate history internally from the snapshot
+            isHistorical: false, 
             rootDataDependencies: ['history']
         };
     }
@@ -17,134 +23,173 @@ class UserHistoryReconstructor {
     static getDependencies() { return []; }
 
     static getSchema() {
-        // Schema for a single Ticker's stats
-        const tickerSchema = {
+        // Schema for a single Ticker's stats for a single Day
+        const tickerDailyStats = {
             "type": "object",
             "properties": {
                 "isHolder": { "type": "number", "description": "1 if the user holds the asset at EOD, 0 otherwise." },
-                "didBuy": { "type": "number", "description": "Count of buy trades executed today." },
-                "didSell": { "type": "number", "description": "Count of sell trades executed today." },
+                "didBuy": { "type": "number", "description": "Count of buy trades executed this day." },
+                "didSell": { "type": "number", "description": "Count of sell trades executed this day." },
                 "avgEntry": { "type": "number", "description": "Average entry price of held positions." },
                 "avgLeverage": { "type": "number", "description": "Average leverage of held positions." },
-                "buyLeverage": { "type": "number", "description": "Average leverage of new buys executed today." },
+                "buyLeverage": { "type": "number", "description": "Average leverage of new buys executed this day." },
                 "closeReasons": { 
                     "type": "object", 
                     "description": "Map of close reason codes to counts (0=Manual, 1=Stop/Liq, 5=TP)." 
                 }
-            },
-            "required": ["isHolder", "didBuy", "didSell", "avgEntry", "avgLeverage"]
+            }
         };
 
-        // The result for a user is a Map of Ticker -> TickerSchema
+        // Output is now: Date -> Ticker -> Stats
         return {
             "type": "object",
             "patternProperties": {
-                "^.*$": tickerSchema
+                // Key is YYYY-MM-DD
+                "^\\d{4}-\\d{2}-\\d{2}$": {
+                    "type": "object",
+                    "patternProperties": {
+                        // Key is Ticker
+                        "^.*$": tickerDailyStats
+                    }
+                }
             }
         };
     }
 
     async process(context) {
-        const { user, math, mappings, date } = context;
+        const { user, math, mappings } = context;
         
-        // 1. Get History (V2 Format Only)
+        // 1. Get History (Granular V2 Format)
         const history = math.history.getDailyHistory(user);
         const allTrades = history?.PublicHistoryPositions || [];
         
         if (allTrades.length === 0) return;
 
-        // 2. Define Time Boundaries for "Yesterday" (Target Date)
-        const dayStart = new Date(date.today + "T00:00:00.000Z").getTime();
-        const dayEnd   = new Date(date.today + "T23:59:59.999Z").getTime();
-
-        this.results[user.id] = {};
-        const userState = this.results[user.id];
-
+        // 2. Identify all relevant tickers and dates
+        const events = []; // { time, type, trade, ticker }
+        const tickerSet = new Set();
+        
         for (const trade of allTrades) {
             const instId = trade.InstrumentID;
             const ticker = mappings.instrumentToTicker[instId];
             if (!ticker) continue;
+            tickerSet.add(ticker);
 
-            // Parse Dates
             const openTime = new Date(trade.OpenDateTime).getTime();
             const closeTime = trade.CloseDateTime ? new Date(trade.CloseDateTime).getTime() : null;
 
-            // 3. Determine States
-            const isOpenBeforeEOD = openTime <= dayEnd;
-            // Active if it wasn't closed before the day started
-            const isClosedAfterSOD = closeTime === null || closeTime >= dayStart;
-            
-            const wasActiveToday = isOpenBeforeEOD && isClosedAfterSOD;
-
-            // "Held" means active at End of Day
-            const isHeldAtEOD = isOpenBeforeEOD && (closeTime === null || closeTime > dayEnd);
-
-            // "Opened" means OpenTime is inside today
-            const isOpenedToday = openTime >= dayStart && openTime <= dayEnd;
-
-            // "Closed" means CloseTime is inside today
-            const isClosedToday = closeTime !== null && closeTime >= dayStart && closeTime <= dayEnd;
-
-            if (!wasActiveToday) continue;
-
-            if (!userState[ticker]) {
-                userState[ticker] = {
-                    isHolder: 0,
-                    didBuy: 0,
-                    didSell: 0,
-                    sumEntry: 0,
-                    sumLev: 0,
-                    holdCount: 0,
-                    sumBuyLev: 0,
-                    closeReasons: { "0": 0, "1": 0, "5": 0 }
-                };
+            // Add OPEN event
+            events.push({ time: openTime, type: 'OPEN', trade, ticker });
+
+            // Add CLOSE event (if closed)
+            if (closeTime) { events.push({ time: closeTime, type: 'CLOSE', trade, ticker }); }
+        }
+
+        // Sort events by time
+        events.sort((a, b) => a.time - b.time);
+
+        if (events.length === 0) return;
+
+        // 3. Scan-Line Execution (Replay History)
+        const userTimeline = {}; // { "2024-01-01": { "AAPL": {...} } }
+        
+        // Tracking State
+        const activePositions = new Map(); // Map<PositionID, Trade>
+        
+        // Determine Start and End dates for the loop
+        const firstEventTime = events[0].time;
+        const lastEventTime = events[events.length - 1].time;
+        
+        const startDate = new Date(firstEventTime); startDate.setUTCHours(0,0,0,0);
+        const endDate   = new Date(lastEventTime);   endDate.setUTCHours(0,0,0,0);
+
+        let currentEventIdx = 0;
+        const oneDayMs = 86400000;
+
+        // Iterate day by day from first trade to last trade
+        for (let d = startDate.getTime(); d <= endDate.getTime(); d += oneDayMs) {
+            const dateStr = new Date(d).toISOString().slice(0, 10);
+            const dayEnd = d + oneDayMs - 1;
+
+            const dayStats = {}; // Ticker -> Stats
+
+            // Process all events that happened TODAY (before EOD)
+            while (currentEventIdx < events.length && events[currentEventIdx].time <= dayEnd) {
+                const event = events[currentEventIdx];
+                const { ticker, trade, type } = event;
+
+                if (!dayStats[ticker]) this.initTickerStats(dayStats, ticker);
+                
+                if (type === 'OPEN') {
+                    activePositions.set(trade.PositionID, trade);
+                    dayStats[ticker].didBuy++;
+                    dayStats[ticker].sumBuyLev += (trade.Leverage || 1);
+                } else if (type === 'CLOSE') {
+                    activePositions.delete(trade.PositionID);
+                    dayStats[ticker].didSell++;
+                    
+                    const reason = String(trade.CloseReason || 0);
+                    if (dayStats[ticker].closeReasons[reason] === undefined) dayStats[ticker].closeReasons[reason] = 0;
+                    dayStats[ticker].closeReasons[reason]++;
+                }
+                currentEventIdx++;
             }
-            const stats = userState[ticker];
 
-            // 4. Populate Metrics
-            if (isHeldAtEOD) {
-                stats.isHolder = 1;
+            // Snapshot the "Held" State at EOD
+            for (const [posId, trade] of activePositions) {
+                const ticker = mappings.instrumentToTicker[trade.InstrumentID];
+                if (!ticker) continue;
+                
+                if (!dayStats[ticker]) this.initTickerStats(dayStats, ticker);
+                
+                const stats = dayStats[ticker];
+                stats.isHolder = 1; // User is a holder today
                 stats.holdCount++;
                 stats.sumEntry += (trade.OpenRate || 0);
                 stats.sumLev += (trade.Leverage || 1);
             }
 
-            if (isOpenedToday) {
-                stats.didBuy++;
-                stats.sumBuyLev += (trade.Leverage || 1);
-            }
+            // Finalize Averages for this Day
+            for (const ticker in dayStats) {
+                const stats = dayStats[ticker];
+                
+                if (stats.holdCount > 0) {
+                    stats.avgEntry = stats.sumEntry / stats.holdCount;
+                    stats.avgLeverage = stats.sumLev / stats.holdCount;
+                }
+                if (stats.didBuy > 0) {
+                    stats.buyLeverage = stats.sumBuyLev / stats.didBuy;
+                }
 
-            if (isClosedToday) {
-                stats.didSell++;
-                const reason = String(trade.CloseReason || 0);
-                if (stats.closeReasons[reason] === undefined) stats.closeReasons[reason] = 0;
-                stats.closeReasons[reason]++;
+                // Cleanup temp sums
+                delete stats.sumEntry;
+                delete stats.sumLev;
+                delete stats.sumBuyLev;
+                delete stats.holdCount;
             }
-        }
 
-        // 5. Cleanup / Average
-        for (const ticker in userState) {
-            const stats = userState[ticker];
-            
-            if (stats.holdCount > 0) {
-                stats.avgEntry = stats.sumEntry / stats.holdCount;
-                stats.avgLeverage = stats.sumLev / stats.holdCount;
-            } else {
-                stats.avgEntry = 0;
-                stats.avgLeverage = 0;
+            // Store in timeline if any activity exists for this day
+            if (Object.keys(dayStats).length > 0) {
+                userTimeline[dateStr] = dayStats;
             }
+        }
 
-            if (stats.didBuy > 0) {
-                stats.buyLeverage = stats.sumBuyLev / stats.didBuy;
-            } else {
-                stats.buyLeverage = 0;
-            }
+        // 4. Output the full timeline for this user
+        // The ResultCommitter will handle splitting this into date buckets.
+        this.results[user.id] = userTimeline;
+    }
 
-            delete stats.sumEntry;
-            delete stats.sumLev;
-            delete stats.sumBuyLev;
-            delete stats.holdCount;
-        }
+    initTickerStats(dayStats, ticker) {
+        dayStats[ticker] = {
+            isHolder: 0,
+            didBuy: 0,
+            didSell: 0,
+            sumEntry: 0,
+            sumLev: 0,
+            holdCount: 0,
+            sumBuyLev: 0,
+            closeReasons: { "0": 0, "1": 0, "5": 0 }
+        };
     }
 
     async getResult() { return this.results; }

package/calculations/gauss/daily-dna-filter.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview GAUSS Product Line (Pass 1)
- * REFACTORED: Uses context.math.history.getSummary().
+ * REFACTORED: Uses the centralized SmartMoneyScorer for consistent classification.
  */
 class DailyDnaFilter {
     constructor() {
@@ -10,7 +10,7 @@ class DailyDnaFilter {
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['history'],
+            rootDataDependencies: ['history', 'portfolio', 'price'], // Added portfolio/price for hybrid scoring
             isHistorical: false,
             userType: 'all',
             category: 'gauss'
@@ -33,30 +33,17 @@ class DailyDnaFilter {
     }
 
     process(context) {
-        const { user, math } = context;
-        const { history } = math; // 'history' is the TOOL
-
-        // 1. Get strict daily history data
-        const historyDoc = history.getDailyHistory(user);
-        
-        // 2. Get strict summary object using the tool
-        const summary = history.getSummary(historyDoc);
-        
-        // Validation
-        if (!summary || summary.totalTrades < 20) return;
+        // Use the centralized Intelligence Engine injected via Context
+        const { SmartMoneyScorer } = context.math;
         
-        // 3. Use properties from the SUMMARY object, not the history tool
-        const winRate = summary.winRatio / 100.0;
-        const lossRate = 1.0 - winRate;
-        
-        // CORRECTED LINE: uses summary.avgProfitPct
-        const avgWin = summary.avgProfitPct; 
-        const avgLoss = Math.abs(summary.avgLossPct);
-        
-        const lt_skill = (winRate * avgWin) - (lossRate * avgLoss);
+        if (!SmartMoneyScorer) return;
+
+        const result = SmartMoneyScorer.scoreHybrid(context);
+        const score = result.totalScore;
 
-        if (isFinite(lt_skill)) {
-            this.allUserSkills.push([user.id, lt_skill]);
+        // Filter out users with insufficient data (Score 0 or Neutral with no method)
+        if (score > 0) {
+            this.allUserSkills.push([context.user.id, score]);
         }
     }
 
@@ -64,8 +51,10 @@ class DailyDnaFilter {
         const totalUsers = this.allUserSkills.length;
         if (totalUsers === 0) return { smart_cohort_ids: [], dumb_cohort_ids: [], total_users_analyzed: 0, cohort_size: 0 };
 
+        // Sort Descending (Highest Score First)
         this.allUserSkills.sort((a, b) => b[1] - a[1]);
         
+        // Top 20% Smart, Bottom 20% Dumb
         const cohortSize = Math.floor(totalUsers * 0.20);
         if (cohortSize === 0) return { smart_cohort_ids: [], dumb_cohort_ids: [], total_users_analyzed: totalUsers, cohort_size: 0 };
 

package/calculations/gem/cohort-skill-definition.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview GEM Product Line (Pass 1)
- * REFACTORED: Strictly uses context.math.history to access user history.
+ * REFACTORED: Uses SmartMoneyScorer for advanced hybrid classification.
  */
 class CohortSkillDefinition {
     constructor() { this.userScores = new Map(); }
@@ -21,7 +21,8 @@ class CohortSkillDefinition {
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['history'],
+            // Updated dependencies to support hybrid scoring
+            rootDataDependencies: ['history', 'portfolio', 'price'], 
             isHistorical: false,
             userType: 'all',
             category: 'gem'
@@ -31,26 +32,19 @@ class CohortSkillDefinition {
     static getDependencies() { return []; }
 
     process(context) {
-        const { user, math } = context;
-        const { history } = math;
+        // Use the centralized engine injected via context
+        const { SmartMoneyScorer } = context.math;
         
-        // 1. Get strict daily history
-        const historyDoc = history.getDailyHistory(user);
-        
-        // 2. Get strict summary DTO
-        const summary = history.getSummary(historyDoc);
+        if (!SmartMoneyScorer) return;
 
-        if (!summary || summary.totalTrades < 10) return;
+        const result = SmartMoneyScorer.scoreHybrid(context);
+        const score = result.totalScore;
 
-        // 3. Valid DTO usage
-        const winRate = summary.winRatio / 100.0;
-        const lossRate = 1.0 - winRate;
-        
-        const expectancy = (winRate * summary.avgProfitPct) - (lossRate * Math.abs(summary.avgLossPct));
-        
-        const skillScore = expectancy * Math.log10(Math.max(1, summary.totalTrades));
-
-        if (isFinite(skillScore)) this.userScores.set(user.id, skillScore);
+        // GEM requires a minimum threshold of activity usually, 
+        // but SmartMoneyScorer handles low-data cases by returning neutral/0.
+        if (score > 0) {
+            this.userScores.set(context.user.id, score);
+        }
     }
 
     getResult() {

package/calculations/pyro/squeeze-potential.js

@@ -49,8 +49,8 @@ class SqueezePotential {
 
         for (const ticker of tickers) {
             const shortSlAvg = signals.getMetric(computed, 'speculator-stop-loss-distance-by-ticker-short-long-breakdown', ticker, 'avg_short_sl_distance_pct');
-            const userCount = signals.getMetric(computed, 'short-position-per-stock', ticker, 'short_count');
-            const weight = signals.getMetric(computed, 'short-position-per-stock', ticker, 'total_short_exposure_weight');
+            const userCount  = signals.getMetric(computed, 'short-position-per-stock', ticker, 'short_count');
+            const weight     = signals.getMetric(computed, 'short-position-per-stock', ticker, 'total_short_exposure_weight');
 
             if (userCount > 0) {
                 result[ticker] = {

package/package.json

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