bulltrackers-module 1.0.211 → 1.0.212

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

@@ -0,0 +1,397 @@
+/**
+ * @fileoverview Mathematics Layer
+ * Core mathematical functions, statistics, and signal primitives.
+ */
+
+const { DataExtractor } = require('./extractors');
+const { SCHEMAS } = require('./profiling');
+
+class MathPrimitives {
+    static average(values) {
+        if (!values || !values.length) return 0;
+        return values.reduce((a, b) => a + b, 0) / values.length;
+    }
+    
+    static median(values) {
+        if (!values || !values.length) return 0;
+        const sorted = [...values].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];
+    }
+
+    static standardDeviation(values) {
+        if (!values || !values.length) return 0;
+        const avg         = this.average(values);
+        const squareDiffs = values.map(val => Math.pow((val || 0) - avg, 2));
+        return Math.sqrt(this.average(squareDiffs));
+    }
+
+    static bucketBinary(value, threshold = 0) {
+        return value > threshold ? 'winner' : 'loser';
+    }
+
+    static calculateHitProbability(currentPrice, barrierPrice, volatility, days, drift = 0) {
+        if (currentPrice <= 0 || barrierPrice <= 0 || volatility <= 0 || days <= 0) return 0;
+
+        const t          = days / 365.0; 
+        const sigma      = volatility;
+        const mu         = drift;
+        const b          = Math.log(barrierPrice / currentPrice);
+        const nu         = mu - 0.5 * Math.pow(sigma, 2);
+        const sqrtT      = Math.sqrt(t);
+        const sigmaSqrtT = sigma * sqrtT;
+
+        const normCDF = (x) => {
+            const t    = 1 / (1 + 0.2316419 * Math.abs(x));
+            const d    = 0.3989423 * Math.exp(-x * x / 2);
+            const prob = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))));
+            return x > 0 ? 1 - prob : prob;
+        };
+
+        const term1 = (b - nu * t) / sigmaSqrtT;
+        const term2 = (2 * nu * b) / (sigma * sigma);
+        const term3 = (b + nu * t) / sigmaSqrtT;
+
+        if ((currentPrice > barrierPrice && barrierPrice > currentPrice) || 
+            (currentPrice < barrierPrice && barrierPrice < currentPrice)) {
+             return 1.0;
+        }
+
+        const probability = normCDF(( -Math.abs(b) - nu * t ) / sigmaSqrtT) +  Math.exp((2 * nu * Math.abs(b)) / (sigma * sigma)) * normCDF(( -Math.abs(b) + nu * t ) / sigmaSqrtT);
+
+        return Math.min(Math.max(probability, 0), 1);
+    }
+
+    static simulateGBM(currentPrice, volatility, days, simulations = 1000, drift = 0) {
+        if (currentPrice <= 0 || volatility <= 0 || days <= 0) return new Float32Array(0);
+        
+        const t         = days / 365.0;
+        const sigma     = volatility;
+        const mu        = drift;
+        const driftTerm = (mu - 0.5 * sigma * sigma) * t;
+        const volTerm   = sigma * Math.sqrt(t);
+        
+        const results = new Float32Array(simulations);
+        
+        for (let i = 0; i < simulations; i++) {
+            const u1 = Math.random();
+            const u2 = Math.random();
+            const z  = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2.0 * Math.PI * u2);
+            results[i] = currentPrice * Math.exp(driftTerm + volTerm * z);
+        }
+        return results;
+    }
+
+    static simulatePopulationBreakdown(pricePaths, userProfiles) {
+        if (!pricePaths.length || !userProfiles.length) return 0;
+        
+        let totalBreakdownEvents = 0;
+        const totalSims = pricePaths.length;
+        const totalUsers = userProfiles.length;
+
+        for (let i = 0; i < totalSims; i++) {
+            const simPrice = pricePaths[i];
+            let capitulatedUsersInScenario = 0;
+
+            for (let j = 0; j < totalUsers; j++) {
+                const user = userProfiles[j];
+                const hypotheticalPnL = ((simPrice - user.entryPrice) / user.entryPrice) * 100;
+                
+                if (hypotheticalPnL < user.thresholdPct) {
+                    capitulatedUsersInScenario++;
+                }
+            }
+            
+            totalBreakdownEvents += (capitulatedUsersInScenario / totalUsers);
+        }
+        
+        return totalBreakdownEvents / totalSims;
+    }
+}
+
+class FinancialEngineering {
+    /**
+     * Calculates the Sortino Ratio based on a series of trade returns.
+     * Uses Downside Deviation (risk of loss) rather than Standard Deviation (volatility).
+     * @param {number[]} returns - Array of PnL percentages from trades.
+     * @param {number} targetReturn - Minimum acceptable return (default 0).
+     */
+    static sortinoRatio(returns, targetReturn = 0) {
+        if (!returns || returns.length < 2) return 0;
+        
+        const avgReturn = MathPrimitives.average(returns);
+        
+        // Calculate Downside Deviation (only negative deviations from target)
+        const downsideDiffs = returns.map(r => Math.min(0, r - targetReturn));
+        const downsideVariance = downsideDiffs.reduce((sum, d) => sum + (d * d), 0) / returns.length;
+        const downsideDev = Math.sqrt(downsideVariance);
+        
+        if (downsideDev === 0) return 0; // No downside risk found
+        return (avgReturn - targetReturn) / downsideDev;
+    }
+
+    /**
+     * Calculates the Kelly Criterion (Optimal Leverage Fraction).
+     * f* = (bp - q) / b
+     * @param {number} winRatio - Win Rate (0-100).
+     * @param {number} avgWinPct - Average Win %.
+     * @param {number} avgLossPct - Average Loss % (must be negative or positive magnitude).
+     */
+    static kellyCriterion(winRatio, avgWinPct, avgLossPct) {
+        const p = winRatio / 100;
+        const q = 1 - p;
+        const lossMag = Math.abs(avgLossPct);
+        
+        if (lossMag === 0) return 0; // Infinite edge (or divide by zero error)
+        
+        const b = avgWinPct / lossMag; // Payoff odds (b to 1)
+        
+        // Kelly Formula: (bp - q) / b
+        const f = (b * p - q) / b;
+        
+        return Math.max(0, f); // Clamp negative Kelly to 0 (Do not bet)
+    }
+}
+
+class TimeSeriesAnalysis {
+    /**
+     * Calculates the Hurst Exponent via Rescaled Range (R/S) Analysis.
+     * H = 0.5: Random Walk (Gambler).
+     * H > 0.5: Persistent/Trending (Momentum).
+     * H < 0.5: Anti-Persistent/Mean Reverting (Oscillator).
+     * @param {number[]} series - Time series data (e.g. cumulative PnL or prices).
+     */
+    static hurstExponent(series) {
+        if (!series || series.length < 10) return 0.5; // Insufficient data
+
+        // Create logarithmic differences (returns)
+        const logReturns = [];
+        for (let i = 1; i < series.length; i++) {
+            logReturns.push(Math.log(series[i] / series[i-1]));
+        }
+
+        // Simplified R/S calculation over full range
+        const mean = MathPrimitives.average(logReturns);
+        const stdDev = MathPrimitives.standardDeviation(logReturns);
+        
+        if (stdDev === 0) return 0.5;
+
+        // Calculate Deviations from mean
+        const deviations = logReturns.map(r => r - mean);
+        
+        // Calculate Cumulative Deviations (Cumulative Range)
+        let sum = 0;
+        const cumulativeDeviations = deviations.map(d => sum += d);
+        
+        const maxDev = Math.max(...cumulativeDeviations);
+        const minDev = Math.min(...cumulativeDeviations);
+        const range = maxDev - minDev;
+        
+        const rs = range / stdDev;
+        const n = logReturns.length;
+        
+        // H = log(R/S) / log(n)
+        // Note: This is a point-estimate simplification of the full regression method
+        // but sufficient for behavioral classification.
+        const hurst = Math.log(rs) / Math.log(n);
+        
+        return Math.min(1, Math.max(0, hurst));
+    }
+}
+
+class SignalPrimitives {
+    static getMetric(dependencies, calcName, ticker, fieldName, fallback = 0) {
+        if (!dependencies || !dependencies[calcName]) return fallback;
+        const tickerData = dependencies[calcName][ticker];
+        if (!tickerData) return fallback;
+        
+        const val = tickerData[fieldName];
+        return (typeof val === 'number') ? val : fallback;
+    }
+
+    static getUnionKeys(dependencies, calcNames) {
+        const keys = new Set();
+        if (!dependencies) return [];
+        for (const name of calcNames) {
+            const resultObj = dependencies[name];
+            if (resultObj && typeof resultObj === 'object') {
+                Object.keys(resultObj).forEach(k => keys.add(k));
+            }
+        }
+        return Array.from(keys);
+    }
+
+    static normalizeTanh(value, scale = 10, sensitivity = 10.0) {
+        if (value === 0) return 0;
+        return Math.tanh(value / sensitivity) * scale;
+    }
+
+    static normalizeZScore(value, mean, stdDev) {
+        if (!stdDev || stdDev === 0) return 0;
+        return (value - mean) / stdDev;
+    }
+
+    static divergence(valueA, valueB) {
+        return (valueA || 0) - (valueB || 0);
+    }
+
+    static getPreviousState(previousComputed, calcName, ticker, fieldName = null) {
+        if (!previousComputed || !previousComputed[calcName]) return null;
+        const tickerData = previousComputed[calcName][ticker];
+        if (!tickerData) return null;
+
+        if (fieldName) {
+             return tickerData[fieldName];
+        }
+        return tickerData; 
+    }
+}
+
+class Aggregators {
+    static bucketUsersByPnlPerAsset(usersData, tickerMap) {
+        const buckets = new Map();
+        for (const [userId, portfolio] of Object.entries(usersData)) {
+            const userType  = portfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
+            const positions = DataExtractor.getPositions(portfolio, userType);
+            
+            for (const pos of positions) {
+                const id = DataExtractor.getInstrumentId(pos);
+                const pnl = DataExtractor.getNetProfit(pos);
+                if (!id || pnl === 0) continue;
+                
+                const ticker = tickerMap[id];
+                if (!ticker) continue;
+
+                if (!buckets.has(ticker)) buckets.set(ticker, { winners: [], losers: [] });
+                const b = buckets.get(ticker);
+                
+                if (pnl > 0) b.winners.push(userId);
+                else b.losers.push(userId);
+            }
+        }
+        return Object.fromEntries(buckets);
+    }
+
+    static getWeightedSentiment(positions) {
+        if (!positions || positions.length === 0) return 0;
+
+        let totalWeightedPnL = 0;
+        let totalWeight = 0;
+
+        for (const pos of positions) {
+            const pnl = DataExtractor.getNetProfit(pos);
+            const weight = DataExtractor.getPositionWeight(pos);
+
+            if (weight > 0) {
+                totalWeightedPnL += (pnl * weight);
+                totalWeight += weight;
+            }
+        }
+
+        if (totalWeight === 0) return 0;
+        return totalWeightedPnL / totalWeight;
+    }
+}
+
+class TimeSeries {
+    static updateEMAState(value, state, alpha = 0.1) {
+        const mean = state ? (state.mean || 0) : 0;
+        const variance = state ? (state.variance || 1) : 1; 
+
+        if (value === undefined || value === null || isNaN(value)) {
+            return { mean, variance };
+        }
+
+        const diff = value - mean;
+        const newMean = mean + (alpha * diff);
+        const newVariance = (1 - alpha) * (variance + (alpha * diff * diff));
+
+        return { mean: newMean, variance: newVariance };
+    }
+
+    static pearsonCorrelation(x, y) {
+        if (!x || !y || x.length !== y.length || x.length === 0) return 0;
+        
+        const n = x.length;
+        let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
+
+        for (let i = 0; i < n; i++) {
+            sumX  += x[i];
+            sumY  += y[i];
+            sumXY += x[i] * y[i];
+            sumX2 += x[i] * x[i];
+            sumY2 += y[i] * y[i];
+        }
+
+        const numerator   = (n * sumXY) - (sumX * sumY);
+        const denominator = Math.sqrt(((n * sumX2) - (sumX * sumX)) * ((n * sumY2) - (sumY * sumY)));
+
+        return (denominator === 0) ? 0 : numerator / denominator;
+    }
+}
+
+class DistributionAnalytics {
+    static computeKDE(data, bandwidth, steps = 60) {
+        if (!data || data.length === 0) return [];
+
+        let min = Infinity, max = -Infinity;
+        for (const p of data) {
+            if (p.value < min) min = p.value;
+            if (p.value > max) max = p.value;
+        }
+        
+        min -= bandwidth * 3;
+        max += bandwidth * 3;
+        const stepSize = (max - min) / steps;
+        const curve = [];
+
+        for (let i = 0; i <= steps; i++) {
+            const x = min + (i * stepSize);
+            let density = 0;
+            for (const p of data) {
+                const diff = (x - p.value);
+                if (Math.abs(diff) > bandwidth * 3) continue;
+                
+                const u = diff / bandwidth;
+                const k = 0.39894228 * Math.exp(-0.5 * u * u); 
+                density += (p.weight * k) / bandwidth;
+            }
+            if (density > 0) curve.push({ price: x, density });
+        }
+        return curve;
+    }
+
+    static integrateProfile(curve, startPrice, endPrice) {
+        if (!curve || !Array.isArray(curve)) return 0; // Fix for potential crash
+        let sum = 0;
+        for (let i = 0; i < curve.length - 1; i++) {
+            const p1 = curve[i];
+            const p2 = curve[i+1];
+            if (p1.price >= startPrice && p2.price <= endPrice) {
+                sum += (p2.price - p1.price) * ((p1.density + p2.density) / 2);
+            }
+        }
+        return sum;
+    }
+
+    static linearRegression(xValues, yValues) {
+        const n = xValues.length;
+        if (n !== yValues.length || n < 2) return { slope: 0, r2: 0 };
+        
+        let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0, sumYY = 0;
+        for (let i = 0; i < n; i++) {
+            sumX  += xValues[i];
+            sumY  += yValues[i];
+            sumXY += xValues[i] * yValues[i];
+            sumXX += xValues[i] * xValues[i];
+            sumYY += yValues[i] * yValues[i];
+        }
+        
+        const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+        return { slope, n };
+    }
+}
+
+module.exports = { MathPrimitives, SignalPrimitives, Aggregators, TimeSeries, DistributionAnalytics, FinancialEngineering, TimeSeriesAnalysis };

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

