bulltrackers-module 1.0.768 → 1.0.770

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

@@ -1,6 +1,10 @@
 /**
  * @fileoverview Computation Dispatcher
- * ...
+ * Handles incoming HTTP requests to run computations.
+ * Supports:
+ * 1. Standard execution (Scheduled/On-Demand)
+ * 2. Deployment Events (Triggers History Backfill Fan-Out)
+ * 3. Stale Task Protection (Prevents running old code versions)
  */
 
 const crypto = require('crypto');
@@ -9,6 +13,7 @@ exports.dispatcherHandler = async (req, res) => {
     const startTime = Date.now();
     
     try {
+        // Load the system entry point (index.js)
         const system = require('../index');
 
         const {
@@ -30,56 +35,84 @@ exports.dispatcherHandler = async (req, res) => {
             });
         }
 
-        // [FIXED LOGIC HERE] --------------------------------------------------
-        // Stale Task Protection
+        console.log(`[Dispatcher] Received ${source} request: ${computationName}`);
+
+        // Safety check to ensure system is loaded correctly
+        if (!system) {
+            throw new Error('System not fully initialized. Check index.js exports.');
+        }
+
+        // =====================================================================
+        // SPECIAL HANDLING: DEPLOYMENT EVENTS (Fan-Out)
+        // =====================================================================
+        if (source === 'deployment') {
+            if (typeof system.triggerBackfill !== 'function') {
+                throw new Error('System does not support auto-backfill (triggerBackfill missing).');
+            }
+
+            console.log(`[Dispatcher] 🚀 Triggering Deployment Backfill for ${computationName}...`);
+            const stats = await system.triggerBackfill(computationName);
+
+            const duration = Date.now() - startTime;
+            console.log(`[Dispatcher] Deployment processed in ${duration}ms. Scheduled ${stats.scheduled} tasks.`);
+
+            return res.status(200).json({
+                status: 'triggered',
+                computation: computationName,
+                action: 'backfill_fan_out',
+                scheduledTasks: stats.scheduled,
+                duration
+            });
+        }
+        // =====================================================================
+
+        // 2. Stale Task Protection
+        // Prevents execution if the task was scheduled with an older version of the configuration
         if (configHash && !force) {
-            // FIX: Use getManifest() as system.manifest is not exposed directly.
             const manifest = await system.getManifest();
             
-            // Normalize name to match manifest keys (matches logic in core-api.js)
+            // Normalize name to match manifest keys
             const normalizedName = computationName.toLowerCase().replace(/[^a-z0-9]/g, '');
             const entry = manifest.find(c => c.name === normalizedName);
             
             if (entry) {
-                // 1. Re-calculate the hash of the CURRENTLY DEPLOYED code
+                // Re-calculate the hash of the CURRENTLY DEPLOYED code
                 const input = JSON.stringify(entry.schedule) + `|PASS:${entry.pass}`;
                 const currentHash = crypto.createHash('md5').update(input).digest('hex').substring(0, 8);
                 
-                // 2. Compare
+                // Compare Task Hash vs Current Hash
                 if (configHash !== currentHash) {
                     console.warn(`[Dispatcher] ♻️ Skipped STALE task for ${computationName}. (Task Hash: ${configHash} != Current: ${currentHash})`);
                     
                     return res.status(200).json({
                         status: 'skipped',
                         reason: 'STALE_CONFIG',
-                        message: 'Task configuration (schedule/pass) is obsolete relative to current deployment.',
+                        message: 'Task configuration is obsolete relative to current deployment.',
                         hash: currentHash
                     });
                 }
             }
         }
-        // ---------------------------------------------------------------------
 
+        // 3. Prepare Execution
         const date = targetDate || new Date().toISOString().split('T')[0];
-        console.log(`[Dispatcher] Received ${source} request: ${computationName} for ${date}`);
-
-        // Safety check to ensure system is loaded correctly
-        if (!system || typeof system.runComputation !== 'function') {
-            throw new Error('System not fully initialized (runComputation is missing). Check index.js exports.');
-        }
         
-        // 2. DELEGATE TO ORCHESTRATOR
+        // 4. DELEGATE TO ORCHESTRATOR
+        if (typeof system.runComputation !== 'function') {
+            throw new Error('system.runComputation is missing.');
+        }
+
         const result = await system.runComputation({
             date,
             computation: computationName,
             entityIds,
             dryRun,
-            force // Pass force down to orchestrator if needed
+            force
         });
 
         const duration = Date.now() - startTime;
 
-        // 3. HANDLE SUCCESS (Completed or Skipped/Up-to-date)
+        // 5. HANDLE SUCCESS (Completed or Skipped/Up-to-date)
         if (result.status === 'completed' || result.status === 'skipped') {
             console.log(`[Dispatcher] ${computationName} ${result.status}: ${result.resultCount || 0} entities in ${duration}ms`);
             
@@ -94,7 +127,7 @@ exports.dispatcherHandler = async (req, res) => {
             });
         } 
         
