aiden-shared-calculations-unified 1.0.98 → 1.0.100

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

@@ -1,7 +1,7 @@
 /**
  * @fileoverview CORE Product Line (Pass 1 - Meta)
  * Calculates annualized volatility.
- * Safe for sharded execution (accumulates results).
+ * Clean: System automatically handles sharding for large result sets.
  */
 class AssetVolatilityEstimator {
     constructor() {
@@ -37,16 +37,10 @@ class AssetVolatilityEstimator {
         const { compute, priceExtractor } = math; 
         
         if (!prices || !prices.history) return;
-
-        // Efficiently extract only histories present in this shard/context
         const allHistories = priceExtractor.getAllHistories(prices);
 
-        const batchResult = {};
-
         for (const [key, candles] of allHistories.entries()) {
             let ticker = key;
-
-            // Resolve ticker logic
             if (prices.history[key] && prices.history[key].instrumentId) {
                 const instId = prices.history[key].instrumentId;
                 if (mappings && mappings.instrumentToTicker && mappings.instrumentToTicker[instId]) {
@@ -54,7 +48,6 @@ class AssetVolatilityEstimator {
                 }
             }
 
-            // Guard: Need enough data for a trend
             if (!candles || candles.length < 10) continue;
 
             const logReturns = [];
@@ -63,36 +56,32 @@ class AssetVolatilityEstimator {
             for (let i = 1; i < candles.length; i++) {
                 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;
                 }
             }
 
-            const LOOKBACK = 30;
-            const relevantReturns = logReturns.slice(-LOOKBACK);
-
-            // Guard: Need enough returns for Standard Deviation
+            const relevantReturns = logReturns.slice(-30);
             if (relevantReturns.length < 5) continue;
 
             const stdDev = compute.standardDeviation(relevantReturns);
             const annualizedVol = stdDev * Math.sqrt(365);
 
-            batchResult[ticker] = {
+            this.result[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; }
+    async getResult() { 
+        // No manual sharding needed. 
+        // If this object > 1MB, the system auto-shards it.
+        return this.result; 
+    }
+
     reset() { this.result = {}; }
 }
-
 module.exports = AssetVolatilityEstimator;

package/calculations/core/Insights-total-long-per-stock.js

@@ -1,56 +1,38 @@
-/**
- * @fileoverview Calculation (Pass 1) for total long figures.
- * REFACTORED: Uses INSIGHTS DATA.
- * TYPE: META
- */
-class InsightsTotalLongFigures {
-    constructor() {
-        this.totalPositions = 0;
+class InsightsTotalPositionsHeld {
+    constructor() { this.totalPositions = 0; }
+    
+    static getMetadata() { 
+        return { 
+            type: 'meta', 
+            rootDataDependencies: ['insights'], 
+            isHistorical: false, 
+            userType: 'n/a', 
+            category: 'Global-Platform-Metrics' 
+        }; 
     }
-
-    static getMetadata() {
-        return {
-            type: 'meta',
-            rootDataDependencies: ['insights'],
-            isHistorical: false,
-            category: 'core_sentiment'
-        };
-    }
-
+    
     static getDependencies() { return []; }
-
-    static getSchema() {
-        return {
-            "type": "object",
-            "properties": {
-                "total_long_exposure_weight": { "type": "number" },
-                "total_positions_count": { "type": "number" }
-            },
-            "required": ["total_long_exposure_weight", "total_positions_count"]
-        };
+    
+    static getSchema() { 
+        return { 
+            "type": "object", 
+            "properties": { "total_positions_count": { "type": "number" } }, 
+            "required": ["total_positions_count"] 
+        }; 
     }
-
+    
     process(context) {
         const { insights: insightsHelper } = context.math;
-        const insights = insightsHelper.getInsights(context);
+        const insights = insightsHelper.getInsights(context); // FIXED: Direct call
 
-        if (!insights) return;
+        if (insights.length === 0) return;
 
         for (const insight of insights) {
-            this.totalPositions += insightsHelper.getLongCount(insight);
+            this.totalPositions += insightsHelper.getTotalOwners(insight);
         }
     }
-
-    getResult() {
-        return {
-            total_long_exposure_weight: 0, // Not available in Insights
-            total_positions_count: this.totalPositions
-        };
-    }
-
-    reset() {
-        this.totalPositions = 0;
-    }
+    
+    getResult() { return { total_positions_count: this.totalPositions }; }
+    reset() { this.totalPositions = 0; }
 }
-
-module.exports = InsightsTotalLongFigures;
+module.exports = InsightsTotalPositionsHeld;

package/calculations/core/asset-pnl-status.js

@@ -1,12 +1,9 @@
 /**
  * @fileoverview Core Metric (Pass 2)
- * REFACTORED: Buckets P&L status by User Profile.
- * - Pivots data to be User-Centric (User -> Winners/Losers).
- * - Removes sharding complexity (fits within 1MB via structure optimization).
+ * Clean: System automatically handles sharding (e.g. 20k users).
  */
 class AssetPnlStatus {
     constructor() {
-        // Map<UserId, { winners: Set<String>, losers: Set<String> }>
         this.userStats = new Map();
     }
 
@@ -28,9 +25,8 @@ class AssetPnlStatus {
             "properties": {
                 "by_user": {
                     "type": "object",
-                    "description": "Map of User IDs to their winning/losing assets and sectors.",
                     "patternProperties": {
-                        "^[0-9]+$": { // Matches User IDs (CIDs)
+                        "^[0-9]+$": {
                             "type": "object",
                             "properties": {
                                 "winners": { "type": "array", "items": { "type": "string" } },
@@ -56,11 +52,9 @@ class AssetPnlStatus {
         const { mappings, user } = context;
         const userId = user.id;
 
-        // 1. Get Positions using the standard extractor
         const positions = extract.getPositions(user.portfolio.today, user.type);
         if (!positions || positions.length === 0) return;
 
-        // 2. Lazy init stats only if needed
         let stats = null;
 
         for (const pos of positions) {
@@ -68,7 +62,7 @@ class AssetPnlStatus {
             if (!instId) continue;
             
             const pnl = extract.getNetProfit(pos);
-            if (pnl === 0) continue; // Ignore flat positions
+            if (pnl === 0) continue; 
             
             const ticker = mappings.instrumentToTicker[instId];
             const sector = mappings.instrumentToSector[instId];
@@ -76,15 +70,11 @@ class AssetPnlStatus {
 
             if (ticker || sector) {
                 if (!stats) stats = this._initUser(userId);
-
                 if (ticker) {
-                    if (isWinner) stats.winners.add(ticker);
-                    else stats.losers.add(ticker);
+                    if (isWinner) stats.winners.add(ticker); else stats.losers.add(ticker);
                 }
-                
                 if (sector) {
-                    if (isWinner) stats.winners.add(sector);
-                    else stats.losers.add(sector);
+                    if (isWinner) stats.winners.add(sector); else stats.losers.add(sector);
                 }
             }
         }
@@ -94,7 +84,6 @@ class AssetPnlStatus {
         const byUser = {};
 
         for (const [userId, stats] of this.userStats) {
-            // Only include users who actually have relevant P&L data
             if (stats.winners.size > 0 || stats.losers.size > 0) {
                 byUser[userId] = {
                     winners: Array.from(stats.winners),
@@ -103,12 +92,11 @@ class AssetPnlStatus {
             }
         }
 
+        // Return flat object. Orchestrator handles 1MB limit.
         return { by_user: byUser };
     }
     
-    reset() {
-        this.userStats.clear();
-    }
+    reset() { this.userStats.clear(); }
 }
 
 module.exports = AssetPnlStatus;

package/calculations/core/insights-daily-bought-vs-sold-count.js

@@ -1,18 +1,38 @@
 class InsightsDailyBoughtVsSoldCount {
     constructor() { this.results = {}; }
-    static getMetadata() { return { type: 'meta', rootDataDependencies: ['insights'], isHistorical: true, category: 'core_metrics' }; }
+    
+    static getMetadata() { 
+        return { 
+            type: 'meta', 
+            rootDataDependencies: ['insights'], 
+            isHistorical: true, 
+            userType: 'n/a',
+            category: 'core_metrics' 
+        }; 
+    }
+    
     static getDependencies() { return []; }
+    
     static getSchema() {
-        const tickerSchema = { "type": "object", "properties": { "positions_bought": { "type": "number" }, "positions_sold": { "type": "number" }, "net_change": { "type": "number" } }, "required": ["positions_bought", "positions_sold", "net_change"] };
+        const tickerSchema = { 
+            "type": "object", 
+            "properties": { 
+                "positions_bought": { "type": "number" }, 
+                "positions_sold": { "type": "number" }, 
+                "net_change": { "type": "number" } 
+            }, 
+            "required": ["positions_bought", "positions_sold", "net_change"] 
+        };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
+    
     process(context) {
         const { insights: insightsHelper } = context.math;
-        const insights = insightsHelper.getInsights(context);
+        const insights = insightsHelper.getInsights(context); // FIXED: Direct call
         const { mappings } = context;
         const tickerMap = mappings.instrumentToTicker || {};
 
-        if (!insights || !Array.isArray(insights)) return; // FIX: Strict array check
+        if (insights.length === 0) return;
 
         for (const insight of insights) {
             const instId = insight.instrumentId;
@@ -22,10 +42,15 @@ class InsightsDailyBoughtVsSoldCount {
             const sold   = netChange < 0 ? Math.abs(netChange) : 0;
 
             if (bought > 0 || sold > 0) {
-                this.results[ticker] = { positions_bought: bought, positions_sold: sold, net_change: netChange };
+                this.results[ticker] = { 
+                    positions_bought: bought, 
+                    positions_sold: sold, 
+                    net_change: netChange 
+                };
             }
         }
     }
+    
     async getResult() { return this.results; }
     reset() { this.results = {}; }
 }

package/calculations/core/insights-daily-ownership-delta.js

@@ -1,30 +1,56 @@
 class InsightsDailyOwnershipDelta {
     constructor() { this.results = {}; }
-    static getMetadata() { return { type: 'meta', rootDataDependencies: ['insights'], isHistorical: true, category: 'core_metrics' }; }
+    
+    static getMetadata() { 
+        return { 
+            type: 'meta', 
+            rootDataDependencies: ['insights'], 
+            isHistorical: true, 
+            userType: 'n/a', 
+            category: 'core_metrics' 
+        }; 
+    }
+    
     static getDependencies() { return []; }
+    
     static getSchema() {
-        const tickerSchema = { "type": "object", "properties": { "owners_added": { "type": "number" }, "owners_removed": { "type": "number" }, "net_ownership_change": { "type": "number" } }, "required": ["owners_added", "owners_removed", "net_ownership_change"] };
+        const tickerSchema = { 
+            "type": "object", 
+            "properties": { 
+                "owners_added": { "type": "number" }, 
+                "owners_removed": { "type": "number" }, 
+                "net_ownership_change": { "type": "number" } 
+            }, 
+            "required": ["owners_added", "owners_removed", "net_ownership_change"] 
+        };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
+    
     process(context) {
         const { insights: insightsHelper } = context.math;
-        const insights = insightsHelper.getInsights(context);
+        const insights = insightsHelper.getInsights(context); // FIXED: Direct call
         const { mappings } = context;
         const tickerMap = mappings.instrumentToTicker || {};
 
-        if (!insights || !Array.isArray(insights)) return; // FIX: Strict array check
+        if (insights.length === 0) return;
 
         for (const insight of insights) {
             const netChange = insightsHelper.getNetOwnershipChange(insight);
             if (netChange === 0) continue;
+            
             const instId = insight.instrumentId;
             const ticker = tickerMap[instId] || `id_${instId}`;
             const added = netChange > 0 ? netChange : 0;
             const removed = netChange < 0 ? Math.abs(netChange) : 0;
 
-            this.results[ticker] = { owners_added: added, owners_removed: removed, net_ownership_change: netChange };
+            this.results[ticker] = { 
+                owners_added: added, 
+                owners_removed: removed, 
+                net_ownership_change: netChange 
+            };
         }
     }
+    
     async getResult() { return this.results; }
     reset() { this.results = {}; }
 }

package/calculations/core/insights-sentimet-per-stock.js

@@ -1,30 +1,57 @@
 class InsightsSentimentPerStock {
     constructor() { this.results = {}; }
+    
     static getSchema() {
-        const tickerSchema = { "type": "object", "properties": { "long_count": { "type": "number" }, "short_count": { "type": "number" }, "sentiment_ratio": { "type": ["number", "null"] } }, "required": ["long_count", "short_count", "sentiment_ratio"] };
+        const tickerSchema = { 
+            "type": "object", 
+            "properties": { 
+                "long_count": { "type": "number" }, 
+                "short_count": { "type": "number" }, 
+                "sentiment_ratio": { "type": ["number", "null"] } 
+            }, 
+            "required": ["long_count", "short_count", "sentiment_ratio"] 
+        };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
-    static getMetadata() { return { type: 'meta', rootDataDependencies: ['insights'], isHistorical: false, category: 'core_sentiment' }; }
+    
+    static getMetadata() { 
+        return { 
+            type: 'meta', 
+            rootDataDependencies: ['insights'], 
+            isHistorical: false, 
+            userType: 'n/a', 
+            category: 'core_sentiment' 
+        }; 
+    }
+    
     static getDependencies() { return []; }
+    
     process(context) {
         const { insights: insightsHelper } = context.math;
-        const insights = insightsHelper.getInsights(context);
+        const insights = insightsHelper.getInsights(context); // FIXED: Direct call
         const { mappings } = context;
         const tickerMap = mappings.instrumentToTicker || {};
 
-        if (!insights || !Array.isArray(insights)) return; // FIX: Strict array check
+        if (insights.length === 0) return;
 
         for (const insight of insights) {
             const longCount = insightsHelper.getLongCount(insight);
             const shortCount = insightsHelper.getShortCount(insight);
+            
             if (longCount === 0 && shortCount === 0) continue;
+            
             const instId = insight.instrumentId;
             const ticker = tickerMap[instId] || `id_${instId}`;
 
-            this.results[ticker] = { long_count: longCount, short_count: shortCount, sentiment_ratio: (shortCount > 0) ? (longCount / shortCount) : null };
+            this.results[ticker] = { 
+                long_count: longCount, 
+                short_count: shortCount, 
+                sentiment_ratio: (shortCount > 0) ? (longCount / shortCount) : null 
+            };
         }
     }
+    
     async getResult() { return this.results; }
     reset() { this.results = {}; }
 }
-module.exports = InsightsSentimentPerStock;
+module.exports = InsightsSentimentPerStock;

package/calculations/core/insights-total-long-per-sector.js

@@ -1,8 +1,3 @@
-/**
- * @fileoverview Calculation (Pass 1) for long figures per sector.
- * REFACTORED: Uses INSIGHTS DATA.
- * TYPE: META
- */
 class InsightsTotalLongPerSector {
     constructor() {
         this.sectorData = new Map();
@@ -13,6 +8,7 @@ class InsightsTotalLongPerSector {
             type: 'meta',
             rootDataDependencies: ['insights'],
             isHistorical: false,
+            userType: 'n/a', 
             category: 'core_sentiment'
         };
     }
@@ -33,11 +29,11 @@ class InsightsTotalLongPerSector {
 
     process(context) {
         const { insights: insightsHelper } = context.math;
-        const insights = insightsHelper.getInsights(context);
+        const insights = insightsHelper.getInsights(context); // FIXED: Direct call
         const { mappings } = context;
         const sectorMap = mappings.instrumentToSector || {};
 
-        if (!insights) return;
+        if (insights.length === 0) return;
 
         for (const insight of insights) {
             const longCount = insightsHelper.getLongCount(insight);
@@ -58,7 +54,6 @@ class InsightsTotalLongPerSector {
         for (const [sector, data] of this.sectorData.entries()) {
             if (data.count > 0) {
                 result[sector] = {
-                    total_long_exposure_weight: 0, // Not available
                     total_positions_count: data.count
                 };
             }

package/calculations/core/insights-total-positions-held.js

@@ -1,18 +1,39 @@
 class InsightsTotalPositionsHeld {
     constructor() { this.totalPositions = 0; }
-    static getMetadata() { return { type: 'meta', rootDataDependencies: ['insights'], isHistorical: false, category: 'Global-Platform-Metrics' }; }
+    
+    static getMetadata() { 
+        return { 
+            type: 'meta', 
+            rootDataDependencies: ['insights'], 
+            isHistorical: false, 
+            userType: 'n/a', 
+            category: 'Global-Platform-Metrics' 
+        }; 
+    }
+    
     static getDependencies() { return []; }
-    static getSchema() { return { "type": "object", "properties": { "total_positions_count": { "type": "number" } }, "required": ["total_positions_count"] }; }
+    
+    static getSchema() { 
+        return { 
+            "type": "object", 
+            "properties": { "total_positions_count": { "type": "number" } }, 
+            "required": ["total_positions_count"] 
+        }; 
+    }
+    
     process(context) {
         const { insights: insightsHelper } = context.math;
-        const insights = insightsHelper.getInsights(context);
+        const rawInsights = insightsHelper.getInsights(context);
+
+        const insights = insightsHelper.getInsights(context); // FIXED: Direct call
 
-        if (!insights || !Array.isArray(insights)) return; // FIX: Strict array check
+        if (insights.length === 0) return;
 
         for (const insight of insights) {
             this.totalPositions += insightsHelper.getTotalOwners(insight);
         }
     }
+    
     getResult() { return { total_positions_count: this.totalPositions }; }
     reset() { this.totalPositions = 0; }
 }

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

@@ -8,7 +8,10 @@ class CostBasisDensity {
     static getMetadata() {
         return {
             type: 'meta', // Runs ONCE per day
-            dependencies: ['asset-cost-basis-profile']
+            dependencies: ['asset-cost-basis-profile'],
+            userType: 'n/a',      // FIXED: Added missing field
+            isHistorical: false,  // FIXED: Explicitly defined
+            category: 'ghost_book'
         };
     }
     
@@ -34,37 +37,30 @@ 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];
             
-            // 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 profile = data.profile; 
             const currentPrice = data.current_price;
 
             const resistance = [];
             const support = [];
             let maxDensity = 0;
 
-            // 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) {
                     const priceVal = Number(profile[i].price.toFixed(2));
 
-                    // Classify as Resistance (Overhead Supply) or Support (Underlying Demand)
                     if (profile[i].price > currentPrice) {
                         resistance.push(priceVal);
                     } else {
@@ -75,20 +71,12 @@ class CostBasisDensity {
                 }
             }
 
-            // 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), // Closest 3 resistance levels
-                support_zones: support.slice(0, 3),       // Closest 3 support levels
+                resistance_zones: resistance.slice(0, 3), 
+                support_zones: support.slice(0, 3),       
                 nearest_wall_strength: Number(maxDensity.toFixed(4))
             };
         }

package/calculations/ghost-book/liquidity-vacuum.js

@@ -4,7 +4,10 @@ class LiquidityVacuum {
     static getMetadata() {
         return {
             type: 'meta',
-            dependencies: ['asset-cost-basis-profile']
+            dependencies: ['asset-cost-basis-profile'],
+            userType: 'n/a',     // FIXED: Added missing field
+            isHistorical: false, // FIXED: Explicitly defined
+            category: 'ghost_book'
         };
     }
 
@@ -22,16 +25,12 @@ class LiquidityVacuum {
 
         for (const ticker of tickers) {
             const data = computed['asset-cost-basis-profile'][ticker];
-            // BUG FIX: Ensure data and profile exist before accessing length/integration
             if (!data || !data.profile || !Array.isArray(data.profile)) continue; 
 
             const current = data.current_price;
             const totalInv = data.total_inventory_weight;
 
-            // Integrate Danger Zone (0% to -5% drop)
             const riskVol = distribution.integrateProfile(data.profile, current * 0.95, current);
-            
-            // Ratio: At-Risk Inventory / Total Inventory
             const ratio = (totalInv > 0) ? (riskVol / totalInv) * 10 : 0; 
 
             let status = "STABLE";

package/calculations/ghost-book/retail-gamma-exposure.js

@@ -10,6 +10,8 @@ class RetailGammaExposure {
             type: 'meta',
             dependencies: ['skilled-cohort-flow', 'instrument-price-change-1d'],
             isHistorical: true, // Requires t-1, t-2... for rolling regression
+            userType: 'n/a',    // FIXED: Added missing field
+            category: 'ghost_book'
         };
     }
 
@@ -33,20 +35,16 @@ class RetailGammaExposure {
 
     process(context) {
         const { computed, previousComputed, math } = context;
-        // FIX: Destructure correct keys from context.math
-        // 'signals' maps to SignalPrimitives, 'distribution' maps to DistributionAnalytics
         const { signals, distribution } = math;
 
         const tickers = signals.getUnionKeys(computed, ['skilled-cohort-flow']);
 
         for (const ticker of tickers) {
-            // 1. Inputs
             const flow = signals.getMetric(computed, 'skilled-cohort-flow', ticker, 'net_flow_pct', 0);
             const priceChange = signals.getMetric(computed, 'instrument-price-change-1d', ticker, 'change_1d_pct', 0);
 
-            // 2. State Management (Rolling Window)
             const prevResult = signals.getPreviousState(previousComputed, 'retail-gamma-exposure', ticker);
-            const bufferSize = 14; // 2-week regression window
+            const bufferSize = 14; 
             
             let flowBuffer = prevResult?._state?.flow_buffer || [];
             let priceBuffer = prevResult?._state?.price_buffer || [];
@@ -59,14 +57,12 @@ class RetailGammaExposure {
                 priceBuffer.shift();
             }
 
-            // 3. Regression: Flow ~ Alpha + Beta * PriceChange
             const regression = distribution.linearRegression(priceBuffer, flowBuffer);
             const beta = regression.slope;
 
-            // 4. Regime Logic
             let regime = "NEUTRAL";
-            if (beta > 0.5) regime = "ACCELERANT"; // Volatility Explosion Watch
-            else if (beta < -0.5) regime = "STABILIZER"; // Chop Zone
+            if (beta > 0.5) regime = "ACCELERANT"; 
+            else if (beta < -0.5) regime = "STABILIZER"; 
 
             this.gammaResults[ticker] = {
                 gamma_beta: Number(beta.toFixed(4)),

package/calculations/predicative-alpha/cognitive-dissonance.js

@@ -1,18 +1,18 @@
 /**
  * @fileoverview Cognitive Dissonance Arbitrage (CDA) v2.2
- * REFACTORED: Adheres to System Architecture and Schema v1.
+ * Clean: System automatically handles sharding.
  */
 class CognitiveDissonance {
     constructor() {
         this.cdaResults = {};
-        this.alpha = 2 / (20 + 1); // EMA Alpha
+        this.alpha = 2 / (20 + 1);
     }
 
     static getMetadata() {
         return {
-            type: 'meta', // Runs after standard calculations
+            type: 'meta',
             rootDataDependencies: [],
-            isHistorical: true, // Requires t-1 state
+            isHistorical: true,
             userType: 'aggregate'
         };
     }
@@ -22,7 +22,6 @@ class CognitiveDissonance {
     }
 
     static getSchema() {
-        // Schema remains strictly compliant with user definition
         const metricSchema = {
             "type": "object",
             "properties": {
@@ -31,7 +30,7 @@ class CognitiveDissonance {
                 "z_sentiment": { "type": "number" },
                 "z_flow": { "type": "number" },
                 "price_confirmation": { "type": "boolean" },
-                "_state": { "type": "object" } // Opaque state object
+                "_state": { "type": "object" }
             }
         };
         return { "type": "object", "patternProperties": { "^.*$": metricSchema } };
@@ -44,28 +43,24 @@ class CognitiveDissonance {
         const tickers = SignalPrimitives.getUnionKeys(computed, CognitiveDissonance.getDependencies());
 
         for (const ticker of tickers) {
-            // 1. Get Metrics (Safe Access)
-            // MAP: 'social-topic-sentiment-matrix' uses 'net_sentiment' NOT 'sentiment_score'
             const rawSentiment = SignalPrimitives.getMetric(computed, 'social-topic-sentiment-matrix', ticker, 'net_sentiment', 0);
             const rawFlow = SignalPrimitives.getMetric(computed, 'skilled-cohort-flow', ticker, 'net_flow_pct', 0);
-            const priceChange = SignalPrimitives.getMetric(computed, 'instrument-price-change-1d', ticker, 'change_1d_pct', 0); // Map to correct field
+            const priceChange = SignalPrimitives.getMetric(computed, 'instrument-price-change-1d', ticker, 'change_1d_pct', 0); 
 
-            // 2. Get Previous State
+            // Transparent State Access
+            // The system has already re-assembled previousComputed from shards if necessary.
             const prevResult = SignalPrimitives.getPreviousState(previousComputed, 'cognitive-dissonance', ticker);
             const prevState = prevResult ? prevResult._state : { sent_mean: 0, sent_var: 1, flow_mean: 0, flow_var: 1 };
 
-            // 3. Update Statistics (Math Layer)
             const sentStats = TimeSeries.updateEMAState(rawSentiment, { mean: prevState.sent_mean, variance: prevState.sent_var }, this.alpha);
             const flowStats = TimeSeries.updateEMAState(rawFlow, { mean: prevState.flow_mean, variance: prevState.flow_var }, this.alpha);
 
             const sentStdDev = Math.sqrt(sentStats.variance);
             const flowStdDev = Math.sqrt(flowStats.variance);
 
-            // 4. Compute Z-Scores
             const zSentiment = (sentStdDev > 0.001) ? (rawSentiment - sentStats.mean) / sentStdDev : 0;
             const zFlow = (flowStdDev > 0.001) ? (rawFlow - flowStats.mean) / flowStdDev : 0;
 
-            // 5. Logic (Voice vs Hands)
             const interaction = zSentiment * zFlow;
             let cdaScore = 0;
             let regime = "NEUTRAL";
@@ -76,8 +71,7 @@ class CognitiveDissonance {
             const activeHands = Math.abs(zFlow) > 0.5;
 
             if (disagree && loudVoice && activeHands) {
-                cdaScore = -interaction; // Positive score = Bearish Dissonance (Euphoria + Selling)
-                
+                cdaScore = -interaction;
                 const priceAgreesWithSentiment = (Math.sign(priceChange) === Math.sign(zSentiment));
                 const priceIsFlat = Math.abs(priceChange) < 0.5;
 
@@ -106,7 +100,7 @@ class CognitiveDissonance {
         }
     }
 
-    getResult() { return this.cdaResults; }
+    async getResult() { return this.cdaResults; }
     reset() { this.cdaResults = {}; }
 }
 module.exports = CognitiveDissonance;

package/package.json

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