bulltrackers-module 1.0.286 → 1.0.288

package/functions/computation-system/context/ManifestBuilder.js

@@ -1,9 +1,11 @@
 /**
  * @fileoverview Dynamic Manifest Builder - Handles Topological Sort and Auto-Discovery.
  * UPDATED: Generates Granular Hash Composition for Audit Trails.
+ * UPGRADE: Implements Tarjan's Algorithm for Precise Cycle Detection.
+ * FIXED: Now incorporates System Infrastructure Hash into Calculation Hashes.
  */
-const { generateCodeHash, LEGACY_MAPPING } = require('../topology/HashManager.js');
-const { normalizeName }                    = require('../utils/utils');
+const { generateCodeHash, getInfrastructureHash, LEGACY_MAPPING } = require('../topology/HashManager.js');
+const { normalizeName } = require('../utils/utils');
 
 const SYSTEM_EPOCH = require('../system_epoch');
 
@@ -82,9 +84,74 @@ function getDependencySet(endpoints, adjacencyList) {
     return required;
 }
 
+/**
+ * Helper: Detects cycles using Tarjan's SCC Algorithm.
+ * Returns a string description of the first cycle found.
+ */
+function detectCircularDependencies(manifestMap) {
+    let index = 0;
+    const stack = [];
+    const indices = new Map();
+    const lowLinks = new Map();
+    const onStack = new Set();
+    const cycles = [];
+
+    function strongconnect(v) {
+        indices.set(v, index);
+        lowLinks.set(v, index);
+        index++;
+        stack.push(v);
+        onStack.add(v);
+
+        const entry = manifestMap.get(v);
+        if (entry && entry.dependencies) {
+            for (const w of entry.dependencies) {
+                if (!manifestMap.has(w)) continue; // Skip external/missing deps (handled elsewhere)
+                
+                if (!indices.has(w)) {
+                    strongconnect(w);
+                    lowLinks.set(v, Math.min(lowLinks.get(v), lowLinks.get(w)));
+                } else if (onStack.has(w)) {
+                    lowLinks.set(v, Math.min(lowLinks.get(v), indices.get(w)));
+                }
+            }
+        }
+
+        if (lowLinks.get(v) === indices.get(v)) {
+            const scc = [];
+            let w;
+            do {
+                w = stack.pop();
+                onStack.delete(w);
+                scc.push(w);
+            } while (w !== v);
+
+            if (scc.length > 1) {
+                cycles.push(scc);
+            }
+        }
+    }
+
+    for (const name of manifestMap.keys()) {
+        if (!indices.has(name)) {
+            strongconnect(name);
+        }
+    }
+
+    if (cycles.length > 0) {
+        const cycle = cycles[0];
+        return cycle.join(' -> ') + ' -> ' + cycle[0];
+    }
+    return null;
+}
+
 function buildManifest(productLinesToRun = [], calculations) {
     log.divider('Building Dynamic Manifest');
     
+    // [CRITICAL FIX] Calculate Infrastructure Hash once per build
+    const INFRA_HASH = getInfrastructureHash();
+    log.info(`[ManifestBuilder] System Infrastructure Hash: ${INFRA_HASH.substring(0, 8)}`);
+
     const requestedLog = (!productLinesToRun || productLinesToRun.length === 0) 
         ? "ALL (Wildcard/Empty)" 
         : productLinesToRun.join(', ');
@@ -108,10 +175,11 @@ function buildManifest(productLinesToRun = [], calculations) {
         const codeStr      = Class.toString();
         const selfCodeHash = generateCodeHash(codeStr);
         
-        let compositeHashString = selfCodeHash + `|EPOCH:${SYSTEM_EPOCH}`; 
+        // [CRITICAL FIX] Include INFRA_HASH in the composite signature
+        // This ensures that if the system platform changes, ALL calculations are considered "changed"
+        let compositeHashString = selfCodeHash + `|EPOCH:${SYSTEM_EPOCH}|INFRA:${INFRA_HASH}`; 
         
         const usedDeps = [];
-        // Track layer hashes for composition analysis
         const usedLayerHashes = {}; 
 
         for (const [layerName, exportsMap] of Object.entries(LAYER_TRIGGERS)) {
@@ -123,7 +191,6 @@ function buildManifest(productLinesToRun = [], calculations) {
                         compositeHashString += exportHash;
                         usedDeps.push(`${layerName}.${exportName}`);
                         
-                        // Group hashes by layer for the composition report
                         if (!usedLayerHashes[layerName]) usedLayerHashes[layerName] = '';
                         usedLayerHashes[layerName] += exportHash;
                     }
@@ -131,13 +198,11 @@ function buildManifest(productLinesToRun = [], calculations) {
             }
         }
         
-        // Simplify layer hashes to one hash per layer for the report
         const layerComposition = {};
         for(const [lName, lStr] of Object.entries(usedLayerHashes)) {
             layerComposition[lName] = generateCodeHash(lStr);
         }
 
-        // Safe Mode Fallback
         let isSafeMode = false;
         if (usedDeps.length === 0) {
             isSafeMode = true;
@@ -158,16 +223,14 @@ function buildManifest(productLinesToRun = [], calculations) {
             userType: metadata.userType,
             dependencies: dependencies,
             pass: 0,
-            hash: intrinsicHash, // Will be updated with deps
-            
-            // [NEW] Composition Object for Audit
+            hash: intrinsicHash,
             composition: {
                 epoch: SYSTEM_EPOCH,
                 code: selfCodeHash,
+                infra: INFRA_HASH, // Stored in composition for audit
                 layers: layerComposition,
-                deps: {} // Will be populated after topo sort
+                deps: {} 
             },
-            
             debugUsedLayers: isSafeMode ? ['ALL (Safe Mode)'] : usedDeps
         };
         
@@ -179,9 +242,9 @@ function buildManifest(productLinesToRun = [], calculations) {
     
     for (const folderName in calculations) {
         if (folderName === 'legacy') continue;
-        const group = calculations[folderName];
-        for (const key in group) {
-            const entry = group[key];
+        const calculationGroup = calculations[folderName];
+        for (const key in calculationGroup) {
+            const entry = calculationGroup[key];
             if (typeof entry === 'function') { processCalc(entry, key, folderName); } 
         } 
     }
@@ -189,7 +252,6 @@ function buildManifest(productLinesToRun = [], calculations) {
     if (hasFatalError) throw new Error('Manifest build failed due to missing static methods.');
     log.success(`Loaded ${manifestMap.size} calculations.`);
 
-    // --- Topological Sort & Product Line Filtering ---
     const allNames = new Set(manifestMap.keys());
     for (const [name, entry] of manifestMap) {
         for (const dep of entry.dependencies) {
@@ -257,17 +319,22 @@ function buildManifest(productLinesToRun = [], calculations) {
         queue.sort(); 
     }
 
-    if (sortedManifest.length !== filteredManifestMap.size) throw new Error('Circular dependency detected.');
+    if (sortedManifest.length !== filteredManifestMap.size) {
+        const cycle = detectCircularDependencies(filteredManifestMap);
+        if (cycle) {
+            throw new Error(`Circular dependency detected: ${cycle}`);
+        } else {
+            throw new Error('Circular dependency detected (Unknown topology error).');
+        }
+    }
 
-    // --- Cascading Hash (Phase 2) ---
     for (const entry of sortedManifest) {
-        let dependencySignature = entry.hash; // Start with intrinsic
+        let dependencySignature = entry.hash; 
         
         if (entry.dependencies && entry.dependencies.length > 0) {
             const depHashes = entry.dependencies.map(depName => { 
                 const depEntry = filteredManifestMap.get(depName);
                 if (depEntry) {
-                    // Populate Composition
                     entry.composition.deps[depName] = depEntry.hash;
                     return depEntry.hash;
                 }

package/functions/computation-system/layers/extractors.js

@@ -1,7 +1,6 @@
 /**
  * @fileoverview Extractors Layer
  * Core access methods to raw data.
- * FIX: HistoryExtractor handles both Legacy and Modern (Granular) schemas.
  */
 
 const { SCHEMAS } = require('./profiling');
@@ -23,6 +22,39 @@ class TradeSeriesBuilder {
         }
         return curve;
     }
+
+    /**
+     * UPGRADE: Kadane's Algorithm style O(n) scan for Maximum Drawdown.
+     * Efficiently finds the largest peak-to-trough decline.
+     * @param {Array<number>} curve - The cumulative equity curve
+     * @returns {Object} { maxDrawdownPct: number, peakIndex: number, troughIndex: number }
+     */
+    static calculateMaxDrawdown(curve) {
+        if (!curve || curve.length < 2) return { maxDrawdownPct: 0, peakIndex: 0, troughIndex: 0 };
+        
+        let maxDrawdown = 0;
+        let peakValue = curve[0];
+        let peakIndex = 0;
+        let tempPeakIndex = 0;
+        let troughIndex = 0;
+
+        for (let i = 1; i < curve.length; i++) {
+            const currentVal = curve[i];
+            
+            if (currentVal > peakValue) {
+                peakValue = currentVal;
+                tempPeakIndex = i;
+            } else {
+                const drawdown = (peakValue - currentVal) / peakValue;
+                if (drawdown > maxDrawdown) {
+                    maxDrawdown = drawdown;
+                    peakIndex = tempPeakIndex;
+                    troughIndex = i;
+                }
+            }
+        }
+        return { maxDrawdownPct: maxDrawdown * 100, peakIndex, troughIndex };
+    }
 }
 
 class DataExtractor { 
@@ -106,31 +138,18 @@ class DataExtractor {
     static getOpenDateTime(position) { return (!position || !position.OpenDateTime) ? null : new Date(position.OpenDateTime); }
 
 
-    /**
-     * Returns trades that were active during the given date's 24-hour window.
-     * @param {Array} historyTrades - The PublicHistoryPositions array.
-     * @param {string} dateStr - YYYY-MM-DD string.
-     */
     static getActiveTradesForDate(historyTrades, dateStr) {
         if (!historyTrades || !Array.isArray(historyTrades)) return [];
-        
-        // Define the day's window
         const startTime = new Date(dateStr + "T00:00:00.000Z").getTime();
         const endTime = new Date(dateStr + "T23:59:59.999Z").getTime();
-
         return historyTrades.filter(t => {
             if (!t.OpenDateTime) return false;
             const openTime = new Date(t.OpenDateTime).getTime();
-            
-            // 1. Must be opened before the day ended
             if (openTime > endTime) return false;
-
-            // 2. If closed, must be closed after the day started
             if (t.CloseDateTime) {
                 const closeTime = new Date(t.CloseDateTime).getTime();
                 if (closeTime < startTime) return false;
             }
-
             return true;
         });
     }
@@ -140,7 +159,6 @@ class priceExtractor {
     static getHistory(pricesContext, tickerOrId) {
         if (!pricesContext || !pricesContext.history) return [];
         let assetData = pricesContext.history[tickerOrId];
-        
         if (!assetData) {
             const id = Object.keys(pricesContext.history).find(key => {
                 const data = pricesContext.history[key];
@@ -148,11 +166,9 @@ class priceExtractor {
             });
             if (id) assetData = pricesContext.history[id];
         }
-
         if (!assetData || !assetData.prices) return [];
         const priceMap = assetData.prices;
         const sortedDates = Object.keys(priceMap).sort((a, b) => a.localeCompare(b));
-        
         return sortedDates.map(date => ({
             date: date,
             price: priceMap[date]
@@ -177,15 +193,12 @@ class HistoryExtractor {
     }
 
     static getTradedAssets(historyDoc) {
-        // 1. Try Modern Granular Data (Derive Assets from Trades)
         if (historyDoc?.PublicHistoryPositions?.length) {
             const trades = historyDoc.PublicHistoryPositions;
             const assetsMap = new Map();
-            
             for (const t of trades) {
                 const instId = t.InstrumentID;
                 if (!instId) continue;
-                
                 if (!assetsMap.has(instId)) {
                     assetsMap.set(instId, { 
                         instrumentId: instId, 
@@ -193,12 +206,10 @@ class HistoryExtractor {
                         count: 0 
                     });
                 }
-                
                 const asset = assetsMap.get(instId);
                 const open = new Date(t.OpenDateTime);
                 const close = new Date(t.CloseDateTime);
                 const durationMins = (close - open) / 60000;
-                
                 if (durationMins > 0) {
                     asset.totalDuration += durationMins;
                     asset.count++;
@@ -209,12 +220,9 @@ class HistoryExtractor {
                 avgHoldingTimeInMinutes: a.count > 0 ? (a.totalDuration / a.count) : 0
             }));
         }
-
-        // 2. Fallback to Legacy 'assets' array
         if (historyDoc?.assets && Array.isArray(historyDoc.assets)) {
             return historyDoc.assets;
         }
-
         return [];
     }
 
@@ -227,7 +235,6 @@ class HistoryExtractor {
     }
 
     static getSummary(historyDoc) { 
-        // 1. Try Modern Granular Data (Derive Summary)
         if (historyDoc?.PublicHistoryPositions?.length) {
             const trades = historyDoc.PublicHistoryPositions;
             let totalTrades = trades.length;
@@ -237,7 +244,6 @@ class HistoryExtractor {
             let profCount = 0;
             let lossCount = 0;
             let totalDur = 0;
-
             for (const t of trades) {
                 if (t.NetProfit > 0) {
                     wins++;
@@ -251,7 +257,6 @@ class HistoryExtractor {
                 const close = new Date(t.CloseDateTime);
                 totalDur += (close - open) / 60000;
             }
-
             return { 
                 totalTrades:             totalTrades,
                 winRatio:                totalTrades > 0 ? (wins / totalTrades) * 100 : 0,
@@ -260,49 +265,20 @@ class HistoryExtractor {
                 avgHoldingTimeInMinutes: totalTrades > 0 ? totalDur / totalTrades : 0
             };
         }
-
-        // 2. Fallback to Legacy 'all' object
         if (historyDoc?.all) {
             return historyDoc.all;
         }
-
         return null;
     }
 }
 
-/**
- * FIXED: InsightsExtractor to properly handle document structure
- * Document structure: { fetchedAt: Timestamp, insights: [...] }
- */
-
 class InsightsExtractor {
-    /**
-     * Gets insights array for today (default) or yesterday
-     * @param {Object} context - Computation context
-     * @param {string} timeframe - 'today' or 'yesterday'
-     * @returns {Array} Array of insight objects
-     */
-
-    // MAJOR FIX TO GET INSIGHTS METHOD FOR THE CORRECT STRUCTURE AND SUPPORTING YESTERDAY + TODAY DATA REQUESTS
-    // THIS IS INJECTED TO BE USED LIKE :
-
-    // process(context) {
-       // const { insights: insightsHelper } = context.math;
-        // const insights = insightsHelper.getInsights(context); This is the direct call
-
     static getInsights(context, timeframe = 'today') {
         const insightsData = context.insights;
-        
         if (!insightsData) return [];
-        
-        // Get the document for the requested timeframe
-        const doc = insightsData[timeframe]; // { fetchedAt: ..., insights: [...] }
-        
+        const doc = insightsData[timeframe];
         if (!doc) return [];
-        
-        // Extract the insights array from the document
         if (doc.insights && Array.isArray(doc.insights)) { return doc.insights; }
-        
         return [];
     }
 

package/functions/computation-system/layers/mathematics.js

@@ -112,93 +112,98 @@ class MathPrimitives {
 }
 
 class FinancialEngineering {
-    /**
-     * Calculates the Sortino Ratio based on a series of trade returns.
-     * Uses Downside Deviation (risk of loss) rather than Standard Deviation (volatility).
-     * @param {number[]} returns - Array of PnL percentages from trades.
-     * @param {number} targetReturn - Minimum acceptable return (default 0).
-     */
     static sortinoRatio(returns, targetReturn = 0) {
         if (!returns || returns.length < 2) return 0;
-        
         const avgReturn = MathPrimitives.average(returns);
-        
-        // Calculate Downside Deviation (only negative deviations from target)
         const downsideDiffs = returns.map(r => Math.min(0, r - targetReturn));
         const downsideVariance = downsideDiffs.reduce((sum, d) => sum + (d * d), 0) / returns.length;
         const downsideDev = Math.sqrt(downsideVariance);
-        
-        if (downsideDev === 0) return 0; // No downside risk found
+        if (downsideDev === 0) return 0;
         return (avgReturn - targetReturn) / downsideDev;
     }
 
-    /**
-     * Calculates the Kelly Criterion (Optimal Leverage Fraction).
-     * f* = (bp - q) / b
-     * @param {number} winRatio - Win Rate (0-100).
-     * @param {number} avgWinPct - Average Win %.
-     * @param {number} avgLossPct - Average Loss % (must be negative or positive magnitude).
-     */
     static kellyCriterion(winRatio, avgWinPct, avgLossPct) {
         const p = winRatio / 100;
         const q = 1 - p;
         const lossMag = Math.abs(avgLossPct);
-        
-        if (lossMag === 0) return 0; // Infinite edge (or divide by zero error)
-        
-        const b = avgWinPct / lossMag; // Payoff odds (b to 1)
-        
-        // Kelly Formula: (bp - q) / b
+        if (lossMag === 0) return 0; 
+        const b = avgWinPct / lossMag; 
         const f = (b * p - q) / b;
-        
-        return Math.max(0, f); // Clamp negative Kelly to 0 (Do not bet)
+        return Math.max(0, f); 
     }
 }
 
 class TimeSeriesAnalysis {
-    /**
-     * Calculates the Hurst Exponent via Rescaled Range (R/S) Analysis.
-     * H = 0.5: Random Walk (Gambler).
-     * H > 0.5: Persistent/Trending (Momentum).
-     * H < 0.5: Anti-Persistent/Mean Reverting (Oscillator).
-     * @param {number[]} series - Time series data (e.g. cumulative PnL or prices).
-     */
     static hurstExponent(series) {
-        if (!series || series.length < 10) return 0.5; // Insufficient data
-
-        // Create logarithmic differences (returns)
+        if (!series || series.length < 10) return 0.5;
         const logReturns = [];
         for (let i = 1; i < series.length; i++) {
             logReturns.push(Math.log(series[i] / series[i-1]));
         }
-
-        // Simplified R/S calculation over full range
         const mean = MathPrimitives.average(logReturns);
         const stdDev = MathPrimitives.standardDeviation(logReturns);
-        
         if (stdDev === 0) return 0.5;
-
-        // Calculate Deviations from mean
         const deviations = logReturns.map(r => r - mean);
-        
-        // Calculate Cumulative Deviations (Cumulative Range)
         let sum = 0;
         const cumulativeDeviations = deviations.map(d => sum += d);
-        
         const maxDev = Math.max(...cumulativeDeviations);
         const minDev = Math.min(...cumulativeDeviations);
         const range = maxDev - minDev;
-        
         const rs = range / stdDev;
         const n = logReturns.length;
-        
-        // H = log(R/S) / log(n)
-        // Note: This is a point-estimate simplification of the full regression method
-        // but sufficient for behavioral classification.
         const hurst = Math.log(rs) / Math.log(n);
-        
         return Math.min(1, Math.max(0, hurst));
     }
+
+    /**
+     * UPGRADE: Fast Fourier Transform (Cooley-Tukey Algorithm) - O(n log n)
+     * Useful for detecting cycles in price data.
+     * @param {Array<number>} data - Input signal
+     * @returns {Array<Object>} Array of { real, imag } complex numbers
+     */
+    static fft(data) {
+        const n = data.length;
+        if (n <= 1) return data.map(v => ({ real: v, imag: 0 }));
+
+        if ((n & (n - 1)) !== 0) {
+            // If n is not power of 2, zero-pad to next power of 2 for O(n log n)
+            const nextPow2 = Math.pow(2, Math.ceil(Math.log2(n)));
+            const padded = new Array(nextPow2).fill(0);
+            for(let i=0; i<n; i++) padded[i] = data[i];
+            return this.fft(padded);
+        }
+
+        const even = new Array(n / 2);
+        const odd = new Array(n / 2);
+        for (let i = 0; i < n / 2; i++) {
+            even[i] = data[2 * i];
+            odd[i] = data[2 * i + 1];
+        }
+
+        const evenResult = this.fft(even);
+        const oddResult = this.fft(odd);
+
+        const result = new Array(n);
+        for (let k = 0; k < n / 2; k++) {
+            const t = -2 * Math.PI * k / n;
+            const expReal = Math.cos(t);
+            const expImag = Math.sin(t);
+            
+            // Multiply oddResult[k] by exp
+            const tReal = expReal * oddResult[k].real - expImag * oddResult[k].imag;
+            const tImag = expReal * oddResult[k].imag + expImag * oddResult[k].real;
+
+            result[k] = {
+                real: evenResult[k].real + tReal,
+                imag: evenResult[k].imag + tImag
+            };
+            result[k + n / 2] = {
+                real: evenResult[k].real - tReal,
+                imag: evenResult[k].imag - tImag
+            };
+        }
+        return result;
+    }
 }
 
 class SignalPrimitives {
@@ -206,7 +211,6 @@ class SignalPrimitives {
         if (!dependencies || !dependencies[calcName]) return fallback;
         const tickerData = dependencies[calcName][ticker];
         if (!tickerData) return fallback;
-        
         const val = tickerData[fieldName];
         return (typeof val === 'number') ? val : fallback;
     }
@@ -241,10 +245,7 @@ class SignalPrimitives {
         if (!previousComputed || !previousComputed[calcName]) return null;
         const tickerData = previousComputed[calcName][ticker];
         if (!tickerData) return null;
-
-        if (fieldName) {
-             return tickerData[fieldName];
-        }
+        if (fieldName) return tickerData[fieldName];
         return tickerData; 
     }
 }
@@ -255,18 +256,14 @@ class Aggregators {
         for (const [userId, portfolio] of Object.entries(usersData)) {
             const userType  = portfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
             const positions = DataExtractor.getPositions(portfolio, userType);
-            
             for (const pos of positions) {
                 const id = DataExtractor.getInstrumentId(pos);
                 const pnl = DataExtractor.getNetProfit(pos);
                 if (!id || pnl === 0) continue;
-                
                 const ticker = tickerMap[id];
                 if (!ticker) continue;
-
                 if (!buckets.has(ticker)) buckets.set(ticker, { winners: [], losers: [] });
                 const b = buckets.get(ticker);
-                
                 if (pnl > 0) b.winners.push(userId);
                 else b.losers.push(userId);
             }
@@ -276,20 +273,16 @@ class Aggregators {
 
     static getWeightedSentiment(positions) {
         if (!positions || positions.length === 0) return 0;
-
         let totalWeightedPnL = 0;
         let totalWeight = 0;
-
         for (const pos of positions) {
             const pnl = DataExtractor.getNetProfit(pos);
             const weight = DataExtractor.getPositionWeight(pos);
-
             if (weight > 0) {
                 totalWeightedPnL += (pnl * weight);
                 totalWeight += weight;
             }
         }
-
         if (totalWeight === 0) return 0;
         return totalWeightedPnL / totalWeight;
     }
@@ -299,61 +292,90 @@ class TimeSeries {
     static updateEMAState(value, state, alpha = 0.1) {
         const mean = state ? (state.mean || 0) : 0;
         const variance = state ? (state.variance || 1) : 1; 
-
         if (value === undefined || value === null || isNaN(value)) {
             return { mean, variance };
         }
-
         const diff = value - mean;
         const newMean = mean + (alpha * diff);
         const newVariance = (1 - alpha) * (variance + (alpha * diff * diff));
-
         return { mean: newMean, variance: newVariance };
     }
 
     static pearsonCorrelation(x, y) {
         if (!x || !y || x.length !== y.length || x.length === 0) return 0;
-        
         const n = x.length;
         let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
-
         for (let i = 0; i < n; i++) {
-            sumX  += x[i];
-            sumY  += y[i];
+            sumX  += x[i]; sumY  += y[i];
             sumXY += x[i] * y[i];
-            sumX2 += x[i] * x[i];
-            sumY2 += y[i] * y[i];
+            sumX2 += x[i] * x[i]; sumY2 += y[i] * y[i];
         }
-
         const numerator   = (n * sumXY) - (sumX * sumY);
         const denominator = Math.sqrt(((n * sumX2) - (sumX * sumX)) * ((n * sumY2) - (sumY * sumY)));
-
         return (denominator === 0) ? 0 : numerator / denominator;
     }
+
+    /**
+     * UPGRADE: Sliding Window Min/Max using Monotonic Queue - O(n)
+     * Calculates rolling min/max for a stream of numbers efficiently.
+     * @param {Array<number>} data - Input series
+     * @param {number} windowSize - The rolling window size
+     * @returns {Object} { min: Array, max: Array }
+     */
+    static slidingWindowExtrema(data, windowSize) {
+        if (!data || data.length === 0) return { min: [], max: [] };
+        const resultMin = [];
+        const resultMax = [];
+        const dequeMin = []; // Indexes for Min (increasing values)
+        const dequeMax = []; // Indexes for Max (decreasing values)
+
+        for (let i = 0; i < data.length; i++) {
+            // 1. Remove out of range
+            if (dequeMin.length > 0 && dequeMin[0] <= i - windowSize) dequeMin.shift();
+            if (dequeMax.length > 0 && dequeMax[0] <= i - windowSize) dequeMax.shift();
+
+            // 2. Maintain Monotonic properties
+            // Min: Remove elements from tail that are >= current
+            while (dequeMin.length > 0 && data[dequeMin[dequeMin.length - 1]] >= data[i]) {
+                dequeMin.pop();
+            }
+            // Max: Remove elements from tail that are <= current
+            while (dequeMax.length > 0 && data[dequeMax[dequeMax.length - 1]] <= data[i]) {
+                dequeMax.pop();
+            }
+
+            // 3. Add current
+            dequeMin.push(i);
+            dequeMax.push(i);
+
+            // 4. Record result (once window is full)
+            if (i >= windowSize - 1) {
+                resultMin.push(data[dequeMin[0]]);
+                resultMax.push(data[dequeMax[0]]);
+            }
+        }
+        return { min: resultMin, max: resultMax };
+    }
 }
 
 class DistributionAnalytics {
     static computeKDE(data, bandwidth, steps = 60) {
         if (!data || data.length === 0) return [];
-
         let min = Infinity, max = -Infinity;
         for (const p of data) {
             if (p.value < min) min = p.value;
             if (p.value > max) max = p.value;
         }
-        
         min -= bandwidth * 3;
         max += bandwidth * 3;
         const stepSize = (max - min) / steps;
         const curve = [];
-
         for (let i = 0; i <= steps; i++) {
             const x = min + (i * stepSize);
             let density = 0;
             for (const p of data) {
                 const diff = (x - p.value);
                 if (Math.abs(diff) > bandwidth * 3) continue;
-                
                 const u = diff / bandwidth;
                 const k = 0.39894228 * Math.exp(-0.5 * u * u); 
                 density += (p.weight * k) / bandwidth;
@@ -364,7 +386,7 @@ class DistributionAnalytics {
     }
 
     static integrateProfile(curve, startPrice, endPrice) {
-        if (!curve || !Array.isArray(curve)) return 0; // Fix for potential crash
+        if (!curve || !Array.isArray(curve)) return 0;
         let sum = 0;
         for (let i = 0; i < curve.length - 1; i++) {
             const p1 = curve[i];
@@ -379,16 +401,12 @@ class DistributionAnalytics {
     static linearRegression(xValues, yValues) {
         const n = xValues.length;
         if (n !== yValues.length || n < 2) return { slope: 0, r2: 0 };
-        
         let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0, sumYY = 0;
         for (let i = 0; i < n; i++) {
-            sumX  += xValues[i];
-            sumY  += yValues[i];
+            sumX  += xValues[i]; sumY  += yValues[i];
             sumXY += xValues[i] * yValues[i];
-            sumXX += xValues[i] * xValues[i];
-            sumYY += yValues[i] * yValues[i];
+            sumXX += xValues[i] * xValues[i]; sumYY += yValues[i] * yValues[i];
         }
-        
         const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
         return { slope, n };
     }

package/functions/computation-system/layers/profiling.js

@@ -21,15 +21,7 @@ const SCHEMAS = {
     }
 };
 
-// ========================================================================
-// 1. SMART MONEY SCORING ENGINE (NEW)
-// ========================================================================
-
 class SmartMoneyScorer {
-
-    /**
-     * Internal Helper: Calculate Pearson Correlation
-     */
     static _correlation(x, y) {
         if (!x || !y || x.length !== y.length || x.length < 2) return 0;
         const n = x.length;
@@ -44,14 +36,6 @@ class SmartMoneyScorer {
         return (denominator === 0) ? 0 : numerator / denominator;
     }
 
-    /**
-     * Mode 1: Portfolio-Based Scoring
-     * Heuristics:
-     * 1. Diversification (Sector/Asset count)
-     * 2. Allocation Efficiency (Correlation of Size vs Profit)
-     * 3. Shorting Competence
-     * 4. Concentration Risk (HHI)
-     */
     static scorePortfolio(portfolio, userType, prices, mappings, math) {
         const positions = math.extract.getPositions(portfolio, userType);
         if (!positions || positions.length === 0) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
@@ -66,10 +50,9 @@ class SmartMoneyScorer {
         const sectors = new Set();
         const tickers = new Set();
 
-        // 1. Data Aggregation
         for (const pos of positions) {
             const invested = math.extract.getPositionWeight(pos, userType);
-            const pnl = math.extract.getNetProfit(pos); // %
+            const pnl = math.extract.getNetProfit(pos); 
             const instId = math.extract.getInstrumentId(pos);
             const isShort = math.extract.getDirection(pos) === 'Sell';
             
@@ -94,56 +77,38 @@ class SmartMoneyScorer {
 
         if (totalInvested === 0) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
 
-        // 2. Metrics Calculation
         const avgPnL = weightedPnL / totalInvested;
-        
-        // A. Allocation Efficiency (Do they bet big on winners?)
-        // Correlation between Invested Amount and PnL %
-        const allocEfficiency = this._correlation(weights, pnls); // -1 to 1
+        const allocEfficiency = this._correlation(weights, pnls);
 
-        // B. Diversification & Concentration (HHI)
-        // Sum of squared market shares. 1.0 = Monopoly. 0.0 = Infinite.
         let hhi = 0;
         for (const w of weights) {
             const share = w / totalInvested;
             hhi += (share * share);
         }
         
-        // C. Shorting Competence
         const shortRatio = shortInvested / totalInvested;
         const avgShortPnL = shortInvested > 0 ? shortPnL / shortInvested : 0;
 
-        // 3. Scoring Logic
         let score = 50; 
 
-        // Efficiency Bonus: If > 0.5, they size winners up. (+20)
-        // If < -0.3, they are bagholding losers with large size (-15)
         if (allocEfficiency > 0.5) score += 20;
         else if (allocEfficiency < -0.3) score -= 15;
 
-        // Profitability (The ultimate metric)
         if (avgPnL > 5) score += 10;
         if (avgPnL > 20) score += 10;
         if (avgPnL < -10) score -= 10;
         if (avgPnL < -25) score -= 15;
 
-        // Concentration Logic
-        // High Concentration (HHI > 0.3) is "Smart" ONLY if profitable (Sniper)
-        // High Concentration and unprofitable is "Dumb" (Bagholder/Gambler)
         if (hhi > 0.3) {
-            if (avgPnL > 5) score += 10; // Sniper
-            else if (avgPnL < -5) score -= 10; // Reckless
+            if (avgPnL > 5) score += 10; 
+            else if (avgPnL < -5) score -= 10; 
         }
 
-        // Diversification Logic
-        // High Sector count (>3) reduces risk penalty
         if (sectors.size >= 4) score += 5;
 
-        // Shorting Logic
-        // Penalize speculation unless they are actually good at it
         if (shortRatio > 0.1) {
-            if (avgShortPnL > 0) score += 10; // Smart Short
-            else score -= 10; // Failed Speculation
+            if (avgShortPnL > 0) score += 10; 
+            else score -= 10; 
         }
 
         return {
@@ -152,33 +117,18 @@ class SmartMoneyScorer {
         };
     }
 
-    /**
-     * Mode 2: History-Based Scoring
-     * Heuristics:
-     * 1. Win/Loss Ratio & Profit Factor
-     * 2. Asset Consistency (Revenge trading vs Specialist)
-     * 3. Entry Efficiency (Buying Lows)
-     * 4. Exit Efficiency (Selling Highs - Opportunity Cost)
-     * 5. Churn (Overtrading)
-     * 6. DCA/Entry Patterns
-     */
     static scoreHistory(historyDoc, prices, mappings, math) {
-        // Handle V2 Schema (PublicHistoryPositions)
         const trades = historyDoc?.PublicHistoryPositions || [];
-        // Handle V1 Schema fallback if needed (though prompt implies V2)
         
         if (trades.length < 5) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
-
-        // Filter valid trades
         const validTrades = trades.filter(t => t.OpenDateTime && t.CloseDateTime && t.InstrumentID);
         if (validTrades.length < 5) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
 
         let wins = 0, losses = 0;
         let totalWinPct = 0, totalLossPct = 0;
         let entryScores = [];
-        const assetsTraded = new Map(); // ID -> { count, pnl }
+        const assetsTraded = new Map(); 
 
-        // Time sorting for Churn analysis
         validTrades.sort((a, b) => new Date(a.OpenDateTime) - new Date(b.OpenDateTime));
         const firstDate = new Date(validTrades[0].OpenDateTime);
         const lastDate = new Date(validTrades[validTrades.length-1].OpenDateTime);
@@ -187,21 +137,17 @@ class SmartMoneyScorer {
         for (const t of validTrades) {
             const ticker = mappings.instrumentToTicker[t.InstrumentID];
             
-            // Asset Consistency
             if (!assetsTraded.has(t.InstrumentID)) assetsTraded.set(t.InstrumentID, { count: 0, pnl: 0 });
             const assetStat = assetsTraded.get(t.InstrumentID);
             assetStat.count++;
             assetStat.pnl += t.NetProfit;
 
-            // A. Win/Loss Stats
             if (t.NetProfit > 0) { wins++; totalWinPct += t.NetProfit; }
             else { losses++; totalLossPct += Math.abs(t.NetProfit); }
 
-            // B. Entry Timing (Requires Price History)
             if (ticker && prices) {
                 const priceHist = math.priceExtractor.getHistory(prices, ticker);
                 if (priceHist && priceHist.length > 0) {
-                    // 1.0 = Perfect Low, 0.0 = Bought High
                     const eff = ExecutionAnalytics.calculateEfficiency(t.OpenRate, priceHist, t.OpenDateTime, t.IsBuy ? 'Buy' : 'Sell');
                     entryScores.push(eff);
                 }
@@ -212,45 +158,33 @@ class SmartMoneyScorer {
         const avgLoss = losses > 0 ? totalLossPct / losses : 1;
         const profitFactor = (wins * avgWin) / Math.max(1, (losses * avgLoss));
         
-        // C. Entry Skill
         const avgEntrySkill = entryScores.length > 0 ? math.compute.average(entryScores) : 0.5;
 
-        // D. Consistency / Specialization
-        // Do they trade 100 tickers once (Gambler) or 5 tickers 20 times (Specialist)?
         const totalTrades = validTrades.length;
         const uniqueAssets = assetsTraded.size;
-        const specializationRatio = 1 - (uniqueAssets / totalTrades); // Higher = More specialized
+        const specializationRatio = 1 - (uniqueAssets / totalTrades);
 
-        // E. Overtrading (Churn)
         const tradesPerDay = totalTrades / daysActive;
 
-        // F. Revenge Trading Check
-        // High count on a specific asset with negative total PnL
         let revengeScore = 0;
         for (const [id, stat] of assetsTraded.entries()) {
             if (stat.pnl < -20 && stat.count > 5) revengeScore += 1;
         }
 
-        // Scoring Logic
         let score = 50;
 
-        // Profit Factor (Primary Driver)
         if (profitFactor > 1.2) score += 10;
         if (profitFactor > 2.0) score += 15;
         if (profitFactor < 0.8) score -= 15;
 
-        // Entry Efficiency
-        if (avgEntrySkill > 0.7) score += 10; // Sniper
-        if (avgEntrySkill < 0.3) score -= 10; // FOMO
+        if (avgEntrySkill > 0.7) score += 10; 
+        if (avgEntrySkill < 0.3) score -= 10; 
 
-        // Specialization
-        if (specializationRatio > 0.6) score += 5; // Specialist bonus
-        if (specializationRatio < 0.1 && totalTrades > 20) score -= 5; // Scattergun penalty
+        if (specializationRatio > 0.6) score += 5; 
+        if (specializationRatio < 0.1 && totalTrades > 20) score -= 5; 
 
-        // Churn Penalty
-        if (tradesPerDay > 10 && profitFactor < 1.0) score -= 10; // Brokerage Cash Cow
+        if (tradesPerDay > 10 && profitFactor < 1.0) score -= 10; 
 
-        // Revenge Penalty
         if (revengeScore > 0) score -= (revengeScore * 5);
 
         return {
@@ -259,14 +193,9 @@ class SmartMoneyScorer {
         };
     }
 
-    /**
-     * Mode 3: Hybrid Scoring
-     * Merges Portfolio (Unrealized/Current) and History (Realized/Past).
-     */
     static scoreHybrid(context) {
         const { user, prices, mappings, math } = context;
         
-        // Get Sub-Scores
         const pScore = this.scorePortfolio(user.portfolio.today, user.type, prices, mappings, math);
         const hScore = this.scoreHistory(user.history.today, prices, mappings, math);
 
@@ -277,7 +206,6 @@ class SmartMoneyScorer {
         const hasPortfolio = pScore && pScore.score > 0;
 
         if (hasHistory && hasPortfolio) {
-            // Weighted: 60% Track Record (History), 40% Current Positioning (Portfolio)
             finalScore = (hScore.score * 0.6) + (pScore.score * 0.4);
             method = 'Hybrid';
         } else if (hasHistory) {
@@ -288,7 +216,6 @@ class SmartMoneyScorer {
             method = 'PortfolioOnly';
         }
 
-        // Classification Label
         let label = SCHEMAS.LABELS.NEUTRAL;
         if (finalScore >= 80) label = SCHEMAS.LABELS.ELITE;
         else if (finalScore >= 65) label = SCHEMAS.LABELS.SMART;
@@ -307,10 +234,6 @@ class SmartMoneyScorer {
     }
 }
 
-// ========================================================================
-// 2. SUPPORTING ANALYTICS ENGINES
-// ========================================================================
-
 class CognitiveBiases {
     static calculateAnchoringScore(openPositions, thresholdPct = 2.0, minDaysHeld = 14) {
         if (!openPositions || openPositions.length === 0) return 0;
@@ -376,6 +299,49 @@ class ExecutionAnalytics {
     }
 }
 
+/**
+ * UPGRADE: Risk Geometry Class
+ * Contains Convex Hull (Monotone Chain) for Efficient Frontier analysis.
+ */
+class RiskGeometry {
+    static crossProduct(o, a, b) {
+        return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+    }
+
+    /**
+     * Computes the Convex Hull of a set of 2D points using Monotone Chain algorithm.
+     * @param {Array<{x: number, y: number}>} points
+     * @returns {Array<{x: number, y: number}>} Points on the hull
+     */
+    static computeConvexHull(points) {
+        if (points.length <= 1) return points;
+        
+        // Sort by x coordinate (and y if x is same)
+        points.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
+
+        const lower = [];
+        for (const p of points) {
+            while (lower.length >= 2 && this.crossProduct(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+                lower.pop();
+            }
+            lower.push(p);
+        }
+
+        const upper = [];
+        for (let i = points.length - 1; i >= 0; i--) {
+            const p = points[i];
+            while (upper.length >= 2 && this.crossProduct(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+                upper.pop();
+            }
+            upper.push(p);
+        }
+
+        upper.pop();
+        lower.pop();
+        return lower.concat(upper);
+    }
+}
+
 class Psychometrics {
     static computeDispositionSkew(historyTrades, currentPositions) {
         const getMedian = (arr) => { if (!arr.length) return 0; const sorted = [...arr].sort((a, b) => a - b); const mid = Math.floor(sorted.length / 2); return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2; };
@@ -413,20 +379,16 @@ class AdaptiveAnalytics {
     }
 }
 
-// Legacy Wrapper for backward compatibility with older calculations
 class UserClassifier {
     static classify(context) {
-        // Delegate to the new robust Hybrid Scorer
         const result = SmartMoneyScorer.scoreHybrid(context);
-        
-        // Map new result structure to legacy structure expected by V1 calcs
         return {
             intelligence: { 
                 label: result.label, 
                 score: result.totalScore, 
                 isSmart: result.totalScore >= 65 
             },
-            style: { primary: SCHEMAS.STYLES.INVESTOR }, // Placeholder
+            style: { primary: SCHEMAS.STYLES.INVESTOR }, 
             metrics: {
                 profitFactor: result.components.history?.metrics?.profitFactor || 0,
                 allocEfficiency: result.components.portfolio?.metrics?.allocEfficiency || 0
@@ -438,10 +400,11 @@ class UserClassifier {
 module.exports = { 
     SCHEMAS, 
     UserClassifier,
-    SmartMoneyScorer, // <-- Exporting the new engine
+    SmartMoneyScorer, 
     ExecutionAnalytics,
     Psychometrics,
     AdaptiveAnalytics,
     CognitiveBiases,
-    SkillAttribution
+    SkillAttribution,
+    RiskGeometry
 };

package/functions/computation-system/tools/BuildReporter.js

@@ -1,33 +1,107 @@
+const { analyzeDateExecution } = require('../WorkflowOrchestrator');
+const { fetchComputationStatus, updateComputationStatus } = require('../persistence/StatusRepository');
+const { normalizeName, getExpectedDateStrings, DEFINITIVE_EARLIEST_DATES } = require('../utils/utils');
+const { checkRootDataAvailability } = require('../data/AvailabilityChecker');
+const SimRunner = require('../simulation/SimRunner');
+const pLimit = require('p-limit');
+const path = require('path');
+const crypto = require('crypto');
+const fs = require('fs'); // [NEW] Required for file reading
+const packageJson = require(path.join(__dirname, '..', '..', '..', 'package.json'));
+const packageVersion = packageJson.version;
+const { generateCodeHash } = require('../utils/utils'); // Reuse your standard logic
+
+// Persistent Registry for SimHashes
+const SIMHASH_REGISTRY_COLLECTION = 'system_simhash_registry';
+
+// --- [NEW] RECURSIVE SYSTEM HASHING ---
+
+// 1. define the Root of the system (one level up from 'tools')
+const SYSTEM_ROOT = path.resolve(__dirname, '..');
+
+// 2. Define what to ignore to prevent noise or infinite loops
+const IGNORED_DIRS = new Set(['node_modules', '.git', '.idea', 'coverage', 'logs', 'tests']);
+const IGNORED_FILES = new Set(['package-lock.json', '.DS_Store', '.env']);
+
+/**
+ * Recursively walks a directory and returns a list of file paths.
+ */
+function walkSync(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    
+    files.forEach(file => {
+        if (IGNORED_FILES.has(file)) return;
+        
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        
+        if (stat.isDirectory()) {
+            if (!IGNORED_DIRS.has(file)) {
+                walkSync(filePath, fileList);
+            }
+        } else {
+            // Only hash code files (add .yaml if you want workflows included)
+            if (file.endsWith('.js') || file.endsWith('.json') || file.endsWith('.yaml')) {
+                fileList.push(filePath);
+            }
+        }
+    });
+    return fileList;
+}
+
 /**
- * @fileoverview Build Reporter & Auto-Runner.
- * Generates a "Pre-Flight" report of what the computation system WILL do.
- * UPGRADED: Implements Behavioral Hashing (SimHash) to detect Cosmetic vs Logic changes.
- * OPTIMIZED: Caches SimHashes and actively updates status for Stable items to prevent re-runs.
- * OPTIMIZED (V2): Implements System Fingerprinting to skip 90-day scan if manifest is identical.
+ * Generates a single hash representing the entire infrastructure code state.
  */
+function getInfrastructureHash() {
+    try {
+        const allFiles = walkSync(SYSTEM_ROOT);
+        allFiles.sort(); // Crucial for determinism
+
+        const bigHash = crypto.createHash('sha256');
+
+        for (const filePath of allFiles) {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const relativePath = path.relative(SYSTEM_ROOT, filePath);
+
+            // DECISION: How to clean?
+            let cleanContent = content;
+
+            // 1. If it's JS, use your system standard for code hashing
+            if (filePath.endsWith('.js')) {
+                // This strips comments and whitespace consistently with ManifestBuilder
+                // Note: generateCodeHash returns a hash, we can just use that hash
+                cleanContent = generateCodeHash(content); 
+            } 
+            // 2. If it's JSON/YAML, just strip basic whitespace to ignore indent changes
+            else {
+                cleanContent = content.replace(/\s+/g, '');
+            }
 
-const { analyzeDateExecution }                                             = require('../WorkflowOrchestrator');
-const { fetchComputationStatus, updateComputationStatus }                  = require('../persistence/StatusRepository');
-const { normalizeName, getExpectedDateStrings, DEFINITIVE_EARLIEST_DATES } = require('../utils/utils');
-const { checkRootDataAvailability }                                        = require('../data/AvailabilityChecker');
-const SimRunner                                                            = require('../simulation/SimRunner');
-const pLimit                                                               = require('p-limit');
-const path                                                                 = require('path');
-const crypto                                                               = require('crypto');
-const packageJson                                                          = require(path.join(__dirname, '..', '..', '..', 'package.json'));
-const packageVersion                                                       = packageJson.version;
-
-// Persistent Registry for SimHashes (so Workers don't have to recalc)
-const SIMHASH_REGISTRY_COLLECTION = 'system_simhash_registry';
+            // Feed the PATH and the CLEAN CONTENT into the master hash
+            bigHash.update(`${relativePath}:${cleanContent}|`);
+        }
+
+        return bigHash.digest('hex');
+    } catch (e) {
+        console.warn(`[BuildReporter] ⚠️ Failed to generate infra hash: ${e.message}`);
+        return 'infra_hash_error'; // Fail safe so we run the report rather than crash
+    }
+}
 
 /**
- * Helper: Generates a unique signature for the entire computation system state.
- * If ANY calculation logic or dependency changes, this hash changes.
+ * UPDATED: System Fingerprint = Manifest Hash + Infrastructure Hash
  */
 function getSystemFingerprint(manifest) {
-    // Sort to ensure determinism
-    const sortedHashes = manifest.map(c => c.hash).sort().join('|');
-    return crypto.createHash('sha256').update(sortedHashes).digest('hex');
+    // 1. Business Logic Hash (The Calculations)
+    const sortedManifestHashes = manifest.map(c => c.hash).sort().join('|');
+    
+    // 2. Infrastructure Hash (The System Code)
+    const infraHash = getInfrastructureHash();
+
+    // 3. Combine
+    return crypto.createHash('sha256')
+        .update(sortedManifestHashes + infraHash)
+        .digest('hex');
 }
 
 /**

package/functions/computation-system/topology/HashManager.js

@@ -1,7 +1,10 @@
 /**
  * @fileoverview Manages code versioning, hashing, and legacy mappings.
+ * UPDATED: Includes Centralized Infrastructure Hashing to track system-level changes.
  */
 const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
 
 // Legacy Keys Mapping (Ensures backward compatibility)
 const LEGACY_MAPPING = {
@@ -24,6 +27,10 @@ const LEGACY_MAPPING = {
     AdaptiveAnalytics: 'adaptive'
 };
 
+/**
+ * Generates a SHA-256 hash of a code string.
+ * Strips comments and whitespace for loose equality.
+ */
 function generateCodeHash(codeString) {
     if (!codeString) return 'unknown';
     let clean = codeString.replace(/\/\/.*$/gm, '');
@@ -32,4 +39,66 @@ function generateCodeHash(codeString) {
     return crypto.createHash('sha256').update(clean).digest('hex');
 }
 
-module.exports = { LEGACY_MAPPING, generateCodeHash };
+// --- INFRASTRUCTURE HASHING (The "System Fingerprint") ---
+
+const SYSTEM_ROOT = path.resolve(__dirname, '..');
+const IGNORED_DIRS = new Set(['node_modules', '.git', '.idea', 'coverage', 'logs', 'tests', 'docs']);
+const IGNORED_FILES = new Set(['package-lock.json', '.DS_Store', '.env', 'README.md']);
+
+function walkSync(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    files.forEach(file => {
+        if (IGNORED_FILES.has(file)) return;
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            if (!IGNORED_DIRS.has(file)) {
+                walkSync(filePath, fileList);
+            }
+        } else {
+            // Hash JS, JSON, and YAML (Workflows)
+            if (file.endsWith('.js') || file.endsWith('.json') || file.endsWith('.yaml')) {
+                fileList.push(filePath);
+            }
+        }
+    });
+    return fileList;
+}
+
+/**
+ * Generates a hash representing the state of the entire computation-system codebase.
+ * This ensures that changes to infrastructure (like ContextFactory or Executors)
+ * trigger a re-run of calculations even if the calculation logic itself didn't change.
+ */
+function getInfrastructureHash() {
+    try {
+        const allFiles = walkSync(SYSTEM_ROOT);
+        allFiles.sort(); // Crucial for determinism
+
+        const bigHash = crypto.createHash('sha256');
+
+        for (const filePath of allFiles) {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const relativePath = path.relative(SYSTEM_ROOT, filePath);
+            
+            let cleanContent = content;
+
+            // Reuse the standard code hash logic for JS files to be consistent
+            if (filePath.endsWith('.js')) {
+                cleanContent = generateCodeHash(content);
+            } else {
+                // For JSON/YAML, just strip whitespace
+                cleanContent = content.replace(/\s+/g, '');
+            }
+
+            bigHash.update(`${relativePath}:${cleanContent}|`);
+        }
+
+        return bigHash.digest('hex');
+    } catch (e) {
+        console.warn(`[HashManager] ⚠️ Failed to generate infra hash: ${e.message}`);
+        return 'infra_error'; 
+    }
+}
+
+module.exports = { LEGACY_MAPPING, generateCodeHash, getInfrastructureHash };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.286",
+  "version": "1.0.288",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [