bulltrackers-module 1.0.756 → 1.0.758

package/functions/computation-system-v2/config/bulltrackers.config.js

@@ -278,9 +278,11 @@ module.exports = {
             timezone: 'UTC'
         },
         
-        // Minimum gap between dependent computations (minutes)
-        // Pass 1 @ 14:00 → Pass 2 must be >= 14:15
-        dependencyGapMinutes: 15
+        // Minimum gap between dependent computations (minutes).
+        // When a computation completes, its direct dependents are scheduled
+        // via Cloud Tasks to run at least this many minutes after the latest
+        // dependency completion time (see Orchestrator._scheduleDependents).
+        dependencyGapMinutes: 5
     },
     
     // =========================================================================

package/functions/computation-system-v2/framework/execution/Orchestrator.js

@@ -15,6 +15,7 @@
 
 const crypto = require('crypto');
 const pLimit = require('p-limit');
+const { CloudTasksClient } = require('@google-cloud/tasks');
 
 // Core Components
 const { ManifestBuilder } = require('../core/Manifest');
@@ -82,12 +83,17 @@ class Orchestrator {
         this.manifest = null;
         this.runAnalyzer = null;
         this.referenceDataCache = {};
+        this.dependentsByName = new Map();
+
+        // Cloud Tasks client for dependency-driven cascading
+        this.cloudTasksClient = new CloudTasksClient();
     }
 
     async initialize() {
         this._log('INFO', 'Initializing Orchestrator...');
         this.manifest = this.manifestBuilder.build(this.config.computations || []);
         this.runAnalyzer = new RunAnalyzer(this.manifest, this.dataFetcher, this.logger);
+        this._buildDependentsIndex();
         await this.schemaRegistry.warmCache(this._getAllTables());
         await this._loadReferenceData();
         this._log('INFO', `Initialized with ${this.manifest.length} computations`);
@@ -244,9 +250,19 @@ class Orchestrator {
                     hash: entry.hash,
                     resultHash: stats.hash,
                     dependencyResultHashes: depResultHashes,
-                    entityCount: stats.count
+                    entityCount: stats.count,
+                    updatedAt: new Date().toISOString()
                 });
                 await this.lineageMiddleware.flush();
+
+                // Trigger dependency-driven cascading for downstream computations.
+                // This will enqueue Cloud Tasks for any dependents whose full
+                // dependency set has completed for the given date.
+                try {
+                    await this._scheduleDependents(entry, dateStr);
+                } catch (cascadeError) {
+                    this._log('WARN', `Failed to schedule dependents for ${entry.name}: ${cascadeError.message}`);
+                }
             }
 
             return { name, status: 'completed', duration: Date.now() - startTime, resultCount: stats.count };
@@ -676,6 +692,129 @@ class Orchestrator {
         return prefetched;
     }
 
