aiden-shared-calculations-unified 1.0.86 → 1.0.88

package/calculations/gem/cohort-momentum-state.js

@@ -1,17 +1,13 @@
 /**
  * @fileoverview GEM Product Line (Pass 2)
- * --- FIX ---
- * - Added defensive check in _loadDependencies for 'instrument-price-momentum-20d'.
- * - This calc fails because its dependency fails. The logic is correct.
+ * REFACTORED: Uses context.computed and context.math.
  */
-
 class CohortMomentumState {
     constructor() {
         this.cohortMomentum = new Map();
         this.cohortMap = new Map();
-        this.tickerMap = null;
         this.dependenciesLoaded = false;
-        this.momentumData = null;
+        this.tickerMap = null; // Need to store this
     }
 
     static getMetadata() {
@@ -25,10 +21,7 @@ class CohortMomentumState {
     }
 
     static getDependencies() {
-        return [
-            'cohort-skill-definition',
-            'instrument-price-momentum-20d'
-        ];
+        return ['cohort-skill-definition', 'instrument-price-momentum-20d'];
     }
 
     static getSchema() {
@@ -40,107 +33,69 @@ class CohortMomentumState {
             },
             "required": ["average_momentum_exposure_pct", "trade_count"]
         };
-
-        return {
-            "type": "object",
-            "description": "Calculates the average 20D momentum % for all *new* trades, bucketed by skill cohort.",
-            "properties": {
-                "skilled": cohortSchema,
-                "unskilled": cohortSchema
-            }
-        };
+        return { "type": "object", "properties": { "skilled": cohortSchema, "unskilled": cohortSchema } };
     }
 
-    _loadDependencies(fetchedDependencies) {
+    _loadDependencies(computed) {
         if (this.dependenciesLoaded) return;
-
-        // --- FIX: Add defensive checks ---
-        if (!fetchedDependencies) {
-            throw new Error("[cohort-momentum-state] Critical error: fetchedDependencies is undefined.");
-        }
-        const cohortData = fetchedDependencies['cohort-skill-definition'];
-        if (!cohortData) {
-             throw new Error("[cohort-momentum-state] Dependency Error: 'cohort-skill-definition' was missing.");
+        const cohortData = computed['cohort-skill-definition'];
+        if (cohortData) {
+            (cohortData.skilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'skilled'));
+            (cohortData.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled'));
         }
-        this.momentumData = fetchedDependencies['instrument-price-momentum-20d'];
-        if (!this.momentumData) {
-             throw new Error("[cohort-momentum-state] Dependency Error: 'instrument-price-momentum-20d' was missing. This is the root cause of failure.");
-        }
-        // --- END FIX ---
-
-        // Cohort data structure is correct
-        (cohortData.skilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'skilled'));
-        (cohortData.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled'));
-
         this.dependenciesLoaded = true;
     }
 
     _initCohort(cohortName) {
-        if (!this.cohortMomentum.has(cohortName)) {
-            this.cohortMomentum.set(cohortName, { momentum_sum: 0, count: 0 });
-        }
+        if (!this.cohortMomentum.has(cohortName)) this.cohortMomentum.set(cohortName, { momentum_sum: 0, count: 0 });
     }
 
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        // Use the 7-arg signature
-        this._loadDependencies(fetchedDependencies);
-
-        if (!this.tickerMap) {
-            this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { user, computed, mappings, math } = context;
+        const { extract } = math;
+        
+        this._loadDependencies(computed);
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        const cohortName = this.cohortMap.get(String(userId));
-        if (!cohortName) {
-            return; // Not in a defined cohort
-        }
+        const cohortName = this.cohortMap.get(user.id);
+        if (!cohortName) return;
 
-        if (!this.momentumData || !this.tickerMap) {
-            return; // Dependencies missing
-        }
+        const momentumData = computed['instrument-price-momentum-20d'];
+        if (!momentumData) return;
 
-        // This calc uses the 'hacked' worker logic for portfolio
-        const yIds = new Set((yesterdayPortfolio?.AggregatedPositions || []).map(p => p.InstrumentID));
-        const newPositions = (todayPortfolio?.AggregatedPositions || []).filter(p => p.InstrumentID && !yIds.has(p.InstrumentID));
+        const yIds = new Set(extract.getPositions(user.portfolio.yesterday, user.type).map(p => extract.getInstrumentId(p)));
+        const newPositions = extract.getPositions(user.portfolio.today, user.type).filter(p => !yIds.has(extract.getInstrumentId(p)));
 
-        if (newPositions.length === 0) {
-            return; // No new positions
-        }
+        if (newPositions.length === 0) return;
 
         this._initCohort(cohortName);
         const asset = this.cohortMomentum.get(cohortName);
 
         for (const pos of newPositions) {
-            const ticker = this.tickerMap[pos.InstrumentID];
-            if (ticker && this.momentumData[ticker]) {
-                asset.momentum_sum += this.momentumData[ticker].momentum_20d_pct || 0;
+            const ticker = mappings.instrumentToTicker[extract.getInstrumentId(pos)];
+            if (ticker && momentumData[ticker]) {
+                asset.momentum_sum += momentumData[ticker].momentum_20d_pct || 0;
                 asset.count++;
             }
         }
     }
 
     async getResult() {
-        if (!this.tickerMap) {
-            return {}; 
-        }
-
         const finalResult = {};
-
         for (const [cohortName, data] of this.cohortMomentum.entries()) {
             finalResult[cohortName] = {
                 average_momentum_exposure_pct: (data.count > 0) ? data.momentum_sum / data.count : 0,
                 trade_count: data.count
             };
         }
-
         return finalResult;
     }
 
     reset() {
         this.cohortMomentum.clear();
         this.cohortMap.clear();
-        this.tickerMap = null;
         this.dependenciesLoaded = false;
-        this.momentumData = null;
+        this.tickerMap = null;
     }
 }
 module.exports = CohortMomentumState;

package/calculations/gem/cohort-skill-definition.js

@@ -1,26 +1,20 @@
 /**
- * @fileoverview Calculation (Pass 1) for defining skill-based cohorts.
- * --- FIX ---
- * - 'todayPortfolio' IS the history object.
- * - Changed 'todayPortfolio?.all' to 'historyData?.all' for clarity.
- * - This calculation is already correct based on the worker 'hack'.
+ * @fileoverview GEM Product Line (Pass 1)
+ * REFACTORED: Strictly uses context.math.history to access user history.
  */
 class CohortSkillDefinition {
-    constructor() {
-        this.userScores = new Map();
-    }
+    constructor() { this.userScores = new Map(); }
 
     static getSchema() {
         return {
             "type": "object",
-            "description": "Provides the user ID lists for the 'Skilled' (top 20%) and 'Unskilled' (bottom 20%) cohorts based on historical trade performance.",
             "properties": {
                 "skilled_user_ids": { "type": "array", "items": { "type": "string" } },
                 "unskilled_user_ids": { "type": "array", "items": { "type": "string" } },
                 "skilled_cohort_size": { "type": "number" },
                 "unskilled_cohort_size": { "type": "number" }
             },
-            "required": ["skilled_user_ids", "unskilled_user_ids", "skilled_cohort_size", "unskilled_cohort_size"]
+            "required": ["skilled_user_ids", "unskilled_user_ids"]
         };
     }
 
@@ -34,63 +28,53 @@ class CohortSkillDefinition {
         };
     }
 
-    static getDependencies() {
-        return [];
-    }
-
-    // --- THIS IS THE FIX ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
+    static getDependencies() { return []; }
 
+    process(context) {
+        const { user, math } = context;
+        const { history } = math;
+        
+        // 1. Get strict daily history
+        const historyDoc = history.getDailyHistory(user);
+        
+        // 2. Get strict summary DTO
+        const summary = history.getSummary(historyDoc);
 
-    const historyData = todayPortfolio; 
-    const history = historyData?.all;
+        if (!summary || summary.totalTrades < 10) return;
 
-        if (!history) {
-            return;
-        }
-
-        const { winRatio, avgProfitPct, avgLossPct, totalTrades } = history;
-
-        if (!totalTrades || totalTrades < 10) {
-            return;
-        }
-
-        const winRate = winRatio / 100.0;
+        // 3. Valid DTO usage
+        const winRate = summary.winRatio / 100.0;
         const lossRate = 1.0 - winRate;
-        const avgWin = avgProfitPct;
-        const avgLoss = Math.abs(avgLossPct);
-
-        const expectancy = (winRate * avgWin) - (lossRate * avgLoss);
-        const skillScore = expectancy * Math.log10(Math.max(1, totalTrades));
+        
+        const expectancy = (winRate * summary.avgProfitPct) - (lossRate * Math.abs(summary.avgLossPct));
+        
+        const skillScore = expectancy * Math.log10(Math.max(1, summary.totalTrades));
 
-        if (isFinite(skillScore)) {
-            this.userScores.set(userId, skillScore);
-        }
+        if (isFinite(skillScore)) this.userScores.set(user.id, skillScore);
     }
 
     getResult() {
-        const sortedUsers = Array.from(this.userScores.entries())
-            .sort((a, b) => b[1] - a[1]);
-
-        const cohortSize = Math.floor(sortedUsers.length * 0.20);
+        const sorted = Array.from(this.userScores.entries()).sort((a, b) => b[1] - a[1]);
+        const cohortSize = Math.floor(sorted.length * 0.20);
+        
         if (cohortSize === 0) {
-            return { skilled_user_ids: [], unskilled_user_ids: [], skilled_cohort_size: 0, unskilled_cohort_size: 0 };
+            return { 
+                skilled_user_ids: [], unskilled_user_ids: [], 
+                skilled_cohort_size: 0, unskilled_cohort_size: 0 
+            };
         }
 
-        const skilled_user_ids = sortedUsers.slice(0, cohortSize).map(u => String(u[0]));
-        const unskilled_user_ids = sortedUsers.slice(-cohortSize).map(u => String(u[0]));
+        const skilled = sorted.slice(0, cohortSize).map(u => String(u[0]));
+        const unskilled = sorted.slice(-cohortSize).map(u => String(u[0]));
 
         return {
-            skilled_user_ids: skilled_user_ids,
-            unskilled_user_ids: unskilled_user_ids,
-            skilled_cohort_size: skilled_user_ids.length,
-            unskilled_cohort_size: unskilled_user_ids.length
+            skilled_user_ids: skilled,
+            unskilled_user_ids: unskilled,
+            skilled_cohort_size: skilled.length,
+            unskilled_cohort_size: unskilled.length
         };
     }
 
-    reset() {
-        this.userScores.clear();
-    }
+    reset() { this.userScores.clear(); }
 }
-
 module.exports = CohortSkillDefinition;

package/calculations/gem/platform-conviction-divergence.js

@@ -1,15 +1,9 @@
 /**
  * @fileoverview GEM Product Line (Pass 3)
- * --- FIX ---
- * - This calc is failing because its dependencies are failing.
- * - Added defensive checks for missing dependencies.
- * - Updated process signature to 5-arg meta standard.
+ * REFACTORED: Uses context.math.signals and process(context).
  */
 class PlatformConvictionDivergence {
-
-    constructor() {
-        this.result = {};
-    }
+    constructor() { this.result = {}; }
 
     static getMetadata() {
         return {
@@ -21,12 +15,7 @@ class PlatformConvictionDivergence {
         };
     }
 
-    static getDependencies() {
-        return [
-            'skilled-cohort-flow',
-            'unskilled-cohort-flow'
-        ];
-    }
+    static getDependencies() { return ['skilled-cohort-flow', 'unskilled-cohort-flow']; }
 
     static getSchema() {
         const tickerSchema = {
@@ -38,63 +27,32 @@ class PlatformConvictionDivergence {
             },
             "required": ["skilled_conviction_change_pct", "unskilled_conviction_change_pct", "conviction_divergence_score"]
         };
-
-        return {
-            "type": "object",
-            "description": "Tracks the divergence in 'conviction' (change in avg. position size) between skilled and unskilled cohorts.",
-            "patternProperties": { "^.*$": tickerSchema },
-            "additionalProperties": tickerSchema
-        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    // --- THIS IS THE FIX ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-
-        const skilledFlow = fetchedDependencies['skilled-cohort-flow'];
-        const unskilledFlow = fetchedDependencies['unskilled-cohort-flow'];
-
-        if (!skilledFlow || !unskilledFlow) {
-             // This is expected until the worker bug is fixed
-            this.result = {};
-            return;
-        }
-
-        const allTickers = new Set([
-            ...Object.keys(skilledFlow),
-            ...Object.keys(unskilledFlow)
-        ]);
+    process(context) {
+        const { computed, math } = context;
+        const { signals } = math;
 
+        const tickers = signals.getUnionKeys(computed, ['skilled-cohort-flow', 'unskilled-cohort-flow']);
         const result = {};
 
-        for (const ticker of allTickers) {
-            const skilledData = skilledFlow[ticker];
-            const unskilledData = unskilledFlow[ticker];
-
-            // Get conviction score (avg_position_change_pct)
-            const skilled_conviction = skilledData?.avg_position_change_pct || 0;
-            const unskilled_conviction = unskilledData?.avg_position_change_pct || 0;
-
-            if (skilled_conviction === 0 && unskilled_conviction === 0) {
-                continue;
-            }
+        for (const ticker of tickers) {
+            const skilled = signals.getMetric(computed, 'skilled-cohort-flow', ticker, 'avg_position_change_pct');
+            const unskilled = signals.getMetric(computed, 'unskilled-cohort-flow', ticker, 'avg_position_change_pct');
+            
+            if (skilled === 0 && unskilled === 0) continue;
 
             result[ticker] = {
-                skilled_conviction_change_pct: skilled_conviction,
-                unskilled_conviction_change_pct: unskilled_conviction,
-                conviction_divergence_score: skilled_conviction - unskilled_conviction
+                skilled_conviction_change_pct: skilled,
+                unskilled_conviction_change_pct: unskilled,
+                conviction_divergence_score: signals.divergence(skilled, unskilled)
             };
         }
-
         this.result = result;
     }
-    // --- END FIX ---
-
-    async getResult(fetchedDependencies) {
-        return this.result;
-    }
 
-    reset() {
-        this.result = {};
-    }
+    async getResult() { return this.result; }
+    reset() { this.result = {}; }
 }
 module.exports = PlatformConvictionDivergence;

package/calculations/gem/quant-skill-alpha-signal.js

@@ -1,18 +1,10 @@
 /**
  * @fileoverview GEM Product Line (Pass 4)
- *
- * This is the final, stateless signal generator for the GEM line.
- * It answers: "Are skilled users buying into *positive* momentum
- * while unskilled users are buying into *negative* momentum?"
+ * REFACTORED: Uses context.math.signals and process(context).
  */
 class QuantSkillAlphaSignal {
+    constructor() { this.result = {}; }
 
-    // --- STANDARD 2: ADDED ---
-    constructor() {
-        this.result = {};
-    }
-
-    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'meta',
@@ -23,69 +15,36 @@ class QuantSkillAlphaSignal {
         };
     }
 
-    /** Statically declare dependencies */
     static getDependencies() {
-        return [
-            'skilled-unskilled-divergence',  // from gem (Pass 3)
-            'cohort-momentum-state',       // from gem (Pass 2)
-            'instrument-price-momentum-20d'// from core (Pass 1)
-        ];
+        return ['skilled-unskilled-divergence', 'cohort-momentum-state', 'instrument-price-momentum-20d'];
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
             "properties": {
-                "signal": { "type": "string", "enum": ["Strong Buy", "Buy", "Neutral", "Sell", "Strong Sell"] },
+                "signal": { "type": "string" },
                 "gem_score": { "type": "number" },
-                "components": {
-                    "type": "object",
-                    "properties": {
-                        "flow_divergence": { "type": "number" },
-                        "momentum_divergence": { "type": "number" },
-                        "asset_momentum": { "type": "number" }
-                    }
-                }
+                "components": { "type": "object" }
             },
-            "required": ["signal", "gem_score", "components"]
-        };
-        
-        return {
-            "type": "object",
-            "description": "Generates a final skill-based alpha signal.",
-            "patternProperties": { "^.*$": tickerSchema },
-            "additionalProperties": tickerSchema
+            "required": ["signal", "gem_score"]
         };
-    }
-    
-    _normalize(score) {
-        return Math.tanh(score / 5.0) * 10;
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    /**
-     * This is a 'meta' calculation. It runs once.
-     */
-    // --- STANDARD 1: UPDATED SIGNATURE (added rootData) ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-        const { logger, calculationUtils } = dependencies;
-        
-        const flowDivergence = fetchedDependencies['skilled-unskilled-divergence'];
-        const momentumExposure = fetchedDependencies['cohort-momentum-state'];
-        const assetMomentum = fetchedDependencies['instrument-price-momentum-20d'];
+    process(context) {
+        const { computed, math } = context;
+        const { signals } = math;
 
-        if (!flowDivergence || !momentumExposure || !assetMomentum) {
-            logger.log('WARN', `[gem/quant-skill-alpha-signal] Missing dependencies for ${dateStr}.`);
-            // --- STANDARD 2: DO NOT RETURN ---
-            this.result = {};
-            return;
-        }
+        const flowDivergence = computed['skilled-unskilled-divergence'];
+        const momentumExposure = computed['cohort-momentum-state'];
+        const assetMomentum = computed['instrument-price-momentum-20d'];
+
+        if (!flowDivergence || !momentumExposure || !assetMomentum) return;
 
-        const skilledMomentum = momentumExposure.skilled?.average_momentum_exposure_pct || 0;
-        const unskilledMomentum = momentumExposure.unskilled?.average_momentum_exposure_pct || 0;
-        const momentumDivergence = skilledMomentum - unskilledMomentum;
+        const skilledMom = momentumExposure.skilled?.average_momentum_exposure_pct || 0;
+        const unskilledMom = momentumExposure.unskilled?.average_momentum_exposure_pct || 0;
+        const momentumDivergence = skilledMom - unskilledMom;
 
         const result = {};
         const allTickers = Object.keys(flowDivergence);
@@ -93,32 +52,13 @@ class QuantSkillAlphaSignal {
         for (const ticker of allTickers) {
             const flowData = flowDivergence[ticker];
             const assetMom = assetMomentum[ticker]?.momentum_20d_pct || 0;
-
-            // 1. Flow Divergence (Skilled buying, Unskilled selling)
-            const flowScore = flowData.flow_divergence_score; // e.g., +1.5
-            
-            // 2. Momentum Divergence (Skilled buying high-mom, Unskilled buying low-mom)
-            const momScore = momentumDivergence; // e.g., +20.0
-            
-            // 3. Asset Momentum (Is the asset *actually* in an uptrend?)
-            const assetScore = assetMom; // e.g., +15.0
-
-            // --- Signal Logic ---
-            // We want all three to be positive.
-            // 1. Skilled are buying, Unskilled are selling (flowScore > 0)
-            // 2. Skilled are buying *more* momentum than Unskilled (momScore > 0)
-            // 3. The asset itself has positive momentum (assetScore > 0)
+            const flowScore = flowData.flow_divergence_score;
             
-            // If skilled are buying *and* they are buying into strength, that's a good sign.
-            // We combine flow and momentum divergence.
-            const divergenceFactor = (flowScore > 0 && momScore > 0) ? (flowScore * momScore) : 0;
+            const scaledFlow = flowScore * 10;
+            const finalScore = (scaledFlow + momentumDivergence + assetMom) / 3.0;
             
-            // The final score is the divergence, *validated* by the asset's own momentum.
-            // We scale flowScore (small) and momScore (large) to be comparable
-            const scaledFlow = flowScore * 10; // (e.g., 1.5 -> 15)
-            const finalScore = (scaledFlow + momScore + assetScore) / 3.0;
+            const gem_score = signals.normalizeTanh(finalScore, 10, 5.0);
             
-            const gem_score = this._normalize(finalScore);
             let signal = "Neutral";
             if (gem_score > 7.0) signal = "Strong Buy";
             else if (gem_score > 2.5) signal = "Buy";
@@ -128,26 +68,13 @@ class QuantSkillAlphaSignal {
             result[ticker] = {
                 signal: signal,
                 gem_score: gem_score,
-                components: {
-                    flow_divergence: flowScore,
-                    momentum_divergence: momScore,
-                    asset_momentum: assetScore
-                }
+                components: { flow_divergence: flowScore, momentum_divergence: momentumDivergence, asset_momentum: assetMom }
             };
         }
-        
-        // --- STANDARD 2: SET STATE, DO NOT RETURN ---
         this.result = result;
     }
 
-    // --- STANDARD 2: ADDED ---
-    async getResult(fetchedDependencies) {
-        return this.result;
-    }
-
-    // --- STANDARD 2: ADDED ---
-    reset() {
-        this.result = {};
-    }
+    async getResult() { return this.result; }
+    reset() { this.result = {}; }
 }
 module.exports = QuantSkillAlphaSignal;