aiden-shared-calculations-unified 1.0.16 → 1.0.18

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

@@ -0,0 +1,393 @@
+/**
+ * @fileoverview Calculates a rolling 90-day "Investor Score" (IS) for each normal user.
+ * Heuristic engine (not an academic finance model).  Outputs:
+ *  - sharded_user_profile: { <shardKey>: { profiles: { userId: [history...] }, lastUpdated } }
+ *  - daily_investor_scores: { userId: finalIS }
+ *
+ * Notes:
+ *  - NetProfit / ProfitAndLoss fields are assumed to be percent returns in decimal (e.g. 0.03 = +3%).
+ *  - The "Sharpe" used here is a cross-sectional dispersion proxy computed over position returns,
+ *    weighted by invested amounts. It's renamed/treated as a dispersionRiskProxy in comments.
+ */
+
+const { Firestore } = require('@google-cloud/firestore');
+const firestore = new Firestore();
+const { loadAllPriceData } = require('../../../utils/price_data_provider');
+const { getInstrumentSectorMap, loadInstrumentMappings } = require('../../../utils/sector_mapping_provider');
+
+// Config
+const NUM_SHARDS = 50; // Must match the number of shards to read/write
+const ROLLING_DAYS = 90;
+const SHARD_COLLECTION_NAME = 'user_profile_history'; // The collection to store sharded history
+const PNL_TRACKER_CALC_ID = 'user-profitability-tracker'; // The calc to read PNL from
+
+// Helper: stable shard index for numeric or string IDs
+function getShardIndex(id) {
+    const n = parseInt(id, 10);
+    if (!Number.isNaN(n)) return Math.abs(n) % NUM_SHARDS;
+    // simple deterministic string hash fallback for non-numeric IDs (UUIDs)
+    let h = 0;
+    for (let i = 0; i < id.length; i++) {
+        h = ((h << 5) - h) + id.charCodeAt(i);
+        h |= 0; // keep 32-bit
+    }
+    return Math.abs(h) % NUM_SHARDS;
+}
+
+class UserInvestmentProfile {
+    constructor() {
+        // will hold today's per-user raw heuristic scores
+        this.dailyUserScores = {}; // { userId: { score_rd, score_disc, score_time } }
+
+        // cached dependencies
+        this.priceMap = null;
+        this.sectorMap = null;
+        this.pnlScores = null; // { userId: dailyPnlDecimal }
+        this.dates = {};
+        this.dependenciesLoaded = false;
+    }
+
+    /**
+     * Loads external dependencies once per run.
+     */
+    async _loadDependencies(context, dependencies) {
+        if (this.dependenciesLoaded) return;
+
+        const { db, logger } = dependencies;
+        const { todayDateStr } = context;
+
+        if (logger) logger.log('INFO', '[UserInvestmentProfile] Loading dependencies...');
+
+        // load price data and sector mapping in parallel
+        const [priceData, sectorData] = await Promise.all([
+            loadAllPriceData(),
+            getInstrumentSectorMap()
+        ]);
+        this.priceMap = priceData || {};
+        this.sectorMap = sectorData || {};
+
+        // load PNL map (daily percent returns per user) from PNL calc
+        this.pnlScores = {};
+        try {
+            const pnlCalcRef = db.collection(context.config.resultsCollection).doc(todayDateStr)
+                .collection(context.config.resultsSubcollection).doc('pnl')
+                .collection(context.config.computationsSubcollection).doc(PNL_TRACKER_CALC_ID);
+
+            const pnlSnap = await pnlCalcRef.get();
+            if (pnlSnap.exists) {
+                this.pnlScores = pnlSnap.data().daily_pnl_map || {};
+                if (logger) logger.log('INFO', `[UserInvestmentProfile] Loaded ${Object.keys(this.pnlScores).length} PNL scores.`);
+            } else {
+                if (logger) logger.log('WARN', `[UserInvestmentProfile] Could not find PNL scores dependency for ${todayDateStr}. PNL score will be 0.`);
+            }
+        } catch (e) {
+            if (logger) logger.log('ERROR', `[UserInvestmentProfile] Failed to load PNL scores.`, { error: e.message });
+        }
+
+        this.dependenciesLoaded = true;
+        if (logger) logger.log('INFO', '[UserInvestmentProfile] All dependencies loaded.');
+    }
+
+    /**
+     * HEURISTIC 1: Risk & Diversification Score (0-10).
+     *
+     * Implementation notes:
+     * - NetProfit is assumed to be a percent return in decimal per position (e.g. 0.03 = +3%).
+     * - We compute a weighted mean/std of returns across positions (weights = invested amounts).
+     *   This gives a cross-sectional dispersion proxy (not a time-series Sharpe).
+     */
+    _calculateRiskAndDivScore(todayPortfolio) {
+        if (!todayPortfolio.AggregatedPositions || todayPortfolio.AggregatedPositions.length === 0) {
+            return 5; // neutral
+        }
+
+        const positions = todayPortfolio.AggregatedPositions;
+        let totalInvested = 0;
+        let weightedRetSum = 0;
+        let weightedRetSqSum = 0;
+        let maxPosition = 0;
+        const sectors = new Set();
+
+        for (const pos of positions) {
+            const invested = pos.InvestedAmount || pos.Amount || 0;
+            const netProfit = ('NetProfit' in pos) ? pos.NetProfit : (pos.ProfitAndLoss || 0); // decimal % return
+            const ret = invested > 0 ? (netProfit) : netProfit; // if invested==0 we still include ret but weight 0
+
+            weightedRetSum += ret * invested;
+            weightedRetSqSum += (ret * ret) * invested;
+            totalInvested += invested;
+            if (invested > maxPosition) maxPosition = invested;
+
+            sectors.add(this.sectorMap[pos.InstrumentID] || 'N/A');
+        }
+
+        // Weighted mean & variance of returns
+        const meanReturn = totalInvested > 0 ? (weightedRetSum / totalInvested) : 0;
+        const meanReturnSq = totalInvested > 0 ? (weightedRetSqSum / totalInvested) : (meanReturn * meanReturn);
+        const variance = Math.max(0, meanReturnSq - (meanReturn * meanReturn));
+        const stdReturn = Math.sqrt(variance);
+
+        // dispersion proxy: mean / std (if std is zero we treat as neutral 0)
+        let dispersionRiskProxy = stdReturn > 0 ? meanReturn / stdReturn : 0;
+
+        // cap and map dispersion proxy to [0..10].
+        // dispersionRiskProxy can be outside [-2..4], clamp to reasonable bounds first.
+        const capped = Math.max(-2, Math.min(4, dispersionRiskProxy));
+        const scoreSharpe = ((capped + 2) / 6) * 10; // maps [-2..4] -> [0..10]
+
+        // Sector diversification (monotonic - diminishing returns)
+        const sectorCount = sectors.size;
+        let scoreDiversification = 0;
+        if (sectorCount === 1) scoreDiversification = 0;
+        else if (sectorCount <= 4) scoreDiversification = 5;
+        else if (sectorCount <= 7) scoreDiversification = 8;
+        else scoreDiversification = 10;
+
+        // Position sizing / concentration penalty
+        const concentrationRatio = totalInvested > 0 ? (maxPosition / totalInvested) : 0;
+        let scoreSizing = 0;
+        if (concentrationRatio > 0.8) scoreSizing = 0;
+        else if (concentrationRatio > 0.5) scoreSizing = 2;
+        else if (concentrationRatio > 0.3) scoreSizing = 5;
+        else if (concentrationRatio > 0.15) scoreSizing = 8;
+        else scoreSizing = 10;
+
+        const final = (scoreSharpe * 0.4) + (scoreDiversification * 0.3) + (scoreSizing * 0.3);
+        return Math.max(0, Math.min(10, final));
+    }
+
+    /**
+     * HEURISTIC 2: Discipline Score (0-10).
+     *
+     * Uses yesterday's positions to evaluate closes, averaging down, holding losers/winners.
+     * Defensive: uses safe field fallbacks and guards against division by zero.
+     */
+    _calculateDisciplineScore(yesterdayPortfolio = {}, todayPortfolio = {}) {
+        const yPositions = yesterdayPortfolio.AggregatedPositions || [];
+        const tPositions = new Map((todayPortfolio.AggregatedPositions || []).map(p => [p.PositionID, p]));
+
+        if (yPositions.length === 0) {
+            return 5; // neutral if nothing to judge
+        }
+
+        let eventPoints = 0;
+        let eventCount = 0;
+
+        for (const yPos of yPositions) {
+            const profitAndLoss = ('ProfitAndLoss' in yPos) ? yPos.ProfitAndLoss : (yPos.NetProfit || 0);
+            const invested = yPos.InvestedAmount || yPos.Amount || 0;
+            const pnlPercent = profitAndLoss; // This is already the decimal % return
+
+            const tPos = tPositions.get(yPos.PositionID);
+
+            if (!tPos) {
+                // Closed position
+                eventCount++;
+                if (pnlPercent < -0.05) eventPoints += 10;         // cut loser (good)
+                else if (pnlPercent > 0.20) eventPoints += 8;     // took big profit (good)
+                else if (pnlPercent > 0 && pnlPercent < 0.05) eventPoints += 2; // paper hands (bad)
+                else eventPoints += 5; // neutral close
+            } else {
+                // Held or modified
+                if (pnlPercent < -0.10) {
+                    eventCount++;
+                    const tInvested = tPos.InvestedAmount || tPos.Amount || 0;
+                    if (tInvested > invested) eventPoints += 0; // averaged down (very poor)
+                    else eventPoints += 3; // held loser (poor)
+                } else if (pnlPercent > 0.15) {
+                    eventCount++;
+                    eventPoints += 10; // held/added to winner (good)
+                }
+            }
+        }
+
+        const avg = (eventCount > 0) ? (eventPoints / eventCount) : 5;
+        return Math.max(0, Math.min(10, avg));
+    }
+
+    /**
+     * HEURISTIC 3: Market Timing Score (0-10).
+     *
+     * For new positions opened today (not present yesterday), measure proximity of openRate to
+     * the last 30-day low/high. Uses date-sorted price history and clamps.
+     */
+    _calculateMarketTimingScore(yesterdayPortfolio = {}, todayPortfolio = {}) {
+        const yIds = new Set((yesterdayPortfolio.AggregatedPositions || []).map(p => p.PositionID));
+        const newPositions = (todayPortfolio.AggregatedPositions || []).filter(p => !yIds.has(p.PositionID));
+
+        if (newPositions.length === 0) return 5;
+
+        let timingPoints = 0;
+        let timingCount = 0;
+
+        for (const tPos of newPositions) {
+            const prices = this.priceMap[tPos.InstrumentID];
+            if (!prices) continue;
+
+            // Accept prices as either array or {date:price} map; build sorted array of prices
+            let historyPrices = [];
+            if (Array.isArray(prices)) {
+                // assume array of numbers or objects with .price/.close
+                historyPrices = prices
+                    .map(p => (typeof p === 'number' ? p : (p.price || p.close || null)))
+                    .filter(v => v != null);
+            } else {
+                // object keyed by date -> price
+                const entries = Object.keys(prices)
+                    .map(d => ({ d, p: prices[d] }))
+                    .filter(e => e.p != null)
+                    .sort((a, b) => new Date(a.d) - new Date(b.d));
+                historyPrices = entries.map(e => e.p);
+            }
+
+            const last30 = historyPrices.slice(-30);
+            if (last30.length < 2) continue;
+
+            const minPrice = Math.min(...last30);
+            const maxPrice = Math.max(...last30);
+            const openRate = tPos.OpenRate;
+            const range = maxPrice - minPrice;
+            if (!isFinite(range) || range === 0) continue;
+
+            let proximity = (openRate - minPrice) / range; // 0 = at low, 1 = at high
+            proximity = Math.max(0, Math.min(1, proximity)); // clamp to [0,1]
+
+            timingCount++;
+            if (proximity < 0.2) timingPoints += 10;
+            else if (proximity < 0.4) timingPoints += 8;
+            else if (proximity > 0.9) timingPoints += 1;
+            else if (proximity > 0.7) timingPoints += 3;
+            else timingPoints += 5;
+        }
+
+        const avg = (timingCount > 0) ? (timingPoints / timingCount) : 5;
+        return Math.max(0, Math.min(10, avg));
+    }
+
+    /**
+     * PROCESS: called per-user per-day to compute and store today's heuristics.
+     */
+    async process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, todaySocial, yesterdaySocial) {
+        // run only for normal users with portfolios
+        if (!todayPortfolio || !todayPortfolio.AggregatedPositions) return;
+
+        if (!this.dependenciesLoaded) {
+            await this._loadDependencies(context, context.dependencies);
+            this.dates.today = context.todayDateStr;
+        }
+
+        const yPort = yesterdayPortfolio || {};
+
+        const score_rd = this._calculateRiskAndDivScore(todayPortfolio);
+        const score_disc = this._calculateDisciplineScore(yPort, todayPortfolio);
+        const score_time = this._calculateMarketTimingScore(yPort, todayPortfolio);
+
+        this.dailyUserScores[userId] = {
+            score_rd,
+            score_disc,
+            score_time
+        };
+    }
+
+    /**
+     * GETRESULT: Aggregate into rolling 90-day history, compute avg components and final IS.
+     *
+     * Returns a structure prepared for writing where each shardKey maps to:
+     *   { profiles: { userId: historyArray, ... }, lastUpdated: todayStr }
+     *
+     * This must match how existing shards are read (snap.data().profiles).
+     */
+    async getResult() {
+        if (Object.keys(this.dailyUserScores).length === 0) return {};
+
+        const todayStr = this.dates.today || (new Date()).toISOString().slice(0, 10);
+
+        // prepare sharded output objects with profiles container (Option A)
+        const shardedResults = {};
+        for (let i = 0; i < NUM_SHARDS; i++) {
+            const shardKey = `${SHARD_COLLECTION_NAME}_shard_${i}`;
+            shardedResults[shardKey] = { profiles: {}, lastUpdated: todayStr };
+        }
+
+        const dailyInvestorScoreMap = {};
+
+        // fetch existing shards in parallel
+        const shardPromises = [];
+        for (let i = 0; i < NUM_SHARDS; i++) {
+            const docRef = firestore.collection(SHARD_COLLECTION_NAME).doc(`${SHARD_COLLECTION_NAME}_shard_${i}`);
+            shardPromises.push(docRef.get());
+        }
+        const shardSnapshots = await Promise.all(shardPromises);
+
+        // Build existingShards map of profiles for quick access
+        const existingShards = shardSnapshots.map((snap, idx) => {
+            if (!snap.exists) return {}; // no profiles
+            const data = snap.data() || {};
+            return data.profiles || {};
+        });
+
+        // process users
+        for (const userId of Object.keys(this.dailyUserScores)) {
+            const shardIndex = getShardIndex(userId);
+            const scores = this.dailyUserScores[userId];
+
+            // fetch existing history for this user (if present)
+            const existingProfiles = existingShards[shardIndex] || {};
+            // clone to avoid mutating snapshot data directly
+            const history = (existingProfiles[userId] || []).slice();
+
+            history.push({
+                date: todayStr,
+                ...scores,
+                pnl: (this.pnlScores && (userId in this.pnlScores)) ? this.pnlScores[userId] : 0
+            });
+
+            const newHistory = history.slice(-ROLLING_DAYS);
+
+            // compute rolling averages
+            let avg_rd = 0, avg_disc = 0, avg_time = 0, avg_pnl = 0;
+            for (const entry of newHistory) {
+                avg_rd += (entry.score_rd || 0);
+                avg_disc += (entry.score_disc || 0);
+                avg_time += (entry.score_time || 0);
+                avg_pnl += (entry.pnl || 0);
+            }
+            const N = newHistory.length || 1;
+            avg_rd /= N;
+            avg_disc /= N;
+            avg_time /= N;
+            avg_pnl /= N;
+
+            // Normalize PNL: avg_pnl is decimal percent (0.005 -> 0.5%). Map to 0-10 scale:
+            // multiply by 1000 (0.005 -> 5). Clamp to [-10, 10] to avoid outliers.
+            const normalizedPnl = Math.max(-10, Math.min(10, avg_pnl * 1000));
+
+            // Final IS (weights): discipline 40%, risk/div 30%, timing 20%, pnl 10%
+            const finalISRaw = (avg_disc * 0.4) + (avg_rd * 0.3) + (avg_time * 0.2) + (normalizedPnl * 0.1);
+            const finalIS = Math.max(0, Math.min(10, finalISRaw));
+
+            // store in prepared shard result under 'profiles'
+            const shardKey = `${SHARD_COLLECTION_NAME}_shard_${shardIndex}`;
+            shardedResults[shardKey].profiles[userId] = newHistory;
+
+            // also set the daily investor score
+            dailyInvestorScoreMap[userId] = finalIS;
+        }
+
+        return {
+            sharded_user_profile: shardedResults,
+            daily_investor_scores: dailyInvestorScoreMap
+        };
+    }
+
+    reset() {
+        this.dailyUserScores = {};
+        this.dependenciesLoaded = false;
+        this.priceMap = null;
+        this.sectorMap = null;
+        this.pnlScores = null;
+        this.dates = {};
+    }
+}
+
+module.exports = UserInvestmentProfile;

