aiden-shared-calculations-unified 1.0.87 → 1.0.88

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

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview CORE Product Line (Pass 1 - Meta)
+ * Calculates annualized volatility using the new priceExtractor.
+ */
+class AssetVolatilityEstimator {
+    constructor() {
+        this.result = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: ['price'], 
+            isHistorical: false,
+            userType: 'n/a',
+            category: 'market_stats'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "volatility_30d": { "type": "number" },
+                "last_price": { "type": "number" },
+                "data_points": { "type": "number" }
+            },
+            "required": ["volatility_30d"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
+    }
+
+    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; 
+
+        // 1. Get ALL histories properly sorted and parsed
+        const allHistories = priceExtractor.getAllHistories(prices);
+
+        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) {
+                const instId = prices.history[key].instrumentId;
+                if (mappings && mappings.instrumentToTicker && mappings.instrumentToTicker[instId]) {
+                    ticker = mappings.instrumentToTicker[instId];
+                }
+            }
+
+            if (candles.length < 10) continue;
+
+            // 2. Calculate Log Returns
+            const logReturns = [];
+            let lastPrice = 0;
+
+            for (let i = 1; i < candles.length; i++) {
+                const prev = candles[i-1].price;
+                const curr = candles[i].price;
+                
+                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);
+
+            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,
+                last_price: lastPrice,
+                data_points: relevantReturns.length
+            };
+        }
+    }
+
+    async getResult() { return this.result; }
+    reset() { this.result = {}; }
+}
+
+module.exports = AssetVolatilityEstimator;

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

