bulltrackers-module 1.0.213 → 1.0.215

package/functions/computation-system/controllers/computation_controller.js

@@ -4,8 +4,7 @@
  */
 
 // Load all layers dynamically from the index
-const mathLayer = require('../layers/index');
-
+const mathLayer                                                                                   = require('../layers/index');
 const { loadDailyInsights, loadDailySocialPostInsights, getRelevantShardRefs, getPriceShardRefs } = require('../utils/data_loader');
 
 // Legacy Keys Mapping (Ensures backward compatibility with existing Calculations)
@@ -26,76 +25,20 @@ const LEGACY_MAPPING = {
 };
 
 class DataLoader {
-    constructor(config, dependencies) {
-        this.config = config;
-        this.deps = dependencies;
-        this.cache = { mappings: null, insights: new Map(), social: new Map(), prices: null };
-    }
-    
-    get mappings() { return this.cache.mappings; }
-
-    async loadMappings() {
-        if (this.cache.mappings) return this.cache.mappings;
-        const { calculationUtils } = this.deps;
-        this.cache.mappings = await calculationUtils.loadInstrumentMappings();
-        return this.cache.mappings;
-    }
-    async loadInsights(dateStr) {
-        if (this.cache.insights.has(dateStr)) return this.cache.insights.get(dateStr);
-        const insights = await loadDailyInsights(this.config, this.deps, dateStr);
-        this.cache.insights.set(dateStr, insights);
-        return insights;
-    }
-    async loadSocial(dateStr) {
-        if (this.cache.social.has(dateStr)) return this.cache.social.get(dateStr);
-        const social = await loadDailySocialPostInsights(this.config, this.deps, dateStr);
-        this.cache.social.set(dateStr, social);
-        return social;
-    }
-    
-    async getPriceShardReferences() {
-        return getPriceShardRefs(this.config, this.deps);
-    }
-    
-    async getSpecificPriceShardReferences(targetInstrumentIds) {
-        return getRelevantShardRefs(this.config, this.deps, targetInstrumentIds);
-    }
-
-    async loadPriceShard(docRef) {
-        try {
-            const snap = await docRef.get();
-            if (!snap.exists) return {};
-            return snap.data();
-        } catch (e) {
-            console.error(`Error loading shard ${docRef.path}:`, e);
-            return {};
-        }
-    }
+    constructor(config, dependencies)     { this.config = config; this.deps = dependencies; this.cache = { mappings: null, insights: new Map(), social: new Map(), prices: null }; }
+    get mappings()                        { return this.cache.mappings; }
+    async loadMappings()                  { if (this.cache.mappings) return this.cache.mappings; const { calculationUtils } = this.deps; this.cache.mappings = await calculationUtils.loadInstrumentMappings(); return this.cache.mappings; }
+    async loadInsights(dateStr)           { if (this.cache.insights.has(dateStr)) return this.cache.insights.get(dateStr); const insights = await loadDailyInsights(this.config, this.deps, dateStr); this.cache.insights.set(dateStr, insights); return insights; }
+    async loadSocial(dateStr)             { if (this.cache.social.has(dateStr)) return this.cache.social.get(dateStr); const social = await loadDailySocialPostInsights(this.config, this.deps, dateStr); this.cache.social.set(dateStr, social); return social; }
+    async getPriceShardReferences()       { return getPriceShardRefs(this.config, this.deps); }
+    async getSpecificPriceShardReferences (targetInstrumentIds) { return getRelevantShardRefs(this.config, this.deps, targetInstrumentIds); }
+    async loadPriceShard(docRef)          { try { const snap = await docRef.get(); if (!snap.exists) return {}; return snap.data(); } catch (e) { console.error(`Error loading shard ${docRef.path}:`, e); return {}; } }
 }
 
 class ContextBuilder { 
-    
-    /**
-     * dynamically constructs the 'math' object.
-     * 1. Iterates over all exports from layers/index.js
-     * 2. Maps standard classes to legacy keys (extract, compute, etc.)
-     * 3. Adds ALL classes by their actual name to support new features automatically.
-     */
     static buildMathContext() {
         const mathContext = {};
-
-        // 1. Auto-discover and map
-        for (const [key, value] of Object.entries(mathLayer)) {
-            // Add by actual name (e.g. math.NewFeature)
-            mathContext[key] = value;
-
-            // Map to legacy key if exists (e.g. math.extract)
-            const legacyKey = LEGACY_MAPPING[key];
-            if (legacyKey) {
-                mathContext[legacyKey] = value;
-            }
-        }
-        
+        for (const [key, value] of Object.entries(mathLayer)) { mathContext[key] = value; const legacyKey = LEGACY_MAPPING[key]; if (legacyKey) { mathContext[legacyKey] = value; } }
         return mathContext;
     }
 
@@ -107,7 +50,7 @@ class ContextBuilder {
             insights: { today: insights?.today, yesterday: insights?.yesterday },
             social: { today: socialData?.today, yesterday: socialData?.yesterday },
             mappings: mappings || {},
-            math: ContextBuilder.buildMathContext(), // DYNAMIC LOAD
+            math: ContextBuilder.buildMathContext(), 
             computed: computedDependencies || {},
             previousComputed: previousComputedDependencies || {},
             meta: metadata, config, deps
@@ -122,7 +65,7 @@ class ContextBuilder {
             social: { today: socialData?.today, yesterday: socialData?.yesterday },
             prices: prices || {},
             mappings: mappings || {},
-            math: ContextBuilder.buildMathContext(), // DYNAMIC LOAD
+            math: ContextBuilder.buildMathContext(), 
             computed: computedDependencies || {},
             previousComputed: previousComputedDependencies || {},
             meta: metadata, config, deps
@@ -133,23 +76,23 @@ class ContextBuilder {
 class ComputationExecutor {
     constructor(config, dependencies, dataLoader) {
         this.config = config;
-        this.deps = dependencies;
+        this.deps   = dependencies;
         this.loader = dataLoader;
     }
 
     async executePerUser(calcInstance, metadata, dateStr, portfolioData, yesterdayPortfolioData, historyData, computedDeps, prevDeps) {
-        const { logger } = this.deps;
+        const { logger }     = this.deps;
         const targetUserType = metadata.userType; 
-        const mappings = await this.loader.loadMappings();
-        const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
+        const mappings       = await this.loader.loadMappings();
+        const insights       = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
         
         // Access SCHEMAS dynamically from the loaded layer
         const SCHEMAS = mathLayer.SCHEMAS;
 
         for (const [userId, todayPortfolio] of Object.entries(portfolioData)) {
             const yesterdayPortfolio = yesterdayPortfolioData ? yesterdayPortfolioData[userId] : null;
-            const todayHistory = historyData ? historyData[userId] : null;
-            const actualUserType = todayPortfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
+            const todayHistory       = historyData ? historyData[userId] : null;
+            const actualUserType     = todayPortfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
             if (targetUserType !== 'all') {
                  const mappedTarget = (targetUserType === 'speculator') ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
                  if (mappedTarget !== actualUserType) continue;
@@ -160,10 +103,10 @@ class ComputationExecutor {
     }
 
     async executeOncePerDay(calcInstance, metadata, dateStr, computedDeps, prevDeps) {
-        const mappings = await this.loader.loadMappings();
+        const mappings   = await this.loader.loadMappings();
         const { logger } = this.deps;
-        const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
-        const social = metadata.rootDataDependencies?.includes('social') ? { today: await this.loader.loadSocial(dateStr) } : null;
+        const insights   = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
+        const social     = metadata.rootDataDependencies?.includes('social')   ? { today: await this.loader.loadSocial(dateStr)   } : null;
         
         if (metadata.rootDataDependencies?.includes('price')) {
             logger.log('INFO', `[Executor] Running Batched/Sharded Execution for ${metadata.name}`);
@@ -171,7 +114,7 @@ class ComputationExecutor {
             if (shardRefs.length === 0) { logger.log('WARN', '[Executor] No price shards found.'); return {}; }
             let processedCount = 0;
             for (const ref of shardRefs) {
-                const shardData = await this.loader.loadPriceShard(ref);
+                const shardData      = await this.loader.loadPriceShard(ref);
                 const partialContext = ContextBuilder.buildMetaContext({ dateStr, metadata, mappings, insights, socialData: social, prices: { history: shardData }, computedDependencies: computedDeps, previousComputedDependencies: prevDeps, config: this.config, deps: this.deps });
                 await calcInstance.process(partialContext);
                 partialContext.prices = null; 
@@ -189,9 +132,9 @@ class ComputationExecutor {
 
 class ComputationController {
     constructor(config, dependencies) {
-        this.config = config;
-        this.deps = dependencies;
-        this.loader = new DataLoader(config, dependencies);
+        this.config   = config;
+        this.deps     = dependencies;
+        this.loader   = new DataLoader(config, dependencies);
         this.executor = new ComputationExecutor(config, dependencies, this.loader);
     }
 }

package/functions/computation-system/helpers/computation_dispatcher.js

@@ -17,53 +17,42 @@ const TOPIC_NAME = 'computation-tasks';
  */
 async function dispatchComputationPass(config, dependencies, computationManifest) {
     const { logger } = dependencies;
-
-    // Create fresh PubSubUtils instance
     const pubsubUtils = new PubSubUtils(dependencies);
-
     const passToRun = String(config.COMPUTATION_PASS_TO_RUN);
-
-    if (!passToRun) {
-        return logger.log('ERROR', '[Dispatcher] No pass defined (COMPUTATION_PASS_TO_RUN). Aborting.');
-    }
+    if (!passToRun) { return logger.log('ERROR', '[Dispatcher] No pass defined (COMPUTATION_PASS_TO_RUN). Aborting.'); }
 
     // 1. Validate Pass Existence
     const passes = groupByPass(computationManifest);
     const calcsInThisPass = passes[passToRun] || [];
 
-    if (!calcsInThisPass.length) {
-        return logger.log('WARN', `[Dispatcher] No calcs for Pass ${passToRun}. Exiting.`);
-    }
+    if (!calcsInThisPass.length) { return logger.log('WARN', `[Dispatcher] No calcs for Pass ${passToRun}. Exiting.`); }
 
     const calcNames = calcsInThisPass.map(c => c.name).join(', ');
     logger.log('INFO', `🚀 [Dispatcher] Preparing PASS ${passToRun}.`);
     logger.log('INFO', `[Dispatcher] Included Calculations: [${calcNames}]`);
 
     // 2. Determine Date Range
-    // Hardcoded earliest dates - keep synced with PassRunner for now
     const earliestDates = {
         portfolio: new Date('2025-09-25T00:00:00Z'),
-        history: new Date('2025-11-05T00:00:00Z'),
-        social: new Date('2025-10-30T00:00:00Z'),
-        insights: new Date('2025-08-26T00:00:00Z'),
-        price: new Date('2025-08-01T00:00:00Z')
+        history:   new Date('2025-11-05T00:00:00Z'),
+        social:    new Date('2025-10-30T00:00:00Z'),
+        insights:  new Date('2025-08-26T00:00:00Z'),
+        price:     new Date('2025-08-01T00:00:00Z')
     };
-    const passEarliestDate = Object.values(earliestDates).reduce((a, b) => a < b ? a : b);
-    const endDateUTC = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
 
+    const passEarliestDate = Object.values(earliestDates).reduce((a, b) => a < b ? a : b);
+    const endDateUTC       = new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), new Date().getUTCDate() - 1));
     const allExpectedDates = getExpectedDateStrings(passEarliestDate, endDateUTC);
 
     logger.log('INFO', `[Dispatcher] Dispatches checks for ${allExpectedDates.length} dates (${allExpectedDates[0]} to ${allExpectedDates[allExpectedDates.length - 1]}). Workers will validate dependencies.`);
 
     // 3. Dispatch Messages
     let dispatchedCount = 0;
-    const BATCH_SIZE = 50;
+    const BATCH_SIZE    = 50;
 
     // We can publish in parallel batches
     const chunks = [];
-    for (let i = 0; i < allExpectedDates.length; i += BATCH_SIZE) {
-        chunks.push(allExpectedDates.slice(i, i + BATCH_SIZE));
-    }
+    for (let i = 0; i < allExpectedDates.length; i += BATCH_SIZE) { chunks.push(allExpectedDates.slice(i, i + BATCH_SIZE)); }
 
     for (const chunk of chunks) {
         const messages = chunk.map(dateStr => ({
@@ -79,9 +68,7 @@ async function dispatchComputationPass(config, dependencies, computationManifest
             await pubsubUtils.publishMessageBatch(TOPIC_NAME, messages);
             dispatchedCount += messages.length;
             logger.log('INFO', `[Dispatcher] Dispatched batch of ${messages.length} tasks.`);
-        } catch (err) {
-            logger.log('ERROR', `[Dispatcher] Failed to dispatch batch: ${err.message}`);
-        }
+        } catch (err) { logger.log('ERROR', `[Dispatcher] Failed to dispatch batch: ${err.message}`); }
     }
 
     logger.log('INFO', `[Dispatcher] Finished. Dispatched ${dispatchedCount} checks for Pass ${passToRun}.`);

package/functions/computation-system/helpers/computation_manifest_builder.js

@@ -1,26 +1,19 @@
 /**
  * @fileoverview
- * Dynamic Manifest Builder (v5.1 - Smart Hashing with Safe Mode)
+ * Dynamic Manifest Builder (v6 - Merkle Tree Dependency Hashing)
  *
- * This script builds the computation manifest and generates a "Smart Hash"
- * for each calculation.
- *
- * KEY FEATURE:
- * It performs static analysis on the calculation code to detect which
- * specific math layers it utilizes. It then combines the calculation's own
- * code hash with the current hashes of those specific layers.
- * * SAFE MODE:
- * If a calculation uses no detectable layer keywords, it defaults to
- * depending on ALL layers to prevent staleness.
- * * FIXED:
- * - Broadened LAYER_TRIGGERS to detect context usage (e.g. 'math.signals')
- * - Updated isHistorical check to look for 'previousComputed'
+ * KEY FEATURES:
+ * 1. Smart Layer Hashing: Detects used layers (Math, Extractors) to avoid stale helper code.
+ * 2. Cascading Invalidation (Merkle Hashing): 
+ * The final hash of a computation is derived from:
+ * [Own Code] + [Layer States] + [Hashes of all Dependencies]
+ * * This guarantees that if Calculation A is updated, Calculation B (which depends on A)
+ * will automatically generate a new hash, forcing the system to re-run it.
  */
 
 const { generateCodeHash } = require('../utils/utils');
 
 // 1. Import Layers directly to generate their "State Hashes"
-// We import them individually to hash them as distinct domains.
 const MathematicsLayer = require('../layers/mathematics');
 const ExtractorsLayer  = require('../layers/extractors');
 const ProfilingLayer   = require('../layers/profiling');
@@ -30,23 +23,15 @@ const ValidatorsLayer  = require('../layers/validators');
  * 1. Layer Hash Generation
  * -------------------------------------------------- */
 
-/**
- * Generates a single hash representing the entire state of a layer module.
- * Combines all exported classes/functions/objects into one deterministic string.
- */
 function generateLayerHash(layerExports, layerName) {
-    const keys = Object.keys(layerExports).sort(); // Sort for determinism
+    const keys = Object.keys(layerExports).sort(); 
     let combinedSource = `LAYER:${layerName}`;
 
     for (const key of keys) {
         const item = layerExports[key];
-        if (typeof item === 'function') {
-            combinedSource += item.toString();
-        } else if (typeof item === 'object' && item !== null) {
-            combinedSource += JSON.stringify(item);
-        } else {
-            combinedSource += String(item);
-        }
+        if (typeof item === 'function')                       { combinedSource += item.toString();
+        } else if (typeof item === 'object' && item !== null) { combinedSource += JSON.stringify(item);
+        } else                                                { combinedSource += String(item); }
     }
     return generateCodeHash(combinedSource);
 }
@@ -54,13 +39,12 @@ function generateLayerHash(layerExports, layerName) {
 // Pre-compute layer hashes at startup
 const LAYER_HASHES = {
     'mathematics': generateLayerHash(MathematicsLayer, 'mathematics'),
-    'extractors':  generateLayerHash(ExtractorsLayer, 'extractors'),
-    'profiling':   generateLayerHash(ProfilingLayer, 'profiling'),
-    'validators':  generateLayerHash(ValidatorsLayer, 'validators')
+    'extractors':  generateLayerHash(ExtractorsLayer,  'extractors'),
+    'profiling':   generateLayerHash(ProfilingLayer,   'profiling'),
+    'validators':  generateLayerHash(ValidatorsLayer,  'validators')
 };
 
 // Map code patterns to Layer dependencies
-// If a calculation's code contains these strings, it depends on that layer.
 const LAYER_TRIGGERS = {
     'mathematics': [
         'math.compute', 'MathPrimitives',
@@ -93,11 +77,11 @@ const LAYER_TRIGGERS = {
  * Pretty Console Helpers
  * -------------------------------------------------- */
 const log = {
-    info:    (msg)   =>  console.log('ℹ︎ ' + msg),
-    step:    (msg)   =>  console.log('› ' + msg),
-    warn:    (msg)   =>  console.warn('⚠︎ ' + msg),
-    success: (msg)   =>  console.log('✔︎ ' + msg),
-    error:   (msg)   =>  console.error('✖ ' + msg),
+    info:    (msg)   =>   console.log('ℹ︎ ' + msg),
+    step:    (msg)   =>   console.log('› ' + msg),
+    warn:    (msg)   =>   console.warn('⚠︎ ' + msg),
+    success: (msg)   =>   console.log('✔︎ ' + msg),
+    error:   (msg)   =>   console.error('✖ ' + msg),
     fatal:   (msg)   => { console.error('✖ FATAL ✖ ' + msg); console.error('✖ FATAL ✖ Manifest build FAILED.'); },
     divider: (label) => { const line = ''.padEnd(60, '─'); console.log(`\n${line}\n${label}\n${line}\n`); },
 };
@@ -124,18 +108,6 @@ function suggestClosest(name, candidates, n = 3) {
     return scores.slice(0, n).map(s => s[0]);
 }
 
-function findCycles(manifestMap, adjacencyList) {
-    const visited = new Set(), stack = new Set(), cycles = [];
-    const dfs = (node, path) => {
-        if (stack.has(node)) { const idx = path.indexOf(node); cycles.push([...path.slice(idx), node]); return; }
-        if (visited.has(node)) return;
-        visited.add(node); stack.add(node);
-        for (const nb of adjacencyList.get(node) || []) dfs(nb, [...path, nb]);
-        stack.delete(node); };
-    for (const name of manifestMap.keys()) dfs(name, [name]);
-    return cycles;
-}
-
 function getDependencySet(endpoints, adjacencyList) {
     const required = new Set(endpoints);
     const queue    = [...endpoints];
@@ -149,72 +121,53 @@ function getDependencySet(endpoints, adjacencyList) {
  * -------------------------------------------------- */
 
 function buildManifest(productLinesToRun = [], calculations) {
-    log.divider('Building Dynamic Manifest (Smart Hashing)');
+    log.divider('Building Dynamic Manifest (Merkle Hashing)');
     log.info(`Target Product Lines: [${productLinesToRun.join(', ')}]`);
-    log.info(`Layer Hashes Initialized: ${Object.keys(LAYER_HASHES).join(', ')}`);
-
+    
     const manifestMap      = new Map();
     const adjacency        = new Map(); 
     const reverseAdjacency = new Map(); 
     const inDegree         = new Map();
     let hasFatalError      = false;
     
-    /* ---------------- 1. Load All Calculations ---------------- */
+    /* ---------------- 1. Load All Calculations (Phase 1: Intrinsic Hash) ---------------- */
     log.step('Loading and validating all calculation classes…');
-    const allCalculationClasses = new Map();
 
     function processCalc(Class, name, folderName) {
         if (!Class || typeof Class !== 'function') return;
         const normalizedName = normalizeName(name);
-        allCalculationClasses.set(normalizedName, Class);
         
-        if (typeof Class.getMetadata !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getMetadata().`); hasFatalError = true; return; }
+        if (typeof Class.getMetadata     !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getMetadata().`);     hasFatalError = true; return; }
         if (typeof Class.getDependencies !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getDependencies().`); hasFatalError = true;return; }
         
         const metadata     = Class.getMetadata();
         const dependencies = Class.getDependencies().map(normalizeName);
         
-        // FIX: Updated check to include 'previousComputed'
         const codeStr = Class.toString();
         if (metadata.isHistorical === true && !codeStr.includes('yesterday') && !codeStr.includes('previousComputed')) { 
-            log.warn(`Calculation "${normalizedName}" marked 'isHistorical' but no 'previousComputed' or 'yesterday' reference found.`); 
+            log.warn(`Calculation "${normalizedName}" marked 'isHistorical' but no 'previousComputed' state reference found.`); 
         }
 
-        let finalCategory = folderName;
-        if (folderName === 'core') {
-            if (metadata.category) finalCategory = metadata.category;
-        } else {
-            finalCategory = folderName;
-        }
+        let finalCategory = folderName === 'core' && metadata.category ? metadata.category : folderName;
 
-        // --- SMART HASH GENERATION ---
-        let compositeHashString = generateCodeHash(codeStr); // Start with own code
+        // --- PHASE 1: INTRINSIC HASH (Code + Layers) ---
+        // We do NOT include dependencies yet.
+        let compositeHashString = generateCodeHash(codeStr); 
         const usedLayers = [];
 
-        // 1. Check for specific layer usage
+        // Check for specific layer usage
         for (const [layerName, triggers] of Object.entries(LAYER_TRIGGERS)) {
-            // If code contains any trigger for this layer
-            if (triggers.some(trigger => codeStr.includes(trigger))) {
-                compositeHashString += LAYER_HASHES[layerName]; // Append Layer Hash
-                usedLayers.push(layerName);
-            }
+            if (triggers.some(trigger => codeStr.includes(trigger))) { compositeHashString += LAYER_HASHES[layerName];  usedLayers.push(layerName); }
         }
 
-        // 2. SAFE MODE FALLBACK
-        // If we found NO specific triggers (e.g. legacy code or unique structure), 
-        // assume it might use anything. Depend on ALL layers to be safe.
+        // Safe Mode Fallback
         let isSafeMode = false;
         if (usedLayers.length === 0) {
             isSafeMode = true;
             Object.values(LAYER_HASHES).forEach(h => compositeHashString += h);
         }
 
-        // Generate final composite hash
-        const finalHash = generateCodeHash(compositeHashString);
-
-        if (isSafeMode) {
-            log.warn(`[Hash] ${normalizedName}: No specific dependencies detected. Enforcing SAFE MODE (Linked to ALL Layers).`);
-        } 
+        const baseHash = generateCodeHash(compositeHashString);
 
         const manifestEntry = {
             name: normalizedName,
@@ -227,7 +180,7 @@ function buildManifest(productLinesToRun = [], calculations) {
             userType: metadata.userType,
             dependencies: dependencies,
             pass: 0,
-            hash: finalHash, // The Smart Hash
+            hash: baseHash,
             debugUsedLayers: isSafeMode ? ['ALL (Safe Mode)'] : usedLayers
         };
         
@@ -241,7 +194,6 @@ function buildManifest(productLinesToRun = [], calculations) {
         throw new Error('Manifest build failed: Invalid calculations object.');
     }
 
-    // Iterate over folders (folderName becomes the default category)
     for (const folderName in calculations) {
         if (folderName === 'legacy') continue;
         const group = calculations[folderName];
@@ -274,13 +226,8 @@ function buildManifest(productLinesToRun = [], calculations) {
 
     /* ---------------- 3. Filter for Product Lines ---------------- */
     const productLineEndpoints = [];
-    for (const [name, entry] of manifestMap.entries()) { 
-        if (productLinesToRun.includes(entry.category)) { productLineEndpoints.push(name); } 
-    }
-    // Always include core
-    for (const [name, entry] of manifestMap.entries()) { 
-        if (entry.sourcePackage === 'core') { productLineEndpoints.push(name); } 
-    }
+    for (const [name, entry] of manifestMap.entries()) {  if (productLinesToRun.includes(entry.category)) { productLineEndpoints.push(name); }  }
+    for (const [name, entry] of manifestMap.entries()) {  if (entry.sourcePackage === 'core') { productLineEndpoints.push(name); }  }
 
     const requiredCalcs = getDependencySet(productLineEndpoints, adjacency);
     log.info(`Filtered down to ${requiredCalcs.size} active calculations.`);
@@ -288,6 +235,7 @@ function buildManifest(productLinesToRun = [], calculations) {
     const filteredManifestMap      = new Map();
     const filteredInDegree         = new Map();
     const filteredReverseAdjacency = new Map();
+
     for (const name of requiredCalcs) { filteredManifestMap.set(name, manifestMap.get(name)); filteredInDegree.set(name, inDegree.get(name));
     const consumers = (reverseAdjacency.get(name) || []).filter(consumer => requiredCalcs.has(consumer)); filteredReverseAdjacency.set(name, consumers); }
 
@@ -312,6 +260,21 @@ function buildManifest(productLinesToRun = [], calculations) {
     if (sortedManifest.length !== filteredManifestMap.size) {
         throw new Error('Circular dependency detected. Manifest build failed.'); }
 
+    /* ---------------- 5. Phase 2: Cascading Dependency Hashing ---------------- */
+    log.step('Computing Cascading Merkle Hashes...');
+
+    for (const entry of sortedManifest) {
+        // Start with the intrinsic hash (Code + Layers)
+        let dependencySignature = entry.hash;
+
+        if (entry.dependencies && entry.dependencies.length > 0) {
+            const depHashes = entry.dependencies.map(depName => { const depEntry = filteredManifestMap.get(depName); if (!depEntry) return '';  return depEntry.hash; }).join('|'); 
+            dependencySignature += `|DEPS:${depHashes}`;
+        }
+        // Generate the Final Smart Hash
+        entry.hash = generateCodeHash(dependencySignature);
+    }
+
     log.success(`Total passes required: ${maxPass}`);
     return sortedManifest;
 }