package/calculations/meta/capital_deployment_strategy.js

@@ -0,0 +1,138 @@
+/**
+ * @fileoverview Meta-calculation (Pass 3) that analyzes "what" the crowd does
+ * following a net deposit signal. It determines if the new capital is used to
+ * buy *new* assets or *add* to existing ones.
+ */
+
+const { FieldValue } = require('@google-cloud/firestore');
+
+class CapitalDeploymentStrategy {
+    constructor() {
+        this.lookbackDays = 7;
+        this.correlationWindow = 3; // How many days after a signal to link behavior
+        this.depositSignalThreshold = -1.0; // From crowd_cash_flow_proxy
+    }
+
+    _getDateStr(baseDate, daysAgo) {
+        const date = new Date(baseDate + 'T00:00:00Z');
+        date.setUTCDate(date.getUTCDate() - daysAgo);
+        return date.toISOString().slice(0, 10);
+    }
+
+    /**
+     * @param {string} dateStr The date to run the analysis for (e.g., "2025-10-31").
+     * @param {object} dependencies The shared dependencies (db, logger).
+     * @param {object} config The computation system configuration.
+     * @returns {Promise<object|null>} The analysis result or null.
+     */
+    async process(dateStr, dependencies, config) {
+        const { db, logger } = dependencies;
+        const collection = config.resultsCollection;
+        const resultsSub = config.resultsSubcollection || 'results';
+        const compsSub = config.computationsSubcollection || 'computations';
+
+        // 1. Find the most recent deposit signal
+        let depositSignal = null;
+        let depositSignalDay = null;
+        let refsToGet = [];
+
+        for (let i = 1; i <= this.lookbackDays; i++) {
+            const checkDate = this._getDateStr(dateStr, i);
+            refsToGet.push({
+                date: checkDate,
+                key: `signal_${checkDate}`,
+                ref: db.collection(collection).doc(checkDate).collection(resultsSub).doc('capital_flow').collection(compsSub).doc('crowd-cash-flow-proxy')
+            });
+        }
+
+        const signalSnapshots = await db.getAll(...refsToGet.map(r => r.ref));
+        const dataMap = new Map();
+        signalSnapshots.forEach((snap, idx) => {
+            if (snap.exists) dataMap.set(refsToGet[idx].key, snap.data());
+        });
+
+        for (let i = 1; i <= this.lookbackDays; i++) {
+            const checkDate = this._getDateStr(dateStr, i);
+            const flowData = dataMap.get(`signal_${checkDate}`);
+            if (flowData && flowData.cash_flow_effect_proxy < this.depositSignalThreshold) {
+                depositSignal = flowData;
+                depositSignalDay = checkDate;
+                break; // Found the most recent signal
+            }
+        }
+
+        if (!depositSignal) {
+            return {
+                status: 'no_deposit_signal_found',
+                lookback_days: this.lookbackDays
+            };
+        }
+
+        // 2. Check if today is within the correlation window
+        const daysSinceSignal = (new Date(dateStr) - new Date(depositSignalDay)) / (1000 * 60 * 60 * 24);
+
+        if (daysSinceSignal <= 0 || daysSinceSignal > this.correlationWindow) {
+            return {
+                status: 'outside_correlation_window',
+                signal_day: depositSignalDay,
+                days_since_signal: daysSinceSignal
+            };
+        }
+
+        // 3. Fetch deployment data for *today*
+        // We are correlating the *past signal* with *today's action*
+        refsToGet = [
+            {
+                key: 'new_alloc',
+                ref: db.collection(collection).doc(dateStr).collection(resultsSub).doc('capital_flow').collection(compsSub).doc('new-allocation-percentage')
+            },
+            {
+                key: 're_alloc',
+                ref: db.collection(collection).doc(dateStr).collection(resultsSub).doc('capital_flow').collection(compsSub).doc('reallocation-increase-percentage')
+            }
+        ];
+
+        const deploymentSnapshots = await db.getAll(...refsToGet.map(r => r.ref));
+        const newAllocData = deploymentSnapshots[0].exists ? deploymentSnapshots[0].data() : null;
+        const reAllocData = deploymentSnapshots[1].exists ? deploymentSnapshots[1].data() : null;
+
+        // 4. Handle "day-delay" for *this* data
+        if (!newAllocData || !reAllocData) {
+            logger.log('WARN', `[CapitalDeploymentStrategy] Missing deployment data for ${dateStr}. Allowing backfill.`);
+            // This is a "same-day" meta-calc, so we return null to let backfill run
+            return null;
+        }
+
+        // 5. Calculate deployment bias
+        const newAlloc = newAllocData.average_new_allocation_percentage || 0;
+        const reAlloc = reAllocData.average_reallocation_increase_percentage || 0;
+
+        const totalDeployment = newAlloc + reAlloc;
+        let newAssetBias = 0;
+        let existingAssetBias = 0;
+
+        if (totalDeployment > 0) {
+            newAssetBias = (newAlloc / totalDeployment) * 100;
+            existingAssetBias = (reAlloc / totalDeployment) * 100;
+        }
+
+        return {
+            status: 'analysis_complete',
+            analysis_date: dateStr,
+            signal_date: depositSignalDay,
+            days_since_signal: daysSinceSignal,
+            signal_deposit_proxy_pct: Math.abs(depositSignal.cash_flow_effect_proxy),
+            deployment_new_alloc_pct: newAlloc,
+            deployment_existing_alloc_pct: reAlloc,
+            total_deployment_pct: totalDeployment,
+            new_asset_bias: newAssetBias,
+            existing_asset_bias: existingAssetBias
+        };
+    }
+
+    // Must exist for the meta-computation runner
+    async getResult() { return null; }
+    reset() {}
+}
+
+module.exports = CapitalDeploymentStrategy;