-        // 4. HANDLE NON-RUNNABLE STATES (Blocked / Impossible)
+        // 6. HANDLE NON-RUNNABLE STATES (Blocked / Impossible)
         if (result.status === 'blocked' || result.status === 'impossible') {
             console.log(`[Dispatcher] ${computationName} ${result.status}: ${result.reason}`);
 
@@ -105,24 +138,19 @@ exports.dispatcherHandler = async (req, res) => {
             });
         }
 
-        // 5. Fallback for other statuses
+        // 7. Fallback
         return res.status(200).json(result);
         
     } catch (error) {
         const duration = Date.now() - startTime;
         console.error(`[Dispatcher] Error after ${duration}ms:`, error);
         
-        if (error.message && error.message.includes('Computation not found')) {
-            return res.status(400).json({
-                status: 'error',
-                reason: 'UNKNOWN_COMPUTATION',
-                message: error.message
-            });
-        }
+        const statusCode = (error.message && error.message.includes('Computation not found')) ? 400 : 500;
+        const reason = statusCode === 400 ? 'UNKNOWN_COMPUTATION' : 'EXECUTION_FAILED';
 
-        return res.status(500).json({
+        return res.status(statusCode).json({
             status: 'error',
-            reason: 'EXECUTION_FAILED',
+            reason: reason,
             message: error.message
         });
     }

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

@@ -1,106 +1,130 @@
 /**
- * @fileoverview Scheduler V2: Planner & Watchdog
- * * 1. planComputations: Runs infrequently (e.g. Hourly/Daily).
- * - Loads Manifest.
- * - Forecasts all Root executions for the next 24-48h.
- * - Enqueues Cloud Tasks with `scheduleTime` and `configHash`.
- * * 2. runWatchdog: Runs frequently (e.g. every 15 mins).
- * - Detects Zombies (stuck running tasks).
- * - Re-queues them immediately.
+ * @fileoverview Scheduler V3.1: Reconciler with Active Garbage Collection
+ * * * 1. Reconcile: Iterates a time window (Past -> Future) to ensure valid tasks exist.
+ * * 2. Purge: Scans the queue for "Orphans" (tasks for deleted computations) and deletes them.
+ * * 3. Watchdog: Recovers "Zombie" tasks (running but stuck).
  */
 
 const { CloudTasksClient } = require('@google-cloud/tasks');
 const crypto = require('crypto');
 const pLimit = require('p-limit');
+
+// Framework
 const { ManifestBuilder } = require('../framework');
 const { StorageManager } = require('../framework/storage/StorageManager');
+const { StateRepository } = require('../framework/storage/StateRepository');
 const config = require('../config/bulltrackers.config');
 
-const CLOUD_TASKS_CONCURRENCY = 10;
+// Config
+const CLOUD_TASKS_CONCURRENCY = 20;
+const PLANNING_LOOKBACK_DAYS = 7;    // Look back to ensure recent history is correct
+const PLANNING_LOOKAHEAD_HOURS = 24; // Schedule future tasks
 const ZOMBIE_THRESHOLD_MINUTES = 15;
-const PLANNING_WINDOW_HOURS = 24; // Look ahead window
 
 // Cache singleton instances
 let manifest = null;
 let tasksClient = null;
 let storageManager = null;
+let stateRepository = null;
 
 async function initialize() {
     if (manifest) return;
     console.log('[Scheduler] Initializing services...');
-    
-    // We pass a no-op logger to prevent noise during frequent checks
-    const builder = new ManifestBuilder(config, { log: () => {} });
+
+    // Use a no-op logger for manifest builder to reduce noise
+    const builder = new ManifestBuilder(config, { log: () => { } });
     manifest = builder.build(config.computations || []);
-    
+
     tasksClient = new CloudTasksClient();
     storageManager = new StorageManager(config, console);
-    
+    stateRepository = new StateRepository(config, console);
+
     console.log(`[Scheduler] Loaded ${manifest.length} computations.`);
 }
 
 /**
- * ENTRY POINT 1: The Planner
+ * ENTRY POINT 1: The Reconciler & Garbage Collector
  * Trigger: Cloud Scheduler -> "0 * * * *" (Every Hour)
- * Goals: Ensure all future tasks for the next 24h are in the queue.
  */
 async function planComputations(req, res) {
-    const startTime = Date.now();
     try {
         await initialize();
 
+        // --- PHASE 1: RECONCILIATION (Ensure valid tasks exist) ---
         const now = new Date();
-        const windowEnd = new Date(now.getTime() + PLANNING_WINDOW_HOURS * 60 * 60 * 1000);
+        const windowStart = new Date(now);
+        windowStart.setDate(now.getDate() - PLANNING_LOOKBACK_DAYS);
+        windowStart.setHours(0, 0, 0, 0);
 
-        console.log(`[Planner] Planning window: ${now.toISOString()} to ${windowEnd.toISOString()}`);
+        const windowEnd = new Date(now);
+        windowEnd.setTime(now.getTime() + (PLANNING_LOOKAHEAD_HOURS * 60 * 60 * 1000));
 
-        const tasksToSchedule = [];
+        console.log(`[Planner] Reconciling window: ${windowStart.toISOString()} to ${windowEnd.toISOString()}`);
 
-        // 1. Walk the Manifest
-        for (const entry of manifest) {
-            // FILTER: Only Roots (Pass 1)
-            // Graph.js assigns roots (no dependencies) to Pass 1.
-            // Resilience: If code changes and a comp becomes Pass 2+, it won't be scheduled here.
-            if (entry.pass !== 1) continue;
-
-            // Calculate Occurrences
-            const occurrences = getOccurrencesInWindow(entry.schedule, now, windowEnd);
-            
-            // Generate Tasks for each occurrence
-            for (const dateObj of occurrences) {
-                // Resilience: Generate a hash of the critical scheduling config.
-                // If schedule OR pass changes, this hash changes, creating a new Task ID.
-                const configHash = generateConfigHash(entry);
-                const targetDateStr = dateObj.toISOString().split('T')[0];
-
-                tasksToSchedule.push({
-                    computation: entry.originalName,
-                    targetDate: targetDateStr,
-                    runAtSeconds: dateObj.getTime() / 1000,
-                    configHash: configHash,
-                    queuePath: getQueuePath(entry)
-                });
-            }
+        const tasksToSchedule = [];
+        const stats = { checked: 0, scheduled: 0, mismatched: 0, missing: 0 };
+
+        // Iterate dates in window
+        const targetDates = [];
+        let cursor = new Date(windowStart);
+        while (cursor <= windowEnd) {
+            targetDates.push(new Date(cursor));
+            cursor.setDate(cursor.getDate() + 1);
         }
 
-        if (tasksToSchedule.length === 0) {
-            return res.status(200).send('No root computations due in planning window.');
-        }
+        const dateLimit = pLimit(5);
+        await Promise.all(targetDates.map(dateObj => dateLimit(async () => {
+            const dateStr = dateObj.toISOString().split('T')[0];
+            const dailyStatus = await stateRepository.getDailyStatus(dateStr);
+
+            for (const entry of manifest) {
+                if (entry.pass !== 1) continue; // Only schedule Roots
+                if (!shouldRunOnDate(entry.schedule, dateObj)) continue;
+
+                stats.checked++;
+                const lastRun = dailyStatus.get(entry.name);
+                let reason = null;
+
+                if (!lastRun) {
+                    reason = 'MISSING_RUN';
+                    stats.missing++;
+                } else if (lastRun.hash !== entry.hash) {
+                    reason = 'HASH_MISMATCH';
+                    stats.mismatched++;
+                }
+
+                if (reason) {
+                    tasksToSchedule.push({
+                        computation: entry.originalName,
+                        targetDate: dateStr,
+                        runAtSeconds: getRunTimeSeconds(entry.schedule, dateObj),
+                        configHash: entry.hash,
+                        queuePath: getQueuePath(),
+                        reason
+                    });
+                }
+            }
+        })));
 
-        // 2. Dispatch to Cloud Tasks (Idempotent)
-        const results = await dispatchPlannedTasks(tasksToSchedule);
+        // --- PHASE 2: GARBAGE COLLECTION (Remove invalid tasks) ---
+        console.log('[Planner] Starting Garbage Collection...');
+        const deletedCount = await cleanupOrphanedTasks();
 
-        const created = results.filter(r => r.status === 'scheduled').length;
-        const exists = results.filter(r => r.status === 'exists').length;
+        // --- PHASE 3: DISPATCH ---
+        let scheduledCount = 0;
+        if (tasksToSchedule.length > 0) {
+            const results = await dispatchTasks(tasksToSchedule);
+            scheduledCount = results.filter(r => r.status === 'scheduled').length;
+        }
 
-        console.log(`[Planner] Window Processed. Created: ${created}, Already Existed: ${exists}, Errors: ${results.length - created - exists}`);
+        console.log(`[Planner] Complete. Scheduled: ${scheduledCount}, Deleted Orphans: ${deletedCount}`);
 
         return res.status(200).json({
-            status: 'ok',
-            window: `${PLANNING_WINDOW_HOURS}h`,
-            created,
-            exists,
-            details: results
+            status: 'success',
+            window: `${PLANNING_LOOKBACK_DAYS}d back, ${PLANNING_LOOKAHEAD_HOURS}h fwd`,
+            scheduled: scheduledCount,
+            deletedOrphans: deletedCount,
+            stats
         });
 
     } catch (error) {
@@ -112,57 +136,32 @@ async function planComputations(req, res) {
 /**
  * ENTRY POINT 2: The Watchdog
  * Trigger: Cloud Scheduler -> "*\/15 * * * *" (Every 15 mins)
- * Goals: Find stuck tasks and re-queue them.
  */
 async function runWatchdog(req, res) {
     try {
         await initialize();
-        
-        // 1. Find Zombies
         const zombies = await storageManager.findZombies(ZOMBIE_THRESHOLD_MINUTES);
-        
-        // Filter out excessive attempts
-        const actionableZombies = [];
-        for (const z of zombies) {
-            if ((z.attempts || 0) >= 3) {
-                console.warn(`[Watchdog] Ignoring zombie ${z.name} (Checkpoint: ${z.checkpointId}) - Max attempts reached (${z.attempts})`);
-                continue;
-            }
-            actionableZombies.push(z);
-        }
-
-        if (actionableZombies.length === 0) {
-            return res.status(200).send('No recoverable zombies.');
-        }
+        const actionableZombies = zombies.filter(z => (z.attempts || 0) < 3);
 
-        console.log(`[Watchdog] 🧟 Found ${actionableZombies.length} zombies. Initiating recovery...`);
+        if (actionableZombies.length === 0) return res.status(200).send('No recoverable zombies.');
 
-        // 2. Claim & Recover
-        // We claim them first so the next watchdog doesn't grab them while we are dispatching
+        console.log(`[Watchdog] 🧟 Found ${actionableZombies.length} zombies. Recovering...`);
         await Promise.all(actionableZombies.map(z => storageManager.claimZombie(z.checkpointId)));
 
         const recoveryTasks = actionableZombies.map(z => {
             const entry = manifest.find(m => m.name === z.name);
-            if (!entry) {
-                console.error(`[Watchdog] Computation ${z.name} no longer exists in manifest. Cannot recover.`);
-                return null;
-            }
+            if (!entry) return null;
             return {
                 computation: entry.originalName,
                 targetDate: z.date,
                 isRecovery: true,
                 recoveryId: z.checkpointId,
-                queuePath: getQueuePath(entry)
+                queuePath: getQueuePath()
             };
         }).filter(Boolean);
 
-        const results = await dispatchRecoveryTasks(recoveryTasks);
-
-        return res.status(200).json({
-            status: 'recovered',
-            count: results.length,
-            details: results
-        });
+        const results = await dispatchTasks(recoveryTasks);
+        return res.status(200).json({ status: 'recovered', count: results.length });
 
     } catch (error) {
         console.error('[Watchdog] Error:', error);
@@ -171,131 +170,106 @@ async function runWatchdog(req, res) {
 }
 
 // =============================================================================
-// HELPER FUNCTIONS
+// ACTIVE GARBAGE COLLECTION LOGIC
 // =============================================================================
 
-/**
- * Calculates all execution times for a schedule within a start/end window.
- * Returns Array<Date>
- */
-function getOccurrencesInWindow(schedule, start, end) {
-    const times = [];
-    const [h, m] = (schedule.time || '02:00').split(':').map(Number);
-    
-    // Clone start date to iterate
-    let current = new Date(start);
-    current.setUTCHours(h, m, 0, 0);
-
-    // If current is before start (e.g. window starts at 10:00, schedule is 02:00), move to tomorrow
-    if (current < start) {
-        current.setDate(current.getDate() + 1);
-    }
+async function cleanupOrphanedTasks() {
+    const parent = getQueuePath();
+    const validKebabNames = new Set(manifest.map(m => toKebab(m.originalName)));
+    const limit = pLimit(CLOUD_TASKS_CONCURRENCY);
+    let deletedCount = 0;
 
-    while (current <= end) {
-        let match = true;
-        
-        // Weekly Check
-        if (schedule.frequency === 'weekly' && current.getUTCDay() !== (schedule.dayOfWeek ?? 0)) {
-            match = false;
-        }
-        
-        // Monthly Check
-        if (schedule.frequency === 'monthly' && current.getUTCDate() !== (schedule.dayOfMonth ?? 1)) {
-            match = false;
-        }
+    try {
+        // Iterate over ALL tasks in the queue
+        // Note: listTasksAsync handles pagination automatically
+        const tasksToDelete = [];
+
+        for await (const task of tasksClient.listTasksAsync({ parent, responseView: 'BASIC' })) {
+            const taskNameFull = task.name;
+            const taskNameShort = taskNameFull.split('/').pop(); // e.g., root-my-comp-2023-01-01-abcdef
 
-        if (match) {
-            times.push(new Date(current));
+            // 1. Regex Match: Capture the computation name part
+            // Pattern: (root|recovery)-{kebabName}-{date}-{hash}
+            // Date is YYYY-MM-DD (10 chars)
+            // Hash is 8 chars (or more)
+            const match = taskNameShort.match(/^(?:root|recovery)-(.+)-\d{4}-\d{2}-\d{2}-/);
+
+            if (!match) continue; // Skip tasks that don't match our naming convention
+
+            const extractedKebabName = match[1];
+
+            // 2. Check Validity
+            if (!validKebabNames.has(extractedKebabName)) {
+                // ORPHAN DETECTED!
+                tasksToDelete.push(taskNameFull);
+            }
         }
 
-        // Advance 1 day
-        current.setDate(current.getDate() + 1);
+        if (tasksToDelete.length === 0) return 0;
+
+        console.log(`[Planner] 🗑️ Found ${tasksToDelete.length} orphaned tasks. Deleting...`);
+
+        // 3. Delete in parallel
+        await Promise.all(tasksToDelete.map(name => limit(async () => {
+            try {
+                await tasksClient.deleteTask({ name });
+                deletedCount++;
+            } catch (e) {
+                console.warn(`[Planner] Failed to delete orphan ${name}: ${e.message}`);
+            }
+        })));
+
+    } catch (e) {
+        console.error(`[Planner] GC Error: ${e.message}`);
     }
-    
-    return times;
+
+    return deletedCount;
 }
 
-/**
- * Generates a short hash of the Scheduling Config + Pass.
- * If this changes, we want a new Task ID to enforce the new schedule.
- */
-function generateConfigHash(entry) {
-    const input = JSON.stringify(entry.schedule) + `|PASS:${entry.pass}`;
-    return crypto.createHash('md5').update(input).digest('hex').substring(0, 8);
+// =============================================================================
+// HELPERS
+// =============================================================================
+
+function shouldRunOnDate(schedule, dateObj) {
+    if (schedule.frequency === 'weekly' && dateObj.getUTCDay() !== (schedule.dayOfWeek ?? 0)) return false;
+    if (schedule.frequency === 'monthly' && dateObj.getUTCDate() !== (schedule.dayOfMonth ?? 1)) return false;
+    return true;
+}
+
+function getRunTimeSeconds(schedule, dateObj) {
+    const [h, m] = (schedule.time || '02:00').split(':').map(Number);
+    const runTime = new Date(dateObj);
+    runTime.setUTCHours(h, m, 0, 0);
+    return runTime.getTime() / 1000;
 }
 
-function getQueuePath(entry) {
+function getQueuePath() {
     const { projectId, location, queueName } = config.cloudTasks;
     return tasksClient.queuePath(projectId, location, queueName);
 }
 
-/**
- * Dispatches Planned Root Tasks
- * Uses deterministic naming for deduplication.
- */
-async function dispatchPlannedTasks(tasks) {
-    const limit = pLimit(CLOUD_TASKS_CONCURRENCY);
-    const { dispatcherUrl, serviceAccountEmail } = config.cloudTasks;
-
-    return Promise.all(tasks.map(t => limit(async () => {
-        try {
-            // Task Name: root-{name}-{date}-{configHash}
-            // If developer changes schedule -> hash changes -> new task created.
-            // If developer changes code but not schedule -> hash same -> existing task preserved.
-            const taskName = `${t.queuePath}/tasks/root-${toKebab(t.computation)}-${t.targetDate}-${t.configHash}`;
-            
-            const payload = {
-                computationName: t.computation,
-                targetDate: t.targetDate,
-                source: 'scheduled',
-                configHash: t.configHash // Sent to dispatcher for potential validation
-            };
-
-            const task = {
-                httpRequest: {
-                    httpMethod: 'POST',
-                    url: dispatcherUrl,
-                    headers: { 'Content-Type': 'application/json' },
-                    body: Buffer.from(JSON.stringify(payload)).toString('base64'),
-                    oidcToken: { 
-                        serviceAccountEmail,
-                        audience: dispatcherUrl // <--- FIXED: Must exactly match function URL
-                    }
-                },
-                scheduleTime: { seconds: t.runAtSeconds },
-                name: taskName
-            };
-
-            await tasksClient.createTask({ parent: t.queuePath, task });
-            return { computation: t.computation, date: t.targetDate, status: 'scheduled' };
-
-        } catch (e) {
-            if (e.code === 6 || e.code === 409) {
-                return { computation: t.computation, date: t.targetDate, status: 'exists' };
-            }
-            console.error(`[Planner] Failed to schedule ${t.computation}:`, e.message);
-            return { computation: t.computation, status: 'error', error: e.message };
-        }
-    })));
+function toKebab(str) {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase().replace(/[^a-z0-9-]/g, '');
 }
 
-/**
- * Dispatches Recovery Tasks (Zombies)
- * Always creates unique task names to ensure retry.
- */
-async function dispatchRecoveryTasks(tasks) {
+async function dispatchTasks(tasks) {
     const limit = pLimit(CLOUD_TASKS_CONCURRENCY);
     const { dispatcherUrl, serviceAccountEmail } = config.cloudTasks;
 
     return Promise.all(tasks.map(t => limit(async () => {
         try {
-            // Unique ID for every recovery attempt
-            const taskName = `${t.queuePath}/tasks/recovery-${toKebab(t.computation)}-${t.recoveryId}-${Date.now()}`;
-            
+            const name = t.isRecovery
+                ? `recovery-${toKebab(t.computation)}-${t.targetDate}-${Date.now()}`
+                : `root-${toKebab(t.computation)}-${t.targetDate}-${t.configHash}`;
+
+            const taskName = `${t.queuePath}/tasks/${name}`;
+
             const payload = {
                 computationName: t.computation,
                 targetDate: t.targetDate,
-                source: 'zombie-recovery'
+                source: t.isRecovery ? 'zombie-recovery' : 'scheduled',
+                configHash: t.configHash,
+                reason: t.reason
             };
 
             const task = {
@@ -304,26 +278,21 @@ async function dispatchRecoveryTasks(tasks) {
                     url: dispatcherUrl,
                     headers: { 'Content-Type': 'application/json' },
                     body: Buffer.from(JSON.stringify(payload)).toString('base64'),
-                    oidcToken: { 
-                        serviceAccountEmail,
-                        audience: dispatcherUrl // <--- FIXED: Must exactly match function URL
-                    }
+                    oidcToken: { serviceAccountEmail, audience: dispatcherUrl }
                 },
-                // Run Immediately (no scheduleTime)
                 name: taskName
             };
 
-            await tasksClient.createTask({ parent: t.queuePath, task });
-            return { computation: t.computation, status: 'recovered' };
+            if (t.runAtSeconds) task.scheduleTime = { seconds: t.runAtSeconds };
 
+            await tasksClient.createTask({ parent: t.queuePath, task });
+            return { status: 'scheduled' };
         } catch (e) {
-            return { computation: t.computation, status: 'error', error: e.message };
+            if (e.code === 6 || e.code === 409) return { status: 'exists' };
+            console.error(`[Planner] Failed task ${t.computation}: ${e.message}`);
+            return { status: 'error' };
         }
     })));
 }
 
-function toKebab(str) {
-    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase().replace(/[^a-z0-9-]/g, '');
-}
-
 module.exports = { planComputations, runWatchdog };