Context Navigation

← Previous Changeset
Next Changeset →

Changeset 3420528

Timestamp:

12/15/2025 10:04:54 PM (3 months ago)

Author:

siteskite

Message:

Version 1.0.8 - Improved backup performance

Location:

siteskite/trunk

Files:

: 1 added
: 11 edited

includes/API/RestAPI.php (modified) (2 diffs)
includes/Backup/BackupManager.php (modified) (44 diffs)
includes/Backup/Incremental/Impl/BackblazeB2ObjectStore.php (modified) (4 diffs)
includes/Backup/Incremental/ProviderManifests.php (modified) (1 diff)
includes/Cloud/BackblazeB2Manager.php (modified) (1 diff)
includes/Core/Plugin.php (modified) (7 diffs)
includes/Core/Utils.php (modified) (1 diff)
includes/Cron/CronTriggerHandler.php (modified) (8 diffs)
includes/Cron/ExternalCronManager.php (modified) (11 diffs)
includes/Cron/HybridCronManager.php (added)
readme.txt (modified) (3 diffs)
siteskite-link.php (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed

siteskite/trunk/includes/API/RestAPI.php

-                      r3418578
+                      r3420528
                     'methods' => WP_REST_Server::CREATABLE,
                     'callback' => [$this->cron_trigger_handler, 'handle_trigger'],
+                    'permission_callback' => '__return_true', // Authentication via secret token in header
+                    'permission_callback' => function(\WP_REST_Request $request) {
+                        // Enhanced security: Verify secret token before allowing access
+                        // This is checked in handle_trigger, but we add an extra layer here
+                        $secret = $request->get_header('X-SiteSkite-Cron-Secret');
+                        if (empty($secret)) {
+                            // Also check query parameter as fallback (for services that can't set headers)
+                            $secret = $request->get_param('siteskite_key');
+                        }
+                        // If no secret provided, deny access immediately
+                        if (empty($secret)) {
+                            return false;
+                        }
+                        // Actual verification happens in handle_trigger for proper error handling
+                        // This permission callback just ensures some form of authentication is attempted
+                        return true;
+                    },
                     // Don't validate args here - we handle validation in the callback
                     // This allows cron-job.org to send JSON body without WordPress REST API validation issues
                     'args' => []
+                ]
+            );
+            // Cron continuity check endpoint (for external cron service to check if WordPress cron is running)
+            register_rest_route(
+                self::API_NAMESPACE,
+                '/cron/check-continuity',
+                [
+                    'methods' => WP_REST_Server::READABLE,
+                    'callback' => [$this->cron_trigger_handler, 'handle_continuity_check'],
+                    'permission_callback' => function(\WP_REST_Request $request) {
+                        // Enhanced security: Verify secret token before allowing access
+                        $secret = $request->get_header('X-SiteSkite-Cron-Secret');
+                        if (empty($secret)) {
+                            $secret = $request->get_param('siteskite_key');
+                        }
+                        if (empty($secret)) {
+                            return false;
+                        }
+                        return true;
+                    },
+                    'args' => [
+                        'action' => [
+                            'required' => true,
+                            'type' => 'string',
+                            'sanitize_callback' => 'sanitize_text_field'
+                        ],
+                        'args' => [
+                            'required' => false,
+                            'type' => 'array',
+                            'default' => []
+                        ],
+                        'siteskite_key' => [
+                            'required' => false,
+                            'type' => 'string',
+                            'sanitize_callback' => 'sanitize_text_field',
+                            'description' => 'Alternative authentication method if header cannot be set'
+                        ]
+                    ]
+                ]
             );
 …
             // Log what we received for debugging
             $this->logger->debug('Backup start request parameters check', [
                 'backup_id' => $backup_id,
                 'provider' => $provider,
                 'has_provider_config' => is_array($request->get_param('provider_config')),
                 'provider_config_type' => gettype($request->get_param('provider_config')),
                 'provider_config_keys' => is_array($request->get_param('provider_config')) ? array_keys($request->get_param('provider_config')) : null,
                 'received_credential_keys' => is_array($provider_credentials) ? array_keys($provider_credentials) : null,
                 'all_param_keys' => array_keys($all_params),
                 'has_credentials' => is_array($provider_credentials) && !empty($provider_credentials)
+                // 'backup_id' => $backup_id,
+                // 'provider' => $provider,
+                // 'has_provider_config' => is_array($request->get_param('provider_config')),
+                // 'provider_config_type' => gettype($request->get_param('provider_config')),
+                // 'provider_config_keys' => is_array($request->get_param('provider_config')) ? array_keys($request->get_param('provider_config')) : null,
+                // 'received_credential_keys' => is_array($provider_credentials) ? array_keys($provider_credentials) : null,
+                // 'all_param_keys' => array_keys($all_params),
+                // 'has_credentials' => is_array($provider_credentials) && !empty($provider_credentials)
             ]);

siteskite/trunk/includes/Backup/BackupManager.php

-                      r3418578
+                      r3420528
     private ?ExternalCronManager $external_cron_manager = null;
+    /**
+     * @var \SiteSkite\Cron\HybridCronManager|null Hybrid cron manager instance
+     */
+    private ?\SiteSkite\Cron\HybridCronManager $hybrid_cron_manager = null;
     // Backup directory is now accessed via SITESKITE_BACKUP_PATH constant
 …
         'litespeed',
         'backup-migration-*',
         'wp-content/cache',
         'wp-content/uploads/siteskite-backups',
 …
         'wp-content/wpvividbackups',
+        //temporary test
+        'wp-content/plugins',
+        'wp-admin',
+        'wp-includes',
+        /* --- excluded paths for testing --- */
+        // 'wp-content',
+        // 'wp-admin',
+        // 'wp-includes',
     ];
 …
      * @param \SiteSkite\Backup\Incremental\IncrementalStatus $incremental_status Incremental status manager instance
      * @param ExternalCronManager|null $external_cron_manager External cron manager instance
+     * @param \SiteSkite\Cron\HybridCronManager|null $hybrid_cron_manager Hybrid cron manager instance
      */
     public function __construct(
 …
         AWSManager $aws_manager,
         \SiteSkite\Backup\Incremental\IncrementalStatus $incremental_status,
+        ?ExternalCronManager $external_cron_manager = null
+        ?ExternalCronManager $external_cron_manager = null,
+        ?\SiteSkite\Cron\HybridCronManager $hybrid_cron_manager = null
     ) {
         $this->s3_manager = $s3_manager;
 …
         $this->incremental_status = $incremental_status;
         $this->external_cron_manager = $external_cron_manager;
+        $this->hybrid_cron_manager = $hybrid_cron_manager;
         $this->init_backup_directory();
 …
     /**
      * Schedule cron event (uses external cron if enabled, otherwise WordPress cron)
+     * Schedule cron event (uses hybrid cron if available, otherwise external cron, fallback to WordPress cron)
      */
     private function schedule_cron_event(string $hook, array $args, int $delay_seconds = 0, string $title = ''): void
+    {
+        // Try external cron first if enabled
+        // Determine WordPress cron interval based on hook type
+        $wp_cron_interval = 60; // Default 1 minute
+        if ($hook === 'siteskite_incremental_continue') {
+            $wp_cron_interval = 60; // 1 minute for incremental continuation
+        } elseif (strpos($hook, 'backup') !== false || strpos($hook, 'restore') !== false) {
+            $wp_cron_interval = 300; // 5 minutes for backup/restore operations
+        }
+        // Try hybrid cron first if available
+        if ($this->hybrid_cron_manager) {
+            $scheduled = $this->hybrid_cron_manager->schedule_hybrid_event(
+                $hook,
+                $args,
+                $delay_seconds,
+                $title,
+                $wp_cron_interval
+            );
+            if ($scheduled) {
+                $this->logger->debug('Scheduled hybrid cron event', [
+                    'hook' => $hook,
+                    'delay' => $delay_seconds,
+                    'wp_cron_interval' => $wp_cron_interval
+                ]);
+                return;
+            }
+        }
+        // Fallback to original external cron logic
         if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
             // Check if job already exists to prevent duplicates
 …
         // Fallback to WordPress cron
         wp_schedule_single_event(time() + $delay_seconds, $hook, $args);
+        // Notify hybrid cron manager if WordPress cron was scheduled
+        if ($this->hybrid_cron_manager) {
+            $this->hybrid_cron_manager->on_wp_cron_run($hook, $args);
+        }
+    }
+    /**
+     * Ensure only a single active incremental-continue job per site.
+     * Removes any WP-Cron and external-cron jobs for other incremental backup IDs.
+     */
+    private function cleanup_other_incremental_jobs(string $active_backup_id): void
+    {
+        // Clean up external cron jobs for siteskite_incremental_continue on other backup IDs
+        if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+            $jobs = get_option('siteskite_external_cron_jobs', []);
+            if (is_array($jobs)) {
+                foreach ($jobs as $job) {
+                    if (($job['action'] ?? '') !== 'siteskite_incremental_continue') {
+                        continue;
+                    }
+                    $args = $job['args'] ?? [];
+                    $job_backup_id = $args[0] ?? ($args['backup_id'] ?? '');
+                    if (!empty($job_backup_id) && $job_backup_id !== $active_backup_id && isset($job['job_id'])) {
+                        $this->external_cron_manager->delete_job((int) $job['job_id']);
+                    }
+                }
+            }
+        }
+        // Clean up WordPress cron events for siteskite_incremental_continue on other backup IDs
+        if (function_exists('_get_cron_array')) {
+            $crons = _get_cron_array();
+            if (is_array($crons)) {
+                foreach ($crons as $timestamp => $hooks) {
+                    if (empty($hooks['siteskite_incremental_continue'])) {
+                        continue;
+                    }
+                    foreach ($hooks['siteskite_incremental_continue'] as $event) {
+                        $args = $event['args'] ?? [];
+                        $event_backup_id = $args[0] ?? ($args['backup_id'] ?? '');
+                        if (!empty($event_backup_id) && $event_backup_id !== $active_backup_id) {
+                            // Remove this scheduled event for the other backup ID
+                            wp_unschedule_event((int) $timestamp, 'siteskite_incremental_continue', $args);
+                        }
+                    }
+                }
+            }
+        }
+    }
 …
             update_option(self::OPTION_PREFIX . $backup_id, $backup_info);
+            // If incremental mode is enabled, ensure there are no stray incremental-continue jobs
+            // for previous backups on this site. Only one incremental chain should be active at a time.
+            if ($this->is_incremental_enabled()) {
+                $this->cleanup_other_incremental_jobs($backup_id);
+            }
             // Schedule the actual backup process to run immediately after this request
 …
         $this->update_backup_status($backup_id, ['provider' => 'backblaze_b2']);
