aiden-shared-calculations-unified 1.0.108 → 1.0.110

package/calculations/helix/winner-loser-flow.js

@@ -1,108 +1,39 @@
-/**
- * @fileoverview HELIX Product Line (Pass 2)
- * REFACTORED: Uses context.math.extract.
- */
 class WinnerLoserFlow {
-    constructor() {
-        this.assetFlows = new Map();
-        this.tickerMap = null;
-    }
-
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio'],
-            isHistorical: true,
-            userType: 'all',
-            category: 'helix'
-        };
-    }s
-
+    constructor() { this.assetFlows = new Map(); this.tickerMap = null; }
+    static getMetadata() { return { type: 'standard', rootDataDependencies: ['portfolio'], isHistorical: true, userType: 'all', category: 'helix' }; }
     static getDependencies() { return []; }
 
     static getSchema() {
-        const tickerSchema = {
-            "type": "object",
-            "properties": {
-                "net_winner_flow": { "type": "number" },
-                "net_loser_flow": { "type": "number" },
-                "raw_counts": { "type": "object" }
-            },
-            "required": ["net_winner_flow", "net_loser_flow", "raw_counts"]
-        };
-        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
-    }
-
-    _getHoldings(positions, extract) {
-        const map = new Map();
-        for (const pos of positions) {
-            const id = extract.getInstrumentId(pos);
-            if (id) map.set(id, { pnl: extract.getNetProfit(pos) });
-        }
-        return map;
-    }
-    
-    _initAsset(ticker) {
-        if (!this.assetFlows.has(ticker)) {
-            this.assetFlows.set(ticker, { winners_joined: 0, winners_left: 0, losers_joined: 0, losers_left: 0 });
-        }
+        const s = { "type": "object", "properties": { "net_winner_flow": { "type": ["number", "null"] }, "net_loser_flow": { "type": ["number", "null"] }, "total_winners_today": { "type": "number" }, "total_losers_today": { "type": "number" } }, "required": ["net_winner_flow", "net_loser_flow", "total_winners_today", "total_losers_today"] };
+        return { "type": "object", "patternProperties": { "^.*$": s } };
     }
 
     process(context) {
-        const { user, mappings, math } = context;
-        const { extract } = math;
+        const { user, mappings, math } = context; const { extract } = math;
         if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
-
-        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
         const tPos = extract.getPositions(user.portfolio.today, user.type);
-        
-        const yHoldings = this._getHoldings(yPos, extract);
-        const tHoldings = this._getHoldings(tPos, extract);
-
-        const allIds = new Set([...yHoldings.keys(), ...tHoldings.keys()]);
-
-        for (const instId of allIds) {
-            const ticker = this.tickerMap[instId];
-            if (!ticker) continue;
-            
-            const tPnl = tHoldings.get(instId)?.pnl || 0;
-            const isWinner = tPnl > 0;
-            const isLoser = tPnl < 0;
-            if (!isWinner && !isLoser) continue;
-
-            const heldYesterday = yHoldings.has(instId);
-            const holdsToday = tHoldings.has(instId);
-            if (heldYesterday === holdsToday) continue;
-
-            this._initAsset(ticker);
-            const stats = this.assetFlows.get(ticker);
-
-            if (isWinner) {
-                if (holdsToday && !heldYesterday) stats.winners_joined++;
-                if (!holdsToday && heldYesterday) stats.winners_left++;
-            }
-            if (isLoser) {
-                if (holdsToday && !heldYesterday) stats.losers_joined++;
-                if (!holdsToday && heldYesterday) stats.losers_left++;
+        const yPos = user.portfolio.yesterday ? extract.getPositions(user.portfolio.yesterday, user.type) : [];
+        const yH = new Map(yPos.map(p => [extract.getInstrumentId(p), extract.getNetProfit(p)]));
+        const tH = new Map(tPos.map(p => [extract.getInstrumentId(p), extract.getNetProfit(p)]));
+        const ids = new Set([...yH.keys(), ...tH.keys()]);
+        for (const id of ids) {
+            const tick = this.tickerMap[id]; if (!tick) continue;
+            if (!this.assetFlows.has(tick)) this.assetFlows.set(tick, { wJ: 0, wL: 0, lJ: 0, lL: 0, wT: 0, lT: 0, hasY: !!user.portfolio.yesterday });
+            const s = this.assetFlows.get(tick), tPnl = tH.get(id), yPnl = yH.get(id);
+            if (tH.has(id)) { if (tPnl > 0) s.wT++; if (tPnl < 0) s.lT++; }
+            if (user.portfolio.yesterday) {
+                if (tH.has(id) && !yH.has(id)) { if (tPnl > 0) s.wJ++; if (tPnl < 0) s.lJ++; }
+                if (!tH.has(id) && yH.has(id)) { if (yPnl > 0) s.wL++; if (yPnl < 0) s.lL++; }
             }
         }
     }
 
     async getResult() {
-        const result = {};
-        for (const [ticker, data] of this.assetFlows.entries()) {
-            result[ticker] = {
-                net_winner_flow: data.winners_joined - data.winners_left,
-                net_loser_flow: data.losers_joined - data.losers_left,
-                raw_counts: data
-            };
+        const res = {}; for (const [tick, d] of this.assetFlows.entries()) {
+            res[tick] = { net_winner_flow: d.hasY ? d.wJ - d.wL : null, net_loser_flow: d.hasY ? d.lJ - d.lL : null, total_winners_today: d.wT, total_losers_today: d.lT };
         }
-        return result;
-    }
-
-    reset() {
-        this.assetFlows.clear();
-        this.tickerMap = null;
+        return res;
     }
+    reset() { this.assetFlows.clear(); this.tickerMap = null; }
 }
 module.exports = WinnerLoserFlow;

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

@@ -1,105 +1,39 @@
-/**
- * @fileoverview Cognitive Dissonance Arbitrage (CDA) v2.2
- * Clean: System automatically handles sharding.
- */
 class CognitiveDissonance {
-    constructor() {
-        this.cdaResults = {};
-        this.alpha = 2 / (20 + 1);
-    }
-
-    static getMetadata() {
-        return {
-            type: 'meta',
-            rootDataDependencies: [],
-            isHistorical: true,
-            userType: 'aggregate'
-        };
-    }
-
-    static getDependencies() {
-        return ['social-topic-sentiment-matrix', 'skilled-cohort-flow', 'instrument-price-change-1d'];
-    }
+    constructor() { this.cdaResults = {}; this.alpha = 2 / (20 + 1); }
+    static getMetadata() { return { type: 'meta', rootDataDependencies: [], isHistorical: true, userType: 'aggregate' }; }
+    static getDependencies() { return ['social-topic-sentiment-matrix', 'skilled-cohort-flow', 'instrument-price-change-1d']; }
 
     static getSchema() {
-        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" }
-            }
-        };
-        return { "type": "object", "patternProperties": { "^.*$": metricSchema } };
+        return { "type": "object", "patternProperties": { "^.*$": { "type": "object", "properties": { "cda_score": { "type": ["number", "null"] }, "regime": { "type": "string" }, "_state": { "type": "object" } } } } };
     }
 
     process(context) {
         const { computed, previousComputed, math } = context;
-        const { signals: SignalPrimitives, TimeSeries } = math;
-
-        const tickers = SignalPrimitives.getUnionKeys(computed, CognitiveDissonance.getDependencies());
-
+        const { signals, TimeSeries } = math;
+        const tickers = signals.getUnionKeys(computed, CognitiveDissonance.getDependencies());
         for (const ticker of tickers) {
-            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); 
-
-            // 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 };
-
-            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);
-
-            const zSentiment = (sentStdDev > 0.001) ? (rawSentiment - sentStats.mean) / sentStdDev : 0;
-            const zFlow = (flowStdDev > 0.001) ? (rawFlow - flowStats.mean) / flowStdDev : 0;
-
-            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;
-                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";
+            const sent = signals.getMetric(computed, 'social-topic-sentiment-matrix', ticker, 'net_sentiment', 0);
+            const flow = signals.getMetric(computed, 'skilled-cohort-flow', ticker, 'net_flow_pct', 0);
+            const pChg = signals.getMetric(computed, 'instrument-price-change-1d', ticker, 'change_1d_pct', 0);
+            const prev = signals.getPreviousState(previousComputed, 'cognitive-dissonance', ticker);
+            const pS = prev ? prev._state : { sent_mean: sent, sent_var: 1, flow_mean: flow, flow_var: 1 };
+            const sS = TimeSeries.updateEMAState(sent, { mean: pS.sent_mean, variance: pS.sent_var }, this.alpha);
+            const fS = TimeSeries.updateEMAState(flow, { mean: pS.flow_mean, variance: pS.flow_var }, this.alpha);
+            const sDev = Math.sqrt(sS.variance), fDev = Math.sqrt(fS.variance);
+            const zS = sDev > 0.001 ? (sent - sS.mean) / sDev : 0, zF = fDev > 0.001 ? (flow - fS.mean) / fDev : 0;
+            let cda = null, regime = "WARM_UP";
+            if (prev) {
+                const interact = zS * zF; cda = 0; regime = "NEUTRAL";
+                const disagree = Math.sign(zS) !== Math.sign(zF), loud = Math.abs(zS) > 1.65, active = Math.abs(zF) > 0.5;
+                if (disagree && loud && active) {
+                    cda = -interact;
+                    if (Math.sign(pChg) === Math.sign(zS) && Math.abs(pChg) > 0.5) { cda = 0; regime = "CONVERGENT"; }
+                    else regime = zS > 0 ? "BEARISH_DISSONANCE" : "BULLISH_DISSONANCE";
+                } else if (!disagree && loud) 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
-                }
-            };
+            this.cdaResults[ticker] = { cda_score: (cda !== null && isFinite(cda)) ? Number(cda.toFixed(4)) : null, regime, _state: { sent_mean: sS.mean, sent_var: sS.variance, flow_mean: fS.mean, flow_var: fS.variance } };
         }
     }