@@ -0,0 +1,173 @@
+/**
+ * @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.
+ */
+
+class RetailCapitulationRiskForecast {
+    constructor() {
+        this.assetRiskProfiles = new 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'
+        this.deps = { mathLib: null };
+    }
+
+    static getMetadata() {
+        return {
+            type: 'standard',
+            rootDataDependencies: ['portfolio', 'history'],
+            isHistorical: false,
+            userType: 'all',
+            category: 'risk_models'
+        };
+    }
+
+    static getDependencies() {
+        return ['asset-volatility-estimator']; 
+    }
+
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "capitulation_probability": { "type": "number" },
+                "at_risk_user_count": { "type": "number" },
+                "average_pain_threshold_pct": { "type": "number" },
+                "used_volatility": { "type": "number" }
+            },
+            "required": ["capitulation_probability", "at_risk_user_count"]
+        };
+        
+        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.
+        if (!this.deps.mathLib && compute) {
+            this.deps.mathLib = compute;
+        }
+        
+        if (!this.tickerMap) {
+            this.tickerMap = mappings.instrumentToTicker;
+        }
+
+        // 2. Determine User's "Pain Threshold"
+        const historyDoc = history.getDailyHistory(user);
+        const summary = history.getSummary(historyDoc);
+        let personalPainThreshold = (summary && summary.avgLossPct < 0) 
+            ? summary.avgLossPct 
+            : -25.0;
+
+        // 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
+            const assetStats = signals.getPreviousState(computed, 'asset-volatility-estimator', ticker);
+            
+            const dynamicVol = assetStats ? assetStats.volatility_30d : 0.60;
+            const currentPrice = assetStats ? assetStats.last_price : 0;
+
+            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
+                });
+            }
+        }
+    }
+
+    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 {};
+        }
+
+        for (const [ticker, data] of this.assetRiskProfiles.entries()) {
+            if (data.profiles.length < 1) { 
+                 continue; 
+            }
+            
+            try {
+                // 1. Generate Price Paths
+                const pricePaths = mathLib.simulateGBM(
+                    data.currentPrice, 
+                    data.volatility, 
+                    TIME_HORIZON_DAYS, 
+                    SIMULATION_COUNT
+                );
+                
+                if (!pricePaths || pricePaths.length === 0) continue;
+
+                // 2. Run Population Breakdown
+                const capitulationProb = mathLib.simulatePopulationBreakdown(
+                    pricePaths, 
+                    data.profiles
+                );
+
+                const totalThreshold = data.profiles.reduce((acc, p) => acc + p.thresholdPct, 0);
+                const avgThreshold = totalThreshold / data.profiles.length;
+
+                result[ticker] = {
+                    capitulation_probability: parseFloat(capitulationProb.toFixed(4)),
+                    at_risk_user_count: data.profiles.length,
+                    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}`);
+            }
+        }
+        
+        return result;
+    }
+
+    reset() {
+        this.assetRiskProfiles.clear();
+        this.tickerMap = null;
+        this.deps.mathLib = null; // Reset the container
+    }
+}
+
+module.exports = RetailCapitulationRiskForecast;

package/calculations/core/asset-cost-basis-profile.js

@@ -0,0 +1,127 @@
+/**
+ * @fileoverview Core Calculation (Pass 2)
+ * Generates the "Ghost Book" - KDE of Holder Cost Basis.
+ * ARCHITECTURE COMPLIANT: Uses Context for Math & Prices.
+ */
+class AssetCostBasisProfile {
+    constructor() {
+        // Map<Ticker, Map<PriceKey, Weight>>
+        this.assetBins = new Map(); 
+        this.tickerMap = null;
+        // FIX 1: Change state name to clearly indicate storage of the function pointer
+        this.computeKDE_func = null; 
+    }
+
+    static getMetadata() {
+        return {
+            type: 'standard',
+            rootDataDependencies: ['portfolio'], 
+            dependencies: [], 
+            isHistorical: false,
+            userType: 'all', 
+            category: 'core_distribution'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const profileSchema = {
+            "type": "object",
+            "properties": {
+                "profile": { 
+                    "type": "array", 
+                    "items": { "type": "object", "properties": { "price": {"type": "number"}, "density": {"type": "number"} } } 
+                },
+                "current_price": { "type": "number" },
+                "total_inventory_weight": { "type": "number" }
+            }
+        };
+        return { "type": "object", "patternProperties": { "^.*$": profileSchema } };
+    }
+
+    process(context) {
+        const { user, mappings, math } = context; 
+        
+        // FIX 2 (CRITICAL): Store the *function pointer* itself from math.distribution.computeKDE.
+        // This is necessary because storing the class object (math.distribution) breaks the static method reference when serialized/deserialized by worker threads.
+        if (!this.computeKDE_func) {
+            this.computeKDE_func = math.distribution.computeKDE;
+        }
+        
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
+
+        const { extract } = math; 
+
+        const positions = extract.getPositions(user.portfolio.today, user.type);
+
+        for (const pos of positions) {
+            const instId = extract.getInstrumentId(pos);
+            const ticker = this.tickerMap[instId];
+            
+            if (!ticker) continue;
+
+            const currentPrice = extract.getCurrentRate(pos); 
+            if (currentPrice <= 0) continue;
+
+            const netProfitPct = extract.getNetProfit(pos); 
+            const weight = extract.getPositionWeight(pos, user.type); 
+            
+            if (netProfitPct <= -99.9) continue;
+
+            const entryPrice = currentPrice / (1 + (netProfitPct / 100.0));
+
+            const priceKey = Number(entryPrice.toPrecision(6));
+
+            if (!this.assetBins.has(ticker)) {
+                this.assetBins.set(ticker, { bins: new Map(), currentPrice });
+            }
+            const asset = this.assetBins.get(ticker);
+            
+            asset.currentPrice = currentPrice; 
+            
+            const currentWeight = asset.bins.get(priceKey) || 0;
+            asset.bins.set(priceKey, currentWeight + weight);
+        }
+    }
+
+    async getResult() {
+        const result = {};
+        
+        // Use the function pointer stored in state. No longer need the corrupted 'DistributionAnalytics' variable.
+        const computeKDE = this.computeKDE_func; 
+
+        if (!computeKDE) return {}; // Safety guard
+
+        for (const [ticker, data] of this.assetBins.entries()) {
+            const points = [];
+            let totalWeight = 0;
+            for (const [price, weight] of data.bins.entries()) {
+                points.push({ value: price, weight: weight });
+                totalWeight += weight;
+            }
+
+            if (points.length < 2) continue; 
+
+            const bandwidth = data.currentPrice * 0.02;
+            
+            // FIX 3: Call the stored function directly
+            const profile = computeKDE(points, bandwidth, 60);
+
+            result[ticker] = {
+                profile: profile,
+                current_price: data.currentPrice,
+                total_inventory_weight: totalWeight
+            };
+        }
+        return result;
+    }
+
+    reset() { 
+        this.assetBins.clear(); 
+        this.tickerMap = null;
+        this.computeKDE_func = null;
+    }
+}
+
+module.exports = AssetCostBasisProfile;

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

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Calculation (Pass 1) for ownership delta (users added/lost per asset).
- * REFACTORED: Tracks net change in number of owners.
+ * REFACTORED: Tracks net change in number of owners. ---> TODO IN TEST ENVIRONMENT THE VALUE OF NUMBER OF CLOSURES ALWAYS RETURNS 0, IS THIS A COMPUTATION BUG OR A TEST HARNESS BUG?
  */
 class PlatformDailyOwnershipDelta {
     constructor() {

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

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Ghost Book: Cost-Basis Density Estimation
+ * Identifies "Invisible Walls" of Support/Resistance based on holder break-even psychology.
+ */
+class CostBasisDensity {
+    constructor() { this.walls = {}; }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            dependencies: ['asset-cost-basis-profile'],
+            category: 'ghost_book'
+        };
+    }
+    
+    static getDependencies() { return ['asset-cost-basis-profile']; }
+
+    static getSchema() {
+        return {
+            "type": "object",
+            "patternProperties": {
+                "^.*$": {
+                    "type": "object",
+                    "properties": {
+                        "resistance_zones": { "type": "array", "items": { "type": "number" } },
+                        "support_zones": { "type": "array", "items": { "type": "number" } },
+                        "nearest_wall_strength": { "type": "number" }
+                    }
+                }
+            }
+        };
+    }
+
+    process(context) {
+        const { computed, math } = context;
+        const { signals: SignalPrimitives } = math;
+        
+        const tickers = SignalPrimitives.getUnionKeys(computed, ['asset-cost-basis-profile']);
+
+        for (const ticker of tickers) {
+            const data = computed['asset-cost-basis-profile'][ticker];
+            if (!data || !data.profile) continue;
+
+            const profile = data.profile; // Array of {price, density}
+            const currentPrice = data.current_price;
+
+            const resistance = [];
+            const support = [];
+            let maxDensity = 0;
+
+            // Find Local Maxima in the Density Curve
+            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;
+
+                if (curr > prev && curr > next) {
+                    // We have a peak (Wall)
+                    if (profile[i].price > currentPrice) {
+                        resistance.push(Number(profile[i].price.toFixed(2)));
+                    } else {
+                        support.push(Number(profile[i].price.toFixed(2)));
+                    }
+                    if (curr > maxDensity) maxDensity = curr;
+                }
+            }
+
+            this.walls[ticker] = {
+                resistance_zones: resistance.slice(0, 3), // Top 3
+                support_zones: support.slice(0, 3),
+                nearest_wall_strength: Number(maxDensity.toFixed(4))
+            };
+        }
+    }
+
+    getResult() { return this.walls; }
+    reset() { this.walls = {}; }
+}
+module.exports = CostBasisDensity;

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

@@ -0,0 +1,52 @@
+class LiquidityVacuum {
+    constructor() { this.vacuumResults = {}; }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            dependencies: ['asset-cost-basis-profile'],
+            category: 'ghost_book'
+        };
+    }
+
+    static getDependencies() { return ['asset-cost-basis-profile']; }
+
+    static getSchema() {
+        return { "type": "object", "patternProperties": { "^.*$": { "type": "object", "properties": { "crash_probability": {"type":"number"}, "liquidity_ratio": {"type":"number"} } } } };
+    }
+
+    process(context) {
+        const { computed, math } = context;
+        const { distribution } = math; // Correctly accesses 'distribution' from context
+        
+        const tickers = Object.keys(computed['asset-cost-basis-profile'] || {});
+
+        for (const ticker of tickers) {
+            const data = computed['asset-cost-basis-profile'][ticker];
+            if (!data) 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";
+            if (ratio > 0.5) status = "FRAGILE";
+            if (ratio > 1.0) status = "CRITICAL_VACUUM";
+
+            this.vacuumResults[ticker] = {
+                crash_probability: Number(Math.min(ratio * 0.5, 0.99).toFixed(2)),
+                liquidity_ratio: Number(ratio.toFixed(4)),
+                status: status
+            };
+        }
+    }
+
+    getResult() { return this.vacuumResults; }
+    reset() { this.vacuumResults = {}; }
+}
+module.exports = LiquidityVacuum;

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

@@ -0,0 +1,86 @@
+/**
+ * @fileoverview Ghost Book: Retail Gamma Exposure
+ * Measures the "Elasticity of Intent" (Beta) between Price Change and Net Flow.
+ */
+class RetailGammaExposure {
+    constructor() { this.gammaResults = {}; }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            dependencies: ['skilled-cohort-flow', 'instrument-price-change-1d'],
+            isHistorical: true, // Requires t-1, t-2... for rolling regression
+            category: 'ghost_book'
+        };
+    }
+
+    static getDependencies() { return ['skilled-cohort-flow', 'instrument-price-change-1d']; }
+
+    static getSchema() {
+        return {
+            "type": "object",
+            "patternProperties": {
+                "^.*$": {
+                    "type": "object",
+                    "properties": {
+                        "gamma_beta": { "type": "number" },
+                        "regime": { "type": "string", "enum": ["ACCELERANT", "STABILIZER", "NEUTRAL"] },
+                        "_state": { "type": "object" } // Rolling buffer
+                    }
+                }
+            }
+        };
+    }
+
+    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
+            
+            let flowBuffer = prevResult?._state?.flow_buffer || [];
+            let priceBuffer = prevResult?._state?.price_buffer || [];
+
+            flowBuffer.push(flow);
+            priceBuffer.push(priceChange);
+
+            if (flowBuffer.length > bufferSize) {
+                flowBuffer.shift();
+                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
+
+            this.gammaResults[ticker] = {
+                gamma_beta: Number(beta.toFixed(4)),
+                regime: regime,
+                _state: {
+                    flow_buffer: flowBuffer,
+                    price_buffer: priceBuffer
+                }
+            };
+        }
+    }
+
+    getResult() { return this.gammaResults; }
+    reset() { this.gammaResults = {}; }
+}
+module.exports = RetailGammaExposure;

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

@@ -0,0 +1,113 @@
+/**
+ * @fileoverview Cognitive Dissonance Arbitrage (CDA) v2.2
+ * REFACTORED: Adheres to System Architecture and Schema v1.
+ */
+class CognitiveDissonance {
+    constructor() {
+        this.cdaResults = {};
+        this.alpha = 2 / (20 + 1); // EMA Alpha
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta', // Runs after standard calculations
+            rootDataDependencies: [],
+            isHistorical: true, // Requires t-1 state
+            userType: 'aggregate',
+            category: 'predictive_alpha'
+        };
+    }
+
+    static getDependencies() {
+        return ['social-topic-sentiment-matrix', 'skilled-cohort-flow', 'instrument-price-change-1d'];
+    }
+
+    static getSchema() {
+        // Schema remains strictly compliant with user definition
+        const metricSchema = {
+            "type": "object",
+            "properties": {
+                "cda_score": { "type": "number" },
+                "regime": { "type": "string" },
+                "z_sentiment": { "type": "number" },
+                "z_flow": { "type": "number" },
+                "price_confirmation": { "type": "boolean" },
+                "_state": { "type": "object" } // Opaque state object
+            }
+        };
+        return { "type": "object", "patternProperties": { "^.*$": metricSchema } };
+    }
+
+    process(context) {
+        const { computed, previousComputed, math } = context;
+        const { signals: SignalPrimitives, TimeSeries } = math;
+
+        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
+
+            // 2. Get Previous State
+            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";
+            let priceConfirmation = false;
+
+            const disagree = (Math.sign(zSentiment) !== Math.sign(zFlow));
+            const loudVoice = Math.abs(zSentiment) > 1.65;
+            const activeHands = Math.abs(zFlow) > 0.5;
+
+            if (disagree && loudVoice && activeHands) {
+                cdaScore = -interaction; // Positive score = Bearish Dissonance (Euphoria + Selling)
+                
+                const priceAgreesWithSentiment = (Math.sign(priceChange) === Math.sign(zSentiment));
+                const priceIsFlat = Math.abs(priceChange) < 0.5;
+
+                if (priceAgreesWithSentiment && !priceIsFlat) {
+                    priceConfirmation = true;
+                    regime = "CONVERGENT";
+                    cdaScore = 0;
+                } else {
+                    regime = (zSentiment > 0) ? "BEARISH_DISSONANCE" : "BULLISH_DISSONANCE";
+                }
+            } else if (!disagree && loudVoice) {
+                regime = "CONVERGENT";
+            }
+
+            this.cdaResults[ticker] = {
+                cda_score: Number(cdaScore.toFixed(4)),
+                regime: regime,
+                z_sentiment: Number(zSentiment.toFixed(4)),
+                z_flow: Number(zFlow.toFixed(4)),
+                price_confirmation: priceConfirmation,
+                _state: {
+                    sent_mean: sentStats.mean, sent_var: sentStats.variance,
+                    flow_mean: flowStats.mean, flow_var: flowStats.variance
+                }
+            };
+        }
+    }
+
+    getResult() { return this.cdaResults; }
+    reset() { this.cdaResults = {}; }
+}
+module.exports = CognitiveDissonance;

package/calculations/predicative-alpha/diamond-hand-fracture.js

@@ -0,0 +1,90 @@
+/**
+ * @fileoverview Diamond Hand Fracture Coefficient (DHFC) v2.2
+ * REFACTORED: Adheres to System Architecture.
+ */
+class DiamondHandFracture {
+    constructor() { this.fractureResults = {}; }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: [],
+            isHistorical: true,
+            userType: 'aggregate',
+            category: 'predictive_alpha'
+        };
+    }
+
+    static getDependencies() {
+        return ['holding-duration-per-asset', 'average-daily-pnl-per-stock'];
+    }
+
+    static getSchema() {
+        const metricSchema = {
+            "type": "object",
+            "properties": {
+                "fracture_velocity": { "type": "number" },
+                "capitulation_score": { "type": "number" },
+                "regime": { "type": "string" },
+                "expected_duration_hours": { "type": "number" },
+                "actual_duration_hours": { "type": "number" }
+            }
+        };
+        return { "type": "object", "patternProperties": { "^.*$": metricSchema } };
+    }
+
+    process(context) {
+        const { computed, previousComputed, math } = context;
+        const { signals: SignalPrimitives } = math; // fixed?
+
+        const tickers = SignalPrimitives.getUnionKeys(computed, DiamondHandFracture.getDependencies());
+
+        for (const ticker of tickers) {
+            // 1. Current State
+            const H_t = SignalPrimitives.getMetric(computed, 'holding-duration-per-asset', ticker, 'avg_duration_hours', 0);
+            const OI_t = SignalPrimitives.getMetric(computed, 'holding-duration-per-asset', ticker, 'count', 0);
+            const avgPnl = SignalPrimitives.getMetric(computed, 'average-daily-pnl-per-stock', ticker, 'avg_daily_pnl_pct', 0);
+
+            // 2. Previous State (T-1)
+            // Note: We fetch 'holding-duration-per-asset' from *previous* computed results
+            const prevData = SignalPrimitives.getPreviousState(previousComputed, 'holding-duration-per-asset', ticker);
+            const H_prev = prevData ? (prevData.avg_duration_hours || 0) : 0;
+            const OI_prev = prevData ? (prevData.count || 0) : 0;
+
+            // Init Check
+            if (H_prev === 0 || OI_prev === 0) {
+                this.fractureResults[ticker] = { fracture_velocity: 0, capitulation_score: 0, regime: "STABLE", expected_duration_hours: H_t, actual_duration_hours: H_t };
+                continue;
+            }
+
+            // 3. Logic: Inventory Dilution
+            let dilutionFactor = (OI_t > 0) ? (OI_prev / OI_t) : 1.0;
+            if (dilutionFactor > 2.0) dilutionFactor = 1.0; // Clamp extreme dilution
+
+            const H_expected = H_prev * dilutionFactor;
+            const phi = H_expected - H_t;
+            const phi_normalized = (H_prev > 0) ? (phi / H_prev) * 100 : 0;
+
+            // 4. Capitulation Score
+            const painFactor = (avgPnl < 0) ? Math.abs(avgPnl) : 0;
+            const capitulationScore = phi_normalized * painFactor;
+
+            let regime = "STABLE";
+            if (phi_normalized > 5.0) regime = "FRACTURE";
+            if (capitulationScore > 20.0) regime = "CAPITULATION";
+            if (phi_normalized < -5.0) regime = "ACCUMULATION";
+
+            this.fractureResults[ticker] = {
+                fracture_velocity: Number(phi_normalized.toFixed(4)),
+                capitulation_score: Number(capitulationScore.toFixed(4)),
+                regime: regime,
+                expected_duration_hours: Number(H_expected.toFixed(2)),
+                actual_duration_hours: Number(H_t.toFixed(2))
+            };
+        }
+    }
+
+    getResult() { return this.fractureResults; }
+    reset() { this.fractureResults = {}; }
+}
+module.exports = DiamondHandFracture;

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

@@ -0,0 +1,124 @@
+/**
+ * @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.
+ */
+class MimeticLatencyOscillator {
+    constructor() {
+        this.mloResults = {};
+        this.windowSize = 30;
+        this.maxLag = 10;
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: [],
+            isHistorical: true,
+            userType: 'aggregate',
+            category: 'predictive_alpha'
+        };
+    }
+
+    static getDependencies() {
+        return ['skilled-cohort-flow', 'herd-consensus-score'];
+    }
+
+    static getSchema() {
+        const metricSchema = {
+            "type": "object",
+            "properties": {
+                "lag_days": { "type": "integer" },
+                "correlation_strength": { "type": "number" },
+                "regime": { "type": "string" },
+                "_state": { "type": "object" }
+            }
+        };
+        return { "type": "object", "patternProperties": { "^.*$": metricSchema } };
+    }
+
+    process(context) {
+        const { computed, previousComputed, math } = context;
+        const { signals: SignalPrimitives, TimeSeries } = math;
+
+        const tickers = SignalPrimitives.getUnionKeys(computed, MimeticLatencyOscillator.getDependencies());
+
+        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
+            const prevResult = SignalPrimitives.getPreviousState(previousComputed, 'mimetic-latency', ticker);
+            const prevState = prevResult ? prevResult._state : { flow_buffer: [], herd_buffer: [], last_flow: 0, last_herd: 0 };
+
+            const prevFlow = (prevState.last_flow !== undefined) ? prevState.last_flow : 0;
+            const prevHerd = (prevState.last_herd !== undefined) ? prevState.last_herd : 0;
+
+            // 3. Calculate Detrended Delta
+            const flowDelta = rawFlow - prevFlow;
+            const herdDelta = rawHerd - prevHerd;
+
+            // 4. Update Buffers
+            let flowBuffer = [...(prevState.flow_buffer || [])];
+            let herdBuffer = [...(prevState.herd_buffer || [])];
+
+            flowBuffer.push(flowDelta);
+            herdBuffer.push(herdDelta);
+
+            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;
+
+            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
+
+                    const slicedFlow = flowBuffer.slice(0, len - k);
+                    const slicedHerd = herdBuffer.slice(k, len);
+
+                    const r = TimeSeries.pearsonCorrelation(slicedFlow, slicedHerd);
+                    
+                    if (r > maxCorr) {
+                        maxCorr = r;
+                        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";
+            }
+
+            this.mloResults[ticker] = {
+                lag_days: bestLag,
+                correlation_strength: Number(maxCorr.toFixed(4)),
+                regime: regime,
+                _state: {
+                    flow_buffer: flowBuffer,
+                    herd_buffer: herdBuffer,
+                    last_flow: rawFlow,
+                    last_herd: rawHerd
+                }
+            };
+        }
+    }
+
+    getResult() { return this.mloResults; }
+    reset() { this.mloResults = {}; }
+}
+module.exports = MimeticLatencyOscillator;

package/package.json

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