aiden-shared-calculations-unified 1.0.109 → 1.0.110

package/calculations/gauss/cohort-definer.js

@@ -1,177 +1,96 @@
-/**
- * @fileoverview GAUSS Product Line (Pass 2)
- * REFACTORED: Uses context.computed and context.math.
- */
 class CohortDefiner {
-    constructor() {
-        this.smartVectors = []; 
-        this.dumbVectors = [];
-        this.cohortIdSets = null;
-    }
+    constructor() { this.smartVectors = []; this.dumbVectors = []; this.cohortIdSets = null; }
 
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio', 'history'],
-            isHistorical: true,
-            userType: 'all',
-            category: 'gauss'
-        };
-    }
-
-    static getDependencies() {
-        return ['daily-dna-filter', 'instrument-price-momentum-20d'];
-    }
+    static getMetadata() { return { type: 'standard', rootDataDependencies: ['portfolio', 'history'], isHistorical: true, userType: 'all', category: 'gauss' }; }
+    static getDependencies() { return ['daily-dna-filter', 'instrument-price-momentum-20d']; }
 
     static getSchema() {
-        const cohortList = { 
-            "type": "array", 
-            "items": { "type": "string" },
-            "description": "List of User IDs belonging to this behavioral cohort" 
-        };
-
-        return {
-            "type": "object",
-            "required": [
-                "smart_investors",
-                "smart_scalpers",
-                "uncategorized_smart",
-                "fomo_chasers",
-                "patient_losers",
-                "fomo_bagholders",
-                "uncategorized_dumb"
-            ],
-            "properties": {
-                "smart_investors": cohortList,
-                "smart_scalpers": cohortList,
-                "uncategorized_smart": cohortList,
-                "fomo_chasers": cohortList,
-                "patient_losers": cohortList,
-                "fomo_bagholders": cohortList,
-                "uncategorized_dumb": cohortList
-            }
-        };
+        const list = { "type": "array", "items": { "type": "string" } };
+        return { "type": "object", "properties": { 
+            "smart_investors": list, "smart_scalpers": list, "uncategorized_smart": list,
+            "fomo_chasers": list, "patient_losers": list, "fomo_bagholders": list, "uncategorized_dumb": list
+        }, "required": ["smart_investors", "smart_scalpers", "uncategorized_smart", "fomo_chasers", "patient_losers", "fomo_bagholders", "uncategorized_dumb"] };
     }
     
     _loadDependencies(computed) {
         if (this.cohortIdSets) return;
-        const dnaFilterData = computed['daily-dna-filter'];
-        
-        this.cohortIdSets = {
-            smart: new Set(dnaFilterData?.smart_cohort_ids || []),
-            dumb: new Set(dnaFilterData?.dumb_cohort_ids || [])
-        };
-    }
-
-    _getFomoScore(extract, mappings, today, yesterday, momentumData, userType) {
-        if (!momentumData) return 0;
-
-        const tPos = extract.getPositions(today, userType);
-        const yPos = extract.getPositions(yesterday, userType);
-
-        const yIds = new Set(yPos.map(p => extract.getInstrumentId(p)));
-        const newPositions = tPos.filter(p => !yIds.has(extract.getInstrumentId(p)));
-
-        if (newPositions.length === 0) return 0;
-
-        let fomoSum = 0, count = 0;
-        for (const pos of newPositions) {
-            const instId = extract.getInstrumentId(pos);
-            const ticker = mappings.instrumentToTicker[instId];
-            if (ticker && momentumData[ticker]) {
-                fomoSum += momentumData[ticker].momentum_20d_pct || 0;
-                count++;
-            }
-        }
-        return count > 0 ? fomoSum / count : 0;
-    }
-
-    _getBagholderScore(extract, today, userType) {
-        const positions = extract.getPositions(today, userType);
-        if (positions.length === 0) return 0;
-
-        let durationSum = 0, count = 0;
-        const now = new Date();
-
-        for (const pos of positions) {
-            if (extract.getNetProfit(pos) < -20) {
-                const openDate = extract.getOpenDateTime(pos);
-                if (openDate) { 
-                    try {
-                        const durationDays = (now - openDate) / (86400000);
-                        durationSum += durationDays;
-                        count++;
-                    } catch (e) {}
-                }
-            }
-        }
-        return count > 0 ? durationSum / count : 0;
+        const dna = computed['daily-dna-filter'];
+        this.cohortIdSets = { smart: new Set(dna?.smart_cohort_ids || []), dumb: new Set(dna?.dumb_cohort_ids || []) };
     }
 
     process(context) {
         const { user, computed, mappings, math } = context;
         const { extract, history } = math;
-
         this._loadDependencies(computed);
-
-        const isSmart = this.cohortIdSets.smart.has(user.id);
-        const isDumb = this.cohortIdSets.dumb.has(user.id);
-
+        const isSmart = this.cohortIdSets.smart.has(user.id), isDumb = this.cohortIdSets.dumb.has(user.id);
         if (!isSmart && !isDumb) return;
 
-        // 1. Strict History Access
         const historyDoc = history.getDailyHistory(user);
         const summary = history.getSummary(historyDoc);
+        if (!summary) {
+            // No history? Keep them for aggregate count as uncategorized
+            const v = { userId: user.id, skill: 0, time: 0, fomo: 0, bagholder: 0, coldStart: true };
+            if (isSmart) this.smartVectors.push(v); else this.dumbVectors.push(v);
+            return;
+        }
         
-        if (!summary) return;
-        
-        // 2. Valid usage of Summary DTO properties
-        const winRate = summary.winRatio / 100.0;
-        const lossRate = 1.0 - winRate;
+        const winRate = summary.winRatio / 100.0, lossRate = 1.0 - winRate;
         const lt_skill = (winRate * summary.avgProfitPct) - (lossRate * Math.abs(summary.avgLossPct));
         const lt_time = summary.avgHoldingTimeInMinutes;
-
         const momentumData = computed['instrument-price-momentum-20d'];
-        const st_fomo = this._getFomoScore(extract, mappings, user.portfolio.today, user.portfolio.yesterday, momentumData, user.type);
-        const st_bagholder = this._getBagholderScore(extract, user.portfolio.today, user.type);
-
-        const vector = { userId: user.id, skill: lt_skill, time: lt_time, fomo: st_fomo, bagholder: st_bagholder };
+        
+        // st_fomo logic handles user.portfolio.yesterday internally via extract calls
+        const tPos = extract.getPositions(user.portfolio.today, user.type);
+        const yPos = user.portfolio.yesterday ? extract.getPositions(user.portfolio.yesterday, user.type) : [];
+        const yIds = new Set(yPos.map(p => extract.getInstrumentId(p)));
+        const newPos = tPos.filter(p => !yIds.has(extract.getInstrumentId(p)));
+        let fomo = 0; if (newPos.length > 0 && momentumData) {
+            let sum = 0, count = 0;
+            for (const p of newPos) {
+                const tick = mappings.instrumentToTicker[extract.getInstrumentId(p)];
+                if (tick && momentumData[tick]) { sum += momentumData[tick].momentum_20d_pct || 0; count++; }
+            }
+            fomo = count > 0 ? sum / count : 0;
+        }
 
-        if (isSmart) this.smartVectors.push(vector);
-        else this.dumbVectors.push(vector);
+        let bag = 0, bCount = 0; for (const p of tPos) {
+            if (extract.getNetProfit(p) < -20) {
+                const open = extract.getOpenDateTime(p);
+                if (open) { bag += (new Date() - open) / 86400000; bCount++; }
+            }
+        }
+        const st_bag = bCount > 0 ? bag / bCount : 0;
+        const vector = { userId: user.id, skill: lt_skill, time: lt_time, fomo: fomo, bagholder: st_bag, coldStart: false };
+        if (isSmart) this.smartVectors.push(vector); else this.dumbVectors.push(vector);
     }
 
     _getMedian(vectors, key) {
-        if (vectors.length === 0) return 0;
-        const sorted = vectors.map(v => v[key]).sort((a, b) => a - b);
+        const filtered = vectors.filter(v => !v.coldStart);
+        if (filtered.length === 0) return 0;
+        const sorted = filtered.map(v => v[key]).sort((a, b) => a - b);
         const mid = Math.floor(sorted.length / 2);
         return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
     }
 
     async getResult() {
-        const cohorts = {};
-        const assignedSmart = new Set(), assignedDumb = new Set();
-
-        const smart_time = this._getMedian(this.smartVectors, 'time');
-        cohorts['smart_investors'] = this.smartVectors.filter(u => u.time >= smart_time).map(u => { assignedSmart.add(u.userId); return u.userId; });
-        cohorts['smart_scalpers'] = this.smartVectors.filter(u => u.time < smart_time).map(u => { assignedSmart.add(u.userId); return u.userId; });
-        cohorts['uncategorized_smart'] = this.smartVectors.filter(u => !assignedSmart.has(u.userId)).map(u => u.userId);
-            
-        const dumb_fomo = this._getMedian(this.dumbVectors, 'fomo');
-        const dumb_bag = this._getMedian(this.dumbVectors, 'bagholder');
-
-        cohorts['fomo_chasers'] = this.dumbVectors.filter(u => u.fomo >= dumb_fomo && u.bagholder < dumb_bag).map(u => { assignedDumb.add(u.userId); return u.userId; });
-        cohorts['patient_losers'] = this.dumbVectors.filter(u => u.fomo < dumb_fomo && u.bagholder >= dumb_bag).map(u => { assignedDumb.add(u.userId); return u.userId; });
-        cohorts['fomo_bagholders'] = this.dumbVectors.filter(u => u.fomo >= dumb_fomo && u.bagholder >= dumb_bag).map(u => { assignedDumb.add(u.userId); return u.userId; });
-        cohorts['uncategorized_dumb'] = this.dumbVectors.filter(u => !assignedDumb.has(u.userId)).map(u => u.userId);
-
+        const cohorts = { smart_investors: [], smart_scalpers: [], uncategorized_smart: [], fomo_chasers: [], patient_losers: [], fomo_bagholders: [], uncategorized_dumb: [] };
+        const assSmart = new Set(), assDumb = new Set();
+        const sTime = this._getMedian(this.smartVectors, 'time');
+        this.smartVectors.forEach(u => {
+            if (u.coldStart) { cohorts.uncategorized_smart.push(u.userId); return; }
+            if (u.time >= sTime) { cohorts.smart_investors.push(u.userId); assSmart.add(u.userId); }
+            else { cohorts.smart_scalpers.push(u.userId); assSmart.add(u.userId); }
+        });
+        const dFomo = this._getMedian(this.dumbVectors, 'fomo'), dBag = this._getMedian(this.dumbVectors, 'bagholder');
+        this.dumbVectors.forEach(u => {
+            if (u.coldStart) { cohorts.uncategorized_dumb.push(u.userId); return; }
+            if (u.fomo >= dFomo && u.bagholder < dBag) cohorts.fomo_chasers.push(u.userId);
+            else if (u.fomo < dFomo && u.bagholder >= dBag) cohorts.patient_losers.push(u.userId);
+            else if (u.fomo >= dFomo && u.bagholder >= dBag) cohorts.fomo_bagholders.push(u.userId);
+            else cohorts.uncategorized_dumb.push(u.userId);
+        });
         return cohorts;
     }
