aiden-shared-calculations-unified 1.0.16 → 1.0.18

package/calculations/behavioural/historical/dumb-cohort-flow.js

@@ -0,0 +1,196 @@
+/**
+ * @fileoverview Calculates "Net Crowd Flow" and "Sector Rotation"
+ * *only* for the "Dumb Cohort" (Bottom 20% of Investor Scores).
+ *
+ * This calc depends on 'user-investment-profile.js' being run first for the same day.
+ */
+
+const { Firestore } = require('@google-cloud/firestore');
+const firestore = new Firestore();
+const { loadAllPriceData, getDailyPriceChange } = require('../../../utils/price_data_provider');
+const { loadInstrumentMappings, getInstrumentSectorMap } = require('../../../utils/sector_mapping_provider');
+
+const COHORT_PERCENTILE = 0.2; // Bottom 20%
+const PROFILE_CALC_ID = 'user-investment-profile'; // The calc to read IS scores from
+
+class DumbCohortFlow {
+    constructor() {
+        // Asset Flow
+        this.asset_values = {}; // { instrumentId: { day1_value_sum: 0, day2_value_sum: 0 } }
+        // Sector Rotation
+        this.todaySectorInvestment = {};
+        this.yesterdaySectorInvestment = {};
+        
+        this.dumbCohortIds = null; // Set of user IDs
+        this.user_count = 0; // Number of *cohort* users
+        this.priceMap = null;
+        this.mappings = null;
+        this.sectorMap = null;
+        this.dates = {};
+    }
+
+    /**
+     * Loads the Investor Scores, calculates the cohort threshold, and builds the Set of user IDs.
+     */
+    async _loadCohort(context, dependencies) {
+        const { db, logger } = dependencies;
+        logger.log('INFO', '[DumbCohortFlow] Loading Investor Scores to build cohort...');
+        
+        try {
+            const scoreMapRef = db.collection(context.config.resultsCollection).doc(context.todayDateStr)
+                .collection(context.config.resultsSubcollection).doc('behavioural')
+                .collection(context.config.computationsSubcollection).doc(PROFILE_CALC_ID);
+                
+            const doc = await scoreMapRef.get();
+            if (!doc.exists || !doc.data().daily_investor_scores) {
+                logger.log('WARN', '[DumbCohortFlow] Cannot find dependency: daily_investor_scores. Cohort will be empty.');
+                this.dumbCohortIds = new Set();
+                return;
+            }
+            
+            const scores = doc.data().daily_investor_scores;
+            const allScores = Object.entries(scores).map(([userId, score]) => ({ userId, score }));
+            allScores.sort((a, b) => a.score - b.score);
+            
+            const thresholdIndex = Math.floor(allScores.length * COHORT_PERCENTILE);
+            const thresholdScore = allScores[thresholdIndex]?.score || 0; // Get 20th percentile score
+            
+            this.dumbCohortIds = new Set(
+                allScores.filter(s => s.score <= thresholdScore).map(s => s.userId) // Get users *at or below*
+            );
+            
+            logger.log('INFO', `[DumbCohortFlow] Cohort built. ${this.dumbCohortIds.size} users at or below ${thresholdScore.toFixed(2)} (20th percentile).`);
+            
+        } catch (e) {
+            logger.log('ERROR', '[DumbCohortFlow] Failed to load cohort.', { error: e.message });
+            this.dumbCohortIds = new Set();
+        }
+    }
+
+    // --- Asset Flow Helpers ---
+    _initAsset(instrumentId) {
+        if (!this.asset_values[instrumentId]) {
+            this.asset_values[instrumentId] = { day1_value_sum: 0, day2_value_sum: 0 };
+        }
+    }
+    _sumAssetValue(positions) {
+        const valueMap = {};
+        if (!positions || !Array.isArray(positions)) return valueMap;
+        for (const pos of positions) {
+            if (pos && pos.InstrumentID && pos.Value) {
+                valueMap[pos.InstrumentID] = (valueMap[pos.InstrumentID] || 0) + pos.Value;
+            }
+        }
+        return valueMap;
+    }
+    // --- Sector Rotation Helper ---
+    _accumulateSectorInvestment(portfolio, target) {
+        if (portfolio && portfolio.AggregatedPositions) {
+            for (const pos of portfolio.AggregatedPositions) {
+                const sector = this.sectorMap[pos.InstrumentID] || 'N/A';
+                target[sector] = (target[sector] || 0) + (pos.Invested || pos.Amount || 0);
+            }
+        }
+    }
+
+    /**
+     * PROCESS: Runs daily for each user.
+     */
+    async process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // 1. Load cohort on first run
+        if (!this.dumbCohortIds) {
+            await this._loadCohort(context, context.dependencies);
+            this.dates.today = context.todayDateStr;
+            this.dates.yesterday = context.yesterdayDateStr;
+        }
+
+        // 2. Filter user
+        if (!this.dumbCohortIds.has(userId) || !todayPortfolio || !yesterdayPortfolio || !todayPortfolio.AggregatedPositions || !yesterdayPortfolio.AggregatedPositions) {
+            return;
+        }
+        
+        // 3. User is in the cohort, load maps if needed
+        if (!this.sectorMap) {
+            this.sectorMap = await getInstrumentSectorMap();
+        }
+
+        // --- 4. RUN ASSET FLOW LOGIC ---
+        const yesterdayValues = this._sumAssetValue(yesterdayPortfolio.AggregatedPositions);
+        const todayValues = this._sumAssetValue(todayPortfolio.AggregatedPositions);
+        const allInstrumentIds = new Set([...Object.keys(yesterdayValues), ...Object.keys(todayValues)]);
+        
+        for (const instrumentId of allInstrumentIds) {
+            this._initAsset(instrumentId);
+            this.asset_values[instrumentId].day1_value_sum += (yesterdayValues[instrumentId] || 0);
+            this.asset_values[instrumentId].day2_value_sum += (todayValues[instrumentId] || 0);
+        }
+
+        // --- 5. RUN SECTOR ROTATION LOGIC ---
+        this._accumulateSectorInvestment(todayPortfolio, this.todaySectorInvestment);
+        this._accumulateSectorInvestment(yesterdayPortfolio, this.yesterdaySectorInvestment);
+
+        this.user_count++;
+    }
+
+    /**
+     * GETRESULT: Aggregates and returns the flow data for the cohort.
+     */
+    async getResult() {
+        if (this.user_count === 0 || !this.dates.today) {
+            return { asset_flow: {}, sector_rotation: {}, user_sample_size: 0 };
+        }
+
+        // 1. Load dependencies
+        if (!this.priceMap || !this.mappings) {
+            const [priceData, mappingData] = await Promise.all([
+                loadAllPriceData(),
+                loadInstrumentMappings()
+            ]);
+            this.priceMap = priceData;
+            this.mappings = mappingData;
+        }
+
+        // --- 2. Calculate Asset Flow ---
+        const finalAssetFlow = {};
+        const todayStr = this.dates.today;
+        const yesterdayStr = this.dates.yesterday;
+
+        for (const instrumentId in this.asset_values) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            const avg_day1_value = this.asset_values[instrumentId].day1_value_sum / this.user_count;
+            const avg_day2_value = this.asset_values[instrumentId].day2_value_sum / this.user_count;
+            const priceChangePct = getDailyPriceChange(instrumentId, yesterdayStr, todayStr, this.priceMap);
+
+            if (priceChangePct === null) continue;
+
+            const expected_day2_value = avg_day1_value * (1 + priceChangePct);
+            const net_crowd_flow_pct = avg_day2_value - expected_day2_value;
+
+            finalAssetFlow[ticker] = {
+                net_crowd_flow_pct: net_crowd_flow_pct,
+                avg_value_day1_pct: avg_day1_value,
+                avg_value_day2_pct: avg_day2_value
+            };
+        }
+        
+        // --- 3. Calculate Sector Rotation ---
+        const finalSectorRotation = {};
+        const allSectors = new Set([...Object.keys(this.todaySectorInvestment), ...Object.keys(this.yesterdaySectorInvestment)]);
+        for (const sector of allSectors) {
+            const todayAmount = this.todaySectorInvestment[sector] || 0;
+            const yesterdayAmount = this.yesterdaySectorInvestment[sector] || 0;
+            finalSectorRotation[sector] = todayAmount - yesterdayAmount;
+        }
+
+        // 4. Return combined result
+        return {
+            asset_flow: finalAssetFlow,
+            sector_rotation: finalSectorRotation,
+            user_sample_size: this.user_count
+        };
+    }
+
+    reset() { /* ... reset all constructor properties ... */ }
+}
+
+module.exports = DumbCohortFlow;

