aiden-shared-calculations-unified 1.0.84 → 1.0.87

package/calculations/gauss/cohort-definer.js

@@ -1,29 +1,14 @@
 /**
  * @fileoverview GAUSS Product Line (Pass 2)
- *
- * This 'standard' calculation re-streams all users, filters for
- * the "Smart" and "Dumb" cohorts (from Pass 1), and then calculates
- * their full 4D "Trader DNA".
- *
- * It then buckets these users into our final, named sub-cohorts
- * (e.g., "Smart Investors", "FOMO Chasers").
+ * REFACTORED: Uses context.computed and context.math.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
-
 class CohortDefiner {
     constructor() {
-        // We will store the full DNA for our filtered cohorts
-        this.smartVectors = []; // [ { userId, skill, time, fomo, bagholder }, ... ]
-        this.dumbVectors = [];  // [ { userId, skill, time, fomo, bagholder }, ... ]
-
-        this.momentumData = null;
-        // --- STANDARD 0: RENAMED ---
-        this.tickerMap = null; 
-        this.cohortIdSets = null; // { smart: Set, dumb: Set }
+        this.smartVectors = []; 
+        this.dumbVectors = [];
+        this.cohortIdSets = null;
     }
 
-    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'standard',
@@ -34,197 +19,129 @@ class CohortDefiner {
         };
     }
 
-    /** Statically declare dependencies */
     static getDependencies() {
-        return [
-            'daily-dna-filter',              // from gauss (Pass 1)
-            'instrument-price-momentum-20d'  // from core (Pass 1)
-        ];
+        return ['daily-dna-filter', 'instrument-price-momentum-20d'];
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
-        const cohortSchema = {
-            "type": "array",
-            "description": "A list of User IDs belonging to this cohort.",
-            "items": { "type": "string" }
-        };
-        
+        const cohortSchema = { "type": "array", "items": { "type": "string" } };
         return {
             "type": "object",
-            "description": "A map of named cohorts to the list of user IDs in each.",
-            "properties": {
-                "smart_investors": cohortSchema,
-                "smart_scalpers": cohortSchema,
-                "fomo_chasers": cohortSchema,
-                "patient_losers": cohortSchema,
-                "fomo_bagholders": cohortSchema,
-                "uncategorized_smart": cohortSchema,
-                "uncategorized_dumb": cohortSchema
-            },
-            "additionalProperties": cohortSchema
+            "patternProperties": { "^.*$": cohortSchema }
         };
     }
     
