aiden-shared-calculations-unified 1.0.86 → 1.0.88

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/calculations/pyro/risk-appetite-index.js

@@ -1,10 +1,7 @@
 /**
  * @fileoverview PYRO Product Line (Pass 2)
- * --- FIX ---
- * - Updated 'process' signature to the 7-arg standard to get context.
- * - Logic is already schema-compliant (uses pos.Leverage).
+ * REFACTORED: Uses context.math.extract.
  */
-
 class RiskAppetiteIndex {
     constructor() {
         this.tickerLeverage = new Map();
@@ -18,14 +15,12 @@ class RiskAppetiteIndex {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false, 
-            userType: 'speculator', // Only processes speculators
+            userType: 'speculator',
             category: 'pyro'
         };
     }
 
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
     static getSchema() {
         const schema = {
@@ -36,108 +31,72 @@ class RiskAppetiteIndex {
             },
             "required": ["avg_leverage", "user_count"]
         };
-
         return {
             "type": "object",
-            "description": "Calculates the average leverage used by speculators, aggregated by ticker and sector.",
             "properties": {
-                "by_ticker": { "type": "object", "patternProperties": { "^.*$": schema }, "additionalProperties": schema },
-                "by_sector": { "type": "object", "patternProperties": { "^.*$": schema }, "additionalProperties": schema }
-            },
-            "required": ["by_ticker", "by_sector"]
+                "by_ticker": { "type": "object", "patternProperties": { "^.*$": schema } },
+                "by_sector": { "type": "object", "patternProperties": { "^.*$": schema } }
+            }
         };
     }
 
     _init(map, key) {
-        if (!map.has(key)) {
-            map.set(key, { leverage_sum: 0, user_count: 0 });
-        }
+        if (!map.has(key)) map.set(key, { leverage_sum: 0, user_count: 0 });
     }
 
-    // --- THIS IS THE FIX ---
-    // Updated signature to match the test worker's standard 7-arg call
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-    // --- END FIX ---
-
-        if (!todayPortfolio?.PublicPositions) {
-            return; // Not a speculator or no positions
-        }
+    process(context) {
+        const { user, mappings, math } = context;
+        const { extract } = math;
 
         if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-             this.sectorMap = context.sectorMapping;
-        }
-
-        if (!this.tickerMap || !this.sectorMap) {
-            return; 
+             this.tickerMap = mappings.instrumentToTicker;
+             this.sectorMap = mappings.sectorMapping;
         }
 