-    
-    reset() {
-        this.smartVectors = [];
-        this.dumbVectors = [];
-        this.cohortIdSets = null;
-    }
+    reset() { this.smartVectors = []; this.dumbVectors = []; this.cohortIdSets = null; }
 }
 module.exports = CohortDefiner;

package/calculations/gem/cohort-momentum-state.js

@@ -1,101 +1,51 @@
-/**
- * @fileoverview GEM Product Line (Pass 2)
- * REFACTORED: Uses context.computed and context.math.
- */
 class CohortMomentumState {
-    constructor() {
-        this.cohortMomentum = new Map();
-        this.cohortMap = new Map();
-        this.dependenciesLoaded = false;
-        this.tickerMap = null; // Need to store this
-    }
-
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio'],
-            isHistorical: true, 
-            userType: 'all',
-            category: 'gem'
-        };
-    }
-
-    static getDependencies() {
-        return ['cohort-skill-definition', 'instrument-price-momentum-20d'];
-    }
+    constructor() { this.cohortMomentum = new Map(); this.cohortMap = new Map(); this.dependenciesLoaded = false; this.tickerMap = null; }
+    static getMetadata() { return { type: 'standard', rootDataDependencies: ['portfolio'], isHistorical: true, userType: 'all', category: 'gem' }; }
+    static getDependencies() { return ['cohort-skill-definition', 'instrument-price-momentum-20d']; }
 
     static getSchema() {
-        const cohortSchema = {
-            "type": "object",
-            "properties": {
-                "average_momentum_exposure_pct": { "type": "number" },
-                "trade_count": { "type": "number" }
-            },
-            "required": ["average_momentum_exposure_pct", "trade_count"]
-        };
-        return { "type": "object", "properties": { "skilled": cohortSchema, "unskilled": cohortSchema } };
+        const s = { "type": "object", "properties": { "average_momentum_exposure_pct": { "type": ["number", "null"] }, "trade_count": { "type": "number" }, "total_exposure_today": { "type": "number" } }, "required": ["average_momentum_exposure_pct", "trade_count", "total_exposure_today"] };
+        return { "type": "object", "properties": { "skilled": s, "unskilled": s } };
     }
 
     _loadDependencies(computed) {
         if (this.dependenciesLoaded) return;
-        const cohortData = computed['cohort-skill-definition'];
-        if (cohortData) {
-            (cohortData.skilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'skilled'));
-            (cohortData.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled'));
-        }
+        const d = computed['cohort-skill-definition'];
+        if (d) { (d.skilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'skilled')); (d.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled')); }
         this.dependenciesLoaded = true;
     }
 
-    _initCohort(cohortName) {
-        if (!this.cohortMomentum.has(cohortName)) this.cohortMomentum.set(cohortName, { momentum_sum: 0, count: 0 });
-    }
-
     process(context) {
         const { user, computed, mappings, math } = context;
         const { extract } = math;
-        
         this._loadDependencies(computed);
-        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
-
-        const cohortName = this.cohortMap.get(user.id);
-        if (!cohortName) return;
-
-        const momentumData = computed['instrument-price-momentum-20d'];
-        if (!momentumData) return;
-
-        const yIds = new Set(extract.getPositions(user.portfolio.yesterday, user.type).map(p => extract.getInstrumentId(p)));
-        const newPositions = extract.getPositions(user.portfolio.today, user.type).filter(p => !yIds.has(extract.getInstrumentId(p)));
-
-        if (newPositions.length === 0) return;
-
-        this._initCohort(cohortName);
-        const asset = this.cohortMomentum.get(cohortName);
+        const cohort = this.cohortMap.get(user.id); if (!cohort) return;
+        if (!this.cohortMomentum.has(cohort)) this.cohortMomentum.set(cohort, { sum: 0, count: 0, total_abs: 0 });
+        const asset = this.cohortMomentum.get(cohort);
+
+        const mom = computed['instrument-price-momentum-20d'];
+        const tPos = extract.getPositions(user.portfolio.today, user.type);
+        for (const p of tPos) {
+            const tick = mappings.instrumentToTicker[extract.getInstrumentId(p)];
+            if (tick && mom?.[tick]) asset.total_abs += Math.abs(mom[tick].momentum_20d_pct || 0);
+        }
 
-        for (const pos of newPositions) {
-            const ticker = mappings.instrumentToTicker[extract.getInstrumentId(pos)];
-            if (ticker && momentumData[ticker]) {
-                asset.momentum_sum += momentumData[ticker].momentum_20d_pct || 0;
-                asset.count++;
+        if (user.portfolio.yesterday) {
+            const yIds = new Set(extract.getPositions(user.portfolio.yesterday, user.type).map(p => extract.getInstrumentId(p)));
+            const newPos = tPos.filter(p => !yIds.has(extract.getInstrumentId(p)));
+            for (const p of newPos) {
+                const tick = mappings.instrumentToTicker[extract.getInstrumentId(p)];
+                if (tick && mom?.[tick]) { asset.sum += mom[tick].momentum_20d_pct || 0; asset.count++; }
             }
         }
     }
 
     async getResult() {
-        const finalResult = {};
-        for (const [cohortName, data] of this.cohortMomentum.entries()) {
-            finalResult[cohortName] = {
-                average_momentum_exposure_pct: (data.count > 0) ? data.momentum_sum / data.count : 0,
-                trade_count: data.count
-            };
+        const res = {}; for (const [c, d] of this.cohortMomentum.entries()) {
+            res[c] = { average_momentum_exposure_pct: (d.count > 0) ? d.sum / d.count : null, trade_count: d.count, total_exposure_today: d.total_abs };
         }
-        return finalResult;
-    }
-
-    reset() {
-        this.cohortMomentum.clear();
-        this.cohortMap.clear();
-        this.dependenciesLoaded = false;
-        this.tickerMap = null;
+        return res;
     }
+    reset() { this.cohortMomentum.clear(); this.cohortMap.clear(); this.dependenciesLoaded = false; this.tickerMap = null; }
 }
 module.exports = CohortMomentumState;

package/calculations/gem/skilled-cohort-flow.js

@@ -1,144 +1,66 @@
-/**
- * @fileoverview GEM Product Line (Pass 2)
- * REFACTORED: Uses context.computed and context.math.extract.
- */
 class SkilledCohortFlow {
-    constructor() {
-        this.assetFlows = new Map();
-        this.cohortMap = new Map();
-        this.dependenciesLoaded = false;
-        this.tickerMap = null;
-    }
-
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio'],
-            isHistorical: true, 
-            userType: 'all',
-            category: 'gem'
-        };
-    }
-
-    static getDependencies() {
-        return ['cohort-skill-definition', 'instrument-price-change-1d'];
-    }
+    constructor() { this.assetFlows = new Map(); this.cohortMap = new Map(); this.dependenciesLoaded = false; this.tickerMap = null; }
+    static getMetadata() { return { type: 'standard', rootDataDependencies: ['portfolio'], isHistorical: true, userType: 'all', category: 'gem' }; }
+    static getDependencies() { return ['cohort-skill-definition', 'instrument-price-change-1d']; }
 
     static getSchema() {
-        const tickerSchema = {
-            "type": "object",
-            "properties": {
-                "net_flow_pct": { "type": "number" },
-                "net_flow_contribution": { "type": "number" },
-                "avg_position_change_pct": { "type": "number" },
-                "user_count": { "type": "number" }
-            },
-            "required": ["net_flow_pct", "net_flow_contribution", "avg_position_change_pct", "user_count"]
-        };
-        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
-    }
-
-    _initFlowData(instrumentId) {
-        if (!this.assetFlows.has(instrumentId)) {
-            this.assetFlows.set(instrumentId, {
-                total_invested_yesterday: 0, total_invested_today: 0, price_change_yesterday: 0,
-                total_pos_size_yesterday: 0, total_pos_size_today: 0, user_count_yesterday: 0, user_count_today: 0
-            });
-        }
+        const s = { "type": "object", "properties": { "net_flow_pct": { "type": ["number", "null"] }, "net_flow_contribution": { "type": ["number", "null"] }, "avg_position_change_pct": { "type": ["number", "null"] }, "user_count": { "type": "number" }, "total_invested_today": { "type": "number" } }, "required": ["net_flow_pct", "net_flow_contribution", "avg_position_change_pct", "user_count", "total_invested_today"] };
+        return { "type": "object", "patternProperties": { "^.*$": s } };
     }
 
     _loadDependencies(computed) {
         if (this.dependenciesLoaded) return;
-        const cohortData = computed['cohort-skill-definition'];
-        if (cohortData) {
-            (cohortData.skilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'skilled'));
-        }
+        const d = computed['cohort-skill-definition'];
+        if (d) (d.skilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'skilled'));
         this.dependenciesLoaded = true;
     }
 
     process(context) {
         const { user, computed, mappings, math } = context;
         const { extract } = math;
-        
         this._loadDependencies(computed);
-        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
-
         if (this.cohortMap.get(user.id) !== 'skilled') return;
-        
-        const priceChangeMap = computed['instrument-price-change-1d'];
-        if (!priceChangeMap) return;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
+        const priceMap = computed['instrument-price-change-1d'];
 
-        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
         const tPos = extract.getPositions(user.portfolio.today, user.type);
-
+        const yPos = user.portfolio.yesterday ? extract.getPositions(user.portfolio.yesterday, user.type) : [];
         const yPosMap = new Map(yPos.map(p => [extract.getInstrumentId(p), p]));
         const tPosMap = new Map(tPos.map(p => [extract.getInstrumentId(p), p]));
-        const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
-
-        for (const instId of allInstrumentIds) {
-            if (!instId) continue;
-            this._initFlowData(instId);
-            const asset = this.assetFlows.get(instId);
-
-            const yWeight = extract.getPositionWeight(yPosMap.get(instId), user.type);
-            const tWeight = extract.getPositionWeight(tPosMap.get(instId), user.type);
+        const ids = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
 
-            if (yWeight > 0) {
-                asset.total_invested_yesterday += yWeight;
-                const ticker = mappings.instrumentToTicker[instId];
-                const priceChange = (ticker && priceChangeMap[ticker]) ? priceChangeMap[ticker].change_1d_pct : 0;
-                asset.price_change_yesterday += (priceChange / 100.0) * yWeight;
-                asset.total_pos_size_yesterday += yWeight;
-                asset.user_count_yesterday++;
-            }
-            if (tWeight > 0) {
-                asset.total_invested_today += tWeight;
-                asset.user_count_today++;
-                asset.total_pos_size_today += tWeight;
+        for (const id of ids) {
+            if (!this.assetFlows.has(id)) this.assetFlows.set(id, { yInv: 0, tInv: 0, pChg: 0, ySize: 0, tSize: 0, yCount: 0, tCount: 0, hasY: false });
+            const asset = this.assetFlows.get(id);
+            const tW = extract.getPositionWeight(tPosMap.get(id), user.type);
+            if (tW > 0) { asset.tInv += tW; asset.tCount++; asset.tSize += tW; }
+            if (user.portfolio.yesterday) {
+                asset.hasY = true;
+                const yW = extract.getPositionWeight(yPosMap.get(id), user.type);
+                if (yW > 0) {
+                    asset.yInv += yW; asset.yCount++; asset.ySize += yW;
+                    const tick = mappings.instrumentToTicker[id];
+                    const chg = (tick && priceMap?.[tick]) ? priceMap[tick].change_1d_pct : 0;
+                    asset.pChg += ((chg || 0) / 100.0) * yW;
+                }
             }
         }
     }
 
     async getResult() {
-        if (!this.tickerMap) return {};
-        const finalResult = {};
-        for (const [instId, data] of this.assetFlows.entries()) {
-            const ticker = this.tickerMap[instId];
-            if (!ticker) continue;
-            // ... (Same calculation logic as before, just boilerplate math)
-            let net_flow = 0, flow_contrib = 0;
-            if (data.total_invested_yesterday > 0) {
-                const avg_change = data.price_change_yesterday / data.total_invested_yesterday;
-                const adjusted_y = data.total_invested_yesterday * (1 + avg_change);
-                flow_contrib = data.total_invested_today - adjusted_y;
-                net_flow = (flow_contrib / data.total_invested_yesterday) * 100;
-            } else if (data.total_invested_today > 0) {
-                flow_contrib = data.total_invested_today;
-                net_flow = Infinity;
+        if (!this.tickerMap) return {}; const res = {};
+        for (const [id, d] of this.assetFlows.entries()) {
+            const tick = this.tickerMap[id]; if (!tick) continue;
+            let net = null, contrib = null, avgPos = null;
+            if (d.hasY) {
+                const adjY = d.yInv + d.pChg; contrib = d.tInv - adjY;
+                net = d.yInv > 0 ? (contrib / d.yInv) * 100 : (d.tInv > 0 ? Infinity : 0);
+                if (d.yCount > 0 && d.tCount > 0) avgPos = (((d.tSize / d.tCount) - (d.ySize / d.yCount)) / (d.ySize / d.yCount)) * 100;
             }
-            
-            let avg_pos_change = 0;
-            if (data.user_count_yesterday > 0 && data.user_count_today > 0) {
-                const avg_y = data.total_pos_size_yesterday / data.user_count_yesterday;
-                const avg_t = data.total_pos_size_today / data.user_count_today;
-                if (avg_y > 0) avg_pos_change = ((avg_t - avg_y) / avg_y) * 100;
-            } else if (data.user_count_today > 0) avg_pos_change = Infinity;
-
-            finalResult[ticker] = {
-                net_flow_pct: isFinite(net_flow) ? net_flow : 0,
-                net_flow_contribution: isFinite(flow_contrib) ? flow_contrib : 0,
-                avg_position_change_pct: isFinite(avg_pos_change) ? avg_pos_change : 0,
-                user_count: data.user_count_today
-            };
+            res[tick] = { net_flow_pct: isFinite(net) ? net : null, net_flow_contribution: isFinite(contrib) ? contrib : null, avg_position_change_pct: isFinite(avgPos) ? avgPos : null, user_count: d.tCount, total_invested_today: d.tInv };
         }
-        return finalResult;
-    }
-
-    reset() {
-        this.assetFlows.clear();
-        this.cohortMap.clear();
-        this.dependenciesLoaded = false;
-        this.tickerMap = null;
+        return res;
     }
+    reset() { this.assetFlows.clear(); this.cohortMap.clear(); this.dependenciesLoaded = false; this.tickerMap = null; }
 }
 module.exports = SkilledCohortFlow;