package/calculations/behavioural/historical/in_loss_asset_crowd_flow.js

@@ -0,0 +1,99 @@
+const { loadAllPriceData, getDailyPriceChange } = require('../../../utils/price_data_provider');
+const { loadInstrumentMappings } = require('../../../utils/sector_mapping_provider');
+
+/**
+ * @fileoverview Calculates "Net Crowd Flow" for each asset, BUT
+ * *only* for the cohort of users who are currently IN LOSS
+ * on their positions for that asset.
+ */
+class InLossAssetCrowdFlow {
+    constructor() {
+        this.asset_values = {}; // Stores { day1_value_sum: 0, day2_value_sum: 0 }
+        this.user_count = 0;
+        this.priceMap = null;
+        this.mappings = null;
+        this.dates = {};
+    }
+
+    _initAsset(instrumentId) {
+        if (!this.asset_values[instrumentId]) {
+            this.asset_values[instrumentId] = { day1_value_sum: 0, day2_value_sum: 0 };
+        }
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        if (!todayPortfolio || !yesterdayPortfolio || !todayPortfolio.AggregatedPositions || !yesterdayPortfolio.AggregatedPositions) {
+            return;
+        }
+
+        if (!this.dates.today && context.todayDateStr && context.yesterdayDateStr) {
+            this.dates.today = context.todayDateStr;
+            this.dates.yesterday = context.yesterdayDateStr;
+        }
+
+        const yesterdayPositions = new Map(yesterdayPortfolio.AggregatedPositions.map(p => [p.InstrumentID, p]));
+        const todayPositions = new Map(todayPortfolio.AggregatedPositions.map(p => [p.InstrumentID, p]));
+        
+        const allInstrumentIds = new Set([
+            ...yesterdayPositions.keys(),
+            ...todayPositions.keys()
+        ]);
+
+        for (const instrumentId of allInstrumentIds) {
+            const yPos = yesterdayPositions.get(instrumentId);
+            const tPos = todayPositions.get(instrumentId);
+            
+            // --- COHORT LOGIC ---
+            // Only aggregate if the user is in LOSS on this asset.
+            const tNetProfit = tPos?.NetProfit || 0;
+            if (tNetProfit >= 0) { // Note: >= 0 (includes zero profit)
+                continue; // Skip this asset for this user
+            }
+            // --- END COHORT LOGIC ---
+
+            this._initAsset(instrumentId);
+            this.asset_values[instrumentId].day1_value_sum += (yPos?.Value || 0);
+            this.asset_values[instrumentId].day2_value_sum += (tPos?.Value || 0);
+        }
+        this.user_count++;
+    }
+
+    async getResult() {
+        if (this.user_count === 0 || !this.dates.today) return {};
+        if (!this.priceMap || !this.mappings) {
+            const [priceData, mappingData] = await Promise.all([
+                loadAllPriceData(),
+                loadInstrumentMappings()
+            ]);
+            this.priceMap = priceData;
+            this.mappings = mappingData;
+        }
+        
+        const finalResults = {};
+        const todayStr = this.dates.today;
+        const yesterdayStr = this.dates.yesterday;
+
+        for (const instrumentId in this.asset_values) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            
+            const avg_day1_value = this.asset_values[instrumentId].day1_value_sum / this.user_count;
+            const avg_day2_value = this.asset_values[instrumentId].day2_value_sum / this.user_count;
+            const priceChangePct = getDailyPriceChange(instrumentId, yesterdayStr, todayStr, this.priceMap);
+
+            if (priceChangePct === null) continue;
+
+            const expected_day2_value = avg_day1_value * (1 + priceChangePct);
+            const net_crowd_flow_pct = avg_day2_value - expected_day2_value;
+
+            finalResults[ticker] = {
+                net_crowd_flow_pct: net_crowd_flow_pct,
+                avg_value_day1_pct: avg_day1_value,
+                avg_value_day2_pct: avg_day2_value
+            };
+        }
+        return finalResults;
+    }
+
+    reset() { /*...reset all properties...*/ }
+}
+module.exports = InLossAssetCrowdFlow;

