bulltrackers-module 1.0.283 → 1.0.284

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

@@ -1,7 +1,8 @@
 /**
  * FILENAME: computation-system/helpers/computation_dispatcher.js
- * PURPOSE: "Smart Dispatcher" - Analyzes state and only dispatches valid, runnable tasks.
- * UPDATED: Implements Zombie Task Recovery & Dependency Result Hash Passing.
+ * 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.
  */
 
 const { getExpectedDateStrings, normalizeName, DEFINITIVE_EARLIEST_DATES } = require('../utils/utils.js');
@@ -116,7 +117,6 @@ async function dispatchComputationPass(config, dependencies, computationManifest
                     hash: item.hash || item.newHash, 
                     previousCategory: item.previousCategory || null,
                     triggerReason: item.reason || "Unknown",
-                    // [NEW] Pass Content-Based hashes provided by analyzeDateExecution
                     dependencyResultHashes: item.dependencyResultHashes || {},
                     timestamp: Date.now()
                 });
@@ -142,21 +142,25 @@ async function dispatchComputationPass(config, dependencies, computationManifest
                 await db.runTransaction(async (t) => {
                     const doc = await t.get(ledgerRef);
                     
-                    // [NEW] Zombie Task Recovery Check
+                    // [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();
-                        const now = Date.now();
-                        const isPending = data.status === 'PENDING';
-                        // A task is a zombie if it is PENDING and the lease has expired (or lease is missing but it's been > 1h)
-                        const isLeaseExpired = data.leaseExpiresAt && data.leaseExpiresAt < now;
-                        // Fallback: If no lease exists, assume 1 hour timeout for legacy zombie detection
-                        const isLegacyZombie = !data.leaseExpiresAt && data.createdAt && (now - data.createdAt.toMillis() > 3600000);
-
-                        if (isPending && !isLeaseExpired && !isLegacyZombie) {
-                            return false; // Valid active pending task, do not double dispatch
+                        
+                        // 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.
                     }
                     
+                    // Create/Overwrite entry with PENDING to start the cycle
                     t.set(ledgerRef, {
                         status: 'PENDING',
                         dispatchId: task.dispatchId,
@@ -165,8 +169,9 @@ async function dispatchComputationPass(config, dependencies, computationManifest
                         createdAt: new Date(),
                         dispatcherHash: currentManifestHash,
                         triggerReason: task.triggerReason,
-                        retries: 0
+                        retries: 0 // Reset retries for the new attempt
                     }, { merge: true });
+                    
                     return true;
                 });
                 
@@ -191,7 +196,7 @@ async function dispatchComputationPass(config, dependencies, computationManifest
             
             return { dispatched: finalDispatched.length };
         } else {
-            logger.log('INFO', `[Dispatcher] All tasks were already PENDING (Double Dispatch avoided).`);
+            logger.log('INFO', `[Dispatcher] All tasks were already COMPLETED (Double Dispatch avoided).`);
             return { dispatched: 0 };
         }
 

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

@@ -1,7 +1,8 @@
 /**
  * FILENAME: computation-system/helpers/computation_worker.js
  * PURPOSE: Consumes computation tasks from Pub/Sub.
- * UPDATED: Implements Lease Claiming and passes Dependency Hashes.
+ * UPDATED: Fixed "Silent Failure" bug where tasks got stuck in PENDING.
+ * Increased MAX_RETRIES and ensured Ledger is updated on poison messages.
  */
 
 const { executeDispatchTask } = require('../WorkflowOrchestrator.js');
@@ -13,7 +14,10 @@ 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;
-const MAX_RETRIES = 0;
+
+// [FIX] Increased from 0 to 3. 
+// 0 caused "retryCount >= MAX_RETRIES" to trigger immediately on the first run.
+const MAX_RETRIES = 3;
 
 async function handleComputationTask(message, config, dependencies) {
     const systemLogger = new StructuredLogger({ minLevel: config.minLevel || 'INFO', enableStructured: true, ...config });
@@ -35,24 +39,49 @@ async function handleComputationTask(message, config, dependencies) {
     
     if (!date || !pass || !computation) { logger.log('ERROR', `[Worker] Invalid payload.`, data); return; }
 
-    logger.log('INFO', `[Worker] 📥 Received Task: ${computation} (${date})`, { 
+    // [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.
+    if (retryCount > MAX_RETRIES) {
+            logger.log('ERROR', `[Worker] ☠️ Task POISONED. Moved to DLQ: ${computation}`);
+            try {
+                await db.collection('computation_dead_letter_queue').add({
+                    originalData: data,
+                    dispatchId: dispatchId,
+                    error: { message: 'Max Retries Exceeded', stack: 'PubSub delivery limit reached' },
+                    finalAttemptAt: new Date(),
+                    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 });
+
+                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 
     });
 
-    // [NEW] LEASE CLAIMING
-    // Mark task as IN_PROGRESS and set a lease timeout (e.g., 20 minutes) to prevent Zombies
+    // Mark task as IN_PROGRESS (Visual only, dispatcher does not use this for logic anymore)
     try {
-        const leaseTimeMs = (config.workerLeaseMinutes || 20) * 60 * 1000;
         await db.collection(`computation_audit_ledger/${date}/passes/${pass}/tasks`).doc(computation).set({
             status: 'IN_PROGRESS',
             workerId: process.env.K_REVISION || 'unknown',
             startedAt: new Date(),
-            leaseExpiresAt: Date.now() + leaseTimeMs,
             dispatchId: dispatchId
         }, { merge: true });
     } catch (leaseErr) {
-        logger.log('WARN', `[Worker] Failed to claim lease for ${computation}. Continuing anyway...`, leaseErr);
+        logger.log('WARN', `[Worker] Failed to update status to IN_PROGRESS for ${computation}. Continuing...`, leaseErr);
     }
 
     let computationManifest;
@@ -73,7 +102,7 @@ async function handleComputationTask(message, config, dependencies) {
             runDependencies, 
             computationManifest,
             previousCategory,
-            dependencyResultHashes // [NEW] Pass hashes to executor
+            dependencyResultHashes
         );
         const duration = Date.now() - startTime;
 
@@ -121,28 +150,30 @@ async function handleComputationTask(message, config, dependencies) {
                      finalAttemptAt: new Date(),
                      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',
+                    failedAt: new Date()
+                }, { merge: true });
+
                  await recordRunAttempt(db, { date, computation, pass }, 'FAILURE', { message: err.message, stage: err.stage || 'PERMANENT_FAIL' }, { durationMs: 0 }, triggerReason);
                  return; 
              } catch (dlqErr) { logger.log('FATAL', `[Worker] Failed to write to DLQ`, dlqErr); }
         }
 
-        const retryCount = message.deliveryAttempt || 0;
+        // Standard Retryable Error (Crash)
         if (retryCount >= MAX_RETRIES) {
-             logger.log('ERROR', `[Worker] ☠️ Task POISONED. Moved to DLQ: ${computation}`);
-             try {
-                 await db.collection('computation_dead_letter_queue').add({
-                     originalData: data,
-                     dispatchId: dispatchId,
-                     error: { message: err.message, stack: err.stack },
-                     finalAttemptAt: new Date(),
-                     failureReason: 'MAX_RETRIES_EXCEEDED'
-                 });
-                 return;
-             } catch (dlqErr) { logger.log('FATAL', `[Worker] Failed to write to DLQ`, dlqErr); }
+             // We throw here, PubSub will retry, and the "Poison Logic" at the top 
+             // will catch it on the NEXT attempt to finalize the failure.
+             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; 
     }
 }

package/package.json

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