package/calculations/meta/crowd_sharpe_ratio_proxy.js

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Meta-calculation (Pass 3) to calculate a proxy for the
+ * crowd's "Sharpe Ratio" (risk-adjusted return) on a per-asset basis.
+ * It uses the components from 'pnl_distribution_per_stock' to calculate
+ * the standard deviation of P/L, which serves as the "risk".
+ */
+
+class CrowdSharpeRatioProxy {
+    constructor() {}
+
+    /**
+     * @param {string} dateStr The date to run the analysis for (e.g., "2025-10-31").
+     * @param {object} dependencies The shared dependencies (db, logger).
+     * @param {object} config The computation system configuration.
+     * @returns {Promise<object|null>} The analysis result or null.
+     */
+    async process(dateStr, dependencies, config) {
+        const { db, logger } = dependencies;
+        const collection = config.resultsCollection;
+
+        // 1. Define dependency
+        const dependency = { category: 'pnl', computation: 'pnl-distribution-per-stock' };
+
+        // 2. Build ref and fetch
+        const docRef = db.collection(collection).doc(dateStr)
+            .collection('results').doc(dependency.category)
+            .collection('computations').doc(dependency.computation);
+
+        const snapshot = await docRef.get();
+
+        // 3. Handle the "day-delay"
+        if (!snapshot.exists) {
+            logger.log('WARN', `[CrowdSharpeRatioProxy] Missing dependency 'pnl-distribution-per-stock' for ${dateStr}. Allowing backfill.`);
+            return null; // Let backfill handle it
+        }
+
+        const data = snapshot.data();
+        const pnlDistribution = data.pnl_distribution_by_asset;
+
+        if (!pnlDistribution) {
+             logger.log('WARN', `[CrowdSharpeRatioProxy] Dependency data for ${dateStr} is empty. Skipping.`);
+             return null;
+        }
+
+        const results = {};
+
+        // 4. Calculate Sharpe Proxy for each asset
+        for (const ticker in pnlDistribution) {
+            const stats = pnlDistribution[ticker];
+            const N = stats.position_count;
+            
+            // Need at least 2 data points to calculate variance
+            if (N < 2) continue;
+
+            const mean = stats.pnl_sum / N; // E(x)
+            const mean_sq = stats.pnl_sum_sq / N; // E(x^2)
+            
+            const variance = mean_sq - (mean * mean);
+
+            // If variance is negative (floating point error) or zero, we can't get std_dev
+            if (variance <= 0) {
+                results[ticker] = {
+                    average_pnl: mean,
+                    std_dev_pnl: 0,
+                    sharpe_ratio_proxy: 0,
+                    position_count: N
+                };
+                continue;
+            }
+
+            const std_dev = Math.sqrt(variance); // "Risk"
+            
+            // Calculate Sharpe Ratio (Return / Risk)
+            // (Assuming 0 risk-free rate)
+            const sharpe_proxy = mean / std_dev;
+
+            results[ticker] = {
+                average_pnl: mean,
+                std_dev_pnl: std_dev,
+                sharpe_ratio_proxy: sharpe_proxy,
+                position_count: N
+            };
+        }
+
+        return results;
+    }
+
+    async getResult() { return null; }
+    reset() {}
+}
+
+module.exports = CrowdSharpeRatioProxy;