@@ -0,0 +1,287 @@
+/**
+ * @fileoverview Profiling Layer - Intelligence Engine (V5)
+ * Encapsulates advanced behavioral profiling, psychological scoring, and classification schemas.
+ */
+
+const SCHEMAS = {
+    USER_TYPES: { NORMAL: 'normal', SPECULATOR: 'speculator' },
+    STYLES: { 
+        INVESTOR: 'Investor', 
+        SWING_TRADER: 'Swing Trader', 
+        DAY_TRADER: 'Day Trader', 
+        SCALPER: 'Scalper' 
+    },
+    LABELS: { 
+        ELITE: 'Elite', 
+        SMART: 'Smart Money', 
+        NEUTRAL: 'Neutral', 
+        DUMB: 'Dumb Money', 
+        GAMBLER: 'Gambler' 
+    }
+};
+
+// ========================================================================
+// 1. BEHAVIORAL ANALYTICS ENGINES
+// ========================================================================
+
+class CognitiveBiases {
+    /**
+     * Anchoring Bias Detector.
+     * Checks if the user holds "dead money" positions that are hovering near breakeven
+     * for extended periods, refusing to close them.
+     * @param {Array} openPositions - Current holdings. Needs OpenDateTime (Speculators).
+     * @param {number} thresholdPct - +/- % range around 0 PnL (e.g. 2%).
+     * @param {number} minDaysHeld - Minimum days held to qualify as "Anchored".
+     */
+    static calculateAnchoringScore(openPositions, thresholdPct = 2.0, minDaysHeld = 14) {
+        if (!openPositions || openPositions.length === 0) return 0;
+        
+        let anchoredCount = 0;
+        let validPositions = 0;
+        const now = Date.now();
+        const msPerDay = 86400000;
+
+        for (const pos of openPositions) {
+            // Only applicable if we have OpenDateTime (Speculator Schema)
+            if (pos.OpenDateTime) {
+                validPositions++;
+                const ageDays = (now - new Date(pos.OpenDateTime).getTime()) / msPerDay;
+                
+                // Is the trade old AND hovering near 0% PnL?
+                if (ageDays > minDaysHeld && Math.abs(pos.NetProfit) < thresholdPct) {
+                    anchoredCount++;
+                }
+            }
+        }
+        
+        return validPositions > 0 ? (anchoredCount / validPositions) : 0;
+    }
+
+    /**
+     * Disposition Effect (Loss Aversion in Time Domain).
+     * Calculates ratio of Avg Hold Time (Losers) / Avg Hold Time (Winners).
+     * Value > 1.0 means they hold losers longer than winners (Bad).
+     */
+    static calculateDispositionEffect(historyTrades) {
+        let winDur = 0, winCount = 0;
+        let lossDur = 0, lossCount = 0;
+
+        for (const t of historyTrades) {
+            if (!t.OpenDateTime || !t.CloseDateTime) continue;
+            
+            const dur = (new Date(t.CloseDateTime) - new Date(t.OpenDateTime)) / 3600000; // Hours
+            
+            if (t.NetProfit > 0) {
+                winDur += dur;
+                winCount++;
+            } else if (t.NetProfit < 0) {
+                lossDur += dur;
+                lossCount++;
+            }
+        }
+
+        const avgWinHold = winCount > 0 ? winDur / winCount : 0;
+        const avgLossHold = lossCount > 0 ? lossDur / lossCount : 0;
+
+        if (avgWinHold === 0) return 2.0; // Infinite bias if they never hold winners
+        return avgLossHold / avgWinHold;
+    }
+
+    /**
+     * Prospect Theory Utility Function (Kahneman/Tversky).
+     * Models the psychological "utility" (pain/pleasure) of a return.
+     * Losses hurt approx 2.25x more than gains feel good.
+     * @param {number} pnl - Net Profit %.
+     */
+    static prospectUtility(pnl, lambda = 2.25, alpha = 0.88) {
+        if (pnl >= 0) {
+            return Math.pow(pnl, alpha);
+        } else {
+            return -lambda * Math.pow(Math.abs(pnl), alpha);
+        }
+    }
+}
+
+class SkillAttribution {
+    /**
+     * Calculates Selection Skill (Alpha) by comparing User PnL vs Asset Benchmark.
+     * Note: Since we don't have individual asset performance histories easily available
+     * in the user context, we use the 'Insights' global growth as a daily benchmark proxy.
+     * @param {Array} userPositions - Current open positions.
+     * @param {Object} dailyInsights - Map of InstrumentID -> Insight Data (which contains 'growth').
+     */
+    static calculateSelectionAlpha(userPositions, dailyInsights) {
+        let totalAlpha = 0;
+        let count = 0;
+
+        for (const pos of userPositions) {
+            const instrumentId = pos.InstrumentID;
+            // Note: Schema 5 (Insights) is an array, we assume it's converted to a map or we find it.
+            // If passed as array, we find the item.
+            let insight = null;
+            if (Array.isArray(dailyInsights)) {
+                insight = dailyInsights.find(i => i.instrumentId === instrumentId);
+            }
+
+            if (insight && typeof insight.growth === 'number') {
+                // User PnL for today isn't explicitly stored, but Total PnL is.
+                // We use NetProfit as a proxy for "Performance" state.
+                // A Better proxy: Is their NetProfit > The Asset's Weekly Growth?
+                // This is a rough heuristic given schema limitations.
+                
+                // If the user is long and PnL > 0, and Growth is negative, that's high alpha (Bucking the trend).
+                // Simplified: Just returning the difference.
+                const diff = pos.NetProfit - insight.growth;
+                totalAlpha += diff;
+                count++;
+            }
+        }
+        return count > 0 ? totalAlpha / count : 0;
+    }
+}
+
+class ExecutionAnalytics {
+    static calculateEfficiency(price, priceHistory, date, direction, windowDays = 7) {
+        if (!priceHistory || priceHistory.length === 0) return 0.5;
+        const targetDate = new Date(date);
+        const start = new Date(targetDate); start.setDate(start.getDate() - windowDays);
+        const end = new Date(targetDate); end.setDate(end.getDate() + windowDays);
+        const pricesInWindow = priceHistory.filter(p => { const d = new Date(p.date); return d >= start && d <= end; }).map(p => p.price);
+        if (pricesInWindow.length === 0) return 0.5;
+        const minP = Math.min(...pricesInWindow);
+        const maxP = Math.max(...pricesInWindow);
+        const range = maxP - minP;
+        if (range === 0) return 0.5;
+        const location = (price - minP) / range;
+        if (direction === 'Buy') { return 1 - location; } else { return location; }
+    }
+    static calculateLossTolerance(realizedPnL, maxDrawdown) {
+        if (maxDrawdown === 0) return 1; 
+        return (realizedPnL - maxDrawdown) / Math.abs(maxDrawdown);
+    }
+}
+
+class Psychometrics {
+    static computeDispositionSkew(historyTrades, currentPositions) {
+        const getMedian = (arr) => { if (!arr.length) return 0; const sorted = [...arr].sort((a, b) => a - b); const mid = Math.floor(sorted.length / 2); return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2; };
+        const realized = historyTrades.map(t => t.NetProfit);
+        const unrealized = currentPositions.map(p => p.NetProfit);
+        if (realized.length < 5 || unrealized.length < 5) return 0;
+        return getMedian(realized) - getMedian(unrealized);
+    }
+    static detectRevengeTrading(historyTrades) {
+        let riskSpikes = 0; let losses = 0; if (historyTrades.length === 0) return 0;
+        const avgLev = historyTrades.reduce((sum, t) => sum + (t.Leverage || 1), 0) / historyTrades.length;
+        for (let i = 1; i < historyTrades.length; i++) {
+            const prev = historyTrades[i-1]; const curr = historyTrades[i];
+            if (prev.NetProfit < 0) { losses++; if ((curr.Leverage || 1) > (avgLev * 1.5)) { riskSpikes++; } }
+        }
+        return losses > 0 ? (riskSpikes / losses) : 0;
+    }
+}
+
+class AdaptiveAnalytics {
+    static analyzeDrawdownAdaptation(tradeHistory, drawdownThreshold = -15) {
+        let adaptationScore = 0; let eventCount = 0;
+        for (let i = 0; i < tradeHistory.length - 3; i++) {
+            if (tradeHistory[i].NetProfit < drawdownThreshold) {
+                eventCount++; const nextTrades = tradeHistory.slice(i+1, i+4);
+                const prevLev = tradeHistory[i].Leverage || 1;
+                const nextLevAvg = nextTrades.reduce((s, t) => s + (t.Leverage||1), 0) / 3;
+                if (nextLevAvg < prevLev) adaptationScore += 1; else if (nextLevAvg > prevLev * 1.5) adaptationScore -= 2; 
+                const lostInstrument = tradeHistory[i].InstrumentID;
+                const stuckToSame = nextTrades.every(t => t.InstrumentID === lostInstrument);
+                if (!stuckToSame) adaptationScore += 0.5; 
+            }
+        }
+        return eventCount > 0 ? (adaptationScore / eventCount) : 0;
+    }
+}
+
+class UserClassifier {
+    static classify(context) {
+        const { user, math, prices } = context;
+        const history = user.history.today?.PublicHistoryPositions || [];
+        const validHistory = history.filter(t => t.OpenDateTime);
+        validHistory.sort((a, b) => new Date(a.OpenDateTime) - new Date(b.OpenDateTime));
+        const portfolio = math.extract.getPositions(user.portfolio.today, user.type);
+        const summary = math.history.getSummary(user.history.today);
+        if (!summary) return { intelligence: { label: SCHEMAS.LABELS.NEUTRAL, score: 0 }, style: { primary: SCHEMAS.STYLES.INVESTOR } };
+
+        let entryScores = [];
+        const recentTrades = validHistory.slice(-20); 
+        for (const t of recentTrades) {
+            const ticker = context.mappings.instrumentToTicker[t.InstrumentID];
+            const priceData = math.priceExtractor.getHistory(prices, ticker);
+            if (priceData && priceData.length > 0) { entryScores.push(ExecutionAnalytics.calculateEfficiency(t.OpenRate, priceData, t.OpenDateTime, 'Buy')); }
+        }
+        const avgEntryEff = math.compute.average(entryScores) || 0.5;
+        const dispositionSkew = Psychometrics.computeDispositionSkew(validHistory, portfolio);
+        const revengeScore = Psychometrics.detectRevengeTrading(validHistory);
+        const adaptationScore = AdaptiveAnalytics.analyzeDrawdownAdaptation(validHistory);
+        
+        // New Cognitive Bias Checks
+        const anchoring = CognitiveBiases.calculateAnchoringScore(portfolio);
+        const dispositionTime = CognitiveBiases.calculateDispositionEffect(validHistory);
+
+        const riskAdjustedReturn = summary.avgLossPct === 0 ? 10 : (summary.avgProfitPct / Math.abs(summary.avgLossPct));
+        let smartScore = 50; 
+        if (riskAdjustedReturn > 1.5) smartScore += 10;
+        if (riskAdjustedReturn > 3.0) smartScore += 10;
+        if (summary.winRatio > 60) smartScore += 10;
+        if (avgEntryEff > 0.7) smartScore += 10; 
+        if (avgEntryEff < 0.3) smartScore -= 5;  
+        if (dispositionSkew > 15) smartScore -= 20; else if (dispositionSkew < 5) smartScore += 10; 
+        if (revengeScore > 0.3) smartScore -= 25; 
+        if (adaptationScore > 0.5) smartScore += 5; if (adaptationScore < -0.5) smartScore -= 10; 
+        
+        // Penalty for biases
+        if (anchoring > 0.3) smartScore -= 10;
+        if (dispositionTime > 1.5) smartScore -= 10;
+
+        let label = SCHEMAS.LABELS.NEUTRAL;
+        if (smartScore >= 80) label = SCHEMAS.LABELS.ELITE;
+        else if (smartScore >= 65) label = SCHEMAS.LABELS.SMART;
+        else if (smartScore <= 30) label = SCHEMAS.LABELS.GAMBLER;
+        else if (smartScore <= 45) label = SCHEMAS.LABELS.DUMB;
+
+        const styleProfile = this.classifyStyle(validHistory, portfolio);
+        return {
+            intelligence: { label: label, score: Math.max(0, Math.min(100, smartScore)), isSmart: smartScore >= 65 },
+            style: styleProfile,
+            metrics: {
+                entryEfficiency: avgEntryEff,
+                dispositionSkew: dispositionSkew,
+                revengeTendency: revengeScore,
+                riskRewardRatio: riskAdjustedReturn,
+                drawdownAdaptation: adaptationScore,
+                biasAnchoring: anchoring,
+                biasDispositionTime: dispositionTime
+            }
+        };
+    }
+
+    static classifyStyle(history, portfolio) {
+        let totalMinutes = 0; let validTrades = 0;
+        history.forEach(t => { if (t.OpenDateTime && t.CloseDateTime) { const open = new Date(t.OpenDateTime); const close = new Date(t.CloseDateTime); totalMinutes += (close - open) / 60000; validTrades++; } });
+        const avgHoldTime = validTrades > 0 ? totalMinutes / validTrades : 0;
+        let baseStyle = SCHEMAS.STYLES.INVESTOR;
+        if (validTrades > 0) { if (avgHoldTime < 60) baseStyle = SCHEMAS.STYLES.SCALPER; else if (avgHoldTime < 60 * 24) baseStyle = SCHEMAS.STYLES.DAY_TRADER; else if (avgHoldTime < 60 * 24 * 7) baseStyle = SCHEMAS.STYLES.SWING_TRADER; }
+        const subStyles = new Set();
+        const assets = [...history, ...portfolio]; let leverageCount = 0;
+        assets.forEach(p => { if ((p.Leverage || 1) > 1) leverageCount++; });
+        const tradeCount = assets.length || 1;
+        if ((leverageCount / tradeCount) > 0.3) subStyles.add("Speculative"); if ((leverageCount / tradeCount) > 0.8) subStyles.add("High-Leverage");
+        return { primary: baseStyle, tags: Array.from(subStyles), avgHoldTimeMinutes: avgHoldTime };
+    }
+}
+
+module.exports = { 
+    SCHEMAS, 
+    UserClassifier,
+    ExecutionAnalytics,
+    Psychometrics,
+    AdaptiveAnalytics,
+    CognitiveBiases, // New
+    SkillAttribution // New
+};