bulltrackers-module 1.0.473 → 1.0.475

package/functions/computation-system/WorkflowOrchestrator.js

@@ -168,12 +168,17 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
     return report;
 }
 
-async function executeDispatchTask(dateStr, pass, targetComputation, config, dependencies, computationManifest, previousCategory = null, dependencyResultHashes = {}) {
+async function executeDispatchTask(dateStr, pass, targetComputation, config, dependencies, computationManifest, previousCategory = null, dependencyResultHashes = {}, metadata = {}) {
     const { logger } = dependencies;
     const manifestMap = new Map(computationManifest.map(c => [normalizeName(c.name), c]));
     const calcManifest = manifestMap.get(normalizeName(targetComputation));
     
     if (!calcManifest) throw new Error(`Calc '${targetComputation}' not found.`);
+    
+    // Merge runtime metadata (like targetCid) into the manifest
+    // This allows the Executor to access it via 'calcInstance.manifest'
+    Object.assign(calcManifest, metadata);
+    
     calcManifest.dependencyResultHashes = dependencyResultHashes;
 
     const rootData = await checkRootDataAvailability(dateStr, config, dependencies, DEFINITIVE_EARLIEST_DATES);

package/functions/computation-system/executors/StandardExecutor.js

@@ -235,6 +235,14 @@ class StandardExecutor {
         let chunkFailures = 0;
 
         for (const [userId, todayPortfolio] of Object.entries(portfolioData)) {
+            // --- OPTIMIZATION: TARGET SPECIFIC USER ---
+            // If the request contains a targetCid, skip all other users immediately
+            if (metadata.targetCid && String(userId) !== String(metadata.targetCid)) {
+                if (stats) stats.skippedUsers++;
+                continue;
+            }
+            // ------------------------------------------
+            
             const yesterdayPortfolio = yesterdayPortfolioData ? yesterdayPortfolioData[userId] : null;
             const todayHistory = historyData ? historyData[userId] : null;
             

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

@@ -93,7 +93,7 @@ function startMemoryHeartbeat(db, ledgerPath, workerId, computationName, traceId
 /**
  * STRICT IDEMPOTENCY GATE
  */
-async function checkIdempotencyAndClaimLease(db, ledgerPath, dispatchId, workerId) {
+async function checkIdempotencyAndClaimLease(db, ledgerPath, dispatchId, workerId, onDemand = false) {
     const docRef = db.doc(ledgerPath);
 
     try {
@@ -103,25 +103,27 @@ async function checkIdempotencyAndClaimLease(db, ledgerPath, dispatchId, workerI
             if (doc.exists) {
                 const data = doc.data();
                 
-                // [BUG] This blocks legitimate re-runs initiated by the Dispatcher
-                /* if (['COMPLETED', 'FAILED', 'CRASH'].includes(data.status)) {
-                    return { shouldRun: false, reason: `Task already in terminal state: ${data.status}` };
-                }
-                */
-
-                // [FIX] Only block if it's the EXACT SAME Dispatch ID (Duplicate Delivery)
-                if (['COMPLETED', 'FAILED', 'CRASH'].includes(data.status)) {
-                    if (data.dispatchId === dispatchId) {
-                        return { shouldRun: false, reason: `Task already in terminal state: ${data.status}` };
+                // [ON-DEMAND OVERRIDE] If this is an on-demand request, force re-run even if completed
+                if (onDemand && ['COMPLETED', 'FAILED', 'CRASH'].includes(data.status)) {
+                    // Force overwrite - on-demand requests should always run
+                    // Log will be handled by caller
+                    // Continue to claim lease below
+                } else {
+                    // [FIX] Only block if it's the EXACT SAME Dispatch ID (Duplicate Delivery)
+                    if (['COMPLETED', 'FAILED', 'CRASH'].includes(data.status)) {
+                        if (data.dispatchId === dispatchId) {
+                            return { shouldRun: false, reason: `Task already in terminal state: ${data.status}` };
+                        }
+                        // If dispatchId differs, we allow the overwrite (Re-Run).
+                        // The Dispatcher is the authority; if it sent a message, we run it.
                     }
-                    // If dispatchId differs, we allow the overwrite (Re-Run).
-                    // The Dispatcher is the authority; if it sent a message, we run it.
                 }
 
                 if (data.status === 'IN_PROGRESS' && data.dispatchId === dispatchId) {
                     return { shouldRun: false, reason: 'Duplicate delivery: Task already IN_PROGRESS with same ID.' };
                 }
-                if (data.status === 'IN_PROGRESS') {
+                if (data.status === 'IN_PROGRESS' && !onDemand) {
+                    // On-demand can break locks if needed, but regular requests should wait
                     return { shouldRun: false, reason: 'Collision: Task currently IN_PROGRESS by another worker.' };
                 }
             }
@@ -130,7 +132,8 @@ async function checkIdempotencyAndClaimLease(db, ledgerPath, dispatchId, workerI
                 status: 'IN_PROGRESS',
                 workerId: workerId,
                 dispatchId: dispatchId || 'unknown',
-                startedAt: new Date()
+                startedAt: new Date(),
+                onDemand: onDemand || false
             };
             
             t.set(docRef, lease, { merge: true });
@@ -151,8 +154,9 @@ async function handleComputationTask(message, config, dependencies) {
 
     if (!data || data.action !== 'RUN_COMPUTATION_DATE') return;
     
-    const { date, pass, computation, previousCategory, triggerReason, dispatchId, dependencyResultHashes, resources, traceContext } = data;
+    const { date, pass, computation, previousCategory, triggerReason, dispatchId, dependencyResultHashes, resources, traceContext, metadata } = data;
     const resourceTier = resources || 'standard';
+    const onDemand = metadata?.onDemand === true || false; // Extract on-demand flag
     const ledgerPath = `computation_audit_ledger/${date}/passes/${pass}/tasks/${computation}`;
     const workerId = process.env.K_REVISION || os.hostname();
 
@@ -174,12 +178,16 @@ async function handleComputationTask(message, config, dependencies) {
     const runDeps = { ...dependencies, logger };
     const db = dependencies.db;
 
-    // --- STEP 1: IDEMPOTENCY CHECK ---
-    const gate = await checkIdempotencyAndClaimLease(db, ledgerPath, dispatchId, workerId);
+    // --- STEP 1: IDEMPOTENCY CHECK (with on-demand override) ---
+    const gate = await checkIdempotencyAndClaimLease(db, ledgerPath, dispatchId, workerId, onDemand);
     if (!gate.shouldRun) {
         logger.log('WARN', `[Worker] 🛑 Idempotency Gate: Skipping ${computation}. Reason: ${gate.reason}`);
         return; 
     }
+    
+    if (onDemand) {
+        logger.log('INFO', `[Worker] 🔄 On-demand request: Forcing re-run of ${computation} for ${date}`);
+    }
 
     logger.log('INFO', `[Worker] 📥 Task: ${computation} (${date}) [Tier: ${resourceTier}] [ID: ${dispatchId}]`);
 
@@ -195,7 +203,8 @@ async function handleComputationTask(message, config, dependencies) {
         
         const result = await executeDispatchTask(
             date, pass, computation, config, runDeps, 
-            manifest, previousCategory, dependencyResultHashes
+            manifest, previousCategory, dependencyResultHashes,
+            metadata // Pass metadata (including targetCid) to orchestrator
         );
 
         heartbeats.stop();

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

@@ -0,0 +1,151 @@
+/**
+ * @fileoverview Helpers for on-demand computation requests
+ * Handles dependency chain resolution and ordered triggering
+ */
+
+const { getManifest } = require('../topology/ManifestLoader');
+const { normalizeName } = require('../utils/utils');
+
+// Import calculations package (matching computation_worker.js pattern)
+let calculationPackage;
+try { 
+    calculationPackage = require('aiden-shared-calculations-unified'); 
+} catch (e) { 
+    throw new Error(`Failed to load calculations package: ${e.message}`); 
+}
+const calculations = calculationPackage.calculations;
+
+/**
+ * Resolves all dependencies for a given computation and returns them grouped by pass
+ * @param {string} computationName - The target computation name
+ * @param {Array} manifest - The computation manifest
+ * @returns {Array<{pass: number, computations: Array<string>}>} Dependencies grouped by pass
+ */
+function resolveDependencyChain(computationName, manifest) {
+    const manifestMap = new Map(manifest.map(c => [normalizeName(c.name), c]));
+    const normalizedTarget = normalizeName(computationName);
+    
+    const targetCalc = manifestMap.get(normalizedTarget);
+    if (!targetCalc) {
+        throw new Error(`Computation ${computationName} not found in manifest`);
+    }
+    
+    // Build adjacency list (dependencies map)
+    const adjacency = new Map();
+    for (const calc of manifest) {
+        const normName = normalizeName(calc.name);
+        adjacency.set(normName, (calc.dependencies || []).map(d => normalizeName(d)));
+    }
+    
+    // Get all dependencies recursively
+    const required = new Set([normalizedTarget]);
+    const queue = [normalizedTarget];
+    
+    while (queue.length > 0) {
+        const calcName = queue.shift();
+        const dependencies = adjacency.get(calcName) || [];
+        for (const dep of dependencies) {
+            if (!required.has(dep)) {
+                required.add(dep);
+                queue.push(dep);
+            }
+        }
+    }
+    
+    // Group by pass
+    const byPass = new Map();
+    for (const calcName of required) {
+        const calc = manifestMap.get(calcName);
+        if (calc) {
+            const pass = calc.pass || 1;
+            if (!byPass.has(pass)) {
+                byPass.set(pass, []);
+            }
+            byPass.get(pass).push(calc.name); // Use original name, not normalized
+        }
+    }
+    
+    // Convert to sorted array
+    const passes = Array.from(byPass.entries())
+        .sort((a, b) => a[0] - b[0])
+        .map(([pass, computations]) => ({ pass, computations }));
+    
+    return passes;
+}
+
+/**
+ * Triggers computations for a given date, handling dependencies in order
+ * @param {string} targetComputation - The target computation to run
+ * @param {string} date - The date string (YYYY-MM-DD)
+ * @param {object} dependencies - Contains pubsub, logger, etc.
+ * @param {object} config - Computation system config
+ * @param {object} metadata - Additional metadata for the computation request
+ * @returns {Promise<Array>} Array of triggered computation messages
+ */
+async function triggerComputationWithDependencies(targetComputation, date, dependencies, config, metadata = {}) {
+    const { pubsub, logger } = dependencies;
+    const computationTopic = config.computationTopicStandard || 'computation-tasks';
+    const topic = pubsub.topic(computationTopic);
+    const crypto = require('crypto');
+    
+    // Get manifest to resolve dependencies
+    const manifest = getManifest(config.activeProductLines || [], calculations);
+    
+    // Resolve dependency chain
+    const dependencyPasses = resolveDependencyChain(targetComputation, manifest);
+    
+    logger.log('INFO', `[On-Demand] Resolved dependency chain for ${targetComputation}:`, {
+        totalPasses: dependencyPasses.length,
+        passes: dependencyPasses.map(p => `Pass ${p.pass}: ${p.computations.length} computations`)
+    });
+    
+    const triggeredMessages = [];
+    
+    // Trigger each pass in order
+    for (const passGroup of dependencyPasses) {
+        const { pass, computations } = passGroup;
+        
+        // Trigger all computations in this pass
+        for (const computation of computations) {
+            const dispatchId = crypto.randomUUID();
+            const isTarget = normalizeName(computation) === normalizeName(targetComputation);
+            
+            const computationMessage = {
+                action: 'RUN_COMPUTATION_DATE',
+                computation: computation,
+                date: date,
+                pass: String(pass),
+                dispatchId: dispatchId,
+                triggerReason: metadata.triggerReason || 'on_demand',
+                resources: metadata.resources || 'standard',
+                metadata: {
+                    ...metadata,
+                    onDemand: true,
+                    isTargetComputation: isTarget,
+                    targetCid: metadata.targetCid || null // Pass through targetCid for optimization
+                },
+                traceContext: {
+                    traceId: crypto.randomBytes(16).toString('hex'),
+                    spanId: crypto.randomBytes(8).toString('hex'),
+                    sampled: true
+                }
+            };
+            
+            await topic.publishMessage({
+                data: Buffer.from(JSON.stringify(computationMessage))
+            });
+            
+            triggeredMessages.push(computationMessage);
+            
+            logger.log('INFO', `[On-Demand] Triggered ${computation} (Pass ${pass})${isTarget ? ' [TARGET]' : ' [DEPENDENCY]'}`);
+        }
+    }
+    
+    return triggeredMessages;
+}
+
+module.exports = {
+    resolveDependencyChain,
+    triggerComputationWithDependencies
+};
+

package/functions/computation-system/workflows/data_feeder_pipeline.yaml

@@ -1,5 +1,6 @@
-# Data Feeder Pipeline (V2.3 - Try/Retry Syntax Fixed)
-# Orchestrates data fetching with UTC-alignment, Test Mode, and Reliability.
+# Data Feeder Pipeline (V3.1 - Syntax Fixed)
+# Starts at 22:00 UTC via Cloud Scheduler.
+# Fixes: Split assign/call steps and corrected assign syntax.
 
 main:
   params: [input]
@@ -8,17 +9,8 @@ main:
         assign:
           - project: '${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}'
           - location: "europe-west1"
-          - market_date: '${text.split(time.format(sys.now()), "T")[0]}'
-          # Define a central retry policy to reuse across all HTTP calls
-          - default_retry:
-              predicate: ${http.default_retry_predicate}
-              max_retries: 5
-              backoff:
-                initial_delay: 2
-                max_delay: 60
-                multiplier: 2
-
-    # --- TEST MODE / SELECTIVE EXECUTION ---
+
+    # --- TEST MODE ---
     - check_test_mode:
         switch:
           - condition: '${input != null and "target_step" in input}'
@@ -26,130 +18,164 @@ main:
               - route_test:
                   switch:
                     - condition: '${input.target_step == "market"}'
-                      next: run_market_close_tasks
-                    - condition: '${input.target_step == "rankings"}'
-                      next: run_rankings_fetch
+                      next: phase_2200_price
+                    - condition: '${input.target_step == "midnight"}'
+                      next: phase_0000_rankings
                     - condition: '${input.target_step == "social"}'
-                      next: run_social_midnight
-                    - condition: '${input.target_step == "global"}'
-                      next: run_global_indexer
-
-    # --- PHASE 1: MARKET CLOSE (22:00 UTC) ---
-    - run_market_close_tasks:
-        parallel:
-          branches:
-            - price_fetch:
-                steps:
-                  - call_price_fetcher:
-                      try:
-                        call: http.post
-                        args:
-                          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/price-fetcher"}'
-                          auth: { type: OIDC }
-                          timeout: 300
-                      retry: ${default_retry} # Fixed: Moved retry to a Try Step
-            - insights_fetch:
-                steps:
-                  - call_insights_fetcher:
-                      try:
-                        call: http.post
-                        args:
-                          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/insights-fetcher"}'
-                          auth: { type: OIDC }
-                          timeout: 300
-                      retry: ${default_retry} # Fixed: Moved retry to a Try Step
-
-    - index_market_data:
+                      next: social_loop_start
+
+    # ==========================================
+    # PHASE 1: MARKET CLOSE (Starts 22:00 UTC)
+    # ==========================================
+
+    - phase_2200_price:
         try:
           call: http.post
           args:
-            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
-            body:
-              targetDate: '${market_date}'
+            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/price-fetcher"}'
             auth: { type: OIDC }
             timeout: 300
-        retry: ${default_retry}
+        except:
+          as: e
+          steps:
+            - log_price_error:
+                call: sys.log
+                args: { severity: "WARNING", text: "Price fetch timed out/failed. Proceeding." }
+    
+    - wait_10_after_price:
+        call: sys.sleep
+        args: { seconds: 600 } # 10 Minutes
 
-    # --- PHASE 2: ALIGN TO MIDNIGHT ---
-    - wait_for_midnight:
+    # FIX 1: Split assign and call
+    - prepare_index_price:
         assign:
-          - now_sec: '${int(sys.now())}'
-          - day_sec: 86400
-          - sleep_midnight: '${day_sec - (now_sec % day_sec)}'
-    - do_midnight_sleep:
-        call: sys.sleep
+          - today: '${text.split(time.format(sys.now()), "T")[0]}'
+    - index_today_after_price:
+        call: http.post
         args:
-          seconds: '${sleep_midnight}'
+          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+          body: { targetDate: '${today}' }
+          auth: { type: OIDC }
 
-    # --- PHASE 3: RANKINGS & INITIAL SOCIAL (00:00 UTC) ---
-    - run_rankings_fetch:
+    - wait_10_before_insights:
+        call: sys.sleep
+        args: { seconds: 600 }
+
+    - phase_2200_insights:
         try:
           call: http.post
           args:
-            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/fetch-popular-investors"}'
+            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/insights-fetcher"}'
             auth: { type: OIDC }
             timeout: 300
-        retry: ${default_retry}
         except:
           as: e
           steps:
-            - log_rankings_error:
+            - log_insights_error:
                 call: sys.log
-                args:
-                  severity: "ERROR"
-                  text: '${"Rankings Fetch Failed: " + json.encode(e)}'
+                args: { severity: "WARNING", text: "Insights fetch timed out/failed. Proceeding." }
 
-    - run_social_midnight:
-        try:
-          call: http.post
-          args:
-            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/social-orchestrator"}'
-            auth: { type: OIDC }
-            timeout: 300
-        retry: ${default_retry}
+    - wait_10_after_insights:
+        call: sys.sleep
+        args: { seconds: 600 }
 
-    - prepare_midnight_index:
+    # FIX 2: Split assign and call
+    - prepare_index_insights:
         assign:
-            - current_date: '${text.split(time.format(sys.now()), "T")[0]}'
-    - index_midnight_data:
+          - today: '${text.split(time.format(sys.now()), "T")[0]}'
+    - index_today_after_insights:
+        call: http.post
+        args:
+          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+          body: { targetDate: '${today}' }
+          auth: { type: OIDC }
+
+    # ==========================================
+    # PHASE 2: WAIT FOR MIDNIGHT
+    # ==========================================
+
+    - align_to_midnight:
+        assign:
+          - now_sec: '${int(sys.now())}'
+          - day_sec: 86400
+          - sleep_midnight: '${day_sec - (now_sec % day_sec)}'
+    - wait_for_midnight:
+        call: sys.sleep
+        args: { seconds: '${sleep_midnight}' }
+
+    # ==========================================
+    # PHASE 3: MIDNIGHT TASKS (00:00 UTC)
+    # ==========================================
+
+    - phase_0000_rankings:
         try:
           call: http.post
           args:
-            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
-            body:
-               targetDate: '${current_date}'
+            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/fetch-popular-investors"}'
             auth: { type: OIDC }
             timeout: 300
-        retry: ${default_retry}
+        except:
+          as: e
+          steps:
+            - log_ranking_error:
+                call: sys.log
+                args: { severity: "WARNING", text: "Rankings failed. Proceeding to Social (risky)." }
 
-    - run_global_indexer:
+    - wait_10_after_rankings:
+        call: sys.sleep
+        args: { seconds: 600 }
+
+    # FIX 3: Split assign and call
+    - prepare_index_rankings:
+        assign:
+          - today: '${text.split(time.format(sys.now()), "T")[0]}'
+    - index_today_after_rankings:
+        call: http.post
+        args:
+          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+          body: { targetDate: '${today}' }
+          auth: { type: OIDC }
+
+    - phase_0000_social:
         try:
           call: http.post
           args:
-            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+            url: '${"https://" + location + "-" + project + ".cloudfunctions.net/social-orchestrator"}'
             auth: { type: OIDC }
             timeout: 300
-        retry: ${default_retry}
+        except:
+          as: e
+          steps:
+            - log_social_error:
+                call: sys.log
+                args: { severity: "WARNING", text: "Social failed. Proceeding." }
+
+    - wait_10_after_social:
+        call: sys.sleep
+        args: { seconds: 600 }
+
+    - global_index_midnight:
+        call: http.post
+        args:
+          url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+          # No targetDate = Global Run
+          auth: { type: OIDC }
+
+    # ==========================================
+    # PHASE 4: SOCIAL LOOP (Every 3 Hours)
+    # ==========================================
 
-    # --- PHASE 4: RECURRING SOCIAL FETCH (UTC Aligned 3hr) ---
     - init_social_loop:
         assign:
           - i: 0
     
-    - social_loop:
+    - social_loop_start:
         switch:
-          - condition: ${i < 7}
+          - condition: ${i < 7} # Covers the remainder of the 24h cycle
             steps:
-              - calculate_next_window:
-                  assign:
-                    - now_sec_loop: '${int(sys.now())}'
-                    - window_size: 10800 
-                    - sleep_loop: '${window_size - (now_sec_loop % window_size)}'
-              
-              - wait_for_3hr_window:
+              - wait_3_hours:
                   call: sys.sleep
-                  args:
-                    seconds: '${sleep_loop}'
+                  args: { seconds: 10800 }
               
               - run_social_recurring:
                   try:
@@ -158,27 +184,34 @@ main:
                       url: '${"https://" + location + "-" + project + ".cloudfunctions.net/social-orchestrator"}'
                       auth: { type: OIDC }
                       timeout: 300
-                  retry: ${default_retry}
+                  except:
+                    as: e
+                    steps:
+                      - log_loop_social_warn:
+                          call: sys.log
+                          args: { severity: "WARNING", text: "Loop Social timed out. Proceeding." }
 
-              - prepare_recurring_index:
+              - wait_10_in_loop:
+                  call: sys.sleep
+                  args: { seconds: 600 }
+              
+              # FIX 4: Split assign and call
+              - prepare_index_loop:
                    assign:
-                     - cur_date_rec: '${text.split(time.format(sys.now()), "T")[0]}'
-              - index_recurring:
-                   try:
-                     call: http.post
-                     args:
-                       url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
-                       body:
-                         targetDate: '${cur_date_rec}'
-                       auth: { type: OIDC }
-                       timeout: 300
-                   retry: ${default_retry}
+                     - today: '${text.split(time.format(sys.now()), "T")[0]}'
+              - index_today_in_loop:
+                   call: http.post
+                   args:
+                     url: '${"https://" + location + "-" + project + ".cloudfunctions.net/root-data-indexer"}'
+                     body: { targetDate: '${today}' }
+                     auth: { type: OIDC }
               
-              - increment:
-                  assign:
-                    - i: ${i + 1}
+              # FIX 5: Correct assign syntax (must be a list)
+              - increment_loop:
+                  assign: 
+                    - i: '${i + 1}'
               - next_iteration:
-                  next: social_loop
+                  next: social_loop_start
 
     - finish:
-        return: "Daily Data Pipeline Completed"
+        return: "Complete 24h Cycle Finished"

package/functions/etoro-price-fetcher/helpers/handler_helpers.js

@@ -94,6 +94,30 @@ exports.fetchAndStorePrices = async (config, dependencies) => {
         
         logger.log('INFO', `[PriceFetcherHelpers] Wrote price date tracking document for ${today} with ${priceDatesArray.length} dates (from August 2025 onwards)`);
         
+        // Update root data indexer for today's date after price data is stored
+        try {
+            const { runRootDataIndexer } = require('../../root-data-indexer/index');
+            const rootDataIndexerConfig = config.rootDataIndexer || {
+                availabilityCollection: 'system_root_data_index',
+                earliestDate: '2025-08-01',
+                collections: {
+                    prices: priceCollectionName
+                }
+            };
+            
+            const indexerConfig = {
+                ...rootDataIndexerConfig,
+                targetDate: today // Index only today's date for speed
+            };
+            
+            logger.log('INFO', `[PriceFetcherHelpers] Triggering root data indexer for date ${today} after price data storage...`);
+            await runRootDataIndexer(indexerConfig, dependencies);
+            logger.log('INFO', `[PriceFetcherHelpers] Root data indexer completed for date ${today}`);
+        } catch (indexerError) {
+            logger.log('ERROR', `[PriceFetcherHelpers] Failed to run root data indexer for ${today}`, indexerError);
+            // Continue - price data is stored, indexer failure is non-critical
+        }
+        
         const successMessage = `Successfully processed and saved daily prices for ${results.length} instruments to ${batchPromises.length} shards.`;
         logger.log('SUCCESS', `[PriceFetcherHelpers] ${successMessage}`);
         return { success: true, message: successMessage, instrumentsProcessed: results.length };