-    /**
-     * Loads dependencies into memory on the first process() call.
-     */
-    _loadDependencies(fetchedDependencies) {
-        if (this.cohortIdSets) return; // Run once
-        
-        const dnaFilterData = fetchedDependencies['daily-dna-filter'];
-        this.momentumData = fetchedDependencies['instrument-price-momentum-20d'];
+    _loadDependencies(computed) {
+        if (this.cohortIdSets) return;
+        const dnaFilterData = computed['daily-dna-filter'];
         
-        if (dnaFilterData && dnaFilterData.smart_cohort_ids && dnaFilterData.dumb_cohort_ids) {
-            this.cohortIdSets = {
-                smart: new Set(dnaFilterData.smart_cohort_ids),
-                dumb: new Set(dnaFilterData.dumb_cohort_ids)
-            };
-        } else {
-            this.cohortIdSets = {
-                smart: new Set(),
-                dumb: new Set()
-            };
-        }
+        this.cohortIdSets = {
+            smart: new Set(dnaFilterData?.smart_cohort_ids || []),
+            dumb: new Set(dnaFilterData?.dumb_cohort_ids || [])
+        };
     }
 
-    _getFomoScore(todayPortfolio, yesterdayPortfolio) {
-        // --- STANDARD 0: UPDATED CHECK ---
-        if (!this.tickerMap) return 0;
-        
-        if (!this.momentumData) {
-            return 0; // Cannot calculate FOMO without momentum data
-        }
+    _getFomoScore(extract, mappings, today, yesterday, momentumData, userType) {
+        if (!momentumData) return 0;
+
+        const tPos = extract.getPositions(today, userType);
+        const yPos = extract.getPositions(yesterday, userType);
+
+        const yIds = new Set(yPos.map(p => extract.getInstrumentId(p)));
+        const newPositions = tPos.filter(p => !yIds.has(extract.getInstrumentId(p)));
 
-        const yIds = new Set((yesterdayPortfolio?.AggregatedPositions || []).map(p => p.InstrumentID));
-        const newPositions = (todayPortfolio?.AggregatedPositions || []).filter(p => p.InstrumentID && !yIds.has(p.InstrumentID));
         if (newPositions.length === 0) return 0;
 
-        let fomoSum = 0;
-        let count = 0;
+        let fomoSum = 0, count = 0;
         for (const pos of newPositions) {
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[pos.InstrumentID];
-            if (ticker && this.momentumData[ticker]) {
-                fomoSum += this.momentumData[ticker].momentum_20d_pct || 0;
+            const instId = extract.getInstrumentId(pos);
+            const ticker = mappings.instrumentToTicker[instId];
+            if (ticker && momentumData[ticker]) {
+                fomoSum += momentumData[ticker].momentum_20d_pct || 0;
                 count++;
             }
         }
-        return (count > 0) ? fomoSum / count : 0;
+        return count > 0 ? fomoSum / count : 0;
     }
 
-    _getBagholderScore(todayPortfolio) {
-        // FIX: Only Speculator data (PublicPositions) has the OpenDateTime field needed for this calculation.
-        const openPositions = todayPortfolio?.PublicPositions || [];
-        if (openPositions.length === 0) return 0;
+    _getBagholderScore(extract, today, userType) {
+        const positions = extract.getPositions(today, userType);
+        if (positions.length === 0) return 0;
 
-        let durationSum = 0;
-        let count = 0;
+        let durationSum = 0, count = 0;
         const now = new Date();
 
-        for (const pos of openPositions) {
-            if (pos.NetProfit < -20) { 
-                try {
-                    const openDate = new Date(pos.OpenDateTime);
-                    const durationMs = now.getTime() - openDate.getTime();
-                    const durationDays = durationMs / (1000 * 60 * 60 * 24);
-                    if (isFinite(durationDays)) {
+        for (const pos of positions) {
+            if (extract.getNetProfit(pos) < -20) {
+                const openDate = extract.getOpenDateTime(pos);
+                if (openDate) { 
+                    try {
+                        const durationDays = (now - openDate) / (86400000);
                         durationSum += durationDays;
                         count++;
-                    }
-                } catch (e) { /* ignore invalid date */ }
+                    } catch (e) {}
+                }
             }
         }
-        return (count > 0) ? durationSum / count : 0;
+        return count > 0 ? durationSum / count : 0;
     }
 
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        this._loadDependencies(fetchedDependencies);
-        
-        // --- STANDARD 0: FIXED ---
-        if (!this.tickerMap) {
-            this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { user, computed, mappings, math } = context;
+        const { extract, history } = math;
 
-        const isSmart = this.cohortIdSets.smart.has(userId);
-        const isDumb = this.cohortIdSets.dumb.has(userId);
+        this._loadDependencies(computed);
 
-        if (!isSmart && !isDumb) {
-            return; // Not in our extreme cohorts
-        }
+        const isSmart = this.cohortIdSets.smart.has(user.id);
+        const isDumb = this.cohortIdSets.dumb.has(user.id);
+
+        if (!isSmart && !isDumb) return;
 
-        // FIX: Access history data from the nested property provided by the fixed worker.js
-        const history = todayPortfolio?.history?.all;
-        if (!history) return;
+        // 1. Strict History Access
+        const historyDoc = history.getDailyHistory(user);
+        const summary = history.getSummary(historyDoc);
         
-        const winRate = (history.winRatio || 0) / 100.0;
+        if (!summary) return;
+        
+        // 2. Valid usage of Summary DTO properties
+        const winRate = summary.winRatio / 100.0;
         const lossRate = 1.0 - winRate;
-        const avgWin = history.avgProfitPct || 0;
-        const avgLoss = Math.abs(history.avgLossPct || 0);
-        const lt_skill = (winRate * avgWin) - (lossRate * avgLoss);
-        const lt_time = history.avgHoldingTimeInMinutes || 0;
+        const lt_skill = (winRate * summary.avgProfitPct) - (lossRate * Math.abs(summary.avgLossPct));
+        const lt_time = summary.avgHoldingTimeInMinutes;
 
-        const st_fomo = this._getFomoScore(todayPortfolio, yesterdayPortfolio);
-        const st_bagholder = this._getBagholderScore(todayPortfolio);
+        const momentumData = computed['instrument-price-momentum-20d'];
+        const st_fomo = this._getFomoScore(extract, mappings, user.portfolio.today, user.portfolio.yesterday, momentumData, user.type);
+        const st_bagholder = this._getBagholderScore(extract, user.portfolio.today, user.type);
 
-        const vector = { userId, skill: lt_skill, time: lt_time, fomo: st_fomo, bagholder: st_bagholder };
+        const vector = { userId: user.id, skill: lt_skill, time: lt_time, fomo: st_fomo, bagholder: st_bagholder };
 
-        if (isSmart) {
-            this.smartVectors.push(vector);
-        } else if (isDumb) {
-            this.dumbVectors.push(vector);
-        }
+        if (isSmart) this.smartVectors.push(vector);
+        else this.dumbVectors.push(vector);
     }
 
     _getMedian(vectors, key) {
         if (vectors.length === 0) return 0;
         const sorted = vectors.map(v => v[key]).sort((a, b) => a - b);
         const mid = Math.floor(sorted.length / 2);
-        if (sorted.length % 2 === 0 && sorted.length > 0) {
-            return (sorted[mid - 1] + sorted[mid]) / 2;
-        }
-        return sorted[mid];
+        return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
     }
 
-    getResult() {
+    async getResult() {
         const cohorts = {};
-        const assignedSmart = new Set();
-        const assignedDumb = new Set();
+        const assignedSmart = new Set(), assignedDumb = new Set();
 
-        const smart_median_time = this._getMedian(this.smartVectors, 'time');
-        
-        cohorts['smart_investors'] = this.smartVectors
-            .filter(u => u.time >= smart_median_time)
-            .map(u => { assignedSmart.add(u.userId); return u.userId; });
-            
-        cohorts['smart_scalpers'] = this.smartVectors
-            .filter(u => u.time < smart_median_time)
-            .map(u => { assignedSmart.add(u.userId); return u.userId; });
-            
-        cohorts['uncategorized_smart'] = this.smartVectors
-            .filter(u => !assignedSmart.has(u.userId))
-            .map(u => u.userId);
+        const smart_time = this._getMedian(this.smartVectors, 'time');
+        cohorts['smart_investors'] = this.smartVectors.filter(u => u.time >= smart_time).map(u => { assignedSmart.add(u.userId); return u.userId; });
+        cohorts['smart_scalpers'] = this.smartVectors.filter(u => u.time < smart_time).map(u => { assignedSmart.add(u.userId); return u.userId; });
+        cohorts['uncategorized_smart'] = this.smartVectors.filter(u => !assignedSmart.has(u.userId)).map(u => u.userId);
             
-        const dumb_median_fomo = this._getMedian(this.dumbVectors, 'fomo');
-        const dumb_median_bag = this._getMedian(this.dumbVectors, 'bagholder');
-
-        cohorts['fomo_chasers'] = this.dumbVectors
-            .filter(u => u.fomo >= dumb_median_fomo && u.bagholder < dumb_median_bag)
-            .map(u => { assignedDumb.add(u.userId); return u.userId; });
-        
-        cohorts['patient_losers'] = this.dumbVectors
-            .filter(u => u.fomo < dumb_median_fomo && u.bagholder >= dumb_median_bag)
-            .map(u => { assignedDumb.add(u.userId); return u.userId; });
-
-        cohorts['fomo_bagholders'] = this.dumbVectors
-            .filter(u => u.fomo >= dumb_median_fomo && u.bagholder >= dumb_median_bag)
-            .map(u => { assignedDumb.add(u.userId); return u.userId; });
+        const dumb_fomo = this._getMedian(this.dumbVectors, 'fomo');
+        const dumb_bag = this._getMedian(this.dumbVectors, 'bagholder');
 
-        cohorts['uncategorized_dumb'] = this.dumbVectors
-            .filter(u => !assignedDumb.has(u.userId))
-            .map(u => u.userId);
+        cohorts['fomo_chasers'] = this.dumbVectors.filter(u => u.fomo >= dumb_fomo && u.bagholder < dumb_bag).map(u => { assignedDumb.add(u.userId); return u.userId; });
+        cohorts['patient_losers'] = this.dumbVectors.filter(u => u.fomo < dumb_fomo && u.bagholder >= dumb_bag).map(u => { assignedDumb.add(u.userId); return u.userId; });
+        cohorts['fomo_bagholders'] = this.dumbVectors.filter(u => u.fomo >= dumb_fomo && u.bagholder >= dumb_bag).map(u => { assignedDumb.add(u.userId); return u.userId; });
+        cohorts['uncategorized_dumb'] = this.dumbVectors.filter(u => !assignedDumb.has(u.userId)).map(u => u.userId);
 
         return cohorts;
     }
@@ -232,9 +149,6 @@ class CohortDefiner {
     reset() {
         this.smartVectors = [];
         this.dumbVectors = [];
-        this.momentumData = null;
-        // --- STANDARD 0: RENAMED ---
-        this.tickerMap = null;
         this.cohortIdSets = null;
     }
 }

package/calculations/gauss/daily-dna-filter.js

@@ -1,61 +1,30 @@
 /**
  * @fileoverview GAUSS Product Line (Pass 1)
- *
- * This metric is a *filter*. It processes all users and calculates
- * their "Long-Term Skill" (Expectancy) from their 'history' doc.
- *
- * It then filters this list to *only* return the User IDs
- * of the top 20% (Smart) and bottom 20% (Dumb) of users,
- * solving the 1MB document limit for downstream processing.
+ * REFACTORED: Uses context.math.history.getSummary().
  */
 class DailyDnaFilter {
     constructor() {
-        // We will store all users and their primary skill score
-        // [ [userId, skillScore], ... ]
         this.allUserSkills = [];
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
-            // This calc only needs the 'history' doc.
-            // As per the test harness, this means 'todayPortfolio'
-            // in process() *is* the history object.
             rootDataDependencies: ['history'],
-            isHistorical: false, // Reads today's history snapshot
+            isHistorical: false,
             userType: 'all',
             category: 'gauss'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return []; // This is a Pass 1 calculation
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         return {
             "type": "object",
-            "description": "Provides the User ID lists for the 'Smart' (top 20%) and 'Dumb' (bottom 20%) cohorts based on long-term Expectancy.",
             "properties": {
-                "smart_cohort_ids": {
-                    "type": "array",
-                    "description": "List of user IDs in the top 20% 'Smart' cohort.",
-                    "items": { "type": "string" }
-                },
-                "dumb_cohort_ids": {
-                    "type": "array",
-                    "description": "List of user IDs in the bottom 20% 'Dumb' cohort.",
-                    "items": { "type": "string" }
-                },
+                "smart_cohort_ids": { "type": "array", "items": { "type": "string" } },
+                "dumb_cohort_ids": { "type": "array", "items": { "type": "string" } },
                 "total_users_analyzed": { "type": "number" },
                 "cohort_size": { "type": "number" }
             },
@@ -63,74 +32,51 @@ class DailyDnaFilter {
         };
     }
 
+    process(context) {
+        const { user, math } = context;
+        const { history } = math; // 'history' is the TOOL
 
-    /**
-     * Processes a single user's daily data.
-     * @param {object} todayPortfolio - Today's portfolio snapshot.
-     * @param {object} yesterdayPortfolio - Yesterday's portfolio snapshot.
-     * @param {string} userId - The user's ID.
-     */
-    process(todayPortfolio, yesterdayPortfolio, userId) {
+        // 1. Get strict daily history data
+        const historyDoc = history.getDailyHistory(user);
         
-        // ---
-        // FIX: 'todayPortfolio' *is* the history object because
-        // getMetadata() only requests ['history'].
-        // The path is 'todayPortfolio.all', not 'todayPortfolio.history.all'.
-        // ---
-        const history = todayPortfolio?.all;
-        if (!history || !history.totalTrades || history.totalTrades < 20) {
-            return; // Not enough history for a reliable score
-        }
+        // 2. Get strict summary object using the tool
+        const summary = history.getSummary(historyDoc);
+        
+        // Validation
+        if (!summary || summary.totalTrades < 20) return;
         
-        const winRate = (history.winRatio || 0) / 100.0;
+        // 3. Use properties from the SUMMARY object, not the history tool
+        const winRate = summary.winRatio / 100.0;
         const lossRate = 1.0 - winRate;
-        const avgWin = history.avgProfitPct || 0;
-        // Use Math.abs because avgLossPct is stored as a negative number
-        const avgLoss = Math.abs(history.avgLossPct || 0); 
         
-        // Expectancy = (Win % * Avg Win %) - (Loss % * Avg Loss %)
+        // CORRECTED LINE: uses summary.avgProfitPct
+        const avgWin = summary.avgProfitPct; 
+        const avgLoss = Math.abs(summary.avgLossPct);
+        
         const lt_skill = (winRate * avgWin) - (lossRate * avgLoss);
 
-        if (!isFinite(lt_skill)) {
-            return; // Skip bad data (e.g., division by zero)
+        if (isFinite(lt_skill)) {
+            this.allUserSkills.push([user.id, lt_skill]);
         }
-
-        this.allUserSkills.push([userId, lt_skill]);
     }
 
-    /**
-     * Returns the final filtered list of user IDs.
-     */
     getResult() {
         const totalUsers = this.allUserSkills.length;
-        if (totalUsers === 0) {
-            return { smart_cohort_ids: [], dumb_cohort_ids: [], total_users_analyzed: 0, cohort_size: 0 };
-        }
+        if (totalUsers === 0) return { smart_cohort_ids: [], dumb_cohort_ids: [], total_users_analyzed: 0, cohort_size: 0 };
 
-        // Sort by Skill (Expectancy) in descending order (highest skill first)
         this.allUserSkills.sort((a, b) => b[1] - a[1]);
         
-        const cohortSize = Math.floor(totalUsers * 0.20); // Top/Bottom 20%
-        if (cohortSize === 0) {
-            return { smart_cohort_ids: [], dumb_cohort_ids: [], total_users_analyzed: totalUsers, cohort_size: 0 };
-        }
-
-        // Get the top 20% (smartest)
-        const smart_cohort_ids = this.allUserSkills.slice(0, cohortSize).map(u => u[0]);
-        // Get the bottom 20% (dumbest)
-        const dumb_cohort_ids = this.allUserSkills.slice(-cohortSize).map(u => u[0]);
+        const cohortSize = Math.floor(totalUsers * 0.20);
+        if (cohortSize === 0) return { smart_cohort_ids: [], dumb_cohort_ids: [], total_users_analyzed: totalUsers, cohort_size: 0 };
 
-        // Output is now small and compact, solving the 1MB limit.
         return {
-            smart_cohort_ids: smart_cohort_ids,
-            dumb_cohort_ids: dumb_cohort_ids,
+            smart_cohort_ids: this.allUserSkills.slice(0, cohortSize).map(u => u[0]),
+            dumb_cohort_ids: this.allUserSkills.slice(-cohortSize).map(u => u[0]),
             total_users_analyzed: totalUsers,
             cohort_size: cohortSize
         };
     }
     
-    reset() {
-        this.allUserSkills = [];
-    }
+    reset() { this.allUserSkills = []; }
 }
 module.exports = DailyDnaFilter;

package/calculations/gauss/gauss-divergence-signal.js

@@ -1,66 +1,24 @@
 /**
  * @fileoverview GAUSS Product Line (Pass 4)
- *
- * This is the final, stateless signal generator for the Gauss line.
- * It answers: "What is the net 'Smart vs. Dumb' flow divergence?"
- *
- * It consumes the daily flows from all defined cohorts (Pass 3)
- * and aggregates them into a final, actionable signal.
- *
- * --- FIX ---
- * - Aligned data access with the corrected schema of its
- * dependency, 'cohort-capital-flow'.
- * - It now reads 'cohortFlows[cohortName]' directly, instead of
- * the non-existent 'cohortFlows[cohortName].assets'.
+ * REFACTORED: Uses context.math.signals and process(context).
  */
 class GaussDivergenceSignal {
+    constructor() { this.result = {}; }
 
-    // --- STANDARD 2: ADDED ---
-    constructor() {
-        this.result = {};
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
             "properties": {
-                "signal": {
-                    "type": "string",
-                    "enum": ["Strong Buy", "Buy", "Neutral", "Sell", "Strong Sell"]
-                },
-                "gauss_score": {
-                    "type": "number",
-                    "description": "Final divergence score (-10 to +10). Positive = Smart Buying, Negative = Smart Selling."
-                },
-                "smart_flow_total_pct": {
-                    "type": "number",
-                    "description": "The total %-point flow from all 'Smart' cohorts."
-                },
-                "dumb_flow_total_pct": {
-                    "type": "number",
-                    "description": "The total %-point flow from all 'Dumb' cohorts."
-                }
+                "signal": { "type": "string" },
+                "gauss_score": { "type": "number" },
+                "smart_flow_total_pct": { "type": "number" },
+                "dumb_flow_total_pct": { "type": "number" }
             },
-            "required": ["signal", "gauss_score", "smart_flow_total_pct", "dumb_flow_total_pct"]
-        };
-        
-        return {
-            "type": "object",
-            "description": "Generates a final divergence signal by aggregating flow from Smart vs. Dumb cohorts.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
-            "additionalProperties": tickerSchema
+            "required": ["signal", "gauss_score"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'meta',
@@ -71,79 +29,41 @@ class GaussDivergenceSignal {
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [
-            'cohort-capital-flow' // from gauss (Pass 3)
-        ];
-    }
+    static getDependencies() { return ['cohort-capital-flow']; }
     
-    /**
-     * Simple tanh normalization. Scales any number to a -10 to +10 range,
-     * with diminishing returns for extreme values.
-     * 0 -> 0, 1 -> 7.6, 2 -> 9.6, 3 -> 9.95
-     * We scale the input to tune sensitivity.
-     */
-    _normalize(score) {
-        // A score of 2.0 (%-point flow) will be ~9.6
-        // A score of 1.0 (%-point flow) will be ~7.6
-        return Math.tanh(score / 2.0) * 10;
-    }
-
-    /**
-     * This is a 'meta' calculation. It runs once.
-     */
-    // --- THIS IS THE FIX ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-        const { logger } = dependencies;
+    process(context) {
+        const { computed, math } = context;
+        const { signals } = math;
         
-        const cohortFlows = fetchedDependencies['cohort-capital-flow'];
-
-        if (!cohortFlows) {
-            logger.log('WARN', `[gauss/gauss-divergence-signal] Missing dependency 'cohort-capital-flow' for ${dateStr}.`);
-            this.result = {};
-            return;
-        }
+        const cohortFlows = computed['cohort-capital-flow'];
+        if (!cohortFlows) return;
 
         const SMART_COHORTS = ['smart_investors', 'smart_scalpers'];
         const DUMB_COHORTS = ['fomo_chasers', 'patient_losers', 'fomo_bagholders'];
         
-        const blendedFlows = new Map(); // Map<ticker, { smart: 0, dumb: 0 }>
+        const blendedFlows = new Map(); 
 
-        // 1. Blend all cohort flows
         for (const cohortName in cohortFlows) {
             const isSmart = SMART_COHORTS.includes(cohortName);
             const isDumb = DUMB_COHORTS.includes(cohortName);
             if (!isSmart && !isDumb) continue;
 
-            // Was: const assets = cohortFlows[cohortName]?.assets;
-            const assets = cohortFlows[cohortName]; // This is now the ticker map
+            const assets = cohortFlows[cohortName];
             if (!assets) continue;
             
             for (const [ticker, data] of Object.entries(assets)) {
-                if (!blendedFlows.has(ticker)) {
-                    blendedFlows.set(ticker, { smart: 0, dumb: 0 });
-                }
+                if (!blendedFlows.has(ticker)) blendedFlows.set(ticker, { smart: 0, dumb: 0 });
                 
-                // This logic remains correct, as it reads the inner flow object
                 const flow = data.net_flow_contribution || 0; 
-                
-                if (isSmart) {
-                    blendedFlows.get(ticker).smart += flow;
-                } else if (isDumb) {
-                    blendedFlows.get(ticker).dumb += flow;
-                }
+                if (isSmart) blendedFlows.get(ticker).smart += flow;
+                else if (isDumb) blendedFlows.get(ticker).dumb += flow;
             }
         }
-        // --- END FIX ---
 
-        // 2. Calculate final signal (logic unchanged)
         const result = {};
         for (const [ticker, data] of blendedFlows.entries()) {
             const divergence = data.smart - data.dumb;
-            const gauss_score = this._normalize(divergence);
+            const gauss_score = signals.normalizeTanh(divergence, 10, 2.0);
             
             let signal = "Neutral";
             if (gauss_score > 7.0) signal = "Strong Buy";
@@ -158,17 +78,10 @@ class GaussDivergenceSignal {
                 dumb_flow_total_pct: data.dumb
             };
         }
-        
         this.result = result;
     }
 
-    async getResult(fetchedDependencies) {
-        return this.result;
-    }
-
-    reset() {
-        this.result = {};
-    }
+    async getResult() { return this.result; }
+    reset() { this.result = {}; }
 }
-
 module.exports = GaussDivergenceSignal;