package/calculations/behavioural/historical/in_profit_asset_crowd_flow.js

@@ -0,0 +1,100 @@
+const { loadAllPriceData, getDailyPriceChange } = require('../../../utils/price_data_provider');
+const { loadInstrumentMappings } = require('../../../utils/sector_mapping_provider');
+
+/**
+ * @fileoverview Calculates "Net Crowd Flow" for each asset, BUT
+ * *only* for the cohort of users who are currently IN PROFIT
+ * on their positions for that asset.
+ */
+class InProfitAssetCrowdFlow {
+    constructor() {
+        this.asset_values = {}; // Stores { day1_value_sum: 0, day2_value_sum: 0 }
+        this.user_count = 0;
+        this.priceMap = null;
+        this.mappings = null;
+        this.dates = {};
+    }
+
+    _initAsset(instrumentId) {
+        if (!this.asset_values[instrumentId]) {
+            this.asset_values[instrumentId] = { day1_value_sum: 0, day2_value_sum: 0 };
+        }
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        if (!todayPortfolio || !yesterdayPortfolio || !todayPortfolio.AggregatedPositions || !yesterdayPortfolio.AggregatedPositions) {
+            return;
+        }
+
+        if (!this.dates.today && context.todayDateStr && context.yesterdayDateStr) {
+            this.dates.today = context.todayDateStr;
+            this.dates.yesterday = context.yesterdayDateStr;
+        }
+
+        const yesterdayPositions = new Map(yesterdayPortfolio.AggregatedPositions.map(p => [p.InstrumentID, p]));
+        const todayPositions = new Map(todayPortfolio.AggregatedPositions.map(p => [p.InstrumentID, p]));
+        
+        const allInstrumentIds = new Set([
+            ...yesterdayPositions.keys(),
+            ...todayPositions.keys()
+        ]);
+
+        for (const instrumentId of allInstrumentIds) {
+            const yPos = yesterdayPositions.get(instrumentId);
+            const tPos = todayPositions.get(instrumentId);
+            
+            // --- COHORT LOGIC ---
+            // Only aggregate if the user is in PROFIT on this asset.
+            // We check *today's* profit status as the primary signal.
+            const tNetProfit = tPos?.NetProfit || 0;
+            if (tNetProfit <= 0) {
+                continue; // Skip this asset for this user
+            }
+            // --- END COHORT LOGIC ---
+
+            this._initAsset(instrumentId);
+            this.asset_values[instrumentId].day1_value_sum += (yPos?.Value || 0);
+            this.asset_values[instrumentId].day2_value_sum += (tPos?.Value || 0);
+        }
+        this.user_count++; // Note: This is user_count of *all* users, which is fine for avg.
+    }
+
+    async getResult() {
+        if (this.user_count === 0 || !this.dates.today) return {};
+        if (!this.priceMap || !this.mappings) {
+            const [priceData, mappingData] = await Promise.all([
+                loadAllPriceData(),
+                loadInstrumentMappings()
+            ]);
+            this.priceMap = priceData;
+            this.mappings = mappingData;
+        }
+        
+        const finalResults = {};
+        const todayStr = this.dates.today;
+        const yesterdayStr = this.dates.yesterday;
+
+        for (const instrumentId in this.asset_values) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            
+            const avg_day1_value = this.asset_values[instrumentId].day1_value_sum / this.user_count;
+            const avg_day2_value = this.asset_values[instrumentId].day2_value_sum / this.user_count;
+            const priceChangePct = getDailyPriceChange(instrumentId, yesterdayStr, todayStr, this.priceMap);
+
+            if (priceChangePct === null) continue;
+
+            const expected_day2_value = avg_day1_value * (1 + priceChangePct);
+            const net_crowd_flow_pct = avg_day2_value - expected_day2_value;
+
+            finalResults[ticker] = {
+                net_crowd_flow_pct: net_crowd_flow_pct,
+                avg_value_day1_pct: avg_day1_value,
+                avg_value_day2_pct: avg_day2_value
+            };
+        }
+        return finalResults;
+    }
+
+    reset() { /*...reset all properties...*/ }
+}
+module.exports = InProfitAssetCrowdFlow;