+        // Ensure a persistent external cron job exists for incremental continuation of this backup
+        if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+            $continueArgs = [$backup_id];
+            $existingJobId = $this->external_cron_manager->get_job_id_by_action('siteskite_incremental_continue', $continueArgs);
+            if (!$existingJobId) {
+                $jobId = $this->external_cron_manager->create_recurring_job(
+                    'siteskite_incremental_continue',
+                    $continueArgs,
+                    'every_minute',
+                    [],
+                    'SiteSkite Incremental Continue'
+                );
+                if ($jobId) {
+                    $this->logger->info('Scheduled persistent external cron for incremental continue at upload start', [
+                        'backup_id' => $backup_id,
+                        'job_id' => $jobId
+                    ]);
+                } else {
+                    $this->logger->warning('Failed to schedule persistent external cron for incremental continue at upload start', [
+                        'backup_id' => $backup_id
+                    ]);
+                }
+            } else {
+                $this->logger->debug('Persistent external cron for incremental continue already exists at upload start', [
+                    'backup_id' => $backup_id,
+                    'job_id' => $existingJobId
+                ]);
+            }
+        }
         try {
             // Send notification
 …
                     $bytesSinceSave += $chunkSize;
+                    // Save progress every 200 uploads
+                    if ($uploadedSinceSave >= 200) {
+                    // Save progress every 200 uploads (or every 50 uploads to reduce race conditions)
+                    // More frequent saves help prevent duplicate uploads when multiple processes run concurrently
+                    $saveInterval = 50; // Reduced from 200 to save more frequently
+                    if ($uploadedSinceSave >= $saveInterval) {
                         $coordinator->saveRemoteIndex($remoteIndex, $provider);
                         try {
 …
                 if ($hash === '' || $size <= 0) { unset($deferred[$hash]); continue; }
                 if (isset($processedThisRun[$hash])) { unset($deferred[$hash]); continue; }
+                // Check if chunk exists on cloud before retrying (prevents duplicate uploads)
+                if (isset($remoteIndex[$hash])) {
+                    unset($deferred[$hash]);
+                    continue;
+                }
+                // Check if chunk exists on cloud even if not in remoteIndex (handles race conditions)
+                if ($objectStore->exists($hash)) {
+                    $remoteIndex[$hash] = time();
+                    $processedThisRun[$hash] = true;
+                    unset($deferred[$hash]);
+                    $this->logger->debug('Deferred chunk already exists on cloud, skipping upload', [
+                        'backup_id' => $backup_id,
+                        'hash' => $hash
+                    ]);
+                    continue;
+                }
                 if (!isset($remoteIndex[$hash])) {
                     // Find the file for this chunk and read the data
 …
                         $objectStore->put($hash, $mem, strlen($chunkData));
                         $chunkSize = strlen($chunkData);
+                        $uploadedBytes += $chunkSize;
+                        $uploadedSinceSave++;
+                        $bytesSinceSave += $chunkSize;
+                        // Only count bytes if chunk wasn't already uploaded (prevent double-counting)
+                        // Check remoteIndex to see if it was already uploaded in a previous cycle
+                        if (!isset($remoteIndex[$hash])) {
+                            $uploadedBytes += $chunkSize;
+                            $uploadedSinceSave++;
+                            $bytesSinceSave += $chunkSize;
+                        }
                         $remoteIndex[$hash] = time();
                         $processedThisRun[$hash] = true;
 …
                 } else { unset($deferred[$hash]); }
+            }
             if ($uploadedSinceSave >= 200) {
+            if ($uploadedSinceSave >= 50) {
                 $coordinator->saveRemoteIndex($remoteIndex, $provider);
                 try { if (function_exists('set_transient')) { set_transient($processedTransientKey, array_keys($processedThisRun), HOUR_IN_SECONDS); } } catch (\Throwable $e) { /* ignore */ }
 …
                         $bytesSinceSave += $chunkSize;
+                        // Track database uploaded bytes separately for accurate size reporting
+                        $progress['db_uploaded_bytes'] = (int)($progress['db_uploaded_bytes'] ?? 0) + $chunkSize;
                         // Track successfully uploaded chunk for cleanup
                         // For S3ObjectStore (async), we'll delete after waitForUploadsToComplete()
 …
+                        }
                         // Save progress every 200 uploads
                         if ($uploadedSinceSave >= 200) {
+                        // Save progress every 50 uploads (reduced from 200 to prevent duplicates)
+                        if ($uploadedSinceSave >= 50) {
                             $coordinator->saveRemoteIndex($remoteIndex, $provider);
                             try {
 …
                                 $progress = $this->get_incremental_progress($backup_id);
                                 $progress['uploaded_bytes'] = (int) ($progress['uploaded_bytes'] ?? 0) + $bytesSinceSave;
+                                // Save db_uploaded_bytes if it was tracked during this batch
+                                if ($dbUploadedBytes > 0) {
+                                    $progress['db_uploaded_bytes'] = (int)($progress['db_uploaded_bytes'] ?? 0) + $dbUploadedBytes;
+                                }
                                 $this->update_incremental_progress($backup_id, $progress);
                             } catch (\Throwable $e) { /* ignore progress persisting */ }
                             $uploadedSinceSave = 0;
                             $bytesSinceSave = 0;
+                            $dbUploadedBytes = 0; // Reset for next batch
+                        }
 …
                             'chunk_size' => $chunkSize
                         ]);
+                    } catch (\RuntimeException $e) {
+                        $message = $e->getMessage();
+                        $this->logger->debug('Database chunk upload failed', [
+                            'backup_id' => $backup_id,
+                            'provider' => $provider,
+                            'chunk_hash' => $chunkHash,
+                            'error' => $message
+                        ]);
+                        if (isset($mem) && is_resource($mem)) {
+                            fclose($mem);
+                        }
+                        // Centralized retry classification
+                        $action = \SiteSkite\Backup\Incremental\RetryPolicy::classify($provider, $e);
+                        if ($action === 'refresh') {
+                            // Request fresh credentials, persist current progress, and schedule a retry soon
+                            $this->refresh_credentials_for_incremental($backup_id, $provider);
+                            try { $coordinator->saveRemoteIndex($remoteIndex, $provider); } catch (\Throwable $t) { /* ignore */ }
+                            try { $this->update_incremental_progress($backup_id, $progress); } catch (\Throwable $t) { /* ignore */ }
+                            $this->schedule_cron_event('siteskite_incremental_continue', [$backup_id], 60, "SiteSkite Incremental Continue");
+                            // Don't return here - continue processing other chunks
+                        } elseif ($action === 'mark_present') {
+                            // Chunk already exists on cloud, mark as present
+                            $remoteIndex[$chunkHash] = time();
+                            $processedThisRun[$chunkHash] = true;
+                            $dbSkippedCount++;
+                            // Delete local chunk since it's already on cloud
+                            if (file_exists($chunkPath)) {
+                                wp_delete_file($chunkPath);
+                            }
+                        } elseif ($action === 'retry') {
+                            // Defer for retry - add to deferred_chunks in progress
+                            if (!isset($progress['deferred_db_chunks'])) {
+                                $progress['deferred_db_chunks'] = [];
+                            }
+                            $progress['deferred_db_chunks'][$chunkHash] = [
+                                'chunk_path' => $chunkPath,
+                                'size' => strlen($chunkData),
+                                'retry_count' => (int)($progress['deferred_db_chunks'][$chunkHash]['retry_count'] ?? 0) + 1
+                            ];
+                            $this->logger->debug('Deferred database chunk for retry', [
+                                'backup_id' => $backup_id,
+                                'chunk_hash' => $chunkHash,
+                                'retry_count' => $progress['deferred_db_chunks'][$chunkHash]['retry_count']
+                            ]);
+                        } else {
+                            // For fatal errors or skip, log and continue
+                            $this->logger->warning('Database chunk upload failed, skipping', [
+                                'backup_id' => $backup_id,
+                                'chunk_hash' => $chunkHash,
+                                'error' => $message,
+                                'action' => $action
+                            ]);
+                        }
                     } catch (\Throwable $e) {
                         $this->logger->error('Failed to upload database chunk', [
+                        $this->logger->error('Unexpected error uploading database chunk', [
                             'backup_id' => $backup_id,
                             'chunk_hash' => $chunkHash,
+                            'error' => $e->getMessage()
+                            'error' => $e->getMessage(),
+                            'type' => get_class($e)
                         ]);
+                        // Defer for retry on unexpected errors
+                        if (!isset($progress['deferred_db_chunks'])) {
+                            $progress['deferred_db_chunks'] = [];
+                        }
+                        $progress['deferred_db_chunks'][$chunkHash] = [
+                            'chunk_path' => $chunkPath,
+                            'size' => strlen($chunkData),
+                            'retry_count' => (int)($progress['deferred_db_chunks'][$chunkHash]['retry_count'] ?? 0) + 1
+                        ];
+                    }
+                }
 …
                         $progress = $this->get_incremental_progress($backup_id);
                         $progress['uploaded_bytes'] = (int) ($progress['uploaded_bytes'] ?? 0) + $bytesSinceSave;
+                        // Save db_uploaded_bytes if it was tracked during this batch
+                        if ($dbUploadedBytes > 0) {
+                            $progress['db_uploaded_bytes'] = (int)($progress['db_uploaded_bytes'] ?? 0) + $dbUploadedBytes;
+                        }
                         $this->update_incremental_progress($backup_id, $progress);
                     } catch (\Throwable $e) { /* ignore progress persisting */ }
                     $bytesSinceSave = 0;
+                    $dbUploadedBytes = 0; // Reset for next batch
+                }
 …
+                }
+                // Process deferred database chunks with retry logic
+                $deferredDbChunks = $progress['deferred_db_chunks'] ?? [];
+                if (!empty($deferredDbChunks)) {
+                    $this->logger->info('Processing deferred database chunks', [
+                        'backup_id' => $backup_id,
+                        'deferred_count' => count($deferredDbChunks)
+                    ]);
+                    $dbDeferredRetries = 0;
+                    while (!empty($deferredDbChunks) && $dbDeferredRetries < 3) {
+                        if (function_exists('get_option') && get_option('siteskite_disable_network_calls')) { break; }
+                        $dbDeferredRetries++;
+                        // Backoff grows: 2s, 4s, 8s
+                        sleep($dbDeferredRetries === 1 ? 2 : ($dbDeferredRetries === 2 ? 4 : 8));
+                        foreach ($deferredDbChunks as $chunkHash => $meta) {
+                            // Skip if already processed or in remote index
+                            if (isset($processedThisRun[$chunkHash]) || isset($remoteIndex[$chunkHash])) {
+                                unset($deferredDbChunks[$chunkHash]);
+                                continue;
+                            }
+                            // Check if chunk exists on cloud before retrying
+                            if ($objectStore->exists($chunkHash)) {
+                                $remoteIndex[$chunkHash] = time();
+                                $processedThisRun[$chunkHash] = true;
+                                $dbSkippedCount++;
+                                // Delete local chunk since it's already on cloud
+                                $chunkPath = $meta['chunk_path'] ?? $this->backup_config->getChunkPath($chunkHash);
+                                if (file_exists($chunkPath)) {
+                                    wp_delete_file($chunkPath);
+                                }
+                                unset($deferredDbChunks[$chunkHash]);
+                                $this->logger->debug('Deferred database chunk already exists on cloud, skipping upload', [
+                                    'backup_id' => $backup_id,
+                                    'chunk_hash' => $chunkHash
+                                ]);
+                                continue;
+                            }
+                            $chunkPath = $meta['chunk_path'] ?? $this->backup_config->getChunkPath($chunkHash);
+                            $chunkSize = (int)($meta['size'] ?? 0);
+                            $retryCount = (int)($meta['retry_count'] ?? 0);
+                            if (!file_exists($chunkPath) || $chunkSize <= 0) {
+                                $this->logger->warning('Deferred database chunk file missing or invalid, removing from deferred', [
+                                    'backup_id' => $backup_id,
+                                    'chunk_hash' => $chunkHash,
+                                    'chunk_path' => $chunkPath
+                                ]);
+                                unset($deferredDbChunks[$chunkHash]);
+                                continue;
+                            }
+                            // Read chunk data
+                            $chunkData = file_get_contents($chunkPath);
+                            if ($chunkData === false || strlen($chunkData) !== $chunkSize) {
+                                $this->logger->warning('Failed to read deferred database chunk or size mismatch', [
+                                    'backup_id' => $backup_id,
+                                    'chunk_hash' => $chunkHash,
+                                    'expected_size' => $chunkSize,
+                                    'actual_size' => $chunkData !== false ? strlen($chunkData) : 0
+                                ]);
+                                unset($deferredDbChunks[$chunkHash]);
+                                continue;
+                            }
+                            // Retry upload
+                            try {
+                                $mem = fopen('php://temp', 'rb+');
+                                fwrite($mem, $chunkData);
+                                rewind($mem);
+                                $objectStore->put($chunkHash, $mem, strlen($chunkData));
+                                // Only count bytes if chunk wasn't already uploaded (prevent double-counting)
+                                // Check remoteIndex to see if it was already uploaded in a previous cycle
+                                $wasAlreadyUploaded = isset($remoteIndex[$chunkHash]);
+                                $remoteIndex[$chunkHash] = time();
+                                $processedThisRun[$chunkHash] = true;
+                                if (!$wasAlreadyUploaded) {
+                                    $dbUploadedBytes += $chunkSize;
+                                    $uploadedBytes += $chunkSize;
+                                    $dbUploadedCount++;
+                                    $uploadedSinceSave++;
+                                    $bytesSinceSave += $chunkSize;
+                                    // Track database uploaded bytes (only count once)
+                                    $progress['db_uploaded_bytes'] = (int)($progress['db_uploaded_bytes'] ?? 0) + $chunkSize;
+                                } else {
+                                    // Chunk was already uploaded, just mark as processed
+                                    $this->logger->debug('Deferred database chunk was already uploaded, skipping byte count', [
+                                        'backup_id' => $backup_id,
+                                        'chunk_hash' => $chunkHash
+                                    ]);
+                                }
+                                // Delete local chunk after successful upload
+                                if (file_exists($chunkPath)) {
+                                    wp_delete_file($chunkPath);
+                                }
+                                unset($deferredDbChunks[$chunkHash]);
+                                $this->logger->debug('Successfully retried deferred database chunk', [
+                                    'backup_id' => $backup_id,
+                                    'chunk_hash' => $chunkHash,
+                                    'retry_count' => $retryCount
+                                ]);
+                            } catch (\Throwable $e) {
+                                $this->logger->debug('Deferred database chunk retry failed', [
+                                    'backup_id' => $backup_id,
+                                    'chunk_hash' => $chunkHash,
+                                    'retry_count' => $retryCount,
+                                    'error' => $e->getMessage()
+                                ]);
+                                // Keep in deferred for next retry attempt
+                                $deferredDbChunks[$chunkHash]['retry_count'] = $retryCount + 1;
+                            }
+                        }
+                        // Save progress during retry loop
+                        if ($uploadedSinceSave >= 50) {
+                            $coordinator->saveRemoteIndex($remoteIndex, $provider);
+                            try {
+                                if (function_exists('set_transient')) {
+                                    set_transient($processedTransientKey, array_keys($processedThisRun), HOUR_IN_SECONDS);
+                                }
+                            } catch (\Throwable $e) { /* ignore */ }
+                            try {
+                                $progress = $this->get_incremental_progress($backup_id);
+                                $progress['uploaded_bytes'] = (int) ($progress['uploaded_bytes'] ?? 0) + $bytesSinceSave;
+                                if ($dbUploadedBytes > 0) {
+                                    $progress['db_uploaded_bytes'] = (int)($progress['db_uploaded_bytes'] ?? 0) + $dbUploadedBytes;
+                                }
+                                $progress['deferred_db_chunks'] = $deferredDbChunks;
+                                $this->update_incremental_progress($backup_id, $progress);
+                            } catch (\Throwable $e) { /* ignore progress persisting */ }
+                            $uploadedSinceSave = 0;
+                            $bytesSinceSave = 0;
+                            $dbUploadedBytes = 0;
+                        }
+                    }
+                    // Update progress with remaining deferred chunks
+                    $progress['deferred_db_chunks'] = $deferredDbChunks;
+                    if (!empty($deferredDbChunks)) {
+                        $this->logger->info('Some deferred database chunks remain after retries', [
+                            'backup_id' => $backup_id,
+                            'remaining_count' => count($deferredDbChunks)
+                        ]);
+                    } else {
+                        unset($progress['deferred_db_chunks']);
+                    }
+                }
+                // Save final database uploaded bytes to progress
+                if ($dbUploadedBytes > 0) {
+                    try {
+                        $progress = $this->get_incremental_progress($backup_id);
+                        $progress['db_uploaded_bytes'] = (int)($progress['db_uploaded_bytes'] ?? 0) + $dbUploadedBytes;
+                        $this->update_incremental_progress($backup_id, $progress);
+                    } catch (\Throwable $e) { /* ignore */ }
+                }
+                // Comprehensive scan: Check for any remaining chunks in the chunks folder that need upload
+                // This catches chunks that may have been created but not included in the manifest
+                // or chunks from duplicate backup runs
+                $this->logger->info('Scanning chunks folder for any remaining chunks to upload', [
+                    'backup_id' => $backup_id,
+                    'provider' => $provider
+                ]);
+                $chunksBaseDir = SITESKITE_BACKUP_PATH . '/chunks';
+                $remainingChunksUploaded = 0;
+                $remainingChunksSkipped = 0;
+                $remainingChunksBytes = 0;
+                if (is_dir($chunksBaseDir)) {
+                    // Scan all subdirectories in chunks folder (organized by first 2 chars of hash)
+                    $subdirs = glob($chunksBaseDir . '/*', GLOB_ONLYDIR);
+                    foreach ($subdirs as $subdir) {
+                        // Find all .blob files in this subdirectory
+                        $blobFiles = glob($subdir . '/*.blob');
+                        foreach ($blobFiles as $blobFile) {
+                            // Extract hash from filename (filename is hash.blob)
+                            $filename = basename($blobFile, '.blob');
+                            // Validate hash format (should be 64 hex characters for SHA256)
+                            if (strlen($filename) !== 64 || !ctype_xdigit($filename)) {
+                                continue;
+                            }
+                            $chunkHash = $filename;
+                            // Skip if already processed or in remote index
+                            if (isset($processedThisRun[$chunkHash]) || isset($remoteIndex[$chunkHash])) {
+                                $remainingChunksSkipped++;
+                                continue;
+                            }
+                            // Check if chunk exists on cloud
+                            try {
+                                if ($objectStore->exists($chunkHash)) {
+                                    $remoteIndex[$chunkHash] = time();
+                                    $processedThisRun[$chunkHash] = true;
+                                    $remainingChunksSkipped++;
+                                    // Delete local chunk since it's already on cloud
+                                    if (file_exists($blobFile)) {
+                                        wp_delete_file($blobFile);
+                                    }
+                                    continue;
+                                }
+                            } catch (\Throwable $e) {
+                                $this->logger->debug('Error checking if remaining chunk exists on cloud', [
+                                    'backup_id' => $backup_id,
+                                    'chunk_hash' => $chunkHash,
+                                    'error' => $e->getMessage()
+                                ]);
+                                continue;
+                            }
+                            // Chunk exists locally but not on cloud - upload it
+                            try {
+                                $chunkData = file_get_contents($blobFile);
+                                if ($chunkData === false) {
+                                    $this->logger->warning('Failed to read remaining chunk file', [
+                                        'backup_id' => $backup_id,
+                                        'chunk_hash' => $chunkHash,
+                                        'chunk_path' => $blobFile
+                                    ]);
+                                    continue;
+                                }
+                                $mem = fopen('php://temp', 'rb+');
+                                fwrite($mem, $chunkData);
+                                rewind($mem);
+                                $objectStore->put($chunkHash, $mem, strlen($chunkData));
+                                fclose($mem);
+                                $remoteIndex[$chunkHash] = time();
+                                $processedThisRun[$chunkHash] = true;
+                                $chunkSize = strlen($chunkData);
+                                $dbUploadedBytes += $chunkSize;
+                                $uploadedBytes += $chunkSize;
+                                $remainingChunksBytes += $chunkSize;
+                                $remainingChunksUploaded++;
+                                // Track database uploaded bytes
+                                try {
+                                    $progress = $this->get_incremental_progress($backup_id);
+                                    $progress['db_uploaded_bytes'] = (int)($progress['db_uploaded_bytes'] ?? 0) + $chunkSize;
+                                    $this->update_incremental_progress($backup_id, $progress);
+                                } catch (\Throwable $e) { /* ignore */ }
+                                // Delete local chunk after successful upload
+                                if (file_exists($blobFile)) {
+                                    wp_delete_file($blobFile);
+                                    $this->logger->debug('Uploaded and deleted remaining chunk', [
+                                        'backup_id' => $backup_id,
+                                        'chunk_hash' => $chunkHash,
+                                        'chunk_size' => $chunkSize
+                                    ]);
+                                }
+                            } catch (\Throwable $e) {
+                                $this->logger->warning('Failed to upload remaining chunk', [
+                                    'backup_id' => $backup_id,
+                                    'chunk_hash' => $chunkHash,
+                                    'chunk_path' => $blobFile,
+                                    'error' => $e->getMessage()
+                                ]);
+                            }
+                        }
+                    }
+                    // Save remote index after scanning
+                    if ($remainingChunksUploaded > 0 || $remainingChunksSkipped > 0) {
+                        $coordinator->saveRemoteIndex($remoteIndex, $provider);
+                        $this->logger->info('Completed scan of chunks folder', [
+                            'backup_id' => $backup_id,
+                            'provider' => $provider,
+                            'remaining_chunks_uploaded' => $remainingChunksUploaded,
+                            'remaining_chunks_skipped' => $remainingChunksSkipped,
+                            'remaining_chunks_bytes' => $remainingChunksBytes
+                        ]);
+                    }
+                }
                 $this->logger->info('Database chunks processing completed', [
                     'backup_id' => $backup_id,
                     'provider' => $provider,
+                    'uploaded_count' => $dbUploadedCount,
+                    'skipped_count' => $dbSkippedCount,
+                    'uploaded_count' => $dbUploadedCount + $remainingChunksUploaded,
+                    'skipped_count' => $dbSkippedCount + $remainingChunksSkipped,
+                    'remaining_chunks_uploaded' => $remainingChunksUploaded,
                     'uploaded_bytes' => $dbUploadedBytes
                 ]);
 …
                 'manifest_id' => $dbManifestId
             ]);