+    /**
+     * Build a reverse dependency index so that when a computation completes
+     * we can quickly find all computations that depend on it.
+     */
+    _buildDependentsIndex() {
+        this.dependentsByName = new Map();
+        if (!this.manifest) return;
+
+        for (const entry of this.manifest) {
+            for (const dep of entry.dependencies || []) {
+                if (!this.dependentsByName.has(dep)) {
+                    this.dependentsByName.set(dep, []);
+                }
+                this.dependentsByName.get(dep).push(entry);
+            }
+        }
+    }
+
+    /**
+     * Schedule dependent computations via Cloud Tasks after a computation
+     * has successfully completed for a given date.
+     *
+     * The scheduler is responsible only for root / pass-1 computations.
+     * All downstream work is triggered here with a configurable time gap
+     * once ALL dependencies of a computation have completed.
+     */
+    async _scheduleDependents(entry, dateStr) {
+        const dependents = this.dependentsByName.get(entry.name);
+        if (!dependents || dependents.length === 0) return;
+
+        const cloudTasksConfig = this.config.cloudTasks;
+        if (!cloudTasksConfig) {
+            this._log('WARN', 'cloudTasks config missing; skipping dependent scheduling');
+            return;
+        }
+
+        const { projectId, location, queueName, dispatcherUrl, serviceAccountEmail } = cloudTasksConfig;
+        if (!projectId || !location || !queueName || !dispatcherUrl || !serviceAccountEmail) {
+            this._log('WARN', 'cloudTasks configuration incomplete; skipping dependent scheduling');
+            return;
+        }
+
+        const dependencyGapMinutes = this.config.scheduling?.dependencyGapMinutes ?? 5;
+        const queuePath = this.cloudTasksClient.queuePath(projectId, location, queueName);
+
+        // Use the latest in-memory status for this date so we can see the
+        // just-updated computation plus any earlier ones.
+        const dailyStatus = await this.stateRepository.getDailyStatus(dateStr);
+
+        for (const depEntry of dependents) {
+            // Compute the latest completion time across all of this computation's dependencies.
+            let latestDependencyTime = null;
+            let missingDependency = false;
+
+            for (const depName of depEntry.dependencies || []) {
+                const depStatus = dailyStatus.get(depName);
+                if (!depStatus || !depStatus.updatedAt) {
+                    missingDependency = true;
+                    break;
+                }
+
+                const ts = new Date(depStatus.updatedAt.value || depStatus.updatedAt);
+                if (Number.isNaN(ts.getTime())) continue;
+
+                if (!latestDependencyTime || ts > latestDependencyTime) {
+                    latestDependencyTime = ts;
+                }
+            }
+
+            // If any dependency hasn't completed yet, we will schedule this
+            // dependent when that dependency finishes instead.
+            if (missingDependency || !latestDependencyTime) {
+                continue;
+            }
+
+            const scheduleTime = new Date(latestDependencyTime.getTime() + dependencyGapMinutes * 60 * 1000);
+
+            const payload = {
+                computationName: depEntry.originalName,
+                targetDate: dateStr,
+                source: 'dependency',
+                scheduledAt: scheduleTime.toISOString()
+            };
+
+            const taskName = `${queuePath}/tasks/${depEntry.name}-${dateStr}`;
+
+            const task = {
+                httpRequest: {
+                    httpMethod: 'POST',
+                    url: dispatcherUrl,
+                    headers: { 'Content-Type': 'application/json' },
+                    body: Buffer.from(JSON.stringify(payload)).toString('base64'),
+                    oidcToken: {
+                        serviceAccountEmail,
+                        audience: dispatcherUrl
+                    }
+                },
+                scheduleTime: {
+                    seconds: Math.floor(scheduleTime.getTime() / 1000),
+                    nanos: 0
+                },
+                name: taskName
+            };
+
+            try {
+                await this.cloudTasksClient.createTask({
+                    parent: queuePath,
+                    task
+                });
+
+                this._log('INFO', `Scheduled dependent ${depEntry.name} for ${dateStr} at ${scheduleTime.toISOString()}`);
+            } catch (e) {
+                // Code 6: ALREADY_EXISTS – task already scheduled, this is fine (idempotent)
+                if (e.code === 6) {
+                    this._log('INFO', `Dependent ${depEntry.name} for ${dateStr} already scheduled (duplicate task ignored)`);
+                    continue;
+                }
+
+                this._log('WARN', `Failed to schedule dependent ${depEntry.name}: ${e.message}`);
+            }
+        }
+    }
+
     async _lazyLoadDependency(dateStr, depName, entityId, preloaded) {
         if (preloaded[depName] && !entityId) return preloaded[depName];
         if (preloaded[depName] && entityId) return preloaded[depName][entityId];

package/functions/computation-system-v2/framework/storage/StorageManager.js

@@ -523,9 +523,6 @@ class StorageManager {
         
         await this._ensureBigQueryTable(targetTable);
 
-        // FIX: Added SAFE.PARSE_JSON() to BOTH dependency_result_hashes AND result_data
-        // The source (temp table) has these as STRING (from the JSON file).
-        // The destination (target table) has these as JSON types.
         const mergeQuery = `
             MERGE INTO ${fullTarget} T
             USING (
@@ -550,7 +547,24 @@ class StorageManager {
                         SAFE.PARSE_JSON(S.dependency_result_hashes), S.entity_count, SAFE.PARSE_JSON(S.result_data), S.updated_at)
         `;
         
-        await this.bigquery.query({ query: mergeQuery, location: this.config.bigquery.location });
+        // UPDATE: Use createQueryJob to capture DML statistics
+        try {
+            const [job] = await this.bigquery.createQueryJob({ 
+                query: mergeQuery, 
+                location: this.config.bigquery.location 
+            });
+            
+            await job.getQueryResults(); // Wait for completion
+            
+            const metadata = await job.getMetadata();
+            const stats = metadata[0]?.statistics?.query;
+            const affectedRows = stats?.numDmlAffectedRows;
+
+            this._log('INFO', `Merge complete on ${targetTable}. Rows affected (Inserted/Updated): ${affectedRows}`);
+        } catch (e) {
+            this._logError(`Merge Failed on ${targetTable}`, e);
+            throw e;
+        }
     }
 
     async _cleanupGCSFiles(bucketName, prefix) {

package/functions/computation-system-v2/handlers/dispatcher.js

@@ -77,19 +77,19 @@ exports.dispatcherHandler = async (req, res) => {
             });
         } 
         