package/calculations/behavioural/historical/smart-cohort-flow.js

@@ -0,0 +1,196 @@
+/**
+ * @fileoverview Calculates "Net Crowd Flow" and "Sector Rotation"
+ * *only* for the "Smart Cohort" (Top 20% of Investor Scores).
+ *
+ * This calc depends on 'user-investment-profile.js' being run first for the same day.
+ */
+
+const { Firestore } = require('@google-cloud/firestore');
+const firestore = new Firestore();
+const { loadAllPriceData, getDailyPriceChange } = require('../../../utils/price_data_provider');
+const { loadInstrumentMappings, getInstrumentSectorMap } = require('../../../utils/sector_mapping_provider');
+
+const COHORT_PERCENTILE = 0.8; // Top 20%
+const PROFILE_CALC_ID = 'user-investment-profile'; // The calc to read IS scores from
+
+class SmartCohortFlow {
+    constructor() {
+        // Asset Flow
+        this.asset_values = {}; // { instrumentId: { day1_value_sum: 0, day2_value_sum: 0 } }
+        // Sector Rotation
+        this.todaySectorInvestment = {};
+        this.yesterdaySectorInvestment = {};
+        
+        this.smartCohortIds = null; // Set of user IDs
+        this.user_count = 0; // Number of *cohort* users
+        this.priceMap = null;
+        this.mappings = null;
+        this.sectorMap = null;
+        this.dates = {};
+    }
+
+    /**
+     * Loads the Investor Scores, calculates the cohort threshold, and builds the Set of user IDs.
+     */
+    async _loadCohort(context, dependencies) {
+        const { db, logger } = dependencies;
+        logger.log('INFO', '[SmartCohortFlow] Loading Investor Scores to build cohort...');
+        
+        try {
+            const scoreMapRef = db.collection(context.config.resultsCollection).doc(context.todayDateStr)
+                .collection(context.config.resultsSubcollection).doc('behavioural')
+                .collection(context.config.computationsSubcollection).doc(PROFILE_CALC_ID);
+                
+            const doc = await scoreMapRef.get();
+            if (!doc.exists || !doc.data().daily_investor_scores) {
+                logger.log('WARN', '[SmartCohortFlow] Cannot find dependency: daily_investor_scores. Cohort will be empty.');
+                this.smartCohortIds = new Set();
+                return;
+            }
+            
+            const scores = doc.data().daily_investor_scores;
+            const allScores = Object.entries(scores).map(([userId, score]) => ({ userId, score }));
+            allScores.sort((a, b) => a.score - b.score);
+            
+            const thresholdIndex = Math.floor(allScores.length * COHORT_PERCENTILE);
+            const thresholdScore = allScores[thresholdIndex]?.score || 999;
+            
+            this.smartCohortIds = new Set(
+                allScores.filter(s => s.score >= thresholdScore).map(s => s.userId)
+            );
+            
+            logger.log('INFO', `[SmartCohortFlow] Cohort built. ${this.smartCohortIds.size} users at or above ${thresholdScore.toFixed(2)} (80th percentile).`);
+            
+        } catch (e) {
+            logger.log('ERROR', '[SmartCohortFlow] Failed to load cohort.', { error: e.message });
+            this.smartCohortIds = new Set();
+        }
+    }
+
+    // --- Asset Flow Helpers ---
+    _initAsset(instrumentId) {
+        if (!this.asset_values[instrumentId]) {
+            this.asset_values[instrumentId] = { day1_value_sum: 0, day2_value_sum: 0 };
+        }
+    }
+    _sumAssetValue(positions) {
+        const valueMap = {};
+        if (!positions || !Array.isArray(positions)) return valueMap;
+        for (const pos of positions) {
+            if (pos && pos.InstrumentID && pos.Value) {
+                valueMap[pos.InstrumentID] = (valueMap[pos.InstrumentID] || 0) + pos.Value;
+            }
+        }
+        return valueMap;
+    }
+    // --- Sector Rotation Helper ---
+    _accumulateSectorInvestment(portfolio, target) {
+        if (portfolio && portfolio.AggregatedPositions) {
+            for (const pos of portfolio.AggregatedPositions) {
+                const sector = this.sectorMap[pos.InstrumentID] || 'N/A';
+                target[sector] = (target[sector] || 0) + (pos.Invested || pos.Amount || 0);
+            }
+        }
+    }
+
+    /**
+     * PROCESS: Runs daily for each user.
+     */
+    async process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // 1. Load cohort on first run
+        if (!this.smartCohortIds) {
+            await this._loadCohort(context, context.dependencies);
+            this.dates.today = context.todayDateStr;
+            this.dates.yesterday = context.yesterdayDateStr;
+        }
+
+        // 2. Filter user
+        if (!this.smartCohortIds.has(userId) || !todayPortfolio || !yesterdayPortfolio || !todayPortfolio.AggregatedPositions || !yesterdayPortfolio.AggregatedPositions) {
+            return;
+        }
+        
+        // 3. User is in the cohort, load maps if needed
+        if (!this.sectorMap) {
+            this.sectorMap = await getInstrumentSectorMap();
+        }
+
+        // --- 4. RUN ASSET FLOW LOGIC ---
+        const yesterdayValues = this._sumAssetValue(yesterdayPortfolio.AggregatedPositions);
+        const todayValues = this._sumAssetValue(todayPortfolio.AggregatedPositions);
+        const allInstrumentIds = new Set([...Object.keys(yesterdayValues), ...Object.keys(todayValues)]);
+        
+        for (const instrumentId of allInstrumentIds) {
+            this._initAsset(instrumentId);
+            this.asset_values[instrumentId].day1_value_sum += (yesterdayValues[instrumentId] || 0);
+            this.asset_values[instrumentId].day2_value_sum += (todayValues[instrumentId] || 0);
+        }
+
+        // --- 5. RUN SECTOR ROTATION LOGIC ---
+        this._accumulateSectorInvestment(todayPortfolio, this.todaySectorInvestment);
+        this._accumulateSectorInvestment(yesterdayPortfolio, this.yesterdaySectorInvestment);
+
+        this.user_count++;
+    }
+
+    /**
+     * GETRESULT: Aggregates and returns the flow data for the cohort.
+     */
+    async getResult() {
+        if (this.user_count === 0 || !this.dates.today) {
+            return { asset_flow: {}, sector_rotation: {}, user_sample_size: 0 };
+        }
+
+        // 1. Load dependencies
+        if (!this.priceMap || !this.mappings) {
+            const [priceData, mappingData] = await Promise.all([
+                loadAllPriceData(),
+                loadInstrumentMappings()
+            ]);
+            this.priceMap = priceData;
+            this.mappings = mappingData;
+        }
+
+        // --- 2. Calculate Asset Flow ---
+        const finalAssetFlow = {};
+        const todayStr = this.dates.today;
+        const yesterdayStr = this.dates.yesterday;
+
+        for (const instrumentId in this.asset_values) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            const avg_day1_value = this.asset_values[instrumentId].day1_value_sum / this.user_count;
+            const avg_day2_value = this.asset_values[instrumentId].day2_value_sum / this.user_count;
+            const priceChangePct = getDailyPriceChange(instrumentId, yesterdayStr, todayStr, this.priceMap);
+
+            if (priceChangePct === null) continue;
+
+            const expected_day2_value = avg_day1_value * (1 + priceChangePct);
+            const net_crowd_flow_pct = avg_day2_value - expected_day2_value;
+
+            finalAssetFlow[ticker] = {
+                net_crowd_flow_pct: net_crowd_flow_pct,
+                avg_value_day1_pct: avg_day1_value,
+                avg_value_day2_pct: avg_day2_value
+            };
+        }
+        
+        // --- 3. Calculate Sector Rotation ---
+        const finalSectorRotation = {};
+        const allSectors = new Set([...Object.keys(this.todaySectorInvestment), ...Object.keys(this.yesterdaySectorInvestment)]);
+        for (const sector of allSectors) {
+            const todayAmount = this.todaySectorInvestment[sector] || 0;
+            const yesterdayAmount = this.yesterdaySectorInvestment[sector] || 0;
+            finalSectorRotation[sector] = todayAmount - yesterdayAmount; // Note: This is total $, not avg.
+        }
+
+        // 4. Return combined result
+        return {
+            asset_flow: finalAssetFlow,
+            sector_rotation: finalSectorRotation,
+            user_sample_size: this.user_count
+        };
+    }
+
+    reset() { /* ... reset all constructor properties ... */ }
+}
+
+module.exports = SmartCohortFlow;