aiden-shared-calculations-unified 1.0.93 → 1.0.95

package/calculations/capitulation/asset-volatility-estimator.js

@@ -1,7 +1,7 @@
 /**
  * @fileoverview CORE Product Line (Pass 1 - Meta)
- * Calculates annualized volatility using the new priceExtractor.
- * FIXED: Supports Sharded/Batched Execution (Accumulates results).
+ * Calculates annualized volatility.
+ * Safe for sharded execution (accumulates results).
  */
 class AssetVolatilityEstimator {
     constructor() {
@@ -39,7 +39,7 @@ class AssetVolatilityEstimator {
         
         if (!prices || !prices.history) return;
 
-        // 1. Get THIS SHARD'S histories
+        // Efficiently extract only histories present in this shard/context
         const allHistories = priceExtractor.getAllHistories(prices);
 
         const batchResult = {};
@@ -47,15 +47,16 @@ class AssetVolatilityEstimator {
         for (const [key, candles] of allHistories.entries()) {
             let ticker = key;
 
-            // Resolve ticker (logic maintained from original)
-            if (prices.history && prices.history[key] && prices.history[key].instrumentId) {
+            // Resolve ticker logic
+            if (prices.history[key] && prices.history[key].instrumentId) {
                 const instId = prices.history[key].instrumentId;
                 if (mappings && mappings.instrumentToTicker && mappings.instrumentToTicker[instId]) {
                     ticker = mappings.instrumentToTicker[instId];
                 }
             }
 
-            if (candles.length < 10) continue;
+            // Guard: Need enough data for a trend
+            if (!candles || candles.length < 10) continue;
 
             const logReturns = [];
             let lastPrice = 0;
@@ -64,6 +65,7 @@ class AssetVolatilityEstimator {
                 const prev = candles[i-1].price;
                 const curr = candles[i].price;
                 
+                // Guard: Prevent log(0) or log(negative) errors
                 if (prev > 0 && curr > 0) {
                     logReturns.push(Math.log(curr / prev));
                     lastPrice = curr;
@@ -73,19 +75,20 @@ class AssetVolatilityEstimator {
             const LOOKBACK = 30;
             const relevantReturns = logReturns.slice(-LOOKBACK);
 
+            // Guard: Need enough returns for Standard Deviation
             if (relevantReturns.length < 5) continue;
 
             const stdDev = compute.standardDeviation(relevantReturns);
             const annualizedVol = stdDev * Math.sqrt(365);
 
             batchResult[ticker] = {
-                volatility_30d: annualizedVol,
+                volatility_30d: Number(annualizedVol.toFixed(4)),
                 last_price: lastPrice,
                 data_points: relevantReturns.length
             };
         }
         
-        // Accumulate
+        // Accumulate results (handling batched execution)
         Object.assign(this.result, batchResult);
     }
 

package/calculations/capitulation/retail-capitulation-risk-forecast.js

@@ -1,16 +1,18 @@
 /**
  * @fileoverview CORE Product Line (Pass 2 - Standard)
  * Calculates capitulation risk using DYNAMIC volatility from asset-volatility-estimator.
- * Relies on 'schema.md' definitions for portfolio extraction via MathPrimitives.
+ * MEMORY OPTIMIZED: Uses Cohort Aggregation instead of raw user arrays.
  */
 
 class RetailCapitulationRiskForecast {
     constructor() {
-        this.assetRiskProfiles = new Map();
+        // Map<Ticker, Map<CohortKey, { entryPrice, thresholdPct, weight }>>
+        this.assetCohorts = new Map();
+        
+        // Cache for Ticker Map
         this.tickerMap = null;
         
-        // FIX: Use a container object (like the Maps in other calculations)
-        // This allows us to MUTATE 'deps.mathLib' instead of RE-ASSIGNING 'this.mathLib'
+        // Container for dependency injection (MathLib)
         this.deps = { mathLib: null };
     }
 
@@ -43,23 +45,11 @@ class RetailCapitulationRiskForecast {
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    _initAsset(ticker, currentPrice, volatility) {
-        if (!this.assetRiskProfiles.has(ticker)) {
-            this.assetRiskProfiles.set(ticker, {
-                currentPrice: currentPrice,
-                volatility: volatility, 
-                profiles: []
-            });
-        }
-    }
-
     process(context) {
         const { user, mappings, math, computed } = context;
         const { extract, history, compute, signals } = math;
 
-        // 1. Capture Libraries via MUTATION
-        // We are retrieving the 'deps' object (GET) and mutating its property.
-        // This bypasses the Proxy SET trap entirely.
+        // 1. Capture MathLib (Mutation Pattern)
         if (!this.deps.mathLib && compute) {
             this.deps.mathLib = compute;
         }
@@ -69,68 +59,123 @@ class RetailCapitulationRiskForecast {
         }
 
         // 2. Determine User's "Pain Threshold"
+        // We bucket this to the nearest 5% to reduce cardinality
         const historyDoc = history.getDailyHistory(user);
         const summary = history.getSummary(historyDoc);
-        let personalPainThreshold = (summary && summary.avgLossPct < 0) 
-            ? summary.avgLossPct 
-            : -25.0;
+        let rawThreshold = (summary && summary.avgLossPct < 0) ? summary.avgLossPct : -25.0;
+        const bucketedThreshold = Math.round(rawThreshold / 5) * 5; 
 
         // 3. Analyze Positions
         const positions = extract.getPositions(user.portfolio.today, user.type);
 
        for (const pos of positions) {
             const instId = extract.getInstrumentId(pos);
-            
             if (!this.tickerMap) continue;
-
             const ticker = this.tickerMap[instId];
-            
             if (!ticker) continue;
 
-            // Fetch Dependency
+            // Fetch Volatility & Price from Dependency
+            // Note: We access this to normalize Entry Price, but we store Volatility 
+            // at the aggregation stage to keep it consistent.
             const assetStats = signals.getPreviousState(computed, 'asset-volatility-estimator', ticker);
-            
-            const dynamicVol = assetStats ? assetStats.volatility_30d : 0.60;
             const currentPrice = assetStats ? assetStats.last_price : 0;
+            const dynamicVol = assetStats ? assetStats.volatility_30d : 0.60;
 
             if (currentPrice <= 0) continue;
 
-            // Get P&L from Position Schema
             const netProfit = extract.getNetProfit(pos);     
-            
-            // Calculate Entry Price using the Dependency Price
             const entryPrice = extract.deriveEntryPrice(currentPrice, netProfit);
 
             if (entryPrice > 0) {
-                this._initAsset(ticker, currentPrice, dynamicVol);
-                this.assetRiskProfiles.get(ticker).profiles.push({
-                    entryPrice: entryPrice,
-                    thresholdPct: personalPainThreshold
-                });
+                this._aggregateCohort(ticker, entryPrice, bucketedThreshold, currentPrice, dynamicVol);
+            }
+        }
+    }
+
+    /**
+     * Aggregates a user into a memory-efficient cohort.
+     */
+    _aggregateCohort(ticker, entryPrice, thresholdPct, currentPrice, volatility) {
+        if (!this.assetCohorts.has(ticker)) {
+            this.assetCohorts.set(ticker, {
+                currentPrice,
+                volatility,
+                cohorts: new Map() // Key: "Entry_Threshold" -> Value: { count }
+            });
+        }
+
+        const assetData = this.assetCohorts.get(ticker);
+        
+        // Update volatility/price (last write wins is fine for streaming updates of same asset)
+        assetData.currentPrice = currentPrice;
+        assetData.volatility = volatility;
+
+        // Create Cohort Key
+        // Round Entry Price to 2 significant digits to bucket users
+        const entryKey = entryPrice.toPrecision(3); 
+        const cohortKey = `${entryKey}_${thresholdPct}`;
+
+        if (!assetData.cohorts.has(cohortKey)) {
+            assetData.cohorts.set(cohortKey, {
+                entryPrice: parseFloat(entryKey),
+                thresholdPct: thresholdPct,
+                count: 0
+            });
+        }
+
+        // Increment count (Weighting)
+        assetData.cohorts.get(cohortKey).count++;
+    }
+
+    /**
+     * Local implementation of Population Breakdown that handles WEIGHTED cohorts.
+     * Replaces math.simulatePopulationBreakdown for this specific optimized calculation.
+     */
+    _simulateWeightedBreakdown(pricePaths, cohorts) {
+        if (!pricePaths.length || cohorts.length === 0) return 0;
+        
+        let totalBreakdownEvents = 0;
+        const totalSims = pricePaths.length;
+        
+        // Calculate total users (sum of all cohort counts)
+        const totalUsers = cohorts.reduce((sum, c) => sum + c.count, 0);
+        if (totalUsers === 0) return 0;
+
+        for (let i = 0; i < totalSims; i++) {
+            const simPrice = pricePaths[i];
+            let capitulatedCount = 0;
+
+            for (const cohort of cohorts) {
+                // P&L% = (CurrentValue - EntryValue) / EntryValue
+                const hypotheticalPnL = ((simPrice - cohort.entryPrice) / cohort.entryPrice) * 100;
+                
+                if (hypotheticalPnL < cohort.thresholdPct) {
+                    capitulatedCount += cohort.count; // Add the WEIGHT of the cohort
+                }
             }
+            
+            totalBreakdownEvents += (capitulatedCount / totalUsers);
         }
+        
+        return totalBreakdownEvents / totalSims;
     }
 
     async getResult() {
         const result = {};
         const TIME_HORIZON_DAYS = 3;      
         const SIMULATION_COUNT = 1000;    
-        
-        // Access the library from the container
         const mathLib = this.deps.mathLib;
 
-        if (!mathLib || !mathLib.simulateGBM) {
-            console.log('[DEBUG RCRF] MathLib missing in deps container!');
-            return {};
-        }
+        if (!mathLib || !mathLib.simulateGBM) return {};
 
-        for (const [ticker, data] of this.assetRiskProfiles.entries()) {
-            if (data.profiles.length < 1) { 
-                 continue; 
-            }
+        for (const [ticker, data] of this.assetCohorts.entries()) {
+            // Flatten Map values to Array for iteration
+            const cohortArray = Array.from(data.cohorts.values());
+            
+            if (cohortArray.length === 0) continue;
             
             try {
-                // 1. Generate Price Paths
+                // 1. Generate Price Paths (O(Sims))
                 const pricePaths = mathLib.simulateGBM(
                     data.currentPrice, 
                     data.volatility, 
@@ -140,23 +185,26 @@ class RetailCapitulationRiskForecast {
                 
                 if (!pricePaths || pricePaths.length === 0) continue;
 
-                // 2. Run Population Breakdown
-                const capitulationProb = mathLib.simulatePopulationBreakdown(
+                // 2. Run Weighted Population Breakdown (O(Sims * Cohorts))
+                // This is much faster than O(Sims * Users)
+                const capitulationProb = this._simulateWeightedBreakdown(
                     pricePaths, 
-                    data.profiles
+                    cohortArray
                 );
 
-                const totalThreshold = data.profiles.reduce((acc, p) => acc + p.thresholdPct, 0);
-                const avgThreshold = totalThreshold / data.profiles.length;
+                // Calculate weighted average threshold for reporting
+                const totalUsers = cohortArray.reduce((sum, c) => sum + c.count, 0);
+                const weightedThresholdSum = cohortArray.reduce((sum, c) => sum + (c.thresholdPct * c.count), 0);
+                const avgThreshold = totalUsers > 0 ? weightedThresholdSum / totalUsers : -25;
 
                 result[ticker] = {
                     capitulation_probability: parseFloat(capitulationProb.toFixed(4)),
-                    at_risk_user_count: data.profiles.length,
+                    at_risk_user_count: totalUsers,
                     average_pain_threshold_pct: parseFloat(avgThreshold.toFixed(2)),
                     used_volatility: parseFloat(data.volatility.toFixed(4))
                 };
             } catch (err) {
-                console.log(`[DEBUG RCRF] Error processing ${ticker}: ${err.message}`);
+                // Silent catch to prevent one bad ticker from stopping the batch
             }
         }
         
@@ -164,9 +212,9 @@ class RetailCapitulationRiskForecast {
     }
 
     reset() {
-        this.assetRiskProfiles.clear();
+        this.assetCohorts.clear();
         this.tickerMap = null;
-        this.deps.mathLib = null; // Reset the container
+        this.deps.mathLib = null;
     }
 }
 

package/calculations/gauss/cohort-definer.js

@@ -24,10 +24,32 @@ class CohortDefiner {
     }
 
     static getSchema() {
-        const cohortSchema = { "type": "array", "items": { "type": "string" } };
+        const cohortList = { 
+            "type": "array", 
+            "items": { "type": "string" },
+            "description": "List of User IDs belonging to this behavioral cohort" 
+        };
+
         return {
             "type": "object",
-            "patternProperties": { "^.*$": cohortSchema }
+            "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
+            }
         };
     }
     

package/calculations/ghost-book/cost-basis-density.js

@@ -7,7 +7,7 @@ class CostBasisDensity {
 
     static getMetadata() {
         return {
-            type: 'meta',
+            type: 'meta', // Runs ONCE per day
             dependencies: ['asset-cost-basis-profile'],
             category: 'ghost_book'
         };
@@ -35,11 +35,17 @@ class CostBasisDensity {
         const { computed, math } = context;
         const { signals: SignalPrimitives } = math;
         
+        // 1. Get Union of Tickers (Safe Iteration)
         const tickers = SignalPrimitives.getUnionKeys(computed, ['asset-cost-basis-profile']);
 
         for (const ticker of tickers) {
+            // 2. Safe Data Access
             const data = computed['asset-cost-basis-profile'][ticker];
-            if (!data || !data.profile) continue;
+            
+            // Check for 'profile' specifically as it contains the density curve
+            if (!data || !Array.isArray(data.profile) || data.profile.length < 3) {
+                continue; 
+            }
 
             const profile = data.profile; // Array of {price, density}
             const currentPrice = data.current_price;
@@ -48,26 +54,42 @@ class CostBasisDensity {
             const support = [];
             let maxDensity = 0;
 
-            // Find Local Maxima in the Density Curve
+            // 3. Peak Detection Algorithm
+            // Iterate through the KDE curve to find local maxima
             for (let i = 1; i < profile.length - 1; i++) {
                 const prev = profile[i-1].density;
                 const curr = profile[i].density;
                 const next = profile[i+1].density;
 
+                // Simple Peak Check
                 if (curr > prev && curr > next) {
-                    // We have a peak (Wall)
+                    const priceVal = Number(profile[i].price.toFixed(2));
+
+                    // Classify as Resistance (Overhead Supply) or Support (Underlying Demand)
                     if (profile[i].price > currentPrice) {
-                        resistance.push(Number(profile[i].price.toFixed(2)));
+                        resistance.push(priceVal);
                     } else {
-                        support.push(Number(profile[i].price.toFixed(2)));
+                        support.push(priceVal);
                     }
+
                     if (curr > maxDensity) maxDensity = curr;
                 }
             }
 
+            // 4. Sort Walls by proximity to current price? 
+            // Currently slice(0,3) takes the first found, which are lower prices in a sorted KDE.
+            // Support: We want HIGHEST prices below current (closest to current).
+            // Resistance: We want LOWEST prices above current (closest to current).
+            
+            // Sort Descending (Highest Price First)
+            support.sort((a, b) => b - a);
+            
+            // Sort Ascending (Lowest Price First)
+            resistance.sort((a, b) => a - b);
+
             this.walls[ticker] = {
-                resistance_zones: resistance.slice(0, 3), // Top 3
-                support_zones: support.slice(0, 3),
+                resistance_zones: resistance.slice(0, 3), // Closest 3 resistance levels
+                support_zones: support.slice(0, 3),       // Closest 3 support levels
                 nearest_wall_strength: Number(maxDensity.toFixed(4))
             };
         }

package/calculations/predicative-alpha/mimetic-latency.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Mimetic Latency Oscillator (MLO) v2.2
- * REFACTORED: Offloaded math to primitives, corrected dependencies. TODO - HOW IS THIS GOING TO WORK GIVEN IT REQUIRES ITS OWN YESTERDAY DATA, BUT IT WILL BACKFILL IMMEDIATELY ON ITS FIRST PASS, AND THUS NOT FIND ANY YESTERDAY DATA? CONFUSED.
+ * Measures the lag between "Smart Money" flow and "Herd" conviction.
+ * Self-healing state: Warms up over 15-30 days automatically.
  */
 class MimeticLatencyOscillator {
     constructor() {
@@ -44,12 +45,10 @@ class MimeticLatencyOscillator {
 
         for (const ticker of tickers) {
             // 1. Inputs
-            // 'skilled-cohort-flow' -> net_flow_pct
             const rawFlow = SignalPrimitives.getMetric(computed, 'skilled-cohort-flow', ticker, 'net_flow_pct', 0);
-            // 'herd-consensus-score' -> herd_conviction_score
             const rawHerd = SignalPrimitives.getMetric(computed, 'herd-consensus-score', ticker, 'herd_conviction_score', 0);
 
-            // 2. Restore State
+            // 2. Restore State (Handle Cold Start)
             const prevResult = SignalPrimitives.getPreviousState(previousComputed, 'mimetic-latency', ticker);
             const prevState = prevResult ? prevResult._state : { flow_buffer: [], herd_buffer: [], last_flow: 0, last_herd: 0 };
 
@@ -67,20 +66,20 @@ class MimeticLatencyOscillator {
             flowBuffer.push(flowDelta);
             herdBuffer.push(herdDelta);
 
+            // Cap memory usage
             if (flowBuffer.length > this.windowSize) flowBuffer.shift();
             if (herdBuffer.length > this.windowSize) herdBuffer.shift();
 
             // 5. Lagged Cross-Correlation
             let maxCorr = -1.0;
             let bestLag = 0;
+            let regime = "WARM_UP";
 
+            // Only compute if we have statistical significance (>= 15 samples)
             if (flowBuffer.length >= 15) {
                 for (let k = 0; k <= this.maxLag; k++) {
-                    // Check if Flow[t-k] predicts Herd[t]
-                    // Slice Flow: 0 to End-k
-                    // Slice Herd: k to End
                     const len = flowBuffer.length;
-                    if (len - k < 5) continue; // Min sample check
+                    if (len - k < 5) continue; 
 
                     const slicedFlow = flowBuffer.slice(0, len - k);
                     const slicedHerd = herdBuffer.slice(k, len);
@@ -92,16 +91,15 @@ class MimeticLatencyOscillator {
                         bestLag = k;
                     }
                 }
-            }
 
-            // 6. Regime
-            let regime = "NO_SIGNAL";
-            if (maxCorr > 0.3) {
-                if (bestLag >= 3) regime = "EARLY_ALPHA";
-                else if (bestLag >= 1) regime = "MARKUP";
-                else regime = "FOMO_TRAP";
-            } else {
-                regime = "DECOUPLING";
+                // 6. Regime Classification
+                if (maxCorr > 0.3) {
+                    if (bestLag >= 3) regime = "EARLY_ALPHA";
+                    else if (bestLag >= 1) regime = "MARKUP";
+                    else regime = "FOMO_TRAP";
+                } else {
+                    regime = "DECOUPLING";
+                }
             }
 
             this.mloResults[ticker] = {

package/package.json

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