+        }
+            // Even without a manifest, scan for any remaining chunks that need upload
+            // This handles cases where chunks were created but manifest wasn't saved
+            $this->logger->info('Scanning chunks folder for orphaned chunks (no manifest found)', [
+                'backup_id' => $backup_id,
+                'provider' => $provider
+            ]);
+            $chunksBaseDir = SITESKITE_BACKUP_PATH . '/chunks';
+            $orphanedChunksUploaded = 0;
+            $orphanedChunksSkipped = 0;
+            if (is_dir($chunksBaseDir)) {
+                $subdirs = glob($chunksBaseDir . '/*', GLOB_ONLYDIR);
+                foreach ($subdirs as $subdir) {
+                    $blobFiles = glob($subdir . '/*.blob');
+                    foreach ($blobFiles as $blobFile) {
+                        $filename = basename($blobFile, '.blob');
+                        if (strlen($filename) !== 64 || !ctype_xdigit($filename)) {
+                            continue;
+                        }
+                        $chunkHash = $filename;
+                        // Skip if already in remote index
+                        if (isset($remoteIndex[$chunkHash])) {
+                            $orphanedChunksSkipped++;
+                            continue;
+                        }
+                        // Check if chunk exists on cloud
+                        try {
+                            if ($objectStore->exists($chunkHash)) {
+                                $remoteIndex[$chunkHash] = time();
+                                $orphanedChunksSkipped++;
+                                if (file_exists($blobFile)) {
+                                    wp_delete_file($blobFile);
+                                }
+                                continue;
+                            }
+                        } catch (\Throwable $e) {
+                            continue;
+                        }
+                        // Upload orphaned chunk
+                        try {
+                            $chunkData = file_get_contents($blobFile);
+                            if ($chunkData === false) {
+                                continue;
+                            }
+                            $mem = fopen('php://temp', 'rb+');
+                            fwrite($mem, $chunkData);
+                            rewind($mem);
+                            $objectStore->put($chunkHash, $mem, strlen($chunkData));
+                            fclose($mem);
+                            $remoteIndex[$chunkHash] = time();
+                            $chunkSize = strlen($chunkData);
+                            $uploadedBytes += $chunkSize;
+                            $orphanedChunksUploaded++;
+                            // Track database uploaded bytes
+                            try {
+                                $progress = $this->get_incremental_progress($backup_id);
+                                $progress['db_uploaded_bytes'] = (int)($progress['db_uploaded_bytes'] ?? 0) + $chunkSize;
+                                $this->update_incremental_progress($backup_id, $progress);
+                            } catch (\Throwable $e) { /* ignore */ }
+                            if (file_exists($blobFile)) {
+                                wp_delete_file($blobFile);
+                            }
+                        } catch (\Throwable $e) {
+                            // Log but continue
+                        }
+                    }
+                }
+                if ($orphanedChunksUploaded > 0 || $orphanedChunksSkipped > 0) {
+                    $coordinator->saveRemoteIndex($remoteIndex, $provider);
+                    $this->logger->info('Completed scan for orphaned chunks', [
+                        'backup_id' => $backup_id,
+                        'provider' => $provider,
+                        'orphaned_chunks_uploaded' => $orphanedChunksUploaded,
+                        'orphaned_chunks_skipped' => $orphanedChunksSkipped
+                    ]);
+                }
+            }
+        }
+        // Final comprehensive scan: Always check for any remaining chunks in the chunks folder
+        // This ensures we catch chunks that may have been created after manifest processing
+        // or from duplicate backup runs
+        $this->logger->info('Performing final scan of chunks folder for any remaining chunks', [
+            'backup_id' => $backup_id,
+            'provider' => $provider
+        ]);
+        $chunksBaseDir = SITESKITE_BACKUP_PATH . '/chunks';
+        $finalScanUploaded = 0;
+        $finalScanSkipped = 0;
+        $finalScanBytes = 0;
+        if (is_dir($chunksBaseDir)) {
+            $subdirs = glob($chunksBaseDir . '/*', GLOB_ONLYDIR);
+            foreach ($subdirs as $subdir) {
+                $blobFiles = glob($subdir . '/*.blob');
+                foreach ($blobFiles as $blobFile) {
+                    $filename = basename($blobFile, '.blob');
+                    if (strlen($filename) !== 64 || !ctype_xdigit($filename)) {
+                        continue;
+                    }
+                    $chunkHash = $filename;
+                    // Skip if already processed or in remote index
+                    if (isset($processedThisRun[$chunkHash]) || isset($remoteIndex[$chunkHash])) {
+                        $finalScanSkipped++;
+                        continue;
+                    }
+                    // Check if chunk exists on cloud
+                    try {
+                        if ($objectStore->exists($chunkHash)) {
+                            $remoteIndex[$chunkHash] = time();
+                            $processedThisRun[$chunkHash] = true;
+                            $finalScanSkipped++;
+                            if (file_exists($blobFile)) {
+                                wp_delete_file($blobFile);
+                            }
+                            continue;
+                        }
+                    } catch (\Throwable $e) {
+                        $this->logger->debug('Error checking chunk in final scan', [
+                            'backup_id' => $backup_id,
+                            'chunk_hash' => $chunkHash,
+                            'error' => $e->getMessage()
+                        ]);
+                        continue;
+                    }
+                    // Chunk exists locally but not on cloud - upload it
+                    try {
+                        $chunkData = file_get_contents($blobFile);
+                        if ($chunkData === false) {
+                            continue;
+                        }
+                        $mem = fopen('php://temp', 'rb+');
+                        fwrite($mem, $chunkData);
+                        rewind($mem);
+                        $objectStore->put($chunkHash, $mem, strlen($chunkData));
+                        fclose($mem);
+                        $remoteIndex[$chunkHash] = time();
+                        $processedThisRun[$chunkHash] = true;
+                        $chunkSize = strlen($chunkData);
+                        $uploadedBytes += $chunkSize;
+                        $finalScanBytes += $chunkSize;
+                        $finalScanUploaded++;
+                        // Track database uploaded bytes
+                        try {
+                            $progress = $this->get_incremental_progress($backup_id);
+                            $progress['db_uploaded_bytes'] = (int)($progress['db_uploaded_bytes'] ?? 0) + $chunkSize;
+                            $this->update_incremental_progress($backup_id, $progress);
+                        } catch (\Throwable $e) { /* ignore */ }
+                        if (file_exists($blobFile)) {
+                            wp_delete_file($blobFile);
+                            $this->logger->info('Uploaded remaining chunk from final scan', [
+                                'backup_id' => $backup_id,
+                                'chunk_hash' => $chunkHash,
+                                'chunk_size' => $chunkSize
+                            ]);
+                        }
+                    } catch (\Throwable $e) {
+                        $this->logger->warning('Failed to upload chunk in final scan', [
+                            'backup_id' => $backup_id,
+                            'chunk_hash' => $chunkHash,
+                            'error' => $e->getMessage()
+                        ]);
+                    }
+                }
+            }
+            // Save remote index after final scan
+            if ($finalScanUploaded > 0 || $finalScanSkipped > 0) {
+                $coordinator->saveRemoteIndex($remoteIndex, $provider);
+                $this->logger->info('Final scan of chunks folder completed', [
+                    'backup_id' => $backup_id,
+                    'provider' => $provider,
+                    'final_scan_uploaded' => $finalScanUploaded,
+                    'final_scan_skipped' => $finalScanSkipped,
+                    'final_scan_bytes' => $finalScanBytes
+                ]);
+            }
+        }
         $this->logger->info('Chunk upload completed', [
             'backup_id' => $backup_id,
 …
             'files_processed' => count($filesToProcess),
             'total_files' => $progress['total_files'],
+            'processed_files_count' => count($progress['processed_files'])
+            'processed_files_count' => count($progress['processed_files']),
+            'final_scan_uploaded' => $finalScanUploaded
         ]);
 …
             // Schedule next chunk if not completed and more files to process OR deferred chunks remain
             if ($processed150Files || $hasDeferredChunks) {
+            if ($processedCount < $totalFiles || $hasDeferredChunks) {
                 $this->logger->info('Scheduling next incremental continue chunk', [
                     'backup_id' => $backup_id,
 …
                 ]);
+                // Use external cron if enabled and we processed 150 files (or have deferred chunks)
+                // If we've hit a full batch or have deferred work, use a long-lived external cron
+                // so that continuation is resilient even if WordPress cron stops running.
                 if ($this->external_cron_manager && $this->external_cron_manager->is_enabled() && ($processed150Files || $hasDeferredChunks)) {
                     // Check if job already exists to prevent duplicates
+                    // Check if a recurring incremental-continue job already exists
                     $existing_job_id = $this->external_cron_manager->get_job_id_by_action('siteskite_incremental_continue', [$backup_id]);
                     if (!$existing_job_id) {
+                        // Schedule recurring "every_minute" job that continues until all files are processed
+                        // Do NOT mark for auto-deletion - it will run every minute until completion
+                        // Schedule a recurring "every_minute" job that stays visible until we explicitly clean it up
                         $job_id = $this->external_cron_manager->create_recurring_job(
                             'siteskite_incremental_continue',
 …
                         if ($job_id) {
                             $this->logger->info('Scheduled external cron for incremental continue (recurring every minute)', [
+                            $this->logger->info('Scheduled persistent external cron for incremental continue', [
                                 'backup_id' => $backup_id,
                                 'job_id' => $job_id,
 …
                             ]);
                         } else {
                             // Fallback to coordinator scheduling if external cron fails
                             $this->logger->warning('Failed to schedule external cron, falling back to coordinator', [
+                            // Fallback to coordinator scheduling if external cron creation fails
+                            $this->logger->warning('Failed to schedule persistent external cron, falling back to WordPress cron coordinator', [
                                 'backup_id' => $backup_id
                             ]);
 …
+                        }
                     } else {
                         $this->logger->debug('External cron job already exists for incremental continue, skipping creation', [
+                        $this->logger->debug('Persistent external cron job for incremental continue already exists, skipping creation', [
                             'backup_id' => $backup_id,
                             'existing_job_id' => $existing_job_id
 …
+                    }
                 } else {
                     // Use coordinator scheduling if external cron is disabled or conditions not met
+                    // Use coordinator / WordPress cron scheduling if external cron is not available
                     $delay = $hasDeferredChunks ? 10 : 15;
                     $coordinator->scheduleNext($backup_id, $delay);
+                }
             } else {
+                // Not enough files processed and no deferred chunks - use normal scheduling
+                $delay = $hasDeferredChunks ? 10 : 15;
+                $coordinator->scheduleNext($backup_id, $delay);
+                // No additional work detected; nothing to schedule
+                $this->logger->info('No additional work detected for incremental continue', [
+                    'backup_id' => $backup_id,
+                    'processed_files' => $processedCount,
+                    'total_files' => $totalFiles
+                ]);
+            }
         } else {
 …
+    {
         try {
+            // Check if backup is already completed to prevent duplicate runs
+            $backup_info = get_option(self::OPTION_PREFIX . $backup_id);
+            if ($backup_info && isset($backup_info['status']) && $backup_info['status'] === 'completed') {
+                $this->logger->info('Backup already completed, skipping duplicate run', [
+                    'backup_id' => $backup_id,
+                    'status' => $backup_info['status']
+                ]);
+                return;
+            }
+            // Prevent duplicate concurrent executions with a lightweight lock
+            $lock_key = 'siteskite_full_backup_lock_' . $backup_id;
+            $lock_value = time();
+            if (!add_option($lock_key, $lock_value, '', 'no')) {
+                $existing_lock = get_option($lock_key);
+                // If another run started within the last 2 minutes, skip this trigger
+                if ($existing_lock && (time() - (int) $existing_lock) < 120) {
+                    $this->logger->info('Full backup already in progress, skipping duplicate trigger', [
+                        'backup_id' => $backup_id,
+                        'lock_age' => time() - (int) $existing_lock
+                    ]);
+                    return;
+                }
+                // Stale lock: remove and attempt to acquire once more
+                delete_option($lock_key);
+                if (!add_option($lock_key, $lock_value, '', 'no')) {
+                    $this->logger->info('Failed to acquire full backup lock, skipping trigger', [
+                        'backup_id' => $backup_id
+                    ]);
+                    return;
+                }
+            }
             $this->logger->info('Processing full backup cron', [
+                      'backup_id' => $backup_id
+                  ]);
+            $this->process_full_backup($backup_id);
+                'backup_id' => $backup_id
+            ]);
+            try {
+                $this->process_full_backup($backup_id);
+            } finally {
+                // Release lock after processing attempt
+                delete_option($lock_key);
+            }
         } catch (\Exception $e) {
             $this->logger->error('Full backup cron failed', [
 …
             return;
+        }
+        // Ensure no other incremental-continue jobs are active for different backup IDs
+        // This enforces the "only one incremental job at a time" rule.
+        $this->cleanup_other_incremental_jobs($backup_id);
         // Check if backup is still valid
 …
                 'backup_id' => $backup_id
             ]);
+            return;
+        }
+        // If backup is already completed, no need to continue processing
+        $backup_status = $backup_info['status'] ?? '';
+        if ($backup_status === 'completed') {
+            $this->logger->debug('Backup already completed, skipping incremental continue', [
+                'backup_id' => $backup_id,
+                'status' => $backup_status
+            ]);
+            // Clean up any pending incremental continuation jobs for this backup
+            // Clean up external cron jobs for non-existent backup
             if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
                 $deleted_count = $this->external_cron_manager->delete_jobs_by_backup_id('siteskite_incremental_continue', $backup_id);
                 if ($deleted_count > 0) {
                     $this->logger->info('Cleaned up pending incremental continuation jobs for completed backup', [
+                    $this->logger->info('Cleaned up external cron jobs for non-existent backup', [
                         'backup_id' => $backup_id,
                         'deleted_count' => $deleted_count
 …
+                }
+            }
-            // Also clear WordPress cron events for this backup
             wp_clear_scheduled_hook('siteskite_incremental_continue', [$backup_id]);
-            // Ensure logs are cleared once more on any stray continue invocations post-completion
-            try { $this->logger->delete_todays_log(); } catch (\Throwable $t) { /* ignore */ }
-            try { $this->logger->cleanup_old_logs(30); } catch (\Throwable $t) { /* ignore */ }
             return;
+        }
+        // Early check: If backup is already completed, clean up and return immediately
+        $backup_status = $backup_info['status'] ?? '';
+        if ($backup_status === 'completed') {
+            // Check if there are any remaining database chunks that need to be uploaded
+            // This can happen if a duplicate backup run created new chunks after completion
+            $dbManifestId = 'database:' . $backup_id;
+            $dbManifestJson = $this->manifest_store->get($dbManifestId);
+            $hasRemainingChunks = false;
+            if ($dbManifestJson) {
+                $dbManifest = json_decode($dbManifestJson, true);
+                if (json_last_error() === JSON_ERROR_NONE && is_array($dbManifest)) {
+                    $newDbChunks = $dbManifest['changes']['new_chunks'] ?? [];
+                    if (!empty($newDbChunks)) {
+                        // Check if any of these chunks exist locally but haven't been uploaded
+                        $status_data = $this->get_backup_status_data($backup_id);
+                        $provider = is_array($status_data) ? ($status_data['provider'] ?? '') : '';
+                        if ($provider) {
+                            try {
+                                $objectStore = \SiteSkite\Backup\Incremental\ProviderFactory::build($this->logger, $provider, $status_data);
+                                if ($objectStore) {
+                                    $coordinator = new \SiteSkite\Backup\Incremental\RemoteIndexCoordinator($this->logger, $this->backup_config);
+                                    $remoteIndex = $coordinator->loadRemoteIndex($backup_id, $provider);
+                                    foreach ($newDbChunks as $chunkHash) {
+                                        $chunkPath = $this->backup_config->getChunkPath($chunkHash);
+                                        if (file_exists($chunkPath) && !isset($remoteIndex[$chunkHash]) && !$objectStore->exists($chunkHash)) {
+                                            $hasRemainingChunks = true;
+                                            $this->logger->warning('Found remaining database chunk that needs upload after backup completion', [
+                                                'backup_id' => $backup_id,
+                                                'chunk_hash' => $chunkHash,
+                                                'chunk_path' => $chunkPath
+                                            ]);
+                                            break;
+                                        }
+                                    }
+                                }
+                            } catch (\Throwable $t) {
+                                $this->logger->debug('Error checking for remaining chunks', [
+                                    'backup_id' => $backup_id,
+                                    'error' => $t->getMessage()
+                                ]);
+                            }
+                        }
+                    }
+                }
+            }
+            if (!$hasRemainingChunks) {
+                $this->logger->debug('Backup already completed, skipping incremental continue', [
+                    'backup_id' => $backup_id,
+                    'status' => $backup_status
+                ]);
+                // Clean up any pending incremental continuation jobs for this backup
+                if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
+                    $deleted_count = $this->external_cron_manager->delete_jobs_by_backup_id('siteskite_incremental_continue', $backup_id);
+                    if ($deleted_count > 0) {
+                        $this->logger->info('Cleaned up pending incremental continuation jobs for completed backup', [
+                            'backup_id' => $backup_id,
+                            'deleted_count' => $deleted_count
+                        ]);
+                    }
+                }
+                // Also clear WordPress cron events for this backup
+                wp_clear_scheduled_hook('siteskite_incremental_continue', [$backup_id]);
+                // Ensure logs are cleared once more on any stray continue invocations post-completion
+                try { $this->logger->delete_todays_log(); } catch (\Throwable $t) { /* ignore */ }
+                try { $this->logger->cleanup_old_logs(30); } catch (\Throwable $t) { /* ignore */ }
+                return;
+            } else {
+                // There are remaining chunks, continue processing to upload them
+                $this->logger->info('Backup completed but found remaining database chunks, continuing to upload', [
+                    'backup_id' => $backup_id
+                ]);
+            }
+        }
 …
         $provider = $status_data['provider'] ?? 'unknown';
         // Guard against duplicate completion calls
+        // Guard against duplicate completion calls using atomic lock mechanism
         $completion_lock_key = 'siteskite_completing_' . $backup_id;
+        if (function_exists('get_transient') && get_transient($completion_lock_key)) {
+        $lock_timeout = 300; // 5 minutes
+        // Use WordPress options for more atomic lock checking
+        if (function_exists('get_option')) {
+            $existing_lock = get_option($completion_lock_key, false);
+            if ($existing_lock) {
+                $lock_timestamp = (int)$existing_lock;
+                $lock_age = time() - $lock_timestamp;
+                // If lock is still valid (less than timeout), skip
+                if ($lock_age < $lock_timeout) {
+                    $this->logger->debug('Incremental backup completion already in progress, skipping duplicate call', [
+                        'backup_id' => $backup_id,
+                        'provider' => $provider,
+                        'lock_age_seconds' => $lock_age
+                    ]);
+                    return;
+                } else {
+                    // Lock expired, log and continue (will set new lock below)
+                    $this->logger->debug('Completion lock expired, proceeding with new completion attempt', [
+                        'backup_id' => $backup_id,
+                        'lock_age_seconds' => $lock_age
+                    ]);
+                }
+            }
+            // Set completion lock atomically using current timestamp
+            update_option($completion_lock_key, time(), false);
+        } elseif (function_exists('get_transient') && get_transient($completion_lock_key)) {
+            // Fallback to transient if options not available
             $this->logger->debug('Incremental backup completion already in progress, skipping duplicate call', [
                 'backup_id' => $backup_id,
 …
             ]);
             return;
+        }
+        // Set completion lock (expires in 5 minutes to prevent permanent locks)
+        if (function_exists('set_transient')) {
+            set_transient($completion_lock_key, true, 300);
+        } elseif (function_exists('set_transient')) {
+            // Fallback: Set completion lock (expires in 5 minutes to prevent permanent locks)
+            set_transient($completion_lock_key, true, $lock_timeout);
+        }
 …
                 $this->update_incremental_progress($backup_id, $progress);
+                // Release completion lock on verification failure to allow retry
+                if (function_exists('delete_option')) {
+                    delete_option($completion_lock_key);
+                } elseif (function_exists('delete_transient')) {
+                    delete_transient($completion_lock_key);
+                }
                 return;
+            }
             // Calculate file info for completion - use tracked uploaded_bytes instead of manifest stats
+            // This ensures we only report actually uploaded bytes, not total bytes including skipped chunks
             $db_manifestId = $this->manifest_store->getLatestId('database');
             $db_manifestJson = $db_manifestId ? $this->manifest_store->get('database:' . $db_manifestId) : null;
             $db_manifest = $db_manifestJson ? json_decode($db_manifestJson, true) : [];
-            $db_size = (int)($db_manifest['stats']['bytes_processed'] ?? 0);
             // Get actual uploaded bytes from progress tracker (tracks chunk uploads accurately)
 …
             $uploadedBytes = (int)($progressNow['uploaded_bytes'] ?? 0);
             $totalFilesPlanned = (int)($progressNow['total_files'] ?? 0);
+            // Log current progress state for debugging
+            $this->logger->debug('Size calculation from progress', [
+                'backup_id' => $backup_id,
+                'uploaded_bytes' => $uploadedBytes,
+                'db_uploaded_bytes' => $progressNow['db_uploaded_bytes'] ?? 'not set',
+                'total_files' => $totalFilesPlanned
+            ]);
+            // Calculate database size: only count actually uploaded chunks, not all chunks
+            // Get database uploaded bytes from the upload process (stored separately)
+            // For database, we need to check if chunks were uploaded or skipped
+            $db_uploaded_bytes = 0;
+            if (isset($progressNow['db_uploaded_bytes'])) {
+                $db_uploaded_bytes = (int)($progressNow['db_uploaded_bytes']);
+                $this->logger->debug('Using tracked db_uploaded_bytes from progress', [
+                    'backup_id' => $backup_id,
+                    'db_uploaded_bytes' => $db_uploaded_bytes
+                ]);
+            } else {
+                // Fallback: if tracking is missing, we need to calculate from actually uploaded chunks
+                // This is more accurate than using bytes_processed which includes reused chunks
+                $new_db_chunks = $db_manifest['changes']['new_chunks'] ?? [];
+                $reused_db_chunks = $db_manifest['changes']['reused_chunks'] ?? [];
+                $total_db_chunks = count($new_db_chunks) + count($reused_db_chunks);
+                if ($total_db_chunks > 0 && count($new_db_chunks) > 0) {
+                    // Calculate size based on new chunks only (reused chunks weren't uploaded)
+                    $total_bytes_processed = (int)($db_manifest['stats']['bytes_processed'] ?? 0);
+                    // Estimate: only count new chunks proportionally
+                    $db_uploaded_bytes = (int)(($total_bytes_processed * count($new_db_chunks)) / $total_db_chunks);
+                    $this->logger->debug('Calculated db_uploaded_bytes from manifest (new chunks only)', [
+                        'backup_id' => $backup_id,
+                        'db_uploaded_bytes' => $db_uploaded_bytes,
+                        'new_chunks' => count($new_db_chunks),
+                        'reused_chunks' => count($reused_db_chunks),
+                        'total_bytes_processed' => $total_bytes_processed
+                    ]);
+                } else {
+                    // No new chunks means nothing was uploaded
+                    $db_uploaded_bytes = 0;
+                    $this->logger->debug('No new database chunks, db_uploaded_bytes is 0', [
+                        'backup_id' => $backup_id
+                    ]);
+                }
+            }
             // Use tracked uploaded_bytes when files were actually uploaded; fallback to manifest stats if tracking is missing
 …
                 $db_manifest_bytes = $db_manifestJson ? strlen($db_manifestJson) : 0;
                 $files_manifest_bytes = $files_manifestJson ? strlen($files_manifestJson) : 0;
                 $db_size = $db_manifest_bytes;
+                $db_uploaded_bytes = $db_manifest_bytes;
                 $files_size = $files_manifest_bytes;
                 $this->logger->info('Reporting manifest upload sizes since no content needed upload', [
 …
             $file_info = [
                 'database' => [
                     'size' => $db_size,
+                    'size' => $db_uploaded_bytes,
                     'path' => 'incremental_database_objects',
                     'download_url' => null // No direct download for incremental
 …
                     'path' => 'incremental_objects'
                 ],
                 'total_size' => $db_size + $files_size
+                'total_size' => $db_uploaded_bytes + $files_size
             ];
 …
             $this->cleanup_incremental_records($backup_id, $provider);
+            // Cleanup chunks folder - remove database chunks that were uploaded in this backup
+            try {
+                $this->cleanup_uploaded_chunks($backup_id, $provider);
+            } catch (\Throwable $t) {
+                $this->logger->warning('Failed to cleanup chunks folder', [
+                    'backup_id' => $backup_id,
+                    'error' => $t->getMessage()
+                ]);
+            }
             // Clean up external cron recurring job for incremental continue
             if ($this->external_cron_manager && $this->external_cron_manager->is_enabled()) {
 …
             wp_clear_scheduled_hook('siteskite_incremental_continue', [$backup_id]);
             $this->logger->delete_todays_log();
+         //   $this->logger->delete_todays_log();
             // Immediately cleanup old logs (mirroring restore behavior). Does not touch manifests or indexes.
             try {
                 $this->logger->cleanup_old_logs(30);
+            //  $this->logger->cleanup_old_logs(30);
                 $this->logger->info('Old logs cleanup completed (immediate post-incremental)', [ 'backup_id' => $backup_id ]);
             } catch (\Throwable $t) {
 …
             // Release completion lock on success
+            if (function_exists('delete_transient')) {
+            if (function_exists('delete_option')) {
+                delete_option($completion_lock_key);
+            } elseif (function_exists('delete_transient')) {
                 delete_transient($completion_lock_key);
+            }
 …
             // Release completion lock on error
+            if (function_exists('delete_transient')) {
+            if (function_exists('delete_option')) {
+                delete_option($completion_lock_key);
+            } elseif (function_exists('delete_transient')) {
                 delete_transient($completion_lock_key);
+            }
 …
                 'backup_id' => $backup_id,
                 'provider' => $provider,
+                'error' => $t->getMessage()
+            ]);
+        }
+    }
+    /**
+     * Cleanup chunks folder - remove database chunks that were uploaded in this backup
+     * Only removes chunks from this specific backup to avoid deleting shared chunks
+     * Checks if chunks exist on cloud before deleting to prevent data loss
+     */
+    private function cleanup_uploaded_chunks(string $backup_id, string $provider): void
+    {
+        try {
+            // Get object store to check if chunks exist on cloud
+            $objectStore = null;
+            try {
+                // Get status data for the provider to build object store
+                $status_data = $this->get_backup_status_data($backup_id);
+                if (is_array($status_data) && !empty($status_data)) {
+                    $objectStore = \SiteSkite\Backup\Incremental\ProviderFactory::build($this->logger, $provider, $status_data);
+                } else {
+                    // Try to get status data from provider-specific option
+                    $provider_keys = [
+                        'dropbox' => 'siteskite_dropbox_status_' . $backup_id,
+                        'google_drive' => 'siteskite_gdrive_status_' . $backup_id,
+                        'backblaze_b2' => 'siteskite_backblaze_b2_status_' . $backup_id,
+                        'pcloud' => 'siteskite_pcloud_status_' . $backup_id,
+                        'aws_s3' => 'siteskite_aws_status_' . $backup_id,
+                        'aws' => 'siteskite_aws_status_' . $backup_id,
+                    ];
+                    $optKey = $provider_keys[$provider] ?? null;
+                    if ($optKey) {
+                        $status_data = get_option($optKey);
+                        if (is_array($status_data) && !empty($status_data)) {
+                            $objectStore = \SiteSkite\Backup\Incremental\ProviderFactory::build($this->logger, $provider, $status_data);
+                        }
+                    }
+                }
+            } catch (\Throwable $e) {
+                $this->logger->warning('Failed to build object store for cleanup verification', [
+                    'backup_id' => $backup_id,
+                    'provider' => $provider,
+                    'error' => $e->getMessage()
+                ]);
+                // Continue without verification if object store can't be built
+            }
+            // Get database manifest to find chunks that were uploaded in this backup
+            $db_manifestId = 'database:' . $backup_id;
+            $db_manifestJson = $this->manifest_store->get($db_manifestId);
+            if (!$db_manifestJson) {
+                $this->logger->debug('No database manifest found for chunks cleanup', [
+                    'backup_id' => $backup_id
+                ]);
+                return;
+            }
+            $db_manifest = json_decode($db_manifestJson, true);
+            if (json_last_error() !== JSON_ERROR_NONE || !is_array($db_manifest)) {
+                return;
+            }
+            // Only cleanup new chunks that were uploaded (not reused chunks which may be needed by other backups)
+            $new_chunks = $db_manifest['changes']['new_chunks'] ?? [];
+            // Also check deferred_db_chunks from progress - these may have been uploaded in retries
+            $progress = $this->get_incremental_progress($backup_id);
+            $deferred_db_chunks = $progress['deferred_db_chunks'] ?? [];
+            $chunksToCheck = array_unique(array_merge($new_chunks, array_keys($deferred_db_chunks)));
+            if (empty($chunksToCheck)) {
+                $this->logger->debug('No chunks to cleanup', [
+                    'backup_id' => $backup_id
+                ]);
+                return;
+            }
+            $chunksBaseDir = SITESKITE_BACKUP_PATH . '/chunks';
+            if (!is_dir($chunksBaseDir)) {
+                return;
+            }
+            $deletedCount = 0;
+            $failedCount = 0;
+            $skippedNotOnCloud = 0;
+            $verifiedOnCloud = 0;
+            foreach ($chunksToCheck as $chunkHash) {
+                $chunkPath = $this->backup_config->getChunkPath($chunkHash);
+                // Only delete if file exists
+                if (!file_exists($chunkPath)) {
+                    continue;
+                }
+                // Verify chunk exists on cloud before deleting (safety check)
+                $shouldDelete = true;
+                if ($objectStore !== null) {
+                    try {
+                        if ($objectStore->exists($chunkHash)) {
+                            $verifiedOnCloud++;
+                            $shouldDelete = true;
+                        } else {
+                            // Chunk not on cloud - don't delete, it may need to be uploaded
+                            $skippedNotOnCloud++;
+                            $shouldDelete = false;
+                            $this->logger->warning('Chunk not found on cloud, skipping deletion', [
+                                'backup_id' => $backup_id,
+                                'chunk_hash' => substr($chunkHash, 0, 16) . '...',
+                                'chunk_path' => $chunkPath
+                            ]);
+                        }
+                    } catch (\Throwable $e) {
+                        // If verification fails, be conservative and don't delete
+                        $this->logger->warning('Failed to verify chunk on cloud, skipping deletion', [
+                            'backup_id' => $backup_id,
+                            'chunk_hash' => substr($chunkHash, 0, 16) . '...',
+                            'error' => $e->getMessage()
+                        ]);
+                        $shouldDelete = false;
+                    }
+                }
+                if ($shouldDelete) {
+                    if (wp_delete_file($chunkPath)) {
+                        $deletedCount++;
+                    } else {
+                        $failedCount++;
+                        $this->logger->warning('Failed to delete chunk file', [
+                            'backup_id' => $backup_id,
+                            'chunk_hash' => substr($chunkHash, 0, 16) . '...',
+                            'chunk_path' => $chunkPath
+                        ]);
+                    }
+                }
+            }
+            if ($deletedCount > 0 || $skippedNotOnCloud > 0) {
+                $this->logger->info('Cleaned up uploaded chunks after backup completion', [
+                    'backup_id' => $backup_id,
+                    'deleted_count' => $deletedCount,
+                    'failed_count' => $failedCount,
+                    'skipped_not_on_cloud' => $skippedNotOnCloud,
+                    'verified_on_cloud' => $verifiedOnCloud,
+                    'total_chunks_checked' => count($chunksToCheck)
+                ]);
+            }
+        } catch (\Throwable $t) {
+            $this->logger->error('Error during chunks cleanup', [
+                'backup_id' => $backup_id,
                 'error' => $t->getMessage()
             ]);

siteskite/trunk/includes/Backup/Incremental/Impl/BackblazeB2ObjectStore.php

-                      r3418578
+                      r3420528
     public function exists(string $hash): bool
+    {
+        // Use cached authentication instead of authenticating every time
+        $this->ensureAuthenticated();
         $fileName = $this->keyFor($hash);
+        $resp = \call_user_func('\\wp_remote_post', 'https://api.backblazeb2.com/b2api/v2/b2_authorize_account', [ 'headers' => [ 'Authorization' => 'Basic ' . base64_encode($this->keyId . ':' . $this->applicationKey) ], 'body' => '{}', 'timeout' => 30 ]);
+        if (\call_user_func('\\is_wp_error', $resp)) { return false; }
+        $auth = json_decode((string) \call_user_func('\\wp_remote_retrieve_body', $resp), true);
+        $apiUrl = $auth['apiUrl'] ?? '';
+        $token = $auth['authorizationToken'] ?? '';
+        if (!$apiUrl || !$token) { return false; }
+        $bucketResp = \call_user_func('\\wp_remote_post', $apiUrl . '/b2api/v2/b2_list_buckets', [ 'headers' => [ 'Authorization' => $token, 'Content-Type' => 'application/json' ], 'body' => \call_user_func('\\wp_json_encode', [ 'accountId' => $auth['accountId'] ?? '', 'bucketName' => $this->bucketName ]) ]);
+        if (\call_user_func('\\is_wp_error', $bucketResp)) { return false; }
+        $bucketData = json_decode((string) \call_user_func('\\wp_remote_retrieve_body', $bucketResp), true);
+        $bucketId = null;
+        foreach (($bucketData['buckets'] ?? []) as $b) { if (($b['bucketName'] ?? '') === $this->bucketName) { $bucketId = $b['bucketId'] ?? null; break; } }
+        if (!$bucketId) { return false; }
+        $list = \call_user_func('\\wp_remote_post', $apiUrl . '/b2api/v2/b2_list_file_names', [ 'headers' => [ 'Authorization' => $token, 'Content-Type' => 'application/json' ], 'body' => \call_user_func('\\wp_json_encode', [ 'bucketId' => $bucketId, 'prefix' => $fileName, 'maxFileCount' => 1 ]) ]);
+        if (\call_user_func('\\is_wp_error', $list)) { return false; }
+        $bucketId = $this->getBucketId();
+        // Use cached API URL and auth token
+        $list = \call_user_func('\\wp_remote_post', $this->apiUrl . '/b2api/v2/b2_list_file_names', [
+            'headers' => [
+                'Authorization' => $this->authToken,
+                'Content-Type' => 'application/json'
+            ],
+            'body' => \call_user_func('\\wp_json_encode', [
+                'bucketId' => $bucketId,
+                'prefix' => $fileName,
+                'maxFileCount' => 1
+            ]),
+            'timeout' => 30
+        ]);
+        if (\call_user_func('\\is_wp_error', $list)) {
+            return false;
+        }
         $listData = json_decode((string) \call_user_func('\\wp_remote_retrieve_body', $list), true);
+        foreach (($listData['files'] ?? []) as $f) { if (($f['fileName'] ?? '') === $fileName) { return true; } }
+        foreach (($listData['files'] ?? []) as $f) {
+            if (($f['fileName'] ?? '') === $fileName) {
+                return true;
+            }
+        }
         return false;
+    }
 …
         elseif ($this->tokenExpiresAt && ($this->tokenExpiresAt - $currentTime) < 3600) {
             $needsRefresh = true;
             $this->logger->debug('Backblaze B2 token expires within 1 hour, proactively refreshing credentials', [
                 'expires_in' => $this->tokenExpiresAt - $currentTime
             ]);
+            // $this->logger->debug('Backblaze B2 token expires within 1 hour, proactively refreshing credentials', [
+            //     'expires_in' => $this->tokenExpiresAt - $currentTime
+            // ]);
+        }
         // Check if we've uploaded too many files (refresh after ~1500 files)
 …
         $this->clearCredentials();
         $this->logger->debug('Authenticating with Backblaze B2', [
             'key_id' => substr($this->keyId, 0, 8) . '...'
         ]);
+        // $this->logger->debug('Authenticating with Backblaze B2', [
+        //     'key_id' => substr($this->keyId, 0, 8) . '...'
+        // ]);
         $resp = \call_user_func('\\wp_remote_post', 'https://api.backblazeb2.com/b2api/v2/b2_authorize_account', [
 …
+        }
         $this->logger->debug('Backblaze B2 authentication successful', [
             'api_url' => $this->apiUrl,
             'upload_count_reset' => true
         ]);
+        // $this->logger->debug('Backblaze B2 authentication successful', [
+        //     'api_url' => $this->apiUrl,
+        //     'upload_count_reset' => true
+        // ]);
+    }

siteskite/trunk/includes/Backup/Incremental/ProviderManifests.php

-                      r3389896
+                      r3420528
                 return [ 'success' => false, 'error' => 'Missing Backblaze B2 credentials' ];
+            }
+            // Check if manifest already exists to prevent duplicate uploads
+            $existing_file = $this->b2->get_file_by_name($manifest_path, $key_id, $application_key, $bucket_name);
+            if (($existing_file['success'] ?? false) && !empty($existing_file['file_id'])) {
+                $this->logger->debug('Manifest already exists on cloud, skipping upload', [
+                    'manifest_path' => $manifest_path,
+                    'file_id' => $existing_file['file_id'] ?? 'unknown'
+                ]);
+                return [ 'success' => true, 'skipped' => true, 'file_id' => $existing_file['file_id'] ?? null ];
+            }
             $temp_file = $this->createTempFile('manifest_');
             file_put_contents($temp_file, $content);

siteskite/trunk/includes/Cloud/BackblazeB2Manager.php

-                      r3400025
+                      r3420528
             $this->logger->debug('Backblaze B2 authentication successful', [
                 'api_url' => $this->api_url,
                 'account_id' => $this->account_id ? 'present' : 'missing'
             ]);
+            // $this->logger->debug('Backblaze B2 authentication successful', [
+            //     'api_url' => $this->api_url,
+            //     'account_id' => $this->account_id ? 'present' : 'missing'
+            // ]);
             return ['success' => true];

siteskite/trunk/includes/Core/Plugin.php

-                      r3418578
+                      r3420528
 use SiteSkite\Cron\ExternalCronManager;
 use SiteSkite\Cron\CronTriggerHandler;
+use SiteSkite\Cron\HybridCronManager;
 use function add_action;
 …
     /**
+     * @var HybridCronManager Hybrid cron manager instance
+     */
+    private ?HybridCronManager $hybrid_cron_manager = null;
+    /**
      * @var CronTriggerHandler Cron trigger handler instance
      */
 …
             // Initialize external cron manager
             $this->external_cron_manager = new ExternalCronManager($this->logger);
+            // Initialize hybrid cron manager
+            $this->hybrid_cron_manager = new HybridCronManager($this->logger, $this->external_cron_manager);
             // Initialize cloud storage managers
 …
                 $this->aws_manager,
                 $incremental_status,
+                $this->external_cron_manager
+                $this->external_cron_manager,
+                $this->hybrid_cron_manager
             );
 …
                 $this->backup_manager,
                 $this->schedule_manager,
+                $this->restore_manager
+                $this->restore_manager,
+                $this->hybrid_cron_manager
             );
 …
             'handle_incremental_continue'
         ], 10, 1);
+        // Hook into WordPress cron actions to notify hybrid cron manager
+        if ($this->hybrid_cron_manager) {
+            // List of cron hooks that should use hybrid cron
+            $hybrid_cron_hooks = [
+                'siteskite_incremental_continue',
+                'process_database_backup_cron',
+                'process_files_backup_cron',
+                'process_full_backup_cron',
+                'siteskite_process_restore',
+                'siteskite_process_incremental_restore'
+            ];
+            foreach ($hybrid_cron_hooks as $hook) {
+                add_action($hook, function(...$args) use ($hook) {
+                    if ($this->hybrid_cron_manager) {
+                        $this->hybrid_cron_manager->on_wp_cron_run($hook, $args);
+                    }
+                }, 999); // High priority to run after the actual action
+            }
+        }
+        // Verify SiteSkite cron token when wp-cron.php is called with siteskite_key
+        // This adds security layer for SiteSkite-triggered cron
+        if (defined('DOING_CRON') && DOING_CRON && isset($_GET['siteskite_key'])) {
+            add_action('init', function() {
+                if ($this->hybrid_cron_manager) {
+                    $token = sanitize_text_field($_GET['siteskite_key'] ?? '');
+                    if (!$this->hybrid_cron_manager->verify_siteskite_cron_token($token)) {
+                        // Invalid token - log and exit gracefully
+                        if ($this->logger) {
+                            $this->logger->warning('Invalid SiteSkite cron token in wp-cron.php', [
+                                'token_length' => strlen($token),
+                                'ip' => $_SERVER['REMOTE_ADDR'] ?? 'unknown'
+                            ]);
+                        }
+                        // Don't block cron execution, but log the security issue
+                    } else {
+                        // Valid token - log for telemetry
+                        if ($this->logger) {
+                            $this->logger->debug('SiteSkite-triggered cron verified', [
+                                'ip' => $_SERVER['REMOTE_ADDR'] ?? 'unknown'
+                            ]);
+                        }
+                    }
+                }
+            }, 1); // Early priority
+        }
+    }
 …
         if (strpos($route, '/cron/trigger') !== false) {
             $this->logger->debug('REST API request received', [
                 'route' => $route,
                 'method' => $request->get_method(),
                 'headers' => $request->get_headers(),
                 'body' => substr($request->get_body(), 0, 500) // First 500 chars
+                // 'route' => $route,
+                // 'method' => $request->get_method(),
+                // 'headers' => $request->get_headers(),
+                // 'body' => substr($request->get_body(), 0, 500) // First 500 chars
             ]);
+        }

siteskite/trunk/includes/Core/Utils.php

-                      r3418578
+                      r3420528
         return (string)$query_params['userID'];
+    }
+    /**
+     * Check if current cron execution was triggered by SiteSkite
+     * This allows identification of SiteSkite-triggered cron vs normal WordPress cron
+     *
+     * Usage:
+     * if (Utils::is_siteskite_triggered_cron()) {
+     *     // Run SiteSkite-specific logic
+     *     // Skip heavy jobs for normal cron
+     *     // Add telemetry
+     * }
+     *
+     * @return bool True if cron was triggered by SiteSkite (wp-cron.php?doing_wp_cron&siteskite_key=...)
+     */
+    public static function is_siteskite_triggered_cron(): bool
+    {
+        return defined('DOING_CRON') && DOING_CRON &&
+               isset($_GET['siteskite_key']) &&
+               !empty($_GET['siteskite_key']);
+    }
+}

siteskite/trunk/includes/Cron/CronTriggerHandler.php

-                      r3418578
+                      r3420528
     private Logger $logger;
     private ExternalCronManager $cron_manager;
+    private ?HybridCronManager $hybrid_cron_manager;
     private BackupManager $backup_manager;
     private ScheduleManager $schedule_manager;
 …
         BackupManager $backup_manager,
         ScheduleManager $schedule_manager,
+        RestoreManager $restore_manager
+        RestoreManager $restore_manager,
+        ?HybridCronManager $hybrid_cron_manager = null
     ) {
         $this->logger = $logger;
         $this->cron_manager = $cron_manager;
+        $this->hybrid_cron_manager = $hybrid_cron_manager;
         $this->backup_manager = $backup_manager;
         $this->schedule_manager = $schedule_manager;
 …
         // Log that we received the request (for debugging)
         $this->logger->info('Cron trigger endpoint called', [
             'method' => $request->get_method(),
             'route' => $request->get_route(),
             'headers' => $request->get_headers(),
             'has_body' => !empty($request->get_body())
+            // 'method' => $request->get_method(),
+            // 'route' => $request->get_route(),
+            // 'headers' => $request->get_headers(),
+            // 'has_body' => !empty($request->get_body())
         ]);
         try {
             // Verify secret token
+            // Enhanced security: Verify secret token from header or query parameter
             $secret = $request->get_header('X-SiteSkite-Cron-Secret');
+            if (empty($secret)) {
+                // Fallback to query parameter for services that can't set custom headers
+                $secret = $request->get_param('siteskite_key');
+            }
             $expected_secret = $this->cron_manager->get_secret_token();
+            if (empty($secret) || $secret !== $expected_secret) {
+            // Use hash_equals for timing-safe comparison
+            if (empty($secret) || !hash_equals($expected_secret, $secret)) {
                 $this->logger->warning('Invalid or missing secret token in cron trigger', [
                     'received' => substr($secret ?? '', 0, 10) . '...',
                     'expected' => substr($expected_secret, 0, 10) . '...',
                     'headers' => $request->get_headers(),
                     'all_headers' => $request->get_headers()->getAll()
+                    'has_header' => !empty($request->get_header('X-SiteSkite-Cron-Secret')),
+                    'has_query_param' => !empty($request->get_param('siteskite_key')),
+                    'ip' => $_SERVER['REMOTE_ADDR'] ?? 'unknown',
+                    'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? 'unknown'
                 ]);
                 return new WP_Error(
                     'invalid_secret',
                     'Invalid secret token',
+                    'Invalid or missing authentication token',
                     ['status' => 401]
                 );
 …
             // Log the received body for debugging
             $this->logger->info('Received cron trigger request', [
                 'body' => $body,
                 'body_type' => gettype($body),
                 'raw_body' => substr($request->get_body(), 0, 500),
                 'content_type' => $request->get_header('Content-Type')
+                // 'body' => $body,
+                // 'body_type' => gettype($body),
+                // 'raw_body' => substr($request->get_body(), 0, 500),
+                // 'content_type' => $request->get_header('Content-Type')
             ]);
 …
             $result = $this->execute_action($action, $args);
+            // Notify hybrid cron manager that external trigger occurred
+            // This will schedule WordPress cron for next run
+            // Only do this if the action was actually executed (not skipped)
+            if ($this->hybrid_cron_manager && ($result['status'] ?? '') !== 'skipped') {
+                $this->hybrid_cron_manager->on_external_trigger($action, $args);
+            }
             // Check if job should be deleted after successful run
             if ($this->cron_manager->should_delete_after_first_run($action, $args)) {
 …
                     if ($deleted) {
                         $this->logger->info('Deleted recurring job after first successful execution', [
                             'job_id' => $job_id,
                             'action' => $action,
                             'args' => $args
+                            // 'job_id' => $job_id,
+                            // 'action' => $action,
+                            // 'args' => $args
                         ]);
                     } else {
 …
+        }
+        // Early check: If backup doesn't exist or is already completed, skip execution and clean up jobs
+        $backup_info = get_option('siteskite_backup_' . $backup_id);
+        if (!$backup_info) {
+            $this->logger->info('Backup info not found, skipping incremental continue trigger and cleaning up jobs', [
+                'backup_id' => $backup_id
+            ]);
+            // Clean up external cron jobs immediately
+            if ($this->cron_manager && $this->cron_manager->is_enabled()) {
+                $deleted_count = $this->cron_manager->delete_jobs_by_backup_id('siteskite_incremental_continue', $backup_id);
+                if ($deleted_count > 0) {
+                    $this->logger->info('Cleaned up external cron jobs for non-existent backup', [
+                        'backup_id' => $backup_id,
+                        'deleted_count' => $deleted_count
+                    ]);
+                }
+            }
+            // Clear WordPress cron events
+            wp_clear_scheduled_hook('siteskite_incremental_continue', [$backup_id]);
+            // Clean up hybrid cron state if it exists
+            if ($this->hybrid_cron_manager) {
+                $this->hybrid_cron_manager->cleanup_job('siteskite_incremental_continue', [$backup_id]);
+            }
+            return [
+                'status' => 'skipped',
+                'backup_id' => $backup_id,
+                'reason' => 'backup_not_found'
+            ];
+        }
+        if (isset($backup_info['status']) && $backup_info['status'] === 'completed') {
+            $this->logger->info('Backup already completed, skipping incremental continue trigger and cleaning up jobs', [
+                'backup_id' => $backup_id
+            ]);
+            // Clean up external cron jobs immediately
+            if ($this->cron_manager && $this->cron_manager->is_enabled()) {
+                $deleted_count = $this->cron_manager->delete_jobs_by_backup_id('siteskite_incremental_continue', $backup_id);
+                if ($deleted_count > 0) {
+                    $this->logger->info('Cleaned up external cron jobs for completed backup', [
+                        'backup_id' => $backup_id,
+                        'deleted_count' => $deleted_count
+                    ]);
+                }
+            }
+            // Clear WordPress cron events
+            wp_clear_scheduled_hook('siteskite_incremental_continue', [$backup_id]);
+            // Clean up hybrid cron state if it exists
+            if ($this->hybrid_cron_manager) {
+                $this->hybrid_cron_manager->cleanup_job('siteskite_incremental_continue', [$backup_id]);
+            }
+            return [
+                'status' => 'skipped',
+                'backup_id' => $backup_id,
+                'reason' => 'backup_already_completed'
+            ];
+        }
         $this->backup_manager->handle_incremental_continue($backup_id);
 …
         ];
+    }
+    /**
+     * Handle continuity check request from external cron service
+     * External service calls this to check if WordPress cron is still running
+     */
+    public function handle_continuity_check(WP_REST_Request $request): WP_REST_Response|WP_Error
+    {
+        try {
+            // Enhanced security: Verify secret token from header or query parameter
+            $secret = $request->get_header('X-SiteSkite-Cron-Secret');
+            if (empty($secret)) {
+                $secret = $request->get_param('siteskite_key');
+            }
+            $expected_secret = $this->cron_manager->get_secret_token();
+            // Use hash_equals for timing-safe comparison
+            if (empty($secret) || !hash_equals($expected_secret, $secret)) {
+                $this->logger->warning('Invalid secret token in continuity check', [
+                    'ip' => $_SERVER['REMOTE_ADDR'] ?? 'unknown'
+                ]);
+                return new WP_Error(
+                    'invalid_secret',
+                    'Invalid or missing authentication token',
+                    ['status' => 401]
+                );
+            }
+            // Get action and args from request
+            $action = $request->get_param('action') ?? '';
+            $args = $request->get_param('args') ?? [];
+            if (empty($action)) {
+                return new WP_Error(
+                    'missing_action',
+                    'Action is required',
+                    ['status' => 400]
+                );
+            }
+            if (!is_array($args)) {
+                $args = [];
+            }
+            // Check continuity using hybrid cron manager
+            if (!$this->hybrid_cron_manager) {
+                return rest_ensure_response([
+                    'success' => false,
+                    'message' => 'Hybrid cron manager not available',
+                    'should_trigger' => true // Default to triggering if we can't check
+                ]);
+            }
+            $continuity_maintained = $this->hybrid_cron_manager->check_continuity($action, $args);
+            return rest_ensure_response([
+                'success' => true,
+                'continuity_maintained' => $continuity_maintained,
+                'should_trigger' => !$continuity_maintained,
+                'action' => $action,
+                'checked_at' => time()
+            ]);
+        } catch (\Exception $e) {
+            $this->logger->error('Error checking cron continuity', [
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString()
+            ]);
+            return new WP_Error(
+                'check_error',
+                $e->getMessage(),
+                ['status' => 500]
+            );
+        }
+    }
+}

siteskite/trunk/includes/Cron/ExternalCronManager.php

-                      r3418578
+                      r3420528
 use function wp_remote_get;
 use function add_query_arg;
+use function site_url;
 /**
 …
             $this->logger->debug('Preparing to create recurring job', [
+                'action' => $action,
+                'url' => $url,
+                'schedule' => $schedule,
+                'body' => $body
+            ]);
+                // 'action' => $action,
+                // 'url' => $url,
+                // 'schedule' => $schedule,
+                // 'body' => $body
+            ]);
+            // For wp-cron trigger, use GET request, no body/headers needed
+            $is_wp_cron_trigger = ($action === 'siteskite_trigger_wp_cron');
             $job_data = [
                 'job' => [
 …
                     'enabled' => true,
                     'title' => $title ?: "SiteSkite: {$action}",
+                    'requestMethod' => 1, // POST
+                    'schedule' => $schedule,
+                    'extendedData' => [
+                        'headers' => [
+                            'X-SiteSkite-Cron-Secret' => $this->secret_token,
+                            'Content-Type' => 'application/json'
+                        ],
+                        'body' => wp_json_encode($body)
+                    ]
+                    'requestMethod' => $is_wp_cron_trigger ? 0 : 1, // 0 = GET, 1 = POST
+                    'schedule' => $schedule
+                ]
             ];
+            // Only add headers and body for non-wp-cron triggers
+            if (!$is_wp_cron_trigger) {
+                $job_data['job']['extendedData'] = [
+                    'headers' => [
+                        'X-SiteSkite-Cron-Secret' => $this->secret_token,
+                        'Content-Type' => 'application/json'
+                    ],
+                    'body' => wp_json_encode($body)
+                ];
+            }
             $this->logger->debug('Sending API request to create recurring job', [
 …
             $this->logger->debug('API response received', [
                 'action' => $action,
                 'response_code' => $response_code,
                 'response_body_length' => strlen($response_body),
                 'response_data' => $data,
                 'json_error' => json_last_error() !== JSON_ERROR_NONE ? json_last_error_msg() : null
+                // 'action' => $action,
+                // 'response_code' => $response_code,
+                // 'response_body_length' => strlen($response_body),
+                // 'response_data' => $data,
+                // 'json_error' => json_last_error() !== JSON_ERROR_NONE ? json_last_error_msg() : null
             ]);
 …
                 $this->logger->info('Created external cron job', [
                     'job_id' => $job_id,
                     'action' => $action,
                     'frequency' => $frequency
+                    //'job_id' => $job_id,
+                    //'action' => $action,
+                    //'frequency' => $frequency
                 ]);
 …
             $body = $this->build_request_body($action, $args);
+            // For wp-cron trigger, use GET request, no body/headers needed
+            $is_wp_cron_trigger = ($action === 'siteskite_trigger_wp_cron');
             $job_data = [
                 'job' => [
 …
                     'enabled' => true,
                     'title' => $title ?: "SiteSkite: {$action}",
+                    'requestMethod' => 1, // POST
+                    'schedule' => $schedule, // Simple single-event schedule (runs once)
+                    'extendedData' => [
+                        'headers' => [
+                            'X-SiteSkite-Cron-Secret' => $this->secret_token,
+                            'Content-Type' => 'application/json'
+                        ],
+                        'body' => wp_json_encode($body)
+                    ]
+                    'requestMethod' => $is_wp_cron_trigger ? 0 : 1, // 0 = GET, 1 = POST
+                    'schedule' => $schedule // Simple single-event schedule (runs once)
+                ]
             ];
+            // Only add headers and body for non-wp-cron triggers
+            if (!$is_wp_cron_trigger) {
+                $job_data['job']['extendedData'] = [
+                    'headers' => [
+                        'X-SiteSkite-Cron-Secret' => $this->secret_token,
+                        'Content-Type' => 'application/json'
+                    ],
+                    'body' => wp_json_encode($body)
+                ];
+            }
             $response = $this->make_api_request('PUT', '/jobs', $job_data);
 …
                 $this->logger->info('Created external cron single job', [
                     'job_id' => $job_id,
                     'action' => $action,
                     'timestamp' => $timestamp,
                     'runs_at' => gmdate('Y-m-d H:i:s', $timestamp),
                     'delete_after_first_run' => $delete_after_first_run
+                    //'job_id' => $job_id,
+                    //'action' => $action,
+                    //'timestamp' => $timestamp,
+                    //'runs_at' => gmdate('Y-m-d H:i:s', $timestamp),
+                    //'delete_after_first_run' => $delete_after_first_run
                 ]);
 …
                 $this->logger->info('Deleted external cron job', ['job_id' => $job_id]);
                 return true;
+            } else {
+                $this->logger->error('Failed to delete external cron job', [
+            }
+            // Treat 404 as already deleted: clean local state and stop retrying
+            if ($response_code === 404) {
+                $this->remove_stored_job($job_id);
+                $this->logger->info('External cron job already deleted remotely, removed locally', [
                     'job_id' => $job_id,
                     'response_code' => $response_code
                 ]);
+                return false;
+            }
+                return true;
+            }
+            $this->logger->error('Failed to delete external cron job', [
+                'job_id' => $job_id,
+                'response_code' => $response_code
+            ]);
+            return false;
         } catch (\Exception $e) {
             $this->logger->error('Exception deleting external cron job', [
 …
     private function get_trigger_url(string $action): string
+    {
+        // Special case: wp-cron trigger should call wp-cron.php directly
+        if ($action === 'siteskite_trigger_wp_cron') {
+            return site_url('wp-cron.php?doing_wp_cron');
+        }
         return rest_url('siteskite/v1/cron/trigger');
+    }
 …
     private function build_request_body(string $action, array $args): array
+    {
+        // For wp-cron trigger, no body needed - just call the URL
+        if ($action === 'siteskite_trigger_wp_cron') {
+            return [];
+        }
         return [
             'action' => $action,

siteskite/trunk/readme.txt

-                      r3418578
+                      r3420528
 Tested up to: 6.9
 Requires PHP: 7.4
 Stable tag: 1.0.7
+Stable tag: 1.0.8
 License: GPLv2 or later
 License URI: https://www.gnu.org/licenses/gpl-2.0.html
 …
 == Changelog ==
+= 1.0.8 (16 December 2025) =
+* Improved: Backup performance
 = 1.0.7 (13 December 2025) =
 * Added: Better Backup management
 …
 == Upgrade Notice ==
+= 1.0.8 (16 December 2025) =
+* Improved: Backup performance
 = 1.0.7 (13 December 2025) =
 * Added: Better Backup management

siteskite/trunk/siteskite-link.php

-                      r3418578
+                      r3420528
  * Plugin URI: https://siteskite.com
  * Description: Link your WordPress site with SiteSkite for effortless updates, backups, monitoring, and maintenance—everything in one place.
  * Version: 1.0.7
+ * Version: 1.0.8
  * Requires at least: 5.3
  * Requires PHP: 7.4
 …
 // Plugin version
 define('SITESKITE_VERSION', '1.0.7');
+define('SITESKITE_VERSION', '1.0.8');
 // Plugin file, path, and URL

Note: See TracChangeset for help on using the changeset viewer.

Trac UI Preferences

Plugin Directory