bulltrackers-module 1.0.311 → 1.0.313

package/functions/computation-system/WorkflowOrchestrator.js

@@ -1,6 +1,6 @@
 /**
  * FILENAME: computation-system/WorkflowOrchestrator.js
- * UPDATED: Implements Data-Drift Detection (Content-Addressable Execution).
+ * UPDATED: Implements Early-Skip Optimization for Data-Drift Detection.
  */
 
 const { normalizeName, DEFINITIVE_EARLIEST_DATES }         = require('./utils/utils');
@@ -12,10 +12,6 @@ const { MetaExecutor }                                     = require('./executor
 
 const STATUS_IMPOSSIBLE_PREFIX = 'IMPOSSIBLE';
 
-/**
- * Groups manifest entries by their pass number.
- * Required by the Dispatcher to identify current work-sets.
- */
 function groupByPass(manifest) {
     const passes = {};
     manifest.forEach(calc => {
@@ -25,34 +21,20 @@ function groupByPass(manifest) {
     return passes;
 }
 
-/**
- * Core Short-Circuit Logic.
- * Checks if a dependency is satisfied AND checks for Data Drift.
- * Returns { ready: boolean, dataChanged: boolean, reason: string }
- */
 function isDependencyReady(depName, isHistoricalSelf, currentStatusMap, prevStatusMap, manifestMap, storedStatus) {
     const norm = normalizeName(depName);
     const targetStatus = isHistoricalSelf ? (prevStatusMap ? prevStatusMap[norm] : null) : currentStatusMap[norm];
     const depManifest = manifestMap.get(norm);
     
-    // 1. Availability Check
     if (!targetStatus) return { ready: false, reason: 'Missing' };
     if (String(targetStatus.hash).startsWith(STATUS_IMPOSSIBLE_PREFIX)) return { ready: false, reason: 'Impossible Upstream' };
     
-    // 2. Code Hash Check (The dependency must be running the correct version)
-    // If the dependency's hash doesn't match its manifest, it means the dependency itself needs to run/update first.
     if (depManifest && targetStatus.hash !== depManifest.hash) {
         return { ready: false, reason: 'Dependency Version Mismatch' };
     }
 
-    // 3. Data Integrity Check (The Short-Circuit Logic)
-    // We check if the result hash of the dependency matches what we remember using last time.
     if (storedStatus && storedStatus.dependencyResultHashes) {
         const lastSeenResultHash = storedStatus.dependencyResultHashes[depName];
-        
-        // If we recorded a dependency hash last time, and it differs from the current live status,
-        // then the dependency has produced NEW data. We are NOT ready to skip.
-        // We return 'ready: true' (it exists) but we flag 'dataChanged: true' to force execution.
         if (lastSeenResultHash && targetStatus.resultHash !== lastSeenResultHash) {
              return { ready: true, dataChanged: true, reason: 'Dependency Data Update' };
         }
@@ -61,6 +43,9 @@ function isDependencyReady(depName, isHistoricalSelf, currentStatusMap, prevStat
     return { ready: true, dataChanged: false };
 }
 
+/**
+ * UPDATED: Logic moved to top of loop for early skip on stable data.
+ */
 function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus = null) {
     const report = { runnable: [], blocked: [], impossible: [], failedDependency: [], reRuns: [], skipped: [] };
     const simulationStatus = { ...dailyStatus };
@@ -82,33 +67,56 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
             continue;
         }
 
-        // 2. Dependency & Temporal Check
+        // --- OPTIMIZATION: Early skip if code matches AND data is stable ---
+        if (stored?.hash === currentHash) {
+            let hasDataDrift = false;
+            let isBlocked = false;
+            let missingDeps = [];
+
+            if (calc.dependencies) {
+                for (const dep of calc.dependencies) {
+                    const check = isDependencyReady(dep, false, simulationStatus, null, manifestMap, stored);
+                    if (!check.ready) missingDeps.push(dep);
+                    else if (check.dataChanged) { hasDataDrift = true; break; }
+                }
+            }
+
+            if (!hasDataDrift && missingDeps.length === 0 && calc.isHistorical) {
+                const yesterday = new Date(dateStr + 'T00:00:00Z');
+                yesterday.setUTCDate(yesterday.getUTCDate() - 1);
+                if (yesterday >= DEFINITIVE_EARLIEST_DATES.absoluteEarliest) {
+                    const check = isDependencyReady(calc.name, true, null, prevDailyStatus, manifestMap, stored);
+                    if (!check.ready) isBlocked = true;
+                    else if (check.dataChanged) hasDataDrift = true;
+                }
+            }
+
+            if (!hasDataDrift && !isBlocked && missingDeps.length === 0) {
+                report.skipped.push({ name: cName, reason: "Up To Date" });
+                continue;
+            }
+        }
+        // --- END OPTIMIZATION ---
+
         const missingDeps = [];
-        let hasDataDrift = false; // Tracks if any dependency produced new results
+        let hasDataDrift = false;
         let isBlocked = false;
 
-        // A. Standard Upstream Dependencies
         if (calc.dependencies) {
             for (const dep of calc.dependencies) {
                 const check = isDependencyReady(dep, false, simulationStatus, null, manifestMap, stored);
-                if (!check.ready) {
-                     missingDeps.push(dep);
-                } else if (check.dataChanged) {
-                    hasDataDrift = true;
-                }
+                if (!check.ready) missingDeps.push(dep);
+                else if (check.dataChanged) hasDataDrift = true;
             }
         }
 
-        // B. Temporal Dependency (Yesterday's Self)
         if (calc.isHistorical) {
             const yesterday = new Date(dateStr + 'T00:00:00Z');
             yesterday.setUTCDate(yesterday.getUTCDate() - 1);
-            
-            // Only block if yesterday is a valid data date. 
             if (yesterday >= DEFINITIVE_EARLIEST_DATES.absoluteEarliest) {
                 const check = isDependencyReady(calc.name, true, null, prevDailyStatus, manifestMap, stored);
                 if (!check.ready) isBlocked = true;
-                else if (check.dataChanged) hasDataDrift = true; // Historical drift implies we need to re-run
+                else if (check.dataChanged) hasDataDrift = true;
             }
         }
 
@@ -128,9 +136,6 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
             continue;
         }
 
-        // 3. Execution Decision
-        
-        // Collect current dependency result hashes to be saved if we run
         const currentDependencyResultHashes = {};
         if (calc.dependencies) {
             calc.dependencies.forEach(d => {
@@ -142,23 +147,11 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         const taskPayload = { name: cName, dependencyResultHashes: currentDependencyResultHashes };
 
         if (!stored?.hash) {
-            // Case A: New Calculation (Never run)
             report.runnable.push({ ...taskPayload, reason: "New Calculation" });
-            simulationStatus[cName] = { hash: currentHash, resultHash: 'SIMULATED' };
-        } 
-        else if (stored.hash !== currentHash) {
-            // Case B: Code Hash Mismatch (Logic Changed)
+        } else if (stored.hash !== currentHash) {
             report.reRuns.push({ ...taskPayload, oldHash: stored.hash, newHash: currentHash, reason: "Hash Mismatch" });
-            simulationStatus[cName] = { hash: currentHash, resultHash: 'SIMULATED' };
-        } 
-        else if (hasDataDrift) {
-            // Case C: Code Matches, BUT Input Data Changed (The Holy Grail Optimization)
+        } else if (hasDataDrift) {
             report.runnable.push({ ...taskPayload, reason: "Input Data Changed" });
-            simulationStatus[cName] = { hash: currentHash, resultHash: 'SIMULATED' };
-        } 
-        else {
-            // Case D: Code Matches AND Data Matches -> Short Circuit
-            report.skipped.push({ name: cName, reason: "Up To Date" });
         }
     }
     return report;
@@ -170,9 +163,6 @@ async function executeDispatchTask(dateStr, pass, targetComputation, config, dep
     const calcManifest = manifestMap.get(normalizeName(targetComputation));
     
     if (!calcManifest) throw new Error(`Calc '${targetComputation}' not found.`);
-    
-    // [CRITICAL] Inject the fresh dependency result hashes so they are saved to DB on commit.
-    // This enables the "lastSeenResultHash" check in future runs.
     calcManifest.dependencyResultHashes = dependencyResultHashes;
 
     const rootData = await checkRootDataAvailability(dateStr, config, dependencies, DEFINITIVE_EARLIEST_DATES);

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

@@ -1,7 +1,7 @@
 /**
  * FILENAME: computation-system/helpers/computation_dispatcher.js
  * PURPOSE: Sequential Cursor-Based Dispatcher with Hyper-Verbose Telemetry.
- * FIX: Added dispatchId generation and triggerReason mapping.
+ * UPDATED: Sweep mode now auto-upgrades missed tasks to high-mem due to potential silent OOMs.
  */
 
 const { getExpectedDateStrings, getEarliestDataDates, normalizeName, DEFINITIVE_EARLIEST_DATES } = require('../utils/utils.js');
@@ -9,7 +9,7 @@ const { groupByPass, analyzeDateExecution } = require('../WorkflowOrchestrator.j
 const { PubSubUtils } = require('../../core/utils/pubsub_utils');
 const { fetchComputationStatus } = require('../persistence/StatusRepository');
 const { checkRootDataAvailability } = require('../data/AvailabilityChecker');
-const crypto = require('crypto'); // [NEW] Required for dispatchId
+const crypto = require('crypto'); 
 
 const OOM_THRESHOLD_MB = 1500; 
 const SECONDS_PER_CALC_MARGIN = 25; 
@@ -43,14 +43,12 @@ async function dispatchComputationPass(config, dependencies, computationManifest
     const targetCursorN = parseInt(reqBody.cursorIndex || 1);
     const dateLimitStr  = reqBody.date || config.date || "2025-01-01"; 
 
-    logger.log('INFO', `[Dispatcher] 🚀 STARTING DISPATCH: Pass ${passToRun}, Cursor ${targetCursorN}, Limit ${dateLimitStr}`);
-
     const manifestMap     = new Map(computationManifest.map(c => [normalizeName(c.name), c]));
     const passes          = groupByPass(computationManifest);
     const calcsInThisPass = passes[passToRun] || [];
 
     if (!calcsInThisPass.length) {
-        logger.log('WARN', `[Dispatcher] 🛑 No calculations found for Pass ${passToRun}. Moving to next pass.`);
+        logger.log('WARN', `[Dispatcher] 🛑 No calculations found for Pass ${passToRun}.`);
         return { status: 'MOVE_TO_NEXT_PASS', dispatched: 0 };
     }
 
@@ -62,6 +60,7 @@ async function dispatchComputationPass(config, dependencies, computationManifest
         return { status: 'MOVE_TO_NEXT_PASS', dispatched: 0 };
     }
 
+    // 1. Identify all "Dirty" dates (dates that actually have work to do)
     const dirtyDates = [];
     for (const d of allDates) {
         const dailyStatus  = await fetchComputationStatus(d, config, dependencies);
@@ -82,10 +81,10 @@ async function dispatchComputationPass(config, dependencies, computationManifest
     let isReroute     = false;
     let isSweep       = false;
 
+    // Logic for Reroutes (Known OOM handling)
     if (targetCursorN > 1 && (targetCursorN - 2) < dirtyDates.length) {
         const prevEntry = dirtyDates[targetCursorN - 2];
         const reroutes  = await getHighMemReroutes(db, prevEntry.date, passToRun, prevEntry.tasks);
-        
         if (reroutes.length > 0) {
             selectedDate  = prevEntry.date;
             selectedTasks = reroutes;
@@ -93,24 +92,47 @@ async function dispatchComputationPass(config, dependencies, computationManifest
         }
     }
 
+    // Logic for standard cursor progression or Sweep (Recovery) mode
     if (!selectedDate) {
         if (targetCursorN <= dirtyDates.length) {
             const entry   = dirtyDates[targetCursorN - 1];
             selectedDate  = entry.date;
             selectedTasks = entry.tasks;
         } else if (dirtyDates.length > 0) {
+            // RECOVERY/SWEEP MODE:
+            // The cursor has passed the number of dirty dates, but tasks still remain.
+            // These tasks are automatically routed to 'high-mem' with recovery reasoning.
             isSweep       = true;
             selectedDate  = dirtyDates[0].date;
-            selectedTasks = dirtyDates[0].tasks;
+            selectedTasks = dirtyDates[0].tasks.map(t => ({
+                ...t,
+                resources: 'high-mem',
+                reason: `${t.reason || 'Missed Computation'} [RECOVERY_AUTO_UPGRADE: Potential Silent OOM]`
+            }));
         }
     }
 
     if (!selectedDate) {
+        logger.log('INFO', `[Dispatcher] 🏁 Pass ${passToRun} is fully satiated. No work remaining.`);
         return { status: 'MOVE_TO_NEXT_PASS', dispatched: 0, etaSeconds: 0 };
     }
 
-    // [FIX] Generate unique Dispatch ID for this wave and map triggerReason
+    // 2. Prepare Payload and Telemetry
     const currentDispatchId = crypto.randomUUID();
+    const etaSeconds = Math.max(20, selectedTasks.length * SECONDS_PER_CALC_MARGIN);
+    const remainingDatesCount = Math.max(0, dirtyDates.length - targetCursorN);
+
+    const computationNames = selectedTasks.map(t => t.name);
+
+    logger.log('INFO', `[Dispatcher] ✅ Dispatching ${selectedTasks.length} tasks for ${selectedDate}. ETA: ${etaSeconds}s. [Mode: ${isSweep ? 'RECOVERY' : 'NORMAL'}]`, {
+        date: selectedDate,
+        pass: passToRun,
+        dispatchedCount: selectedTasks.length,
+        remainingCursorDates: remainingDatesCount,
+        etaSeconds: etaSeconds,
+        dispatchId: currentDispatchId,
+        tasks: computationNames 
+    });
 
     const mapToTaskPayload = (t) => ({
         ...t,
@@ -118,8 +140,9 @@ async function dispatchComputationPass(config, dependencies, computationManifest
         computation: t.name,
         date: selectedDate,
         pass: passToRun,
-        dispatchId: currentDispatchId, // [NEW] Added for Worker Audit Lease
-        triggerReason: t.reason        // [NEW] Map 'reason' from Orchestrator to 'triggerReason'
+        dispatchId: currentDispatchId,
+        triggerReason: t.reason,
+        resources: t.resources || 'standard'
     });
 
     const standardTasks = selectedTasks.filter(t => t.resources !== 'high-mem').map(mapToTaskPayload);
@@ -142,14 +165,13 @@ async function dispatchComputationPass(config, dependencies, computationManifest
     }
     await Promise.all(pubPromises);
 
-    const etaSeconds = Math.max(20, selectedTasks.length * SECONDS_PER_CALC_MARGIN);
-    
     return {
         status          : isSweep ? 'RECOVERY' : 'CONTINUE_PASS',
         dateProcessed   : selectedDate,
         dispatched      : selectedTasks.length,
         n_cursor_ignored: isReroute,
-        etaSeconds      : etaSeconds
+        etaSeconds      : etaSeconds,
+        remainingDates  : remainingDatesCount 
     };
 }
 

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

@@ -75,13 +75,13 @@ async function handleComputationTask(message, config, dependencies) {
 
         const calcUpdate = successUpdates[normalizeName(computation)] || {};
         const metrics = {
-            durationMs: Date.now() - startTime,
-            peakMemoryMB: heartbeat.getPeak(),
-            io: calcUpdate.metrics?.io,
-            storage: calcUpdate.metrics?.storage,
-            execution: calcUpdate.metrics?.execution,
-            validation: calcUpdate.metrics?.validation,
-            composition: calcUpdate.composition
+            durationMs:    Date.now() - startTime,
+            peakMemoryMB:  heartbeat.getPeak(),
+            io:            calcUpdate.metrics?.io,
+            storage:       calcUpdate.metrics?.storage,
+            execution:     calcUpdate.metrics?.execution,
+            validation:    calcUpdate.metrics?.validation,
+            composition:   calcUpdate.composition
         };
 
         await db.doc(ledgerPath).update({ status: 'COMPLETED', completedAt: new Date() });

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

@@ -2,6 +2,7 @@
  * @fileoverview Monitor helper for Cloud Workflows.
  * Checks the state of the Audit Ledger to determine if a pass is complete.
  * This function is stateless and receives dependencies via injection.
+ * THIS FILE IS NOW REDUNDANT, LOGIC HAS MOVED TO THE DISPATCHER AND WORKFLOW
  */
 
 /**

package/functions/computation-system/persistence/ResultCommitter.js

@@ -29,7 +29,15 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     const shardIndexes     = options.shardIndexes || {};
     const nextShardIndexes = {};
     const fanOutLimit      = pLimit(10); 
-    const contractMap      = await fetchContracts(db, Object.keys(stateObj));
+
+    // 1. [BATCH OPTIMIZATION] Fetch all SimHashes and Contracts upfront
+    const calcNames = Object.keys(stateObj);
+    const hashKeys  = calcNames.map(n => stateObj[n].manifest?.hash).filter(Boolean);
+    
+    const [contractMap, simHashMap] = await Promise.all([
+        fetchContracts(db, calcNames),
+        batchFetchSimHashes(db, hashKeys)
+    ]);
 
     for (const name in stateObj) {
         const calc      = stateObj[name];
@@ -40,13 +48,11 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
             storage:    { sizeBytes: 0, isSharded: false, shardCount: 1, keys: 0 },
             validation: { isValid: true, anomalies: [] },
             execution: execStats,
-            // [NEW] Track Ops
             io: { writes: 0, deletes: 0 }
         };
 
         try {
             const result = await calc.getResult();
-            
             const configOverrides = validationOverrides[calc.manifest.name] || {};
             const dataDeps = calc.manifest.rootDataDependencies || [];
             const isPriceOnly = (dataDeps.length === 1 && dataDeps[0] === 'price');
@@ -81,13 +87,8 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
             const isEmpty = !result || (typeof result === 'object' && Object.keys(result).length === 0);
             const resultHash = isEmpty ? 'empty' : generateDataHash(result);
             
-            let simHash = null;
-            if (calc.manifest.hash && flushMode !== 'INTERMEDIATE') {
-                 try {
-                    const regDoc = await db.collection(SIMHASH_REGISTRY_COLLECTION).doc(calc.manifest.hash).get();
-                    if (regDoc.exists) simHash = regDoc.data().simHash;
-                } catch (e) {}
-            }
+            // [NEW] Use pre-fetched SimHash
+            const simHash = (flushMode !== 'INTERMEDIATE') ? (simHashMap[calc.manifest.hash] || null) : null;
 
             if (isEmpty) { 
                 if (flushMode === 'INTERMEDIATE') { nextShardIndexes[name] = currentShardIndex; continue; }
@@ -112,8 +113,6 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
                     if (!dailyData || Object.keys(dailyData).length === 0) return;
                     const historicalDocRef = db.collection(config.resultsCollection).doc(historicalDate).collection(config.resultsSubcollection).doc(calc.manifest.category).collection(config.computationsSubcollection).doc(name);
                     const stats = await writeSingleResult(dailyData, historicalDocRef, name, historicalDate, logger, config, deps, 0, 'STANDARD', false);
-                    
-                    // Aggregate IO Ops
                     runMetrics.io.writes += stats.opCounts.writes;
                     runMetrics.io.deletes += stats.opCounts.deletes;
                 }));
@@ -158,6 +157,17 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     return { successUpdates, failureReport, shardIndexes: nextShardIndexes };
 }
 
+async function batchFetchSimHashes(db, hashes) {
+    if (!hashes || hashes.length === 0) return {};
+    const map = {};
+    const refs = hashes.map(h => db.collection(SIMHASH_REGISTRY_COLLECTION).doc(h));
+    try {
+        const snaps = await db.getAll(...refs);
+        snaps.forEach(snap => { if (snap.exists) map[snap.id] = snap.data().simHash; });
+    } catch (e) {}
+    return map;
+}
+
 async function fetchContracts(db, calcNames) {
     if (!calcNames || calcNames.length === 0) return {};
     const map = {};

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

@@ -1,6 +1,5 @@
 # Cloud Workflows: Precision Cursor-Based Orchestrator
-# PURPOSE: Orchestrates 5 passes with dynamic date detection and cursor logic.
-# UPDATED: Added Short-Circuit logic to break infinite loops on empty dispatches.
+# UPDATED: Added satiation detection to break early on 0 remaining dates.
 
 main:
   params: [input]
@@ -9,15 +8,9 @@ main:
         assign:
           - project: '${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}'
           - passes: ["1", "2", "3", "4", "5"]
-          # Dynamically calculate today's date (YYYY-MM-DD) if no date is provided in input
           - current_date: '${text.split(time.format(sys.now()), "T")[0]}'
           - date_to_run: '${default(map.get(input, "date"), current_date)}'
 
-    - log_start:
-        call: sys.log
-        args:
-          text: '${"Starting Pipeline execution. Target Date Limit: " + date_to_run}'
-
     - run_sequential_passes:
         for:
           value: pass_id
@@ -27,7 +20,7 @@ main:
                 assign:
                   - n_cursor: 1
                   - pass_complete: false
-                  - consecutive_empty_dispatches: 0 # Track consecutive "duds" to prevent infinite loops
+                  - consecutive_empty_dispatches: 0
 
             - sequential_date_loop:
                 switch:
@@ -46,34 +39,36 @@ main:
 
                       - evaluate_dispatch:
                           switch:
-                            # State 1: Dispatcher signal to move to the next pass
                             - condition: '${dispatch_res.body.status == "MOVE_TO_NEXT_PASS"}'
                               assign:
                                 - pass_complete: true
                             
-                            # State 2: Tasks were dispatched (Healthy State)
+                            # NEW: Explicit Satiation Check
+                            - condition: '${dispatch_res.body.status == "CONTINUE_PASS" and dispatch_res.body.remainingDates == 0}'
+                              steps:
+                                - log_satiation:
+                                    call: sys.log
+                                    args:
+                                      text: '${"Pass " + pass_id + " - ✅ Pass satiated (0 remaining dates). Moving to next pass."}'
+                                - mark_complete:
+                                    assign:
+                                      - pass_complete: true
+
                             - condition: '${dispatch_res.body.dispatched > 0}'
                               steps:
                                 - reset_retry_counter:
                                     assign:
-                                      - consecutive_empty_dispatches: 0 # Reset counter because progress was made
-                                - log_dispatch:
-                                    call: sys.log
-                                    args:
-                                      text: '${"Pass " + pass_id + " - Dispatching " + string(dispatch_res.body.dispatched) + " tasks for " + dispatch_res.body.dateProcessed + ". ETA: " + string(dispatch_res.body.etaSeconds) + "s."}'
+                                      - consecutive_empty_dispatches: 0
                                 - wait_for_completion:
                                     call: sys.sleep
                                     args:
                                       seconds: '${int(dispatch_res.body.etaSeconds)}'
                                 - update_cursor:
                                     assign:
-                                      # If n_cursor_ignored is true, stay on same N to retry (e.g. for high-mem)
                                       - n_cursor: '${if(dispatch_res.body.n_cursor_ignored, n_cursor, n_cursor + 1)}'
                                 - next_loop_work:
                                     next: sequential_date_loop
 
-                            # State 3: No tasks dispatched (Potential Infinite Loop Scenario)
-                            # The Dispatcher is "Continuing" but found nothing runnable on the target date.
                             - condition: '${dispatch_res.body.dispatched == 0}'
                               steps:
                                 - increment_retry:
@@ -81,33 +76,19 @@ main:
                                       - consecutive_empty_dispatches: '${consecutive_empty_dispatches + 1}'
                                 - check_break_condition:
                                     switch:
-                                      # If we have tried 3 times in a row with 0 results, assume the date is "stuck"
                                       - condition: '${consecutive_empty_dispatches >= 3}'
-                                        steps:
-                                          - log_break:
-                                              call: sys.log
-                                              args:
-                                                text: '${"Pass " + pass_id + " - 🛑 FORCE BREAK: 3 consecutive empty dispatches. Moving to next pass to prevent infinite loop."}'
-                                          - force_complete:
-                                              assign:
-                                                - pass_complete: true
-                                      # Otherwise, wait briefly and retry (or move cursor depending on dispatcher logic)
+                                        assign:
+                                          - pass_complete: true
                                       - condition: '${true}'
                                         steps:
-                                          - log_retry:
-                                              call: sys.log
-                                              args:
-                                                text: '${"Pass " + pass_id + " - Empty dispatch (" + string(consecutive_empty_dispatches) + "/3). Retrying..."}'
                                           - wait_short:
                                               call: sys.sleep
                                               args:
                                                 seconds: 5
                                           - update_cursor_retry:
                                               assign:
-                                                 # Still advance cursor if it wasn't a strict reroute, to try next date
                                                  - n_cursor: '${if(dispatch_res.body.n_cursor_ignored, n_cursor, n_cursor + 1)}'
                                           - next_loop_retry:
                                               next: sequential_date_loop
-
     - finish:
         return: "Pipeline Execution Satiated and Complete"

package/package.json

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