-        const positions = todayPortfolio.PublicPositions;
-
+        const positions = extract.getPositions(user.portfolio.today, user.type);
         const seenTickers = new Set();
         const seenSectors = new Set();
 
         for (const pos of positions) {
-            if (!pos.InstrumentID || !pos.Leverage) continue;
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
 
-            const leverage = pos.Leverage;
-            if (leverage <= 1) continue; // Only care about leveraged positions
+            const leverage = extract.getLeverage(pos);
+            if (leverage <= 1) continue;
 
-            const ticker = this.tickerMap[pos.InstrumentID];
-            const sector = this.sectorMap[pos.InstrumentID];
+            const ticker = this.tickerMap[instId];
+            const sector = this.sectorMap[instId];
 
             if (ticker) {
                 this._init(this.tickerLeverage, ticker);
                 const asset = this.tickerLeverage.get(ticker);
                 asset.leverage_sum += leverage;
-
-                if (!seenTickers.has(ticker)) {
-                    asset.user_count++;
-                    seenTickers.add(ticker);
-                }
+                if (!seenTickers.has(ticker)) { asset.user_count++; seenTickers.add(ticker); }
             }
 
             if (sector) {
                 this._init(this.sectorLeverage, sector);
                 const sec = this.sectorLeverage.get(sector);
                 sec.leverage_sum += leverage;
-
-                if (!seenSectors.has(sector)) {
-                    sec.user_count++;
-                    seenSectors.add(sector);
-                }
+                if (!seenSectors.has(sector)) { sec.user_count++; seenSectors.add(sector); }
             }
         }
     }
 
     async getResult() {
-        if (!this.tickerMap) {
-            return { by_ticker: {}, by_sector: {} };
-        }
-
-        const result = {
-            by_ticker: {},
-            by_sector: {}
-        };
-
-        for (const [ticker, data] of this.tickerLeverage.entries()) {
-            if (data.user_count > 0) {
-                result.by_ticker[ticker] = {
-                    avg_leverage: data.leverage_sum / data.user_count,
-                    user_count: data.user_count
-                };
-            }
-        }
-
-        for (const [sector, data] of this.sectorLeverage.entries()) {
-            if (data.user_count > 0) {
-                result.by_sector[sector] = {
-                    avg_leverage: data.leverage_sum / data.user_count,
-                    user_count: data.user_count
-                };
+        const result = { by_ticker: {}, by_sector: {} };
+        const build = (map, out) => {
+            for (const [key, data] of map.entries()) {
+                if (data.user_count > 0) {
+                    out[key] = {
+                        avg_leverage: data.leverage_sum / data.user_count,
+                        user_count: data.user_count
+                    };
+                }
             }
-        }
-
+        };
+        build(this.tickerLeverage, result.by_ticker);
+        build(this.sectorLeverage, result.by_sector);
         return result;
     }
 

package/calculations/pyro/squeeze-potential.js

@@ -1,126 +1,69 @@
 /**
  * @fileoverview PYRO Product Line (Pass 3)
- * --- FIX ---
- * - **Corrected Dependency:** Changed from 'short-position-per-stock'
- * to 'total-short-figures' to get the required 'total_invested_usd'.
- * - Updated 'process' to the 5-arg 'meta' signature.
- * - Updated logic to access data from fixed dependencies.
- * * --- ** THIS IS THE FIX FOR THE EMPTY RESULT ** ---
- * - The 'process' function uses 'short-position-per-stock', but the
- * 'getDependencies' function was requesting 'total-short-figures'.
- * - Corrected 'getDependencies' to request what 'process' actually uses.
+ * REFACTORED: Uses context.math.signals and process(context).
  */
 class SqueezePotential {
-
-    constructor() {
-        this.result = {};
-    }
+    constructor() { this.result = {}; }
 
     static getMetadata() {
         return {
             type: 'meta',
             rootDataDependencies: [],
             isHistorical: false,
-            userType: 'n'/'a',
+            userType: 'n/a',
             category: 'pyro'
         };
     }
 
-    // --- THIS IS THE FIX FOR THE EMPTY RESULT ---
     static getDependencies() {
         return [
-            // Was: 'total-short-figures'
-            'short-position-per-stock', // <-- FIX: This is what process() actually uses
-            'speculator-stop-loss-distance-by-ticker-short-long-breakdown' // Pass 1
+            'short-position-per-stock', // Per-ticker counts
+            'speculator-stop-loss-distance-by-ticker-short-long-breakdown' // Per-ticker SL
         ];
     }
-    // --- END FIX ---
 
     static getSchema() {
         const tickerSchema = {
             "type": "object",
             "properties": {
-                "total_short_usd": { "type": "number" },
+                "total_short_exposure_weight": { "type": "number" },
                 "avg_sl_distance_pct": { "type": "number" },
-                "user_count": { "type": "number" } // This is now position_count
+                "user_count": { "type": "number" }
             },
-            "required": ["total_short_usd", "avg_sl_distance_pct", "user_count"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Aggregates total $USD short volume and avg. stop-loss distance per asset.",
-            "patternProperties": { "^.*$": tickerSchema },
-            "additionalProperties": tickerSchema
+            "required": ["avg_sl_distance_pct", "user_count"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    // --- THIS IS THE FIX (Part 2) ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-
-        // 'total-short-figures' is NOT keyed by ticker, it's a single object.
-        // This calculation is fundamentally flawed.
-        // It needs 'total-short-per-sector' or a new calc.
-
-        // --- RE-FIXING based on available dependencies ---
-        // 'total-short-figures' is { total_invested_usd, total_positions_count }
-        // 'speculator-stop-loss-distance...' is { [ticker]: { short_avg_distance_pct, ... } }
-        //
-        // The *intent* is to get short USD per ticker. This is not possible
-        // with the listed dependencies.
-        //
-        // We will use 'total-short-per-sector' as a proxy.
-        // **User must change dependency to 'total-short-per-sector'.**
-        // I will assume this change is made.
+    process(context) {
+        const { computed, math } = context;
+        const { signals } = math;
 
-        // --- HACK: Re-fixing again. ---
-        // I will use 'short-position-per-stock' and just report 0 for USD.
-        // This matches my previous fix and is the only way to get a
-        // per-ticker result.
+        const shortData = computed['short-position-per-stock'];
+        const slData = computed['speculator-stop-loss-distance-by-ticker-short-long-breakdown'];
 
-        const shortData = fetchedDependencies['short-position-per-stock'];
-        const slData = fetchedDependencies['speculator-stop-loss-distance-by-ticker-short-long-breakdown'];
-
-        if (!shortData || !slData) {
-            this.result = {};
-            return; 
-        }
+        if (!shortData || !slData) return;
 
         const result = {};
-
-        // 1. Process SL data (already keyed by ticker)
-        for (const [ticker, data] of Object.entries(slData)) {
-            const shortSlAvg = data.short_avg_distance_pct;
-            if (shortSlAvg > 0) {
-                if (!result[ticker]) {
-                    result[ticker] = { total_short_usd: 0, avg_sl_distance_pct: 0, user_count: 0 };
-                }
-                result[ticker].avg_sl_distance_pct = shortSlAvg;
+        const tickers = signals.getUnionKeys(computed, ['short-position-per-stock', 'speculator-stop-loss-distance-by-ticker-short-long-breakdown']);
+
+        for (const ticker of tickers) {
+            const shortSlAvg = signals.getMetric(computed, 'speculator-stop-loss-distance-by-ticker-short-long-breakdown', ticker, 'avg_short_sl_distance_pct');
+            const userCount = signals.getMetric(computed, 'short-position-per-stock', ticker, 'short_count');
+            const weight = signals.getMetric(computed, 'short-position-per-stock', ticker, 'total_short_exposure_weight');
+
+            if (userCount > 0) {
+                result[ticker] = {
+                    total_short_exposure_weight: weight,
+                    avg_sl_distance_pct: shortSlAvg,
+                    user_count: userCount
+                };
             }
         }
-
-        // 2. Process Short Volume data (already keyed by Ticker)
-        for (const [ticker, count] of Object.entries(shortData)) {
-            if (!result[ticker]) {
-                 result[ticker] = { total_short_usd: 0, avg_sl_distance_pct: 0, user_count: 0 };
-            }
-
-            // This is the only "fix" possible without changing dependencies
-            // to a per-ticker USD calculation (which doesn't exist).
-            result[ticker].total_short_usd = 0; // Cannot be calculated from deps
-            result[ticker].user_count = count; // This is position count
-        }
-
         this.result = result;
     }
-    // --- END FIX (Part 2) ---
-
-    async getResult(fetchedDependencies) {
-        return this.result;
-    }
 
-    reset() {
-        this.result = {};
-    }
+    async getResult() { return this.result; }
+    reset() { this.result = {}; }
 }
 module.exports = SqueezePotential;