-        // 4. HANDLE BLOCKS (The Critical Retry Logic)
-        // If Orchestrator says "blocked", we MUST return 503 for Cloud Tasks to retry.
+        // 4. HANDLE NON-RUNNABLE STATES (Blocked / Impossible)
+        // NEW BEHAVIOUR:
+        // - We NEVER return 503 for logical states like "blocked" or "impossible".
+        // - Cloud Tasks retries are reserved for genuine execution failures (5xx from errors).
+        // - Scheduler + dependency cascade should avoid dispatching truly blocked tasks;
+        //   if we still see them here, we surface the status once and BIN the task.
         if (result.status === 'blocked' || result.status === 'impossible') {
-            console.log(`[Dispatcher] ${computationName} blocked: ${result.reason}`);
-            
-            // Scheduled tasks need 503 to trigger retry
-            // On-demand users need 200 to see the error message immediately
-            const httpStatus = source === 'scheduled' || source === 'zombie-recovery' ? 503 : 200;
-            
-            return res.status(httpStatus).json({
+            console.log(`[Dispatcher] ${computationName} ${result.status}: ${result.reason}`);
+
+            return res.status(200).json({
                 status: result.status,
                 reason: result.reason,
-                message: `Computation blocked: ${result.reason}`
+                message: `Computation ${result.status}: ${result.reason}`
             });
         }
 

package/functions/computation-system-v2/handlers/scheduler.js

@@ -1,14 +1,14 @@
 /**
- * @fileoverview Unified Computation Scheduler
+ * @fileoverview Unified Computation Scheduler (Refactored for Rolling Window)
  * * Triggered every minute.
- * 1. Dispatches normally scheduled tasks.
- * 2. Monitors for "Zombies" (tasks that crashed and haven't updated heartbeat).
- * 3. Re-queues zombies to Cloud Tasks for recovery.
+ * * RESPONSIBILITY: Schedule ROOT tasks (Pass 0) only.
+ * * STRATEGY: Look ahead 1 hour. Dispatch tasks with 'scheduleTime'. 
+ * * DEDUPLICATION: Handled by Cloud Tasks 'name' property.
  */
 
 const { CloudTasksClient } = require('@google-cloud/tasks');
 const pLimit = require('p-limit');
-const { ManifestBuilder, ScheduleValidator } = require('../framework');
+const { ManifestBuilder } = require('../framework');
 const { StorageManager } = require('../framework/storage/StorageManager');
 const config = require('../config/bulltrackers.config');
 
@@ -25,7 +25,8 @@ async function initialize() {
     console.log('[Scheduler] Initializing...');
     
     // Core Services
-    const builder = new ManifestBuilder(config, { log: (l, m) => console.log(`[${l}] ${m}`) });
+    // We pass a no-op logger to ManifestBuilder to keep logs clean during frequent scheduling
+    const builder = new ManifestBuilder(config, { log: () => {} });
     manifest = builder.build(config.computations || []);
     
     // Infrastructure
@@ -41,16 +42,23 @@ async function schedulerHandler(req, res) {
     try {
         await initialize();
         
-        const now = floorToMinute(new Date());
-        const targetDate = formatDate(now);
-        const currentTime = formatTime(now);
+        const now = new Date(); // Exact current time
+        const targetDate = now.toISOString().split('T')[0];
+
+        // 1. ROLLING WINDOW SCHEDULE
+        // Strategy: Look ahead 60 minutes. 
+        // If a task is due in this window, we dispatch it to Cloud Tasks with a 'scheduleTime'.
+        // Cloud Tasks deduplication (via task name) ensures we don't schedule it twice.
+        const windowEnd = new Date(now.getTime() + 60 * 60 * 1000);
         
-        console.log(`[Scheduler] Running for ${targetDate} ${currentTime}`);
+        const dueComputations = findDueComputations(now, windowEnd);
         
-        // 1. STANDARD SCHEDULE
-        const dueComputations = findDueComputations(now);
-        
-        // 2. ZOMBIE DETECTION
+        if (dueComputations.length > 0) {
+            console.log(`[Scheduler] Found ${dueComputations.length} Pass 0 tasks due between ${formatTime(now)} and ${formatTime(windowEnd)}`);
+        }
+
+        // 2. ZOMBIE DETECTION (Preserved from v1)
+        // Checks for tasks that started >15 mins ago but have no result and no recent heartbeat
         let zombies = [];
         try {
             zombies = await storageManager.findZombies(ZOMBIE_THRESHOLD_MINUTES);
@@ -59,49 +67,46 @@ async function schedulerHandler(req, res) {
                 const zombieDetails = zombies.map(z => `${z.name} [${z.date}]`).join(', ');
                 console.log(`[Scheduler] DETECTED ${zombies.length} ZOMBIES: ${zombieDetails}`);
 
-                // --- NEW FIX: CLAIM ZOMBIES ---
-                // "Touch" these rows in the DB so they don't look like zombies for another 15 mins.
-                // This prevents re-dispatching the same task 15 times if the queue is slow.
+                // Claim zombies in DB to prevent re-dispatching in the next minute's run
                 await Promise.all(zombies.map(z => 
                     storageManager.claimZombie(z.checkpointId) 
                 ));
-                // ------------------------------
             }
         } catch (e) {
             console.error(`[Scheduler] Zombie check failed: ${e.message}`);
         }
 
-        const totalTasks = dueComputations.length + zombies.length;
-
-        if (totalTasks === 0) {
+        // 3. EXIT IF NOTHING TO DO
+        if (dueComputations.length === 0 && zombies.length === 0) {
             return res.status(200).json({ status: 'ok', message: 'Nothing due' });
         }
-        
-        // 3. DISPATCH BOTH
-        // We map zombies to the format expected by dispatch logic
+
+        // 4. PREPARE PAYLOADS
+        // Map zombies to the same structure as scheduled tasks
         const zombieEntries = zombies.map(z => {
             const originalEntry = manifest.find(m => m.name === z.name);
-            if (!originalEntry) return null; // Manifest changed?
+            if (!originalEntry) return null;
             
             return {
                 ...originalEntry,
-                isRecovery: true, // Flag for logging
-                originalDate: z.date, // Preserve original run date
-                recoveryId: z.checkpointId // For unique task naming
+                isRecovery: true,
+                originalDate: z.date,
+                recoveryId: z.checkpointId,
+                runAt: 0 // Run immediately
             };
         }).filter(Boolean);
 
         const allTasks = [...dueComputations, ...zombieEntries];
 
-        const results = await dispatchComputations(allTasks, targetDate, now);
+        const results = await dispatchComputations(allTasks, targetDate);
         
         const duration = Date.now() - startTime;
-        const succeeded = results.filter(r => r.status === 'dispatched').length;
         
         return res.status(200).json({
             status: 'ok',
-            dispatched: succeeded,
-            zombiesFound: zombies.length,
+            dispatched: results.filter(r => r.status === 'dispatched').length,
+            duplicates: results.filter(r => r.status === 'skipped').length,
+            errors: results.filter(r => r.status === 'error').length,
             duration,
             results
         });
@@ -112,114 +117,122 @@ async function schedulerHandler(req, res) {
     }
 }
 
-function findDueComputations(now) {
+/**
+ * Identify Pass 0 (Root) computations due within the time window.
+ */
+function findDueComputations(now, windowEnd) {
     const due = [];
-    const currentHour = now.getUTCHours();
-    const currentMinute = now.getUTCMinutes();
-    const currentTime = `${String(currentHour).padStart(2, '0')}:${String(currentMinute).padStart(2, '0')}`;
-    const dayOfWeek = now.getUTCDay();
-    const dayOfMonth = now.getUTCDate();
     
     for (const entry of manifest) {
-        const schedule = entry.schedule;
-        if (isScheduleDue(schedule, currentTime, dayOfWeek, dayOfMonth)) {
-            due.push(entry);
+        // FILTER: Only Roots / Pass 0
+        // Any computation with dependencies is handled by the Orchestrator/Cascade system, not the Scheduler.
+        if (Array.isArray(entry.dependencies) && entry.dependencies.length > 0) {
+            continue;
+        }
+
+        const nextRun = getNextExecutionTime(entry.schedule, now);
+        
+        // CHECK: Is the calculated run time strictly within our window?
+        // Note: nextRun might be null if it doesn't run today (e.g. wrong day of week)
+        if (nextRun && nextRun >= now && nextRun <= windowEnd) {
+            due.push({
+                ...entry,
+                runAt: nextRun.getTime() / 1000 // Convert to Seconds for Cloud Tasks
+            });
         }
     }
     return due;
 }
 
-function isScheduleDue(schedule, currentTime, dayOfWeek, dayOfMonth) {
-    const scheduleTime = schedule.time || '02:00';
-    const [scheduleHour, scheduleMinute] = scheduleTime.split(':').map(Number);
-    const [currentHour, currentMinuteNum] = currentTime.split(':').map(Number);
+/**
+ * Calculate the specific execution Date object for a schedule relative to 'now'.
+ */
+function getNextExecutionTime(schedule, now) {
+    // Simple implementation for Daily/Hourly schedules
+    // Format expected: "HH:mm" (24-hour)
+    const [h, m] = (schedule.time || '02:00').split(':').map(Number);
+    const target = new Date(now);
+    target.setUTCHours(h, m, 0, 0);
     
-    switch (schedule.frequency) {
-        case 'hourly': return scheduleMinute === currentMinuteNum;
-        case 'daily': return scheduleTime === currentTime;
-        case 'weekly': return scheduleTime === currentTime && dayOfWeek === (schedule.dayOfWeek ?? 0);
-        case 'monthly': return scheduleTime === currentTime && dayOfMonth === (schedule.dayOfMonth ?? 1);
-        default: return scheduleTime === currentTime;
+    // Day of Week check (for Weekly frequency)
+    // 0 = Sunday, 1 = Monday, etc.
+    if (schedule.frequency === 'weekly' && target.getUTCDay() !== (schedule.dayOfWeek ?? 0)) {
+        return null; 
     }
+    
+    // Day of Month check (for Monthly frequency)
+    if (schedule.frequency === 'monthly' && target.getUTCDate() !== (schedule.dayOfMonth ?? 1)) {
+        return null;
+    }
+
+    // Note: If 'target' is in the past (e.g. now is 03:00, schedule is 02:00),
+    // it will be filtered out by the window check (target >= now).
+    // We don't need to calculate "tomorrow's" run because the scheduler runs every minute;
+    // eventually "tomorrow" becomes "today".
+    
+    return target;
 }
 
-async function dispatchComputations(computations, defaultDate, scheduledTime) {
+async function dispatchComputations(computations, defaultDate) {
     const limit = pLimit(CLOUD_TASKS_CONCURRENCY);
-    const { projectId, location, queueName, dispatcherUrl, serviceAccountEmail } = config.cloudTasks; // Ensure serviceAccountEmail is destructured
+    const { projectId, location, queueName, dispatcherUrl, serviceAccountEmail } = config.cloudTasks;
     const queuePath = tasksClient.queuePath(projectId, location, queueName);
-    const timeSlot = formatTimeCompact(scheduledTime);
-    
-    // Log the configuration ONCE at the start of dispatch to verify
-    console.log(`[Scheduler] Dispatching to Queue: ${queuePath}`);
-    console.log(`[Scheduler] Using OIDC Service Account: ${serviceAccountEmail}`);
     
     const tasks = computations.map(entry => limit(async () => {
         try {
-            // Determine date: Zombies use their original stuck date, normal tasks use today
             const taskDate = entry.isRecovery ? entry.originalDate : defaultDate;
             const taskSource = entry.isRecovery ? 'zombie-recovery' : 'scheduled';
             
-            // Unique Task Name generation
-            let taskNameSuffix;
-            if (entry.isRecovery) {
-                // Zombies need a unique name every time we try to recover them (NOW)
-                taskNameSuffix = `recovery-${entry.recoveryId}-${Date.now()}`;
-            } else {
-                // Scheduled tasks need to be idempotent (TimeSlot)
-                taskNameSuffix = `${defaultDate}-${timeSlot}`;
-            }
+            // NAMING STRATEGY FOR DEDUPLICATION
+            // 1. Scheduled: compName-YYYYMMDD 
+            //    Ensures a daily task is only ever queued ONCE per day, even if scheduler overlaps.
+            // 2. Recovery:  compName-recovery-ID-timestamp 
+            //    Unique every time because we explicitly want to retry recovery.
+            const taskNameSuffix = entry.isRecovery 
+                ? `recovery-${entry.recoveryId}-${Date.now()}`
+                : `${taskDate}`; 
 
             const taskPayload = {
                 computationName: entry.originalName,
                 targetDate: taskDate,
-                source: taskSource,
-                scheduledAt: scheduledTime.toISOString()
+                source: taskSource
             };
-            
+
             const task = {
                 httpRequest: {
                     httpMethod: 'POST',
                     url: dispatcherUrl,
                     headers: { 'Content-Type': 'application/json' },
                     body: Buffer.from(JSON.stringify(taskPayload)).toString('base64'),
-                    oidcToken: {
-                        serviceAccountEmail: serviceAccountEmail, // Use the destructured variable
-                        audience: dispatcherUrl
-                    }
+                    oidcToken: { serviceAccountEmail }
                 },
+                // Cloud Tasks handles the "wait until X" logic via scheduleTime
+                scheduleTime: entry.runAt > 0 ? { seconds: entry.runAt } : undefined,
                 name: `${queuePath}/tasks/${entry.name}-${taskNameSuffix}`
             };
             
             await tasksClient.createTask({ parent: queuePath, task });
             
-            return {
-                computation: entry.originalName,
+            return { 
+                computation: entry.originalName, 
                 status: 'dispatched',
-                type: taskSource
+                scheduledFor: entry.runAt > 0 ? new Date(entry.runAt * 1000).toISOString() : 'now'
             };
             
         } catch (error) {
-            // EXISTING HANDLE: Duplicate tasks
-            if (error.code === 6) { 
+            // ALREADY_EXISTS (Code 6) or ABORTED/CONFLICT (Code 409)
+            // This is expected and desired behavior for the rolling window.
+            if (error.code === 6 || error.code === 409) { 
                 return { computation: entry.originalName, status: 'skipped', reason: 'duplicate' };
             }
 
-            // NEW HANDLE: NOT_FOUND (Configuration Errors)
+            // Configuration Errors (Code 5: NOT_FOUND)
             if (error.code === 5) {
-                console.error(`[Scheduler] 🚨 CONFIGURATION ERROR: 5 NOT_FOUND`);
-                console.error(`[Scheduler] Check 1: Does Queue exist? "${queuePath}"`);
-                console.error(`[Scheduler] Check 2: Does Service Account exist? "${serviceAccountEmail}"`);
-                console.error(`[Scheduler] Raw Error: ${error.message}`);
-                
-                return { 
-                    computation: entry.originalName, 
-                    status: 'error', 
-                    error: `Configuration Error: Queue or Service Account not found. (${error.message})`
-                };
+                console.error(`[Scheduler] 🚨 CONFIG ERROR: Queue '${queueName}' or SA '${serviceAccountEmail}' not found.`);
+                return { computation: entry.originalName, status: 'error', error: 'Config Error: Queue/SA not found' };
             }
 
-            // General Errors
-            console.error(`[Scheduler] Failed to dispatch ${entry.originalName}:`, error.message);
+            console.error(`[Scheduler] Dispatch failed for ${entry.originalName}:`, error.message);
             return { computation: entry.originalName, status: 'error', error: error.message };
         }
     }));
@@ -227,23 +240,8 @@ async function dispatchComputations(computations, defaultDate, scheduledTime) {
     return Promise.all(tasks);
 }
 
-function floorToMinute(date) {
-    const floored = new Date(date);
-    floored.setUTCSeconds(0);
-    floored.setUTCMilliseconds(0);
-    return floored;
-}
-
-function formatDate(date) { return date.toISOString().split('T')[0]; }
 function formatTime(date) {
-    const h = String(date.getUTCHours()).padStart(2, '0');
-    const m = String(date.getUTCMinutes()).padStart(2, '0');
-    return `${h}:${m}`;
-}
-function formatTimeCompact(date) {
-    const h = String(date.getUTCHours()).padStart(2, '0');
-    const m = String(date.getUTCMinutes()).padStart(2, '0');
-    return `${h}${m}`;
+    return date.toISOString().split('T')[1].substring(0, 5);
 }
 
 module.exports = { schedulerHandler, initialize };

package/functions/computation-system-v2/test/other/test-dependency-cascade.js

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Dependency Cascade Tests
+ *
+ * Verifies that:
+ * 1. Only root computations (no dependencies) are picked up by the scheduler.
+ * 2. When a root computation completes, its dependents are scheduled via
+ *    Cloud Tasks with the configured dependency gap.
+ * 3. Dispatcher does not return 503 for logical "blocked/impossible" states
+ *    so Cloud Tasks will not spin on dependency waits.
+ */
+
+const { Orchestrator } = require('../../framework');
+const config = require('../../config/bulltrackers.config');
+const dispatcherModule = require('../../handlers/dispatcher');
+
+// Simple CloudTasksClient mock
+class MockCloudTasksClient {
+    constructor() {
+        this.createdTasks = [];
+    }
+
+    queuePath(projectId, location, queueName) {
+        return `projects/${projectId}/locations/${location}/queues/${queueName}`;
+    }
+
+    async createTask(request) {
+        this.createdTasks.push(request);
+        return [{ name: `${request.parent}/tasks/mock-task` }];
+    }
+}
+
+function createMockResponse() {
+    let statusCode = 200;
+    let body = null;
+    return {
+        status(code) { statusCode = code; return this; },
+        json(data) { body = data; return this; },
+        send(data) { body = data; return this; },
+        getStatus() { return statusCode; },
+        getBody() { return body; }
+    };
+}
+
+async function testDispatcherNo503OnBlocked() {
+    console.log('\n=== Dependency Cascade: Dispatcher behaviour ===');
+
+    // Patch system.runComputation at runtime to simulate a blocked state
+    const system = require('../../core-api');
+    const originalRun = system.runComputation;
+
+    system.runComputation = async () => ({
+        name: 'popularinvestorriskassessment',
+        status: 'blocked',
+        reason: 'Waiting for: popularinvestorprofilemetrics'
+    });
+
+    const res = createMockResponse();
+    await dispatcherModule.dispatcherHandler(
+        {
+            body: {
+                computationName: 'PopularInvestorRiskAssessment',
+                targetDate: '2026-01-20',
+                source: 'scheduled'
+            }
+        },
+        res
+    );
+
+    console.log('  Status:', res.getStatus());
+    console.log('  Body:', JSON.stringify(res.getBody()));
+
+    if (res.getStatus() === 503) {
+        throw new Error('Expected dispatcher NOT to return 503 for blocked status');
+    }
+
+    // Restore original implementation
+    system.runComputation = originalRun;
+}
+
+async function testOrchestratorDependencyScheduling() {
+    console.log('\n=== Dependency Cascade: Orchestrator scheduling ===');
+
+    // Limit manifest to just the Popular Investor chain for clarity
+    const localConfig = { ...config };
+    localConfig.computations = [
+        require('../../computations/PopularInvestorProfileMetrics'),
+        require('../../computations/PopularInvestorRiskAssessment')
+    ];
+
+    // Mark test mode so we can identify this run in logs if needed
+    localConfig.testMode = { runId: 'dependency-cascade-test' };
+
+    const orch = new Orchestrator(localConfig, console);
+
+    // Inject mock CloudTasks client
+    orch.cloudTasksClient = new MockCloudTasksClient();
+
+    await orch.initialize();
+
+    // Simulate that today is 2026-01-20
+    const date = '2026-01-20';
+
+    // Execute only the root computation (PopularInvestorProfileMetrics).
+    const rootEntry = orch.manifest.find(e => e.originalName === 'PopularInvestorProfileMetrics');
+    if (!rootEntry) {
+        throw new Error('PopularInvestorProfileMetrics not found in manifest');
+    }
+
+    console.log('  Running root computation:', rootEntry.originalName);
+    await orch.runSingle(rootEntry, date, { dryRun: true });
+
+    const tasks = orch.cloudTasksClient.createdTasks;
+    console.log('  Cloud Tasks created:', tasks.length);
+
+    if (tasks.length === 0) {
+        console.log('  NOTE: No dependent tasks were scheduled (expected if dependencies incomplete in status store).');
+        return;
+    }
+
+    const payload = JSON.parse(
+        Buffer.from(tasks[0].task.httpRequest.body, 'base64').toString('utf8')
+    );
+
+    console.log('  First task payload:', payload);
+
+    if (payload.source !== 'dependency') {
+        throw new Error('Expected dependent tasks to be marked with source="dependency"');
+    }
+}
+
+async function main() {
+    console.log('╔════════════════════════════════════════════════════════════╗');
+    console.log('║         Computation System v2 - Dependency Cascade         ║');
+    console.log('╚════════════════════════════════════════════════════════════╝');
+
+    try {
+        await testDispatcherNo503OnBlocked();
+        await testOrchestratorDependencyScheduling();
+
+        console.log('\nAll dependency cascade tests completed.\n');
+    } catch (err) {
+        console.error('\n❌ Dependency cascade test failed:', err);
+        process.exit(1);
+    }
+}
+
+if (require.main === module) {
+    main();
+}
+

package/package.json

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