-
     async getResult() { return this.cdaResults; }
     reset() { this.cdaResults = {}; }
 }

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

@@ -1,88 +1,33 @@
-/**
- * @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'
-        };
-    }
-
-    static getDependencies() {
-        return ['holding-duration-per-asset', 'average-daily-pnl-per-stock'];
-    }
+    static getMetadata() { return { type: 'meta', rootDataDependencies: [], isHistorical: true, userType: 'aggregate' }; }
+    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 } };
+        return { "type": "object", "patternProperties": { "^.*$": { "type": "object", "properties": { "fracture_velocity": { "type": ["number", "null"] }, "regime": { "type": "string" }, "actual_duration_hours": { "type": "number" } } } } };
     }
 
     process(context) {
         const { computed, previousComputed, math } = context;
-        const { signals: SignalPrimitives } = math; // fixed?
-
-        const tickers = SignalPrimitives.getUnionKeys(computed, DiamondHandFracture.getDependencies());
-
+        const { signals } = math;
+        const tickers = signals.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 };
+            const H_t = signals.getMetric(computed, 'holding-duration-per-asset', ticker, 'avg_duration_hours', 0);
+            const OI_t = signals.getMetric(computed, 'holding-duration-per-asset', ticker, 'count', 0);
+            const pnl = signals.getMetric(computed, 'average-daily-pnl-per-stock', ticker, 'avg_daily_pnl_pct', 0);
+            const prev = signals.getPreviousState(previousComputed, 'holding-duration-per-asset', ticker);
+            const H_p = prev?.avg_duration_hours || 0, OI_p = prev?.count || 0;
+            if (H_p === 0 || OI_p === 0) {
+                this.fractureResults[ticker] = { fracture_velocity: null, capitulation_score: 0, regime: "COLD_START", 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))
-            };
+            let dil = (OI_t > 0) ? (OI_p / OI_t) : 1.0; if (dil > 2.0) dil = 1.0;
+            const H_exp = H_p * dil, phi = H_exp - H_t, phi_n = (H_p > 0) ? (phi / H_p) * 100 : 0;
+            const cap = (pnl < 0) ? Math.abs(pnl) * phi_n : 0;
+            let reg = "STABLE"; if (phi_n > 5.0) reg = "FRACTURE"; if (cap > 20.0) reg = "CAPITULATION"; if (phi_n < -5.0) reg = "ACCUMULATION";
+            this.fractureResults[ticker] = { fracture_velocity: Number(phi_n.toFixed(4)), capitulation_score: Number(cap.toFixed(4)), regime: reg, expected_duration_hours: Number(H_exp.toFixed(2)), actual_duration_hours: Number(H_t.toFixed(2)) };
         }
     }
-
     getResult() { return this.fractureResults; }
     reset() { this.fractureResults = {}; }
 }

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

@@ -1,116 +1,37 @@
-/**
- * @fileoverview Mimetic Latency Oscillator (MLO) v2.3
- * FIXED: Safe state access to prevent 'undefined' property errors.
- */
 class MimeticLatencyOscillator {
-    constructor() {
-        this.mloResults = {};
-        this.windowSize = 30;
-        this.maxLag = 10;
-    }
-
-    static getMetadata() {
-        return {
-            type: 'meta',
-            rootDataDependencies: [],
-            isHistorical: true,
-            userType: 'aggregate'
-        };
-    }
-
-    static getDependencies() {
-        return ['skilled-cohort-flow', 'herd-consensus-score'];
-    }
+    constructor() { this.mloResults = {}; this.windowSize = 30; this.maxLag = 10; }
+    static getMetadata() { return { type: 'meta', rootDataDependencies: [], isHistorical: true, userType: 'aggregate' }; }
+    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 } };
+        return { "type": "object", "patternProperties": { "^.*$": { "type": "object", "properties": { "lag_days": { "type": ["number", "null"] }, "regime": { "type": "string" }, "_state": { "type": "object" } } } } };
     }
 
     process(context) {
         const { computed, previousComputed, math } = context;
-        const { signals: SignalPrimitives, TimeSeries } = math;
-
-        const tickers = SignalPrimitives.getUnionKeys(computed, MimeticLatencyOscillator.getDependencies());
-
+        const { signals, TimeSeries } = math;
+        const tickers = signals.getUnionKeys(computed, MimeticLatencyOscillator.getDependencies());
         for (const ticker of tickers) {
-            // 1. Inputs
-            const rawFlow = SignalPrimitives.getMetric(computed, 'skilled-cohort-flow', ticker, 'net_flow_pct', 0);
-            const rawHerd = SignalPrimitives.getMetric(computed, 'herd-consensus-score', ticker, 'herd_conviction_score', 0);
-
-            // 2. Restore State (FIX: Safe Access)
-            const prevResult = SignalPrimitives.getPreviousState(previousComputed, 'mimetic-latency', ticker);
-            const prevState = prevResult ? prevResult._state : null;
-
-            // FIX: Check if prevState exists before accessing properties
-            const prevFlow = (prevState && prevState.last_flow !== undefined) ? prevState.last_flow : 0;
-            const prevHerd = (prevState && prevState.last_herd !== undefined) ? prevState.last_herd : 0;
-            const flowBuffer = (prevState && Array.isArray(prevState.flow_buffer)) ? [...prevState.flow_buffer] : [];
-            const herdBuffer = (prevState && Array.isArray(prevState.herd_buffer)) ? [...prevState.herd_buffer] : [];
-
-            // 3. Calculate Detrended Delta
-            const flowDelta = rawFlow - prevFlow;
-            const herdDelta = rawHerd - prevHerd;
-
-            // 4. Update Buffers
-            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;
-            let regime = "WARM_UP";
-
-            if (flowBuffer.length >= 15) {
+            const flow = signals.getMetric(computed, 'skilled-cohort-flow', ticker, 'net_flow_pct', 0);
+            const herd = signals.getMetric(computed, 'herd-consensus-score', ticker, 'herd_conviction_score', 0);
+            const prev = signals.getPreviousState(previousComputed, 'mimetic-latency', ticker);
+            const pS = prev?._state || null;
+            const pF = pS?.last_flow || 0, pH = pS?.last_herd || 0, fBuf = [...(pS?.flow_buffer || [])], hBuf = [...(pS?.herd_buffer || [])];
+            fBuf.push(flow - pF); hBuf.push(herd - pH);
+            if (fBuf.length > this.windowSize) { fBuf.shift(); hBuf.shift(); }
+            let maxCorr = -1.0, bestLag = null, regime = "WARM_UP";
+            if (fBuf.length >= 15) {
                 for (let k = 0; k <= this.maxLag; k++) {
-                    const len = flowBuffer.length;
-                    if (len - k < 5) continue; 
-
-                    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;
-                    }
-                }
-
-                if (maxCorr > 0.3) {
-                    if (bestLag >= 3) regime = "EARLY_ALPHA";
-                    else if (bestLag >= 1) regime = "MARKUP";
-                    else regime = "FOMO_TRAP";
-                } else {
-                    regime = "DECOUPLING";
+                    const len = fBuf.length; if (len - k < 5) continue;
+                    const r = TimeSeries.pearsonCorrelation(fBuf.slice(0, len - k), hBuf.slice(k, len));
+                    if (r > maxCorr) { maxCorr = r; bestLag = k; }
                 }
+                if (maxCorr > 0.3) regime = bestLag >= 3 ? "EARLY_ALPHA" : (bestLag >= 1 ? "MARKUP" : "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
-                }
-            };
+            this.mloResults[ticker] = { lag_days: bestLag, correlation_strength: Number(maxCorr.toFixed(4)), regime, _state: { flow_buffer: fBuf, herd_buffer: hBuf, last_flow: flow, last_herd: herd } };
         }
     }
-
     getResult() { return this.mloResults; }
     reset() { this.mloResults = {}; }
 }

package/package.json

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