aiden-shared-calculations-unified 1.0.86 → 1.0.88

package/calculations/gem/unskilled-cohort-flow.js

@@ -1,20 +1,13 @@
 /**
  * @fileoverview GEM Product Line (Pass 2)
- * --- FIX ---
- * - Added defensive checks in '_loadDependencies' to prevent crash
- * when dependencies fail to load (e.g., due to worker bug).
- * - **FIXED:** Restored logic to calculate 'avg_position_change_pct'
- * to resolve the hardcoded '0' value. This involves
- * re-adding fields to '_initFlowData' and 'process'.
+ * REFACTORED: Uses context.computed and context.math.extract.
  */
-
 class UnskilledCohortFlow {
     constructor() {
         this.assetFlows = new Map();
         this.cohortMap = new Map();
-        this.tickerMap = null;
         this.dependenciesLoaded = false;
-        this.priceChangeMap = null; 
+        this.tickerMap = null;
     }
 
     static getMetadata() {
@@ -28,10 +21,7 @@ class UnskilledCohortFlow {
     }
 
     static getDependencies() {
-        return [
-            'cohort-skill-definition',     // from gem (Pass 1)
-            'instrument-price-change-1d' // from core (Pass 1)
-        ];
+        return ['cohort-skill-definition', 'instrument-price-change-1d'];
     }
 
     static getSchema() {
@@ -45,206 +35,108 @@ class UnskilledCohortFlow {
             },
             "required": ["net_flow_pct", "net_flow_contribution", "avg_position_change_pct", "user_count"]
         };
-
-        return {
-            "type": "object",
-            "description": "Calculates capital flow and conviction change for the 'Unskilled' cohort.",
-            "patternProperties": { "^.*$": tickerSchema },
-            "additionalProperties": tickerSchema
-        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    _getPortfolioPositions(portfolio) {
-        // --- FIX: Support both Normal (Aggregated) and Speculator (Public) ---
-        return portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-    }
-
-    // --- THIS IS THE FIX (Part 1) ---
     _initFlowData(instrumentId) {
         if (!this.assetFlows.has(instrumentId)) {
             this.assetFlows.set(instrumentId, {
-                total_invested_yesterday: 0,
-                total_invested_today: 0,
-                price_change_yesterday: 0,
-                // Restore fields needed for avg_position_change_pct
-                total_pos_size_yesterday: 0, 
-                total_pos_size_today: 0, 
-                user_count_yesterday: 0, 
-                user_count_today: 0
+                total_invested_yesterday: 0, total_invested_today: 0, price_change_yesterday: 0,
+                total_pos_size_yesterday: 0, total_pos_size_today: 0, user_count_yesterday: 0, user_count_today: 0
             });
         }
     }
-    // --- END FIX (Part 1) ---
 
-    _loadDependencies(fetchedDependencies) {
+    _loadDependencies(computed) {
         if (this.dependenciesLoaded) return;
-
-        if (!fetchedDependencies) {
-            throw new Error(
-                `[unskilled-cohort-flow] CRITICAL ERROR: fetchedDependencies object was UNDEFINED. 
-                This means a dependency test (like 'cohort-skill-definition' or 'instrument-price-change-1d') 
-                failed to run or produced an invalid result.`
-            );
-        }
-
-        const cohortData = fetchedDependencies['cohort-skill-definition'];
-        if (!cohortData) {
-             throw new Error(
-                `[unskilled-cohort-flow] DEPENDENCY ERROR: 'cohort-skill-definition' was missing. 
-                Check logs for errors in that calculation.`
-             );
-        }
-
-        // This logic is correct for 'cohort-skill-definition' output
-        if (cohortData && cohortData.unskilled_user_ids) {
+        const cohortData = computed['cohort-skill-definition'];
+        if (cohortData) {
             (cohortData.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled'));
         }
-
-        this.priceChangeMap = fetchedDependencies['instrument-price-change-1d'];
-        if (!this.priceChangeMap) {
-             throw new Error(
-                `[unskilled-cohort-flow] DEPENDENCY ERROR: 'instrument-price-change-1d' was missing. 
-                This is likely due to the worker bug for 'price' dependencies.`
-             );
-        }
-
         this.dependenciesLoaded = true;
     }
 
-    // --- THIS IS THE FIX (Part 2) ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        this._loadDependencies(fetchedDependencies);
-
-        if (!this.tickerMap) {
-            this.tickerMap = context.instrumentToTicker;
-        }
-
-        const cohortName = this.cohortMap.get(String(userId));
-        if (cohortName !== 'unskilled') {
-            return; // Not in unskilled cohort
-        }
+    process(context) {
+        const { user, computed, mappings, math } = context;
+        const { extract } = math;
+        
+        this._loadDependencies(computed);
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        if (!todayPortfolio || !yesterdayPortfolio || !this.priceChangeMap || !this.tickerMap) {
-            return;
-        }
+        if (this.cohortMap.get(user.id) !== 'unskilled') return;
+        
+        const priceChangeMap = computed['instrument-price-change-1d'];
+        if (!priceChangeMap) return;
 
-        const yPos = this._getPortfolioPositions(yesterdayPortfolio);
-        const tPos = this._getPortfolioPositions(todayPortfolio);
-        if (!yPos || !tPos) return;
+        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
+        const tPos = extract.getPositions(user.portfolio.today, user.type);
 
-        const yPosMap = new Map(yPos.map(p => [p.InstrumentID, p]));
-        const tPosMap = new Map(tPos.map(p => [p.InstrumentID, p]));
+        const yPosMap = new Map(yPos.map(p => [extract.getInstrumentId(p), p]));
+        const tPosMap = new Map(tPos.map(p => [extract.getInstrumentId(p), p]));
         const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
 
-        for (const instrumentId of allInstrumentIds) {
-            if (!instrumentId) continue;
-
-            this._initFlowData(instrumentId);
-            const asset = this.assetFlows.get(instrumentId);
-
-            const yP = yPosMap.get(instrumentId);
-            const tP = tPosMap.get(instrumentId);
-
-            // Get $ flow
-            const yInvested = yP?.Invested || yP?.Amount || 0; 
-            const tInvested = tP?.Invested || tP?.Amount || 0;
-            
-            // Get position size (same as $ flow for these schemas)
-            const ySize = yP?.Invested || yP?.Amount || 0;
-            const tSize = tP?.Invested || tP?.Amount || 0;
+        for (const instId of allInstrumentIds) {
+            if (!instId) continue;
+            this._initFlowData(instId);
+            const asset = this.assetFlows.get(instId);
 
-            if (yInvested > 0) {
-                asset.total_invested_yesterday += yInvested;
+            const yWeight = extract.getPositionWeight(yPosMap.get(instId), user.type);
+            const tWeight = extract.getPositionWeight(tPosMap.get(instId), user.type);
 
-                const ticker = this.tickerMap[instrumentId];
-                const yPriceChange_pct = (ticker && this.priceChangeMap[ticker]) 
-                                            ? this.priceChangeMap[ticker].price_change_1d_pct 
-                                            : 0;
-
-                const yPriceChange_decimal = (yPriceChange_pct || 0) / 100.0;
-                asset.price_change_yesterday += yPriceChange_decimal * yInvested;
-                
-                // Track yesterday's size and user count
-                asset.total_pos_size_yesterday += ySize;
+            if (yWeight > 0) {
+                asset.total_invested_yesterday += yWeight;
+                const ticker = mappings.instrumentToTicker[instId];
+                const priceChange = (ticker && priceChangeMap[ticker]) ? priceChangeMap[ticker].change_1d_pct : 0;
+                asset.price_change_yesterday += (priceChange / 100.0) * yWeight;
+                asset.total_pos_size_yesterday += yWeight;
                 asset.user_count_yesterday++;
             }
-            if (tInvested > 0) {
-                asset.total_invested_today += tInvested;
+            if (tWeight > 0) {
+                asset.total_invested_today += tWeight;
                 asset.user_count_today++;
-                
-                // Track today's size
-                asset.total_pos_size_today += tSize;
+                asset.total_pos_size_today += tWeight;
             }
         }
     }
-    // --- END FIX (Part 2) ---
 
-    // --- THIS IS THE FIX (Part 3) ---
     async getResult() {
-        if (!this.tickerMap) {
-            return {}; 
-        }
-
+        if (!this.tickerMap) return {};
         const finalResult = {};
-
-        for (const [instrumentId, data] of this.assetFlows.entries()) {
-            const ticker = this.tickerMap[instrumentId];
+        for (const [instId, data] of this.assetFlows.entries()) {
+            const ticker = this.tickerMap[instId];
             if (!ticker) continue;
-
-            const { 
-                total_invested_yesterday, total_invested_today, price_change_yesterday,
-                // Destructure the restored fields
-                total_pos_size_yesterday, total_pos_size_today,
-                user_count_yesterday, user_count_today
-            } = data;
-
-            let net_flow_percentage = 0;
-            let flow_contribution = 0;
-
-            if (total_invested_yesterday > 0) {
-                const avg_price_change_decimal = (price_change_yesterday === 0) ? 0 : (price_change_yesterday / total_invested_yesterday);
-                const price_adjusted_yesterday_value = total_invested_yesterday * (1 + avg_price_change_decimal);
-
-                flow_contribution = total_invested_today - price_adjusted_yesterday_value;
-                net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
-            } else if (total_invested_today > 0) {
-                flow_contribution = total_invested_today;
-                net_flow_percentage = Infinity;
-            }
-
-            // Restore the calculation logic for conviction
-            let avg_position_change_pct = 0; 
-            if (user_count_yesterday > 0 && user_count_today > 0) {
-                const avg_pos_y = total_pos_size_yesterday / user_count_yesterday;
-                const avg_pos_t = total_pos_size_today / user_count_today;
-                if (avg_pos_y > 0) {
-                    avg_position_change_pct = ((avg_pos_t - avg_pos_y) / avg_pos_y) * 100;
-                }
-            } else if (user_count_today > 0) {
-                // Pure inflow, conviction is max
-                avg_position_change_pct = Infinity;
-            }
-
-            if (isFinite(net_flow_percentage) && isFinite(flow_contribution)) {
-                finalResult[ticker] = {
-                    net_flow_pct: net_flow_percentage,
-                    net_flow_contribution: flow_contribution,
-                    avg_position_change_pct: avg_position_change_pct, // Now correctly calculated
-                    user_count: user_count_today
-                };
+            let net_flow = 0, flow_contrib = 0;
+            if (data.total_invested_yesterday > 0) {
+                const avg_change = data.price_change_yesterday / data.total_invested_yesterday;
+                const adjusted_y = data.total_invested_yesterday * (1 + avg_change);
+                flow_contrib = data.total_invested_today - adjusted_y;
+                net_flow = (flow_contrib / data.total_invested_yesterday) * 100;
+            } else if (data.total_invested_today > 0) {
+                flow_contrib = data.total_invested_today;
+                net_flow = Infinity;
             }
+            let avg_pos_change = 0;
+            if (data.user_count_yesterday > 0 && data.user_count_today > 0) {
+                const avg_y = data.total_pos_size_yesterday / data.user_count_yesterday;
+                const avg_t = data.total_pos_size_today / data.user_count_today;
+                if (avg_y > 0) avg_pos_change = ((avg_t - avg_y) / avg_y) * 100;
+            } else if (data.user_count_today > 0) avg_pos_change = Infinity;
+
+            finalResult[ticker] = {
+                net_flow_pct: isFinite(net_flow) ? net_flow : 0,
+                net_flow_contribution: isFinite(flow_contrib) ? flow_contrib : 0,
+                avg_position_change_pct: isFinite(avg_pos_change) ? avg_pos_change : 0,
+                user_count: data.user_count_today
+            };
         }
-
         return finalResult;
     }
-    // --- END FIX (Part 3) ---
 
     reset() {
         this.assetFlows.clear();
         this.cohortMap.clear();
-        this.tickerMap = null;
         this.dependenciesLoaded = false;
-        this.priceChangeMap = null;
+        this.tickerMap = null;
     }
 }
 module.exports = UnskilledCohortFlow;

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;