bulltrackers-module 1.0.288 → 1.0.289

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

@@ -1,8 +1,7 @@
 /**
  * FILENAME: computation-system/helpers/computation_dispatcher.js
- * PURPOSE: "Smart Dispatcher" - Analyzes state and dispatches tasks.
- * UPDATED: Removed "Zombie" logic. Now forcefully dispatches any task 
- * that is not explicitly COMPLETED, ensuring reliability for one-shot execution.
+ * PURPOSE: "Smart Dispatcher" - Analyzes state, initializes Run Counters, and dispatches tasks.
+ * UPDATED: Implements Callback Pattern. Initializes 'computation_runs' doc for worker coordination.
  */
 
 const { getExpectedDateStrings, normalizeName, DEFINITIVE_EARLIEST_DATES } = require('../utils/utils.js');
@@ -19,13 +18,22 @@ const STATUS_IMPOSSIBLE = 'IMPOSSIBLE';
 
 /**
  * Dispatches computation tasks for a specific pass.
+ * @param {Object} config - System config
+ * @param {Object} dependencies - { db, logger, ... }
+ * @param {Array} computationManifest - List of calculations
+ * @param {Object} reqBody - (Optional) HTTP Body containing 'callbackUrl' and 'date'
  */
-async function dispatchComputationPass(config, dependencies, computationManifest) {
+async function dispatchComputationPass(config, dependencies, computationManifest, reqBody = {}) {
     const { logger, db } = dependencies;
     const pubsubUtils = new PubSubUtils(dependencies);
     const passToRun   = String(config.COMPUTATION_PASS_TO_RUN);
     
+    // [NEW] Extract Date and Callback from request body (pushed by Workflow)
+    const dateStr     = reqBody.date || config.date; 
+    const callbackUrl = reqBody.callbackUrl || null;
+
     if (!passToRun) { return logger.log('ERROR', '[Dispatcher] No pass defined (COMPUTATION_PASS_TO_RUN). Aborting.'); }
+    if (!dateStr)   { return logger.log('ERROR', '[Dispatcher] No date defined. Aborting.'); }
 
     const currentManifestHash = generateCodeHash(
         computationManifest.map(c => c.hash).sort().join('|')
@@ -37,29 +45,29 @@ async function dispatchComputationPass(config, dependencies, computationManifest
     if (!calcsInThisPass.length) { return logger.log('WARN', `[Dispatcher] No calcs for Pass ${passToRun}. Exiting.`); }
 
     const calcNames = calcsInThisPass.map(c => c.name);
-    logger.log('INFO', `🚀 [Dispatcher] Smart-Dispatching PASS ${passToRun}`);
-    logger.log('INFO', `[Dispatcher] Target Calculations: [${calcNames.join(', ')}]`);
-
+    logger.log('INFO', `🚀 [Dispatcher] Smart-Dispatching PASS ${passToRun} for ${dateStr}`);
+    
+    // -- DATE ANALYSIS LOGIC (Unchanged) --
     const passEarliestDate = Object.values(DEFINITIVE_EARLIEST_DATES).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);
+    
+    // We only analyze the specific requested date to keep dispatch fast for the workflow
+    const allExpectedDates = [dateStr]; 
 
     const manifestMap = new Map(computationManifest.map(c => [normalizeName(c.name), c]));
     const tasksToDispatch = [];
     const limit = pLimit(20);
 
-    logger.log('INFO', `[Dispatcher] Analyzing ${allExpectedDates.length} dates for viability...`);
-
-    const analysisPromises = allExpectedDates.map(dateStr => limit(async () => {
+    const analysisPromises = allExpectedDates.map(d => limit(async () => {
         try {
             const fetchPromises = [
-                fetchComputationStatus(dateStr, config, dependencies),
-                checkRootDataAvailability(dateStr, config, dependencies, DEFINITIVE_EARLIEST_DATES)
+                fetchComputationStatus(d, config, dependencies),
+                checkRootDataAvailability(d, config, dependencies, DEFINITIVE_EARLIEST_DATES)
             ];
 
             let prevDateStr = null;
             if (calcsInThisPass.some(c => c.isHistorical)) {
-                const prevDate = new Date(dateStr + 'T00:00:00Z');
+                const prevDate = new Date(d + 'T00:00:00Z');
                 prevDate.setUTCDate(prevDate.getUTCDate() - 1);
                 prevDateStr = prevDate.toISOString().slice(0, 10);
                 
@@ -77,7 +85,7 @@ async function dispatchComputationPass(config, dependencies, computationManifest
                 hasPortfolio: false, hasHistory: false, hasSocial: false, hasInsights: false, hasPrices: false
             };
 
-            const report = analyzeDateExecution(dateStr, calcsInThisPass, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus);
+            const report = analyzeDateExecution(d, calcsInThisPass, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus);
 
             const statusUpdates = {};
             
@@ -93,25 +101,20 @@ async function dispatchComputationPass(config, dependencies, computationManifest
 
             report.failedDependency.forEach(item => {
                  const missingStr = item.missing ? item.missing.join(', ') : 'unknown';
-                 statusUpdates[item.name] = { 
-                     hash: false, 
-                     category: 'unknown', 
-                     reason: `Dependency Missing: ${missingStr}` 
-                 };
+                 statusUpdates[item.name] = { hash: false, category: 'unknown', reason: `Dependency Missing: ${missingStr}` };
             });
 
             if (Object.keys(statusUpdates).length > 0) {
-                await updateComputationStatus(dateStr, statusUpdates, config, dependencies);
+                await updateComputationStatus(d, statusUpdates, config, dependencies);
             }
 
             const validToRun = [...report.runnable, ...report.reRuns];
             validToRun.forEach(item => {
                 const uniqueDispatchId = crypto.randomUUID(); 
-                
                 tasksToDispatch.push({
                     action: 'RUN_COMPUTATION_DATE',
                     dispatchId: uniqueDispatchId,
-                    date: dateStr,
+                    date: d,
                     pass: passToRun,
                     computation: normalizeName(item.name),
                     hash: item.hash || item.newHash, 
@@ -123,15 +126,41 @@ async function dispatchComputationPass(config, dependencies, computationManifest
             });
 
         } catch (e) {
-            logger.log('ERROR', `[Dispatcher] Failed analysis for ${dateStr}: ${e.message}`);
+            logger.log('ERROR', `[Dispatcher] Failed analysis for ${d}: ${e.message}`);
         }
     }));
 
     await Promise.all(analysisPromises);
 
+    // -- NEW: CALLBACK & COUNTER INITIALIZATION --
+
     if (tasksToDispatch.length > 0) {
-        logger.log('INFO', `[Dispatcher] 📝 Creating Audit Ledger entries (Transactional) for ${tasksToDispatch.length} tasks...`);
+        logger.log('INFO', `[Dispatcher] 📝 Preparing ${tasksToDispatch.length} tasks for execution...`);
         
+        // 1. Initialize Shared State Document (The Counter)
+        const runId = crypto.randomUUID();
+        const metaStatePath = `computation_runs/${runId}`;
+        
+        if (callbackUrl) {
+            await db.doc(metaStatePath).set({
+                createdAt: new Date(),
+                date: dateStr,
+                pass: passToRun,
+                totalTasks: tasksToDispatch.length,
+                remainingTasks: tasksToDispatch.length, // <--- The Countdown
+                callbackUrl: callbackUrl,               // <--- The Workflow Hook
+                status: 'IN_PROGRESS'
+            });
+            logger.log('INFO', `[Dispatcher] 🏁 Run State Initialized: ${runId}`);
+        }
+
+        // 2. Attach Run Metadata to every task
+        tasksToDispatch.forEach(task => {
+            task.runId = runId;
+            task.metaStatePath = callbackUrl ? metaStatePath : null; 
+        });
+        
+        // 3. Create Audit Ledger Entries
         const finalDispatched = [];
         const txnLimit = pLimit(20);
         
@@ -142,34 +171,22 @@ async function dispatchComputationPass(config, dependencies, computationManifest
                 await db.runTransaction(async (t) => {
                     const doc = await t.get(ledgerRef);
                     
-                    // [UPDATED] Robust One-Shot Dispatch Logic
-                    // We REMOVED the "Zombie Timeout" check.
-                    // If the Dispatcher is running, we assume the user intends to ensure these tasks are dispatched.
-                    
                     if (doc.exists) {
                         const data = doc.data();
-                        
-                        // 1. If it's already COMPLETED, do not re-run (Strict idempotency).
-                        if (data.status === 'COMPLETED') {
-                            return false;
-                        }
-
-                        // 2. If it is PENDING or IN_PROGRESS:
-                        // Since the Dispatcher runs ONCE per day, seeing PENDING here means 
-                        // the *previous* run failed to complete, or the worker died.
-                        // We overwrite it to force a restart.
+                        // Strict Idempotency: If completed, don't run again.
+                        if (data.status === 'COMPLETED') return false;
                     }
                     
-                    // Create/Overwrite entry with PENDING to start the cycle
                     t.set(ledgerRef, {
                         status: 'PENDING',
                         dispatchId: task.dispatchId,
+                        runId: task.runId, // Track the batch ID
                         computation: task.computation,
                         expectedHash: task.hash || 'unknown',
                         createdAt: new Date(),
                         dispatcherHash: currentManifestHash,
                         triggerReason: task.triggerReason,
-                        retries: 0 // Reset retries for the new attempt
+                        retries: 0
                     }, { merge: true });
                     
                     return true;
@@ -178,14 +195,15 @@ async function dispatchComputationPass(config, dependencies, computationManifest
                 finalDispatched.push(task);
 
             } catch (txnErr) {
-                logger.log('WARN', `[Dispatcher] Transaction failed for ${task.computation} on ${task.date}: ${txnErr.message}`);
+                logger.log('WARN', `[Dispatcher] Transaction failed for ${task.computation}: ${txnErr.message}`);
             }
         }));
 
         await Promise.all(txnPromises);
 
+        // 4. Publish to Pub/Sub
         if (finalDispatched.length > 0) {
-            logger.log('INFO', `[Dispatcher] ✅ Publishing ${finalDispatched.length} unique tasks to Pub/Sub...`);
+            logger.log('INFO', `[Dispatcher] ✅ Publishing ${finalDispatched.length} tasks to Pub/Sub...`);
             
             await pubsubUtils.batchPublishTasks(dependencies, {
                 topicName: TOPIC_NAME,
@@ -194,14 +212,17 @@ async function dispatchComputationPass(config, dependencies, computationManifest
                 maxPubsubBatchSize: 100
             });
             
-            return { dispatched: finalDispatched.length };
+            // Return count so workflow knows to wait
+            return { dispatched: finalDispatched.length, runId };
         } else {
-            logger.log('INFO', `[Dispatcher] All tasks were already COMPLETED (Double Dispatch avoided).`);
+            // Edge Case: Analysis said "Run", but Ledger said "Already Done"
+            // We must update the state doc to 0 or delete it, OR return 0 so workflow doesn't wait.
+            logger.log('INFO', `[Dispatcher] All tasks were already COMPLETED.`);
             return { dispatched: 0 };
         }
 
     } else {
-        logger.log('INFO', `[Dispatcher] No valid tasks found. System is up to date.`);
+        logger.log('INFO', `[Dispatcher] No valid tasks found (Up to date).`);
         return { dispatched: 0 };
     }
 }

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

@@ -1,24 +1,98 @@
 /**
  * FILENAME: computation-system/helpers/computation_worker.js
- * PURPOSE: Consumes computation tasks from Pub/Sub.
- * UPDATED: Fixed "Silent Failure" bug where tasks got stuck in PENDING.
- * Increased MAX_RETRIES and ensured Ledger is updated on poison messages.
+ * PURPOSE: Consumes tasks, executes logic, and signals Workflow upon Batch Completion.
+ * UPDATED: Implements "Last Worker" Callback Pattern.
  */
 
 const { executeDispatchTask } = require('../WorkflowOrchestrator.js');
 const { getManifest }         = require('../topology/ManifestLoader');
 const { StructuredLogger }    = require('../logger/logger'); 
 const { recordRunAttempt }    = require('../persistence/RunRecorder'); 
+const https                   = require('https'); // [NEW] Required for callback
 
 let calculationPackage;
 try { calculationPackage = require('aiden-shared-calculations-unified');
 } catch (e) {console.error("FATAL: Could not load 'aiden-shared-calculations-unified'."); throw e; }
 const calculations = calculationPackage.calculations;
 
-// [FIX] Increased from 0 to 3. 
-// 0 caused "retryCount >= MAX_RETRIES" to trigger immediately on the first run.
 const MAX_RETRIES = 3;
 
+/**
+ * [NEW] Helper: Fires the webhook back to Google Cloud Workflows.
+ */
+function triggerWorkflowCallback(url, status, logger) {
+    if (!url) return Promise.resolve();
+    logger.log('INFO', `[Worker] 🔔 BATCH COMPLETE! Triggering Workflow Callback: ${status}`);
+    
+    return new Promise((resolve, reject) => {
+        const body = JSON.stringify({ 
+            status: status, 
+            timestamp: new Date().toISOString() 
+        });
+        
+        const req = https.request(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body)
+            }
+        }, (res) => {
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+                resolve();
+            } else {
+                logger.log('WARN', `Callback responded with ${res.statusCode}`);
+                resolve(); // Don't crash the worker if callback fails, logic is done.
+            }
+        });
+
+        req.on('error', (e) => {
+            logger.log('ERROR', `Failed to trigger callback: ${e.message}`);
+            resolve(); 
+        });
+        
+        req.write(body);
+        req.end();
+    });
+}
+
+/**
+ * [NEW] Helper: Decrements 'remainingTasks' in Firestore.
+ * Returns the callbackUrl IF this was the last task.
+ */
+async function decrementAndCheck(db, metaStatePath, logger) {
+    if (!metaStatePath) return null;
+    
+    try {
+        const result = await db.runTransaction(async (t) => {
+            const ref = db.doc(metaStatePath);
+            const doc = await t.get(ref);
+            
+            if (!doc.exists) return null; // State might have expired or been deleted
+            const data = doc.data();
+            
+            const newRemaining = (data.remainingTasks || 0) - 1;
+            
+            t.update(ref, { 
+                remainingTasks: newRemaining,
+                lastUpdated: new Date()
+            });
+            
+            // Return needed data only if we hit 0 (or lower, for safety)
+            return { 
+                remaining: newRemaining, 
+                callbackUrl: data.callbackUrl 
+            };
+        });
+
+        if (result && result.remaining <= 0) {
+            return result.callbackUrl;
+        }
+    } catch (e) {
+        logger.log('ERROR', `[Worker] Failed to decrement batch counter: ${e.message}`);
+    }
+    return null;
+}
+
 async function handleComputationTask(message, config, dependencies) {
     const systemLogger = new StructuredLogger({ minLevel: config.minLevel || 'INFO', enableStructured: true, ...config });
     const runDependencies = { ...dependencies, logger: systemLogger };
@@ -34,15 +108,14 @@ async function handleComputationTask(message, config, dependencies) {
 
     if (!data || data.action !== 'RUN_COMPUTATION_DATE') { return; }
     
-    // Extract fields including new dependencyResultHashes
-    const { date, pass, computation, previousCategory, triggerReason, dispatchId, dependencyResultHashes } = data;
+    // Extract fields including new metaStatePath
+    const { date, pass, computation, previousCategory, triggerReason, dispatchId, dependencyResultHashes, metaStatePath } = data;
     
     if (!date || !pass || !computation) { logger.log('ERROR', `[Worker] Invalid payload.`, data); return; }
 
-    // [FIX] Ensure retryCount defaults to 1 (PubSub usually sends 1 for the first attempt)
     const retryCount = message.deliveryAttempt || 1;
 
-    // [FIX] Changed condition to '>' so attempts 1, 2, and 3 are allowed to run.
+    // --- POISON MESSAGE HANDLING (DLQ) ---
     if (retryCount > MAX_RETRIES) {
             logger.log('ERROR', `[Worker] ☠️ Task POISONED. Moved to DLQ: ${computation}`);
             try {
@@ -54,25 +127,28 @@ async function handleComputationTask(message, config, dependencies) {
                     failureReason: 'MAX_RETRIES_EXCEEDED'
                 });
 
-                // [FIX] CRITICAL: Update Ledger to FAILED.
-                // Previously, this returned without updating, leaving the Ledger stuck in 'PENDING'.
-                // Now we explicitly mark it FAILED so the pipeline knows it's dead.
                 await db.collection(`computation_audit_ledger/${date}/passes/${pass}/tasks`).doc(computation).set({
                     status: 'FAILED',
                     error: 'Max Retries Exceeded (Poison Message)',
                     failedAt: new Date()
                 }, { merge: true });
 
+                // [CRITICAL] Even if it failed, we MUST decrement the counter.
+                // Otherwise the workflow waits 24h for a task that will never finish.
+                const callbackUrl = await decrementAndCheck(db, metaStatePath, logger);
+                if (callbackUrl) {
+                    // We signal SUCCESS to the workflow because the *Batch* is finished processing (even if this task failed).
+                    // The "monitor" or next pass can handle data gaps.
+                    await triggerWorkflowCallback(callbackUrl, 'SUCCESS', logger);
+                }
+
                 return;
             } catch (dlqErr) { logger.log('FATAL', `[Worker] Failed to write to DLQ`, dlqErr); }
     }
 
-    logger.log('INFO', `[Worker] 📥 Received Task: ${computation} (${date}) [Attempt ${retryCount}/${MAX_RETRIES}]`, { 
-        dispatchId: dispatchId || 'legacy', 
-        reason: triggerReason 
-    });
+    logger.log('INFO', `[Worker] 📥 Received Task: ${computation} (${date}) [Attempt ${retryCount}/${MAX_RETRIES}]`);
 
-    // Mark task as IN_PROGRESS (Visual only, dispatcher does not use this for logic anymore)
+    // Update Status to IN_PROGRESS
     try {
         await db.collection(`computation_audit_ledger/${date}/passes/${pass}/tasks`).doc(computation).set({
             status: 'IN_PROGRESS',
@@ -80,29 +156,21 @@ async function handleComputationTask(message, config, dependencies) {
             startedAt: new Date(),
             dispatchId: dispatchId
         }, { merge: true });
-    } catch (leaseErr) {
-        logger.log('WARN', `[Worker] Failed to update status to IN_PROGRESS for ${computation}. Continuing...`, leaseErr);
-    }
+    } catch (leaseErr) {}
 
     let computationManifest;
     try { computationManifest = getManifest(config.activeProductLines || [], calculations, runDependencies);
     } catch (manifestError) { 
         logger.log('FATAL', `[Worker] Failed to load Manifest: ${manifestError.message}`);
-        await recordRunAttempt(db, { date, computation, pass }, 'CRASH', { message: manifestError.message, stage: 'MANIFEST_LOAD' }, { durationMs: 0 }, triggerReason);
+        // Do NOT decrement here, let PubSub retry the task.
         return; 
     }
 
     try {
         const startTime = Date.now();
         const result    = await executeDispatchTask(
-            date, 
-            pass, 
-            computation, 
-            config, 
-            runDependencies, 
-            computationManifest,
-            previousCategory,
-            dependencyResultHashes
+            date, pass, computation, config, runDependencies, 
+            computationManifest, previousCategory, dependencyResultHashes
         );
         const duration = Date.now() - startTime;
 
@@ -110,38 +178,44 @@ async function handleComputationTask(message, config, dependencies) {
         const successUpdates = result?.updates?.successUpdates || {};
 
         if (failureReport.length > 0) {
+            // Logic/Storage failure (handled internally by executor)
             const failReason = failureReport[0]; 
-            logger.log('ERROR', `[Worker] ❌ Failed logic/storage for ${computation}`, failReason.error);
-            const metrics = failReason.metrics || {};
-            metrics.durationMs = duration;
-            await recordRunAttempt(db, { date, computation, pass }, 'FAILURE', failReason.error, metrics, triggerReason);
             throw new Error(failReason.error.message || 'Computation Logic Failed');
         } 
-        else if (Object.keys(successUpdates).length > 0) {
-            const successData  = successUpdates[computation]; 
-            const metrics      = successData.metrics || {};
-            metrics.durationMs = duration;
-            logger.log('INFO', `[Worker] ✅ Stored: ${computation}. ID: ${dispatchId}`);
-            
-            // Mark Ledger as COMPLETED
+        else {
+            if (Object.keys(successUpdates).length > 0) {
+                logger.log('INFO', `[Worker] ✅ Stored: ${computation}`);
+            } else {
+                logger.log('WARN', `[Worker] ⚠️ Empty Result: ${computation}`);
+            }
+
+            // 1. Mark Ledger as COMPLETED
             await db.collection(`computation_audit_ledger/${date}/passes/${pass}/tasks`).doc(computation).update({
                 status: 'COMPLETED',
                 completedAt: new Date()
             }).catch(() => {});
 
-            await recordRunAttempt(db, { date, computation, pass }, 'SUCCESS', null, metrics, triggerReason);
-        } 
-        else {
-            logger.log('WARN', `[Worker] ⚠️ No results produced for ${computation} (Empty?)`);
-            await recordRunAttempt(db, { date, computation, pass }, 'SUCCESS', { message: 'Empty Result' }, { durationMs: duration }, triggerReason);
+            await recordRunAttempt(db, { date, computation, pass }, 'SUCCESS', null, { durationMs: duration }, triggerReason);
+
+            // 2. [NEW] Decrement Batch Counter & Check for Callback
+            const callbackUrl = await decrementAndCheck(db, metaStatePath, logger);
+            
+            // 3. [NEW] If last one, fire callback
+            if (callbackUrl) {
+                await triggerWorkflowCallback(callbackUrl, 'SUCCESS', logger);
+            }
         }
     } catch (err) { 
+        // --- ERROR HANDLING ---
+        
+        // Check for Permanent/Deterministic Errors
         const isDeterministicError = err.stage === 'SHARDING_LIMIT_EXCEEDED' || 
                                      err.stage === 'QUALITY_CIRCUIT_BREAKER' ||
+                                     err.stage === 'SEMANTIC_GATE' ||
                                      (err.message && (err.message.includes('INVALID_ARGUMENT') || err.message.includes('Transaction too big')));
 
         if (isDeterministicError) {
-             logger.log('ERROR', `[Worker] 🛑 Permanent Failure (Limit Issue). Sending to DLQ immediately: ${dispatchId}`);
+             logger.log('ERROR', `[Worker] 🛑 Permanent Failure: ${err.message}`);
              try {
                  await db.collection('computation_dead_letter_queue').add({
                      originalData: data,
@@ -151,7 +225,6 @@ async function handleComputationTask(message, config, dependencies) {
                      failureReason: 'PERMANENT_DETERMINISTIC_ERROR'
                  });
                  
-                 // [FIX] Update Ledger to FAILED immediately for deterministic errors
                  await db.collection(`computation_audit_ledger/${date}/passes/${pass}/tasks`).doc(computation).set({
                     status: 'FAILED',
                     error: err.message || 'Permanent Deterministic Error',
@@ -159,22 +232,29 @@ async function handleComputationTask(message, config, dependencies) {
                 }, { merge: true });
 
                  await recordRunAttempt(db, { date, computation, pass }, 'FAILURE', { message: err.message, stage: err.stage || 'PERMANENT_FAIL' }, { durationMs: 0 }, triggerReason);
-                 return; 
+                 
+                 // [CRITICAL] Permanent failure -> Must decrement so workflow doesn't hang
+                 const callbackUrl = await decrementAndCheck(db, metaStatePath, logger);
+                 if (callbackUrl) {
+                     await triggerWorkflowCallback(callbackUrl, 'SUCCESS', logger);
+                 }
+
+                 return; // Do NOT throw, consume the message
              } catch (dlqErr) { logger.log('FATAL', `[Worker] Failed to write to DLQ`, dlqErr); }
         }
 
-        // Standard Retryable Error (Crash)
+        // Standard Retryable Error (Transient)
         if (retryCount >= MAX_RETRIES) {
-             // We throw here, PubSub will retry, and the "Poison Logic" at the top 
-             // will catch it on the NEXT attempt to finalize the failure.
+             // Let the top-level poison check handle the decrement on the *next* delivery (or handle here if you prefer).
+             // Standard practice: throw so PubSub handles the backoff and redelivery.
+             // The poison logic at the top of this function will catch it on attempt N+1.
              throw err; 
         }
 
         logger.log('ERROR', `[Worker] ❌ Crash: ${computation}: ${err.message}`); 
-        
         await recordRunAttempt(db, { date, computation, pass }, 'CRASH', {  message: err.message, stack: err.stack, stage: 'SYSTEM_CRASH' }, { durationMs: 0 }, triggerReason);
-        // Throwing triggers Pub/Sub retry
-        throw err; 
+        
+        throw err; // Trigger Pub/Sub retry
     }
 }
 

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

@@ -1,5 +1,6 @@
 # Cloud Workflows Definition for BullTrackers Computation Pipeline
-# Orchestrates 5 sequential passes with Self-Healing (Retry) logic.
+# Orchestrates 5 sequential passes using Event-Driven Callbacks (Zero Polling).
+# UPDATED: Implements "Callback Pattern" to eliminate arbitrary sleeps.
 
 main:
   params: [input]
@@ -12,9 +13,6 @@ main:
           - date_to_run: ${default(map.get(input, "date"), text.substring(time.format(sys.now()), 0, 10))}
           - passes: ["1", "2", "3", "4", "5"]
           - max_retries: 3
-          - propagation_wait_seconds: 300 # 5 Minutes
-          # URL of the new Monitor Function
-          - monitor_url: ${"https://europe-west1-" + project + ".cloudfunctions.net/computation-monitor"}
 
     # ======================================================
     # MAIN LOOP: Iterate through Passes 1 to 5
@@ -28,7 +26,7 @@ main:
                 assign:
                   - attempt_count: 0
                   - pass_success: false
-                  # Construct URL for the specific pass function (e.g. computation-pass-1)
+                  # URL of the Cloud Function acting as the Dispatcher
                   - dispatcher_url: ${"https://europe-west1-" + project + ".cloudfunctions.net/computation-pass-" + pass_id}
 
             # -----------------------------------------------
@@ -42,85 +40,82 @@ main:
                           assign:
                             - attempt_count: ${attempt_count + 1}
                       
+                      # 1. GENERATE CALLBACK URL
+                      # This creates a unique HTTP endpoint that points specifically to this step execution.
+                      - create_callback:
+                          call: sys.create_callback_url
+                          result: callback_url
+
                       - log_start:
                           call: sys.log
                           args:
-                            text: ${"Starting Pass " + pass_id + " (Attempt " + attempt_count + ") for " + date_to_run}
+                            text: ${"Starting Pass " + pass_id + " (Attempt " + attempt_count + ") for " + date_to_run + ". Waiting for signal at " + callback_url}
                             severity: "INFO"
 
-                      # 1. TRIGGER DISPATCHER (Fire and Forget mechanism via HTTP)
+                      # 2. TRIGGER DISPATCHER
+                      # We pass the 'callback_url' to the dispatcher so it can hand it to the workers.
                       - trigger_dispatcher:
-                          call: http.get
+                          call: http.post
                           args:
                             url: ${dispatcher_url}
-                            query:
+                            body:
                               date: ${date_to_run}
+                              callbackUrl: ${callback_url} # <--- CRITICAL: Passing the token
                             auth:
                               type: OIDC
                             timeout: 1800 # 30 mins max for dispatch analysis
                           result: dispatch_response
 
-                      # 2. PROPAGATION WAIT
-                      - wait_for_propagation:
-                          call: sys.log
-                          args:
-                            text: ${"Pass " + pass_id + " dispatched. Waiting " + propagation_wait_seconds + "s for propagation..."}
-                          next: sleep_propagation
-                      
-                      - sleep_propagation:
-                          call: sys.sleep
-                          args:
-                            seconds: ${propagation_wait_seconds}
-
-                      # 3. MONITORING LOOP
-                      - monitor_loop:
-                          call: http.get
-                          args:
-                            url: ${monitor_url}
-                            query:
-                              date: ${date_to_run}
-                              pass: ${pass_id}
-                            auth:
-                              type: OIDC
-                          result: status_resp
-
-                      - evaluate_status:
+                      # 3. CHECK FOR "NOTHING TO DO"
+                      # If the dispatcher found 0 tasks, it returns immediate success. We skip waiting.
+                      - check_immediate_completion:
                           switch:
-                            # CASE A: Still Running -> Sleep and Poll Again
-                            - condition: ${status_resp.body.state == "RUNNING"}
+                            - condition: ${dispatch_response.body.dispatched == 0}
                               steps:
-                                - log_running:
+                                - log_empty:
                                     call: sys.log
                                     args:
-                                      text: ${"Pass " + pass_id + " is RUNNING (" + status_resp.body.activeCount + " active). Waiting..."}
-                                - sleep_polling:
-                                    call: sys.sleep
-                                    args:
-                                      seconds: 60
-                                - continue_monitoring:
-                                    next: monitor_loop
+                                      text: ${"Pass " + pass_id + " had 0 tasks. Moving to next pass immediately."}
+                                - mark_success_empty:
+                                    assign:
+                                      - pass_success: true
+                                - next_pass_empty:
+                                    next: pass_retry_loop
 
-                            # CASE B: Clean Success -> Mark done, Break Retry Loop
-                            - condition: ${status_resp.body.state == "SUCCESS"}
+                      # 4. WAIT FOR WORKER SIGNAL
+                      # The workflow freezes here (sleeps) until a worker hits the callback_url.
+                      # This eliminates the need for polling logic.
+                      - wait_for_completion:
+                          call: sys.await_callback
+                          args:
+                            callback_url: ${callback_url}
+                            timeout: 86400 # Wait up to 24 hours for the batch to finish
+                          result: callback_request
+
+                      # 5. PROCESS SIGNAL
+                      - evaluate_signal:
+                          assign:
+                            - signal_data: ${callback_request.http_request.body}
+                          switch:
+                            - condition: ${signal_data.status == "SUCCESS"}
                               steps:
                                 - log_success:
                                     call: sys.log
                                     args:
-                                      text: ${"Pass " + pass_id + " COMPLETED successfully."}
+                                      text: ${"Pass " + pass_id + " signaled COMPLETION via Callback."}
                                       severity: "INFO"
                                 - mark_success:
                                     assign:
                                       - pass_success: true
-                                - proceed_to_next_pass:
-                                    next: pass_retry_loop # Exits inner loop because pass_success is now true
+                                - proceed:
+                                    next: pass_retry_loop
 
-                            # CASE C: Failures Found -> Continue Retry Loop (will trigger dispatcher again)
-                            - condition: ${status_resp.body.state == "HAS_FAILURES"}
+                            - condition: ${signal_data.status == "FAILURE"}
                               steps:
                                 - log_failure:
                                     call: sys.log
                                     args:
-                                      text: ${"Pass " + pass_id + " has " + status_resp.body.failureCount + " FAILURES. Attempting Retry."}
+                                      text: ${"Pass " + pass_id + " signaled FAILURE (DLQ limit hit). Retrying pass."}
                                       severity: "WARNING"
                                 - retry_pass:
                                     next: pass_retry_loop
@@ -136,7 +131,7 @@ main:
                       - log_giving_up:
                           call: sys.log
                           args:
-                            text: ${"Pass " + pass_id + " failed after " + max_retries + " attempts. Proceeding to next pass with potential gaps."}
+                            text: ${"Pass " + pass_id + " failed after " + max_retries + " attempts. Proceeding with potential gaps."}
                             severity: "ERROR"
 
     - finish:

package/package.json

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