aiden-shared-calculations-unified 1.0.92 → 1.0.94

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

@@ -1,6 +1,7 @@
 /**
  * @fileoverview CORE Product Line (Pass 1 - Meta)
- * Calculates annualized volatility using the new priceExtractor.
+ * Calculates annualized volatility.
+ * Safe for sharded execution (accumulates results).
  */
 class AssetVolatilityEstimator {
     constructor() {
@@ -33,31 +34,30 @@ class AssetVolatilityEstimator {
     }
 
     process(context) {
-        // FIXED: Destructure 'mappings' to resolve real tickers
         const { math, prices, mappings } = context; 
-        
-        // FIXED: Destructure 'priceExtractor' directly (matches worker.js injection)
         const { compute, priceExtractor } = math; 
+        
+        if (!prices || !prices.history) return;
 
-        // 1. Get ALL histories properly sorted and parsed
+        // Efficiently extract only histories present in this shard/context
         const allHistories = priceExtractor.getAllHistories(prices);
 
+        const batchResult = {};
+
         for (const [key, candles] of allHistories.entries()) {
-            // RESOLUTION FIX: 
-            // 'key' is likely an index string ("0") because mock data is an array.
-            // We must resolve this to the real Ticker Symbol for the result map.
             let ticker = key;
 
-            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;
 
-            // 2. Calculate Log Returns
             const logReturns = [];
             let lastPrice = 0;
 
@@ -65,28 +65,31 @@ 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;
                 }
             }
 
-            // 3. Filter 30-Day Lookback
             const LOOKBACK = 30;
             const relevantReturns = logReturns.slice(-LOOKBACK);
 
+            // Guard: Need enough returns for Standard Deviation
             if (relevantReturns.length < 5) continue;
 
-            // 4. Calculate Stats
             const stdDev = compute.standardDeviation(relevantReturns);
             const annualizedVol = stdDev * Math.sqrt(365);
 
-            this.result[ticker] = {
-                volatility_30d: annualizedVol,
+            batchResult[ticker] = {
+                volatility_30d: Number(annualizedVol.toFixed(4)),
                 last_price: lastPrice,
                 data_points: relevantReturns.length
             };
         }
+        
+        // Accumulate results (handling batched execution)
+        Object.assign(this.result, batchResult);
     }
 
     async getResult() { return this.result; }

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/core/instrument-price-change-1d.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Calculation (Pass 1 - Meta) for 1-day price change.
- * FIXED: Uses priceExtractor properly
+ * FIXED: Supports Sharded/Batched Execution (Accumulates results).
  */
 class InstrumentPriceChange1D {
     constructor() {
@@ -36,7 +36,7 @@ class InstrumentPriceChange1D {
         const { priceExtractor } = math;
         
         if (!prices || !prices.history) {
-            this.result = {};
+            // Do NOT reset result here, just return if this shard is empty
             return;
         }
 
@@ -46,34 +46,37 @@ class InstrumentPriceChange1D {
         yesterdayDate.setUTCDate(yesterdayDate.getUTCDate() - 1);
         const yesterdayStr = yesterdayDate.toISOString().slice(0, 10);
 
-        const results = {};
+        const batchResults = {};
 
-        // Iterate over all instruments in price history
+        // Iterate over THIS SHARD'S instruments
         for (const [instrumentId, priceData] of Object.entries(prices.history)) {
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue;
 
+            // Note: getHistory works on the partial 'prices' object just fine
             const history = priceExtractor.getHistory(prices, instrumentId);
             if (history.length === 0) continue;
 
-            // Find today's and yesterday's prices
             const todayPrice = priceData.prices?.[todayStr];
             const yesterdayPrice = priceData.prices?.[yesterdayStr];
 
             if (todayPrice && yesterdayPrice && yesterdayPrice > 0) {
                 const changePct = ((todayPrice - yesterdayPrice) / yesterdayPrice) * 100;
-                results[ticker] = {
+                batchResults[ticker] = {
                     change_1d_pct: isFinite(changePct) ? changePct : 0
                 };
             } else {
-                results[ticker] = { change_1d_pct: 0 };
+                batchResults[ticker] = { change_1d_pct: 0 };
             }
         }
         
-        this.result = results;
+        // Merge batch results into main result
+        Object.assign(this.result, batchResults);
     }
 
     async getResult() { return this.result; }
+    
+    // Explicit reset only called by system between full runs
     reset() { this.result = {}; }
 }
 module.exports = InstrumentPriceChange1D;

package/calculations/core/instrument-price-momentum-20d.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Calculation (Pass 1 - Meta) for 20-day momentum.
- * FIXED: Uses priceExtractor properly
+ * FIXED: Supports Sharded/Batched Execution (Accumulates results).
  */
 class InstrumentPriceMomentum20D {
     constructor() {
@@ -49,7 +49,6 @@ class InstrumentPriceMomentum20D {
         const { instrumentToTicker } = mappings;
         
         if (!prices || !prices.history) {
-            this.result = {};
             return;
         }
         
@@ -59,9 +58,9 @@ class InstrumentPriceMomentum20D {
         twentyDaysAgo.setUTCDate(todayDate.getUTCDate() - 20);
         const oldStr = twentyDaysAgo.toISOString().slice(0, 10);
 
-        const results = {};
+        const batchResults = {};
 
-        // Iterate over all instruments in price history
+        // Iterate over THIS SHARD'S instruments
         for (const [instrumentId, priceData] of Object.entries(prices.history)) {
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue;
@@ -71,15 +70,16 @@ class InstrumentPriceMomentum20D {
 
             if (currentPrice && oldPrice && oldPrice > 0) {
                 const momPct = ((currentPrice - oldPrice) / oldPrice) * 100;
-                results[ticker] = {
+                batchResults[ticker] = {
                     momentum_20d_pct: isFinite(momPct) ? momPct : 0
                 };
             } else {
-                results[ticker] = { momentum_20d_pct: 0 };
+                batchResults[ticker] = { momentum_20d_pct: 0 };
             }
         }
         
-        this.result = results;
+        // Merge
+        Object.assign(this.result, batchResults);
     }
 
     async getResult() { return this.result; }

package/calculations/core/price-metrics.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Calculation (Pass 1 - Meta) for historical price metrics.
- * REFACTORED: Uses process(context) solely.
+ * FIXED: Supports Sharded/Batched Execution.
+ * MOVED: Sector aggregation logic moved to getResult() to handle sharding correctly.
  */
 const RANGES = [7, 30, 90, 365];
 const TRADING_DAYS_PER_YEAR = 252;
@@ -8,6 +9,8 @@ const TRADING_DAYS_PER_YEAR = 252;
 class CorePriceMetrics {
     constructor() {
         this.result = { by_instrument: {}, by_sector: {} };
+        // We persist mappings here because we process shard-by-shard
+        this.mappings = null; 
     }
 
     static getMetadata() {
@@ -87,25 +90,22 @@ class CorePriceMetrics {
 
     process(context) {
         const { mappings, prices, date } = context;
-        // FIX 1: Use the correct property name 'instrumentToSector'
-        const { instrumentToTicker, instrumentToSector } = mappings; 
+        const { instrumentToTicker } = mappings;
+        
+        // Save mappings for the final aggregation step
+        if (!this.mappings) this.mappings = mappings;
         
         const priceData = prices?.history;
         const todayDateStr = date.today;
 
         if (!priceData || !todayDateStr) {
-            this.result = { by_instrument: {}, by_sector: {} };
             return;
         }
 
-        const by_instrument = {};
-        const tickerToInstrument = {};
-
-        // FIX 2: Iterate over Object.values() since priceData is a map, not an array
+        // Iterate over THIS SHARD'S data
         for (const p of Object.values(priceData)) {
             const ticker = instrumentToTicker[p.instrumentId];
             if (!ticker) continue;
-            tickerToInstrument[ticker] = p.instrumentId;
 
             const metrics = {};
             for (const range of RANGES) {
@@ -119,14 +119,26 @@ class CorePriceMetrics {
                     ? (stats.mean / stats.stdDev) * Math.sqrt(TRADING_DAYS_PER_YEAR) 
                     : 0;
             }
-            by_instrument[ticker] = metrics;
+            // Accumulate into by_instrument
+            this.result.by_instrument[ticker] = metrics;
+        }
+    }
+
+    async getResult() { 
+        // Perform Sector Aggregation HERE (after all shards are processed)
+        const by_instrument = this.result.by_instrument;
+        const instrumentToSector = this.mappings?.instrumentToSector || {};
+        const instrumentToTicker = this.mappings?.instrumentToTicker || {};
+        
+        // Reverse map ticker -> instrumentId
+        const tickerToInstrument = {};
+        for(const [id, tick] of Object.entries(instrumentToTicker)) {
+            tickerToInstrument[tick] = id;
         }
 
-        // Sector Aggregation
         const sectorAggs = {};
         for (const ticker in by_instrument) {
             const instId = tickerToInstrument[ticker];
-            // FIX 1 (Usage): Use the corrected variable name
             const sector = instrumentToSector[instId] || "Unknown"; 
             
             if (!sectorAggs[sector]) sectorAggs[sector] = { metrics: {}, counts: {} };
@@ -152,11 +164,14 @@ class CorePriceMetrics {
                 by_sector[sector][`average_${key}`] = count > 0 ? sectorAggs[sector].metrics[key] / count : null;
             }
         }
-
-        this.result = { by_instrument, by_sector };
+        
+        this.result.by_sector = by_sector;
+        return this.result; 
     }
 
-    async getResult() { return this.result; }
-    reset() { this.result = { by_instrument: {}, by_sector: {} }; }
+    reset() { 
+        this.result = { by_instrument: {}, by_sector: {} }; 
+        this.mappings = null;
+    }
 }
 module.exports = CorePriceMetrics;

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.92",
+  "version": "1.0.94",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [