From 836d9b01493c7a8c66666c12e076597eab06e4fd Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 20:52:26 +0530
Subject: [PATCH 01/14] Fix date format using month (m) instead of minutes (i)
 in created_at

gmdate('Y-m-d H:m:s') wrote the month number into the minutes slot, so
created_at was off by up to an hour. Use H:i:s.
---
 includes/RapidLoad_Job.php                                | 2 +-
 includes/RapidLoad_Job_Data.php                           | 4 ++--
 includes/modules/optimizer/RapidLoad_Job_Optimization.php | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/includes/RapidLoad_Job.php b/includes/RapidLoad_Job.php
index f8e7fe838..5390142ed 100644
--- a/includes/RapidLoad_Job.php
+++ b/includes/RapidLoad_Job.php
@@ -63,7 +63,7 @@ public function __construct($args = [])
 
         }else{
 
-            $this->created_at = gmdate( "Y-m-d H:m:s", time() );
+            $this->created_at = gmdate( "Y-m-d H:i:s", time() );
         }
 
     }
diff --git a/includes/RapidLoad_Job_Data.php b/includes/RapidLoad_Job_Data.php
index e45ffd3bb..fc53e1184 100644
--- a/includes/RapidLoad_Job_Data.php
+++ b/includes/RapidLoad_Job_Data.php
@@ -48,7 +48,7 @@ public function __construct($job, $type)
             $this->attempts = 0;
             $this->hits = 0;
             $this->status = 'queued';
-            $this->created_at = gmdate( "Y-m-d H:m:s", time() );
+            $this->created_at = gmdate( "Y-m-d H:i:s", time() );
 
         }
 
@@ -120,7 +120,7 @@ public function requeue($attempts = -1){
         $this->stats = null;
         $this->warnings = null;
         $this->error = null;
-        $this->created_at = gmdate( "Y-m-d H:m:s", time() );
+        $this->created_at = gmdate( "Y-m-d H:i:s", time() );
         $this->clearFiles();
     }
 
diff --git a/includes/modules/optimizer/RapidLoad_Job_Optimization.php b/includes/modules/optimizer/RapidLoad_Job_Optimization.php
index 1ae696dc1..a2ce78620 100644
--- a/includes/modules/optimizer/RapidLoad_Job_Optimization.php
+++ b/includes/modules/optimizer/RapidLoad_Job_Optimization.php
@@ -28,7 +28,7 @@ public function __construct($job, $strategy, $id = null)
             $this->data = $exist->data;
             $this->created_at = $exist->created_at;
         }else{
-            $this->created_at = gmdate( "Y-m-d H:m:s", time() );
+            $this->created_at = gmdate( "Y-m-d H:i:s", time() );
         }
     }
 

From d5a33024e0aa5151b8443d68f4ce0525f7c173a0 Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 20:52:35 +0530
Subject: [PATCH 02/14] Do not reset job attempts on every successful page view

mark_as_successful_hit() zeroed attempts on each view, which defeats any
retry cap. Attempts are now reset only when the API actually returns a
successful result (mark_as_success), which ends the retry cycle.
---
 includes/RapidLoad_Job_Data.php | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/includes/RapidLoad_Job_Data.php b/includes/RapidLoad_Job_Data.php
index fc53e1184..871933f07 100644
--- a/includes/RapidLoad_Job_Data.php
+++ b/includes/RapidLoad_Job_Data.php
@@ -144,13 +144,15 @@ public function mark_as_success($data, $stats, $warnings, $status = 'success', $
             $this->status = isset($data) && (isset($data['mobile']) && !empty($data['mobile']) || isset($data['desktop']) && !empty($data['desktop'])) ? 'success' : 'failed';
         }
         $this->hits = 0;
+        // A genuine API success ends the retry cycle. (Page views must not reset
+        // attempts, see mark_as_successful_hit, or the retry cap is defeated.)
+        $this->attempts = 0;
         $this->stats = isset($stats) ? serialize($stats) : null;
         $this->warnings = isset($warnings) && count($warnings) > 0 ? $warnings : null;
         $this->error = null;
     }
 
     public function mark_as_successful_hit(){
-        $this->attempts = 0;
         $this->hits++;
         $this->error = NULL;
     }

From c205be9741ad20b3a8bb5fefe9f7413dfd1caed3 Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 20:52:39 +0530
Subject: [PATCH 03/14] Make cleanCacheFiles consider all successful CPCSS rows

get_success_data() defaulted to LIMIT 1, so cleanCacheFiles() treated only
one URL's files as in use and deleted every other cached CPCSS file, which
forced those URLs to be requeued on their next view. A limit of 0 now
returns all rows; cleanCacheFiles passes 0. Default (1) is unchanged for
other callers. The UnusedCSS cleanCacheFiles() is an empty stub, so it is
not affected.
---
 .../css/critical-css/RapidLoad_CriticalCSS.php        |  2 +-
 .../css/critical-css/RapidLoad_CriticalCSS_DB.php     | 11 +++++++----
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
index e0baec6ae..101a8dd2b 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
@@ -478,7 +478,7 @@ public function init_async_store($job_data, $args)
 
     public function cleanCacheFiles(){
 
-        $data = RapidLoad_CriticalCSS_DB::get_success_data();
+        $data = RapidLoad_CriticalCSS_DB::get_success_data(0);
 
         $used_files = [];
 
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
index 3fd669c1a..8eb501fbb 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
@@ -140,12 +140,15 @@ public static function get_current_processing_tasks_job_ids($limit = 1){
     public static function get_success_data($limit = 1) {
         global $wpdb;
 
+        // $limit = 0 (or negative) returns every successful row.
+        $limit = (int) $limit;
+        $limit_sql = $limit > 0 ? $wpdb->prepare( ' LIMIT %d', $limit ) : '';
+
         $data = $wpdb->get_results(
             $wpdb->prepare(
-                "SELECT data FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'success' AND job_type = %s ORDER BY id DESC LIMIT %d",
-                'cpcss',
-                $limit
-            ),
+                "SELECT data FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'success' AND job_type = %s ORDER BY id DESC",
+                'cpcss'
+            ) . $limit_sql,
             OBJECT
         );
 

From ffa5216717f6dc0f4899f762b6175bc16843b5f6 Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 20:53:22 +0530
Subject: [PATCH 04/14] Cap job retries and add exponential backoff when
 polling fails

update_css() requeued forever on 'Job processing failed in queue'/'Error'
with no cap and no delay, so a failing URL was resubmitted every queue
tick. Add RapidLoad_Job_Data::retry_or_fail(): counts the attempt, requeues
with exponential backoff (120s, 240s, ... max 1h, stored as a future
created_at, no schema change) while attempts < max (default 3, filter
rapidload/job/max_attempts or RAPIDLOAD_JOB_MAX_ATTEMPTS), then marks the
job failed. The queued-job SELECTs skip retry rows (attempts >= 1) until
created_at <= now. Rows with attempts = 0 are unaffected, and user/page-view
requeues set created_at = now so they stay immediately eligible.
---
 includes/RapidLoad_Job_Data.php               | 48 +++++++++++++++++++
 .../critical-css/RapidLoad_CriticalCSS_DB.php |  3 +-
 .../RapidLoad_CriticalCSS_Store.php           | 11 ++++-
 .../css/unused-css/RapidLoad_UnusedCSS_DB.php |  3 +-
 .../unused-css/RapidLoad_UnusedCSS_Store.php  | 11 ++++-
 5 files changed, 70 insertions(+), 6 deletions(-)

diff --git a/includes/RapidLoad_Job_Data.php b/includes/RapidLoad_Job_Data.php
index 871933f07..727fbfdea 100644
--- a/includes/RapidLoad_Job_Data.php
+++ b/includes/RapidLoad_Job_Data.php
@@ -124,6 +124,54 @@ public function requeue($attempts = -1){
         $this->clearFiles();
     }
 
+    /**
+     * Maximum number of API attempts for one job before it is marked as failed.
+     * Override with the RAPIDLOAD_JOB_MAX_ATTEMPTS constant or the
+     * 'rapidload/job/max_attempts' filter.
+     */
+    public static function max_attempts(){
+        $max = defined('RAPIDLOAD_JOB_MAX_ATTEMPTS') ? (int) RAPIDLOAD_JOB_MAX_ATTEMPTS : 3;
+        $max = (int) apply_filters('rapidload/job/max_attempts', $max);
+        return $max > 0 ? $max : 1;
+    }
+
+    /**
+     * Exponential backoff (seconds) before a failed attempt may be retried:
+     * 120s, 240s, 480s ... capped at one hour.
+     */
+    public static function retry_delay($attempts){
+        $attempts = max(1, min((int) $attempts, 10));
+        $delay = (int) apply_filters('rapidload/job/retry_base_delay', 120) * pow(2, $attempts - 1);
+        return min($delay, 3600);
+    }
+
+    /**
+     * Counts one failed attempt. Requeues the job (not eligible for the queue
+     * until the backoff has elapsed) while attempts are left, otherwise marks
+     * it as failed with $error.
+     *
+     * The backoff is stored as a future created_at; the queue only picks up
+     * rows with attempts > 0 once created_at <= now (see the *_DB
+     * get_current_queued_tasks_job_ids methods).
+     *
+     * @return bool true when requeued, false when marked as failed
+     */
+    public function retry_or_fail($error){
+
+        $attempts = (int) $this->attempts + 1;
+
+        if($attempts >= self::max_attempts()){
+            $this->mark_as_failed($error);
+            $this->attempts = $attempts;
+            return false;
+        }
+
+        $this->requeue($attempts);
+        $this->created_at = gmdate( "Y-m-d H:i:s", time() + self::retry_delay($attempts) );
+
+        return true;
+    }
+
     public function clearFiles(){
 
     }
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
index 8eb501fbb..7da5e540a 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
@@ -100,8 +100,9 @@ public static function get_current_queued_tasks_job_ids($limit = 1){
 
         $job_ids = $wpdb->get_results(
             $wpdb->prepare(
-                "SELECT job_id FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'queued' AND job_type = %s ORDER BY id DESC LIMIT %d",  
+                "SELECT job_id FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'queued' AND job_type = %s AND (attempts IS NULL OR attempts < 1 OR created_at <= %s) ORDER BY id DESC LIMIT %d",
                 'cpcss',
+                gmdate( 'Y-m-d H:i:s', time() ),
                 $limit
             ),
             OBJECT
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
index c0ae698d1..b94df9ee9 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
@@ -235,13 +235,20 @@ function update_css(){
 
             if(isset($error['message']) && ($error['message'] === 'Job processing failed in queue' || $error['message'] === 'Error')){
 
+                $requeued = $this->job_data->retry_or_fail($error);
+
                 self::log([
-                    'log' =>  'requeue-> cpcss job processing failed in queue',
+                    'log' =>  ($requeued ? 'requeue-> ' : 'giving up-> ') . 'cpcss job processing failed in queue (attempt ' . $this->job_data->attempts . ')',
                     'url' => $this->job_data->job->url,
                 ]);
-                $this->job_data->requeue();
                 $this->job_data->save();
 
+                if(!$requeued){
+                    do_action( 'uucss/cache_cleared', [
+                        'url' => $this->job_data->job->url
+                    ]);
+                }
+
                 return;
             }
 
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
index fa7a0243e..4b053c17c 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
@@ -149,8 +149,9 @@ public static function get_current_queued_tasks_job_ids($limit = 1){
 
         $job_ids = $wpdb->get_results(
             $wpdb->prepare(
-                "SELECT job_id FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'queued' AND job_type = %s ORDER BY id DESC LIMIT %d",  
+                "SELECT job_id FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'queued' AND job_type = %s AND (attempts IS NULL OR attempts < 1 OR created_at <= %s) ORDER BY id DESC LIMIT %d",
                 'uucss',
+                gmdate( 'Y-m-d H:i:s', time() ),
                 $limit
             ),
             OBJECT
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
index a95e8a1b8..8bf57d46d 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
@@ -250,13 +250,20 @@ function update_css(){
 
             if(isset($error['message']) && ($error['message'] === 'Job processing failed in queue' || $error['message'] === 'Error')){
 
+                $requeued = $this->job_data->retry_or_fail($error);
+
                 self::log([
-                    'log' =>  'requeue-> uucss job processing failed in queue',
+                    'log' =>  ($requeued ? 'requeue-> ' : 'giving up-> ') . 'uucss job processing failed in queue (attempt ' . $this->job_data->attempts . ')',
                     'url' => $this->job_data->job->url,
                 ]);
-                $this->job_data->requeue();
                 $this->job_data->save();
 
+                if(!$requeued){
+                    do_action( 'uucss/cache_cleared', [
+                        'url' => $this->job_data->job->url
+                    ]);
+                }
+
                 return;
             }
 

From 176fd3e59578f1ee8090888536a402981f7a458c Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 20:53:36 +0530
Subject: [PATCH 05/14] Treat purge responses without id or completed as an
 error

A response with neither id nor completed (e.g. {"message":"rate limited"})
left the row 'queued' and it was resent on every queue tick. Now it counts
an attempt via retry_or_fail() (backoff, then failed after the cap) for both
CPCSS and UUCSS. Also guards against non-object results.
---
 .../RapidLoad_CriticalCSS_Store.php           | 28 ++++++++++++++++++-
 .../unused-css/RapidLoad_UnusedCSS_Store.php  | 28 ++++++++++++++++++-
 2 files changed, 54 insertions(+), 2 deletions(-)

diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
index b94df9ee9..7dc62de1d 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
@@ -138,7 +138,7 @@ function purge_css(){
                 $this->job_data->status = 'waiting';
                 $this->job_data->save();
 
-            }else if($result->completed){
+            }else if(is_object($result) && !empty($result->completed)){
 
                 $this->result       = $result;
                 $this->purged_css = $result->data;
@@ -147,6 +147,32 @@ function purge_css(){
                 $this->cache_file($this->purged_css, $this->purged_mobile_css);
                 $this->cpcss_cached($this->job_data->job->url);
 
+            }else{
+
+                // Neither a queued job id nor a completed result: count the attempt
+                // instead of silently leaving the row 'queued' to be resent every tick.
+                $error = [
+                    'code' => 500,
+                    'message' => is_object($result) && isset($result->message) && is_string($result->message)
+                        ? $result->message
+                        : 'Unexpected response from RapidLoad API'
+                ];
+
+                $requeued = $this->job_data->retry_or_fail($error);
+                $this->job_data->save();
+
+                $this->log( [
+                    'log' => ($requeued ? 'requeue-> ' : 'giving up-> ') . 'unexpected response from api (attempt ' . $this->job_data->attempts . ')',
+                    'url' => $this->job_data->job->url,
+                    'type' => 'uucss-cron'
+                ] );
+
+                if(!$requeued){
+                    do_action( 'uucss/cache_cleared', [
+                        'url' => $this->job_data->job->url
+                    ]);
+                }
+
             }
 
         }
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
index 8bf57d46d..334435dac 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
@@ -120,7 +120,7 @@ public function purge_css() {
                 $this->job_data->status = 'waiting';
                 $this->job_data->save();
 
-            }else if($result->completed){
+            }else if(is_object($result) && !empty($result->completed)){
 
                 $this->result       = $result;
                 $this->purged_css = $result->data;
@@ -128,6 +128,32 @@ public function purge_css() {
                 $this->cache_files($this->purged_css);
                 $this->uucss_cached($this->job_data->job->url);
 
+            }else{
+
+                // Neither a queued job id nor a completed result: count the attempt
+                // instead of silently leaving the row 'queued' to be resent every tick.
+                $error = [
+                    'code' => 500,
+                    'message' => is_object($result) && isset($result->message) && is_string($result->message)
+                        ? $result->message
+                        : 'Unexpected response from RapidLoad API'
+                ];
+
+                $requeued = $this->job_data->retry_or_fail($error);
+                $this->job_data->save();
+
+                $this->log( [
+                    'log' => ($requeued ? 'requeue-> ' : 'giving up-> ') . 'unexpected response from api (attempt ' . $this->job_data->attempts . ')',
+                    'url' => $this->job_data->job->url,
+                    'type' => 'uucss-cron'
+                ] );
+
+                if(!$requeued){
+                    do_action( 'uucss/cache_cleared', [
+                        'url' => $this->job_data->job->url
+                    ]);
+                }
+
             }
 
         }

From ae232c7875f11afd626de5b3753180fb33363954 Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 20:54:55 +0530
Subject: [PATCH 06/14] Claim queued jobs atomically and lock the queue run

The row only left 'queued' after the (up to 360s) API POST returned, so
overlapping WP-Cron / rapidload_cron.php runs resent the same row.

- RapidLoad_Job_Data::claim(): UPDATE ... SET status='submitting' WHERE
  id=%d AND status='queued'; the submitter skips the job if 0 rows changed.
- RapidLoad_Job_Data::release_stale_claims(): a row stuck in 'submitting'
  for > 600s (run crashed/killed) counts as a failed attempt and goes back
  to 'queued' with backoff, or to 'failed' at the attempt cap. Called at the
  start of fetch_job_id for cpcss and uucss.
- RapidLoad_Queue::run_task(): short-lived lock (INSERT IGNORE on an
  options row, expires after 600s so a crashed run cannot block forever)
  used by both the WP-Cron hook and rapidload_cron.php.
---
 includes/RapidLoad_Job_Data.php               | 87 +++++++++++++++++
 includes/RapidLoad_Queue.php                  | 93 ++++++++++++++++++-
 .../RapidLoad_CriticalCSS_Queue.php           |  2 +
 .../RapidLoad_CriticalCSS_Store.php           |  5 +
 .../unused-css/RapidLoad_UnusedCSS_Queue.php  |  2 +
 .../unused-css/RapidLoad_UnusedCSS_Store.php  |  5 +
 rapidload_cron.php                            |  8 +-
 7 files changed, 200 insertions(+), 2 deletions(-)

diff --git a/includes/RapidLoad_Job_Data.php b/includes/RapidLoad_Job_Data.php
index 727fbfdea..fba93b33d 100644
--- a/includes/RapidLoad_Job_Data.php
+++ b/includes/RapidLoad_Job_Data.php
@@ -172,6 +172,93 @@ public function retry_or_fail($error){
         return true;
     }
 
+    /**
+     * Seconds after which a claimed ('submitting') row is considered abandoned.
+     * Longer than the 360s API request timeout.
+     */
+    const CLAIM_TIMEOUT = 600;
+
+    /**
+     * Atomically moves this row out of 'queued' so only one queue run submits it.
+     * created_at is set to now and doubles as the claim time.
+     *
+     * @return bool true when this process won the claim
+     */
+    public function claim(){
+
+        if(!isset($this->id)){
+            return true;
+        }
+
+        global $wpdb;
+
+        $now = gmdate( "Y-m-d H:i:s", time() );
+
+        $affected = $wpdb->query(
+            $wpdb->prepare(
+                "UPDATE {$wpdb->prefix}rapidload_job_data SET status = 'submitting', created_at = %s WHERE id = %d AND status = 'queued'",
+                $now,
+                $this->id
+            )
+        );
+
+        if($affected === 1){
+            $this->status = 'submitting';
+            $this->created_at = $now;
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Recovers rows claimed by a run that died (fatal, timeout, killed) before
+     * the API answered. After CLAIM_TIMEOUT the claim counts as a failed attempt:
+     * the row returns to 'queued' (with the usual backoff) or, once the attempt
+     * cap is reached, is marked failed. A row can therefore never stay in
+     * 'submitting' forever, and a request that crashes PHP cannot loop forever.
+     */
+    public static function release_stale_claims($job_type){
+
+        global $wpdb;
+
+        $cutoff = gmdate( "Y-m-d H:i:s", time() - self::CLAIM_TIMEOUT );
+
+        $rows = $wpdb->get_results(
+            $wpdb->prepare(
+                "SELECT job_id FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'submitting' AND job_type = %s AND created_at <= %s LIMIT 50",
+                $job_type,
+                $cutoff
+            )
+        );
+
+        if(empty($rows)){
+            return;
+        }
+
+        foreach ($rows as $row){
+
+            $job = RapidLoad_Job::find_or_fail($row->job_id);
+
+            if(!$job){
+                continue;
+            }
+
+            $job_data = new RapidLoad_Job_Data($job, $job_type);
+
+            // re-check on the loaded object in case another run already recovered it
+            if($job_data->status !== 'submitting'){
+                continue;
+            }
+
+            $job_data->retry_or_fail([
+                'code' => 524,
+                'message' => 'Request was interrupted before the API responded'
+            ]);
+            $job_data->save();
+        }
+    }
+
     public function clearFiles(){
 
     }
diff --git a/includes/RapidLoad_Queue.php b/includes/RapidLoad_Queue.php
index 8d7d8e0f0..a36ac449c 100644
--- a/includes/RapidLoad_Queue.php
+++ b/includes/RapidLoad_Queue.php
@@ -102,10 +102,101 @@ static function get_post_types(){
 
     function uucss_process_queue(){
 
-        do_action('uucss/queue/task');
+        self::run_task();
 
     }
 
+    const LOCK_OPTION = 'rapidload_queue_lock';
+
+    /**
+     * A crashed run leaves its lock behind; it is considered dead after this
+     * many seconds (the claim of any row it held is recovered separately by
+     * RapidLoad_Job_Data::release_stale_claims).
+     */
+    const LOCK_TTL = 600;
+
+    /**
+     * Runs the queue task unless another run (WP-Cron or the system cron script)
+     * holds the lock. Shared by both entry points.
+     *
+     * @return bool false when skipped because another run is active
+     */
+    public static function run_task(){
+
+        if(!self::acquire_lock()){
+            return false;
+        }
+
+        try{
+            do_action('uucss/queue/task');
+        }catch (Exception $e){
+            self::release_lock();
+            throw $e;
+        }
+
+        self::release_lock();
+
+        return true;
+    }
+
+    /**
+     * Atomic lock: INSERT IGNORE on the unique option_name succeeds for exactly
+     * one caller. An expired lock (crashed run) is taken over with a conditional
+     * DELETE so two callers cannot both steal it.
+     */
+    public static function acquire_lock(){
+
+        global $wpdb;
+
+        for ($i = 0; $i < 2; $i++) {
+
+            $locked = $wpdb->query(
+                $wpdb->prepare(
+                    "INSERT IGNORE INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, 'no')",
+                    self::LOCK_OPTION,
+                    (string) time()
+                )
+            );
+
+            if($locked){
+                return true;
+            }
+
+            $current = $wpdb->get_var(
+                $wpdb->prepare(
+                    "SELECT option_value FROM `$wpdb->options` WHERE option_name = %s",
+                    self::LOCK_OPTION
+                )
+            );
+
+            if($current !== null && (time() - (int) $current) < self::LOCK_TTL){
+                return false;
+            }
+
+            $wpdb->query(
+                $wpdb->prepare(
+                    "DELETE FROM `$wpdb->options` WHERE option_name = %s AND option_value = %s",
+                    self::LOCK_OPTION,
+                    (string) $current
+                )
+            );
+        }
+
+        return false;
+    }
+
+    public static function release_lock(){
+
+        global $wpdb;
+
+        $wpdb->query(
+            $wpdb->prepare(
+                "DELETE FROM `$wpdb->options` WHERE option_name = %s",
+                self::LOCK_OPTION
+            )
+        );
+    }
+
     function uucss_process_queue_schedule($schedules){
         $schedules['uucss_cron_interval'] = array(
             'interval' => self::$interval,
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Queue.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Queue.php
index 7187532fd..b03b419ea 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Queue.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Queue.php
@@ -17,6 +17,8 @@ public function __construct()
 
     function fetch_job_id(){
 
+        RapidLoad_Job_Data::release_stale_claims('cpcss');
+
         $current_waiting = RapidLoad_CriticalCSS_DB::get_current_waiting_tasks_count();
 
         if( (RapidLoad_Queue::$job_count - $current_waiting) <= 0 ){
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
index 7dc62de1d..2733bb716 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
@@ -103,6 +103,11 @@ function purge_css(){
 
             $cpcss_config = apply_filters('cpcss/purge/config', ( isset( $this->args['options'] ) ) ? $this->args['options'] : []);
 
+            if(!$this->job_data->claim()){
+                // another queue run already took this job
+                return;
+            }
+
             $result = $uucss_api->post( 's/criticalcss',
                 array_merge( $cpcss_config,
                     [
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Queue.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Queue.php
index 53f48dc11..3477faa25 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Queue.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Queue.php
@@ -18,6 +18,8 @@ public function __construct()
 
     function fetch_job_id(){
 
+        RapidLoad_Job_Data::release_stale_claims('uucss');
+
         $current_waiting = RapidLoad_UnusedCSS_DB::get_current_waiting_tasks_count();
 
         if( (RapidLoad_Queue::$job_count - $current_waiting) <= 0 ){
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
index 334435dac..c0c919a5f 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
@@ -89,6 +89,11 @@ public function purge_css() {
 
             $uucss_config = apply_filters('uucss/purge/config', $api_options);
 
+            if(!$this->job_data->claim()){
+                // another queue run already took this job
+                return;
+            }
+
             $result = $uucss_api->post( 's/unusedcss',
                 array_merge( $uucss_config,
                     [
diff --git a/rapidload_cron.php b/rapidload_cron.php
index 4f4b7315c..b8e0e788b 100644
--- a/rapidload_cron.php
+++ b/rapidload_cron.php
@@ -70,7 +70,13 @@ function rapidload_cron_log($message) {
     rapidload_cron_log('WordPress loaded from: ' . ABSPATH);
 
     // Trigger the optimization process
-    do_action('uucss/queue/task');
+    if (class_exists('RapidLoad_Queue')) {
+        if (!RapidLoad_Queue::run_task()) {
+            rapidload_cron_log('Another RapidLoad queue run is active, skipping');
+        }
+    } else {
+        do_action('uucss/queue/task');
+    }
 
     // Log completion
     rapidload_cron_log('RapidLoad optimization process completed successfully');

From 32adf20c249939931be672bfaaf4b2affdabfee7 Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 21:01:06 +0530
Subject: [PATCH 07/14] Harden queue lock: unique token, refresh between jobs,
 release on shutdown

- Lock value is "<token>|<time>"; release and refresh only touch the
  holder's own lock, so a finishing run cannot delete a newer run's lock.
- touch_lock() is called before every job so a legitimately long run
  (job_count x 360s) is never taken over; a crashed run's lock still
  expires after 600s without refresh.
- Release also runs from a shutdown function, covering PHP Errors, fatals
  and exit() on all PHP versions (no Throwable/finally needed).
---
 includes/RapidLoad_Queue.php                  | 93 ++++++++++++++-----
 .../RapidLoad_CriticalCSS_Queue.php           |  4 +
 .../unused-css/RapidLoad_UnusedCSS_Queue.php  |  4 +
 3 files changed, 76 insertions(+), 25 deletions(-)

diff --git a/includes/RapidLoad_Queue.php b/includes/RapidLoad_Queue.php
index a36ac449c..7506cfd20 100644
--- a/includes/RapidLoad_Queue.php
+++ b/includes/RapidLoad_Queue.php
@@ -109,12 +109,16 @@ function uucss_process_queue(){
     const LOCK_OPTION = 'rapidload_queue_lock';
 
     /**
-     * A crashed run leaves its lock behind; it is considered dead after this
-     * many seconds (the claim of any row it held is recovered separately by
-     * RapidLoad_Job_Data::release_stale_claims).
+     * Seconds without a refresh after which a lock is considered abandoned
+     * (crashed run). A live run refreshes the lock before every job (touch_lock)
+     * and each job is bounded by the 360s API timeout, so a legitimate run
+     * never goes this long without a refresh. Rows claimed by a dead run are
+     * recovered separately by RapidLoad_Job_Data::release_stale_claims.
      */
     const LOCK_TTL = 600;
 
+    private static $lock_token = null;
+
     /**
      * Runs the queue task unless another run (WP-Cron or the system cron script)
      * holds the lock. Shared by both entry points.
@@ -127,12 +131,10 @@ public static function run_task(){
             return false;
         }
 
-        try{
-            do_action('uucss/queue/task');
-        }catch (Exception $e){
-            self::release_lock();
-            throw $e;
-        }
+        // also released on fatals / Errors / exit(); a no-op once released
+        register_shutdown_function([__CLASS__, 'release_lock']);
+
+        do_action('uucss/queue/task');
 
         self::release_lock();
 
@@ -140,25 +142,29 @@ public static function run_task(){
     }
 
     /**
-     * Atomic lock: INSERT IGNORE on the unique option_name succeeds for exactly
-     * one caller. An expired lock (crashed run) is taken over with a conditional
-     * DELETE so two callers cannot both steal it.
+     * Lock value is "<token>|<unix time>". INSERT IGNORE on the unique
+     * option_name succeeds for exactly one caller. An expired lock is taken over
+     * with a DELETE conditional on the exact stale value, so two callers cannot
+     * both steal it, and only the holder's token can refresh or release it.
      */
     public static function acquire_lock(){
 
         global $wpdb;
 
+        $token = uniqid('', true);
+
         for ($i = 0; $i < 2; $i++) {
 
             $locked = $wpdb->query(
                 $wpdb->prepare(
                     "INSERT IGNORE INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, 'no')",
                     self::LOCK_OPTION,
-                    (string) time()
+                    $token . '|' . time()
                 )
             );
 
             if($locked){
+                self::$lock_token = $token;
                 return true;
             }
 
@@ -169,32 +175,69 @@ public static function acquire_lock(){
                 )
             );
 
-            if($current !== null && (time() - (int) $current) < self::LOCK_TTL){
-                return false;
-            }
+            if($current !== null){
 
-            $wpdb->query(
-                $wpdb->prepare(
-                    "DELETE FROM `$wpdb->options` WHERE option_name = %s AND option_value = %s",
-                    self::LOCK_OPTION,
-                    (string) $current
-                )
-            );
+                $parts = explode('|', $current);
+                $since = isset($parts[1]) ? (int) $parts[1] : 0;
+
+                if((time() - $since) < self::LOCK_TTL){
+                    return false;
+                }
+
+                $wpdb->query(
+                    $wpdb->prepare(
+                        "DELETE FROM `$wpdb->options` WHERE option_name = %s AND option_value = %s",
+                        self::LOCK_OPTION,
+                        $current
+                    )
+                );
+            }
         }
 
         return false;
     }
 
+    /**
+     * Refresh the lock timestamp; call between long jobs.
+     */
+    public static function touch_lock(){
+
+        if(self::$lock_token === null){
+            return;
+        }
+
+        global $wpdb;
+
+        $wpdb->query(
+            $wpdb->prepare(
+                "UPDATE `$wpdb->options` SET option_value = %s WHERE option_name = %s AND option_value LIKE %s",
+                self::$lock_token . '|' . time(),
+                self::LOCK_OPTION,
+                $wpdb->esc_like(self::$lock_token . '|') . '%'
+            )
+        );
+    }
+
+    /**
+     * Releases only the lock this process holds.
+     */
     public static function release_lock(){
 
+        if(self::$lock_token === null){
+            return;
+        }
+
         global $wpdb;
 
         $wpdb->query(
             $wpdb->prepare(
-                "DELETE FROM `$wpdb->options` WHERE option_name = %s",
-                self::LOCK_OPTION
+                "DELETE FROM `$wpdb->options` WHERE option_name = %s AND option_value LIKE %s",
+                self::LOCK_OPTION,
+                $wpdb->esc_like(self::$lock_token . '|') . '%'
             )
         );
+
+        self::$lock_token = null;
     }
 
     function uucss_process_queue_schedule($schedules){
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Queue.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Queue.php
index b03b419ea..7a76e673f 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Queue.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Queue.php
@@ -33,6 +33,8 @@ function fetch_job_id(){
 
             foreach ($links as $link){
 
+                RapidLoad_Queue::touch_lock();
+
                 $job = RapidLoad_Job::find_or_fail($link->job_id);
 
                 if($job){
@@ -62,6 +64,8 @@ function fetch_result(){
 
             foreach ($links as $link){
 
+                RapidLoad_Queue::touch_lock();
+
                 $job = RapidLoad_Job::find_or_fail($link->job_id);
 
                 if($job){
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Queue.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Queue.php
index 3477faa25..44b021772 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Queue.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Queue.php
@@ -34,6 +34,8 @@ function fetch_job_id(){
 
             foreach ($links as $link){
 
+                RapidLoad_Queue::touch_lock();
+
                 $job = RapidLoad_Job::find_or_fail($link->job_id);
 
                 if($job){
@@ -63,6 +65,8 @@ function fetch_result(){
 
             foreach ($links as $link){
 
+                RapidLoad_Queue::touch_lock();
+
                 $job = RapidLoad_Job::find_or_fail($link->job_id);
 
                 if($job){

From 1b8892326276cb812e10f8b19e81d7f431c35419 Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 21:01:06 +0530
Subject: [PATCH 08/14] Respect 'submitting' in requeue/purge guards; retry
 transient submit errors

- cache_cpcss/cache_uucss no longer requeue a row that is currently
  'submitting' (a page view or manual action mid-POST could reset it to
  queued and allow a second runner to claim and duplicate the POST); the
  immediate/titan guards in both Stores also skip 'submitting'.
- Errors right after the claim that are transient (timeout/null, cURL
  string, 5xx, 429) go through retry_or_fail; definitive API errors
  (4xx) still fail immediately.
---
 .../css/critical-css/RapidLoad_CriticalCSS_Store.php | 12 ++++++++++--
 .../css/unused-css/RapidLoad_UnusedCSS_Store.php     | 12 ++++++++++--
 2 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
index 2733bb716..71619b871 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
@@ -35,7 +35,7 @@ function purge_css(){
 
             $discontinue = false;
 
-            if(!isset($this->args['titan']) && ($this->job_data->status === 'waiting' || $this->job_data->status === 'processing' || $this->job_data->status === 'success')){
+            if(!isset($this->args['titan']) && ($this->job_data->status === 'waiting' || $this->job_data->status === 'processing' || $this->job_data->status === 'submitting' || $this->job_data->status === 'success')){
                 return;
             }
 
@@ -125,7 +125,15 @@ function purge_css(){
 
             if($uucss_api->is_error($result)){
 
-                $this->job_data->mark_as_failed($uucss_api->extract_error( $result ));
+                $error = $uucss_api->extract_error( $result );
+
+                // timeouts / transport errors / 5xx / 429 are retried with backoff,
+                // definitive API errors fail at once
+                if(RapidLoad_Job_Data::is_transient_error($result, $error)){
+                    $this->job_data->retry_or_fail($error);
+                }else{
+                    $this->job_data->mark_as_failed($error);
+                }
                 $this->job_data->save();
 
                 $this->log( [
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
index c0c919a5f..5de0b50df 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
@@ -33,7 +33,7 @@ public function purge_css() {
 
         if(isset($this->args['immediate']) || isset($this->args['titan'])){
 
-            if(isset($this->args['titan']) && ($this->job_data->status === 'waiting' || $this->job_data->status === 'processing' || $this->job_data->status === 'success')){
+            if(isset($this->args['titan']) && ($this->job_data->status === 'waiting' || $this->job_data->status === 'processing' || $this->job_data->status === 'submitting' || $this->job_data->status === 'success')){
                 return;
             }
 
@@ -107,7 +107,15 @@ public function purge_css() {
 
             if($uucss_api->is_error($result)){
 
-                $this->job_data->mark_as_failed($uucss_api->extract_error( $result ));
+                $error = $uucss_api->extract_error( $result );
+
+                // timeouts / transport errors / 5xx / 429 are retried with backoff,
+                // definitive API errors fail at once
+                if(RapidLoad_Job_Data::is_transient_error($result, $error)){
+                    $this->job_data->retry_or_fail($error);
+                }else{
+                    $this->job_data->mark_as_failed($error);
+                }
                 $this->job_data->save();
 
                 $this->log( [

From 71cb8c461a5034429fe9d9e980cc40531b3fdb14 Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 21:01:06 +0530
Subject: [PATCH 09/14] Keep attempts across successes; back off page-view
 requeues; reset on explicit actions

Resetting attempts in mark_as_success re-opened the loop: the page-view
guards (attempts <= 2, failed && attempts >= 2) rely on attempts growing
across requeues, so a success-with-warnings or missing-file page requeued
and resubmitted on every queue tick.

- Attempts are no longer reset on success or on hits.
- Page-view / automatic requeues (Enqueue paths, cache_cpcss/cache_uucss
  without immediate/requeue) use requeue_delayed(): attempts + 1 and the
  same exponential backoff (future created_at) as retry_or_fail.
- Explicit actions reset attempts and are eligible at once: requeue(0) for
  immediate/requeue args, clear_cache (save_post / manual purge), and the
  bulk SQL (requeue_where_status, clear_data soft, requeueJob,
  update*JobDataStatusWhere set attempts = 0, created_at = now) so rows in
  backoff do not stay ineligible after "requeue all".
- The internal 'submitting' status is shown as 'waiting' in the admin
  (display_status), since the React UI only knows a closed status set.
---
 includes/RapidLoad_DB.php                     | 22 ++++++----
 includes/RapidLoad_Job_Data.php               | 40 +++++++++++++++++--
 .../critical-css/RapidLoad_CriticalCSS.php    | 14 ++++---
 .../critical-css/RapidLoad_CriticalCSS_DB.php |  8 ++--
 .../RapidLoad_CriticalCSS_Enqueue.php         |  2 +-
 .../css/unused-css/RapidLoad_UnusedCSS.php    | 16 +++++---
 .../css/unused-css/RapidLoad_UnusedCSS_DB.php |  8 ++--
 .../RapidLoad_UnusedCSS_Enqueue.php           |  2 +-
 .../modules/optimizer/RapidLoad_Optimizer.php |  8 ++--
 9 files changed, 83 insertions(+), 37 deletions(-)

diff --git a/includes/RapidLoad_DB.php b/includes/RapidLoad_DB.php
index 3f4d4961b..27d4a257e 100644
--- a/includes/RapidLoad_DB.php
+++ b/includes/RapidLoad_DB.php
@@ -656,7 +656,7 @@ public static function transform_link($link, $rule = 'path'){
         $data['applied_successful_links'] = isset( $link->applied_successful_links ) ? $link->applied_successful_links : 0;
         $data['applied_links'] = isset( $link->applied_successful_links ) ? $link->applied_successful_links : 0;
         $data['time'] = isset( $link->created_at ) ? strtotime( $link->created_at ) * 1000 : null;
-        $data['status'] = isset( $link->status ) ? $link->status : null;
+        $data['status'] = isset( $link->status ) ? RapidLoad_Job_Data::display_status($link->status) : null;
         if(isset($data['rule_id'])){
             $job_url = RapidLoad_Job::find_or_fail($data['rule_id']);
             $data['base'] = $job_url->url;
@@ -689,7 +689,7 @@ public static function requeueJob($id){
 
         global $wpdb;
 
-        $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s WHERE job_id = %d", 'queued', $id ) );
+        $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, attempts = 0, created_at = %s WHERE job_id = %d", 'queued', gmdate( 'Y-m-d H:i:s' ), $id ) );
 
         $error = $wpdb->last_error;
 
@@ -704,6 +704,9 @@ public static function updateUrlJobDataStatusWhere($status = 'queued', $ids = []
 
         global $wpdb;
 
+        // explicit requeue: clear retry state and any backoff
+        $reset = $status === 'queued' ? ", attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "'" : '';
+
         if (!empty($ids)) {
             $ids = implode(",", array_map('intval', $ids));
         } else {
@@ -712,12 +715,12 @@ public static function updateUrlJobDataStatusWhere($status = 'queued', $ids = []
         }
 
         if (empty($wherStatus)) {
-            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s WHERE job_id IN (%d)", $status, $ids));
+            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d)", $status, $ids));
         } else {
             if($wherStatus === "success"){
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", $status, $ids, $wherStatus));
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", $status, $ids, $wherStatus));
             }else{
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s WHERE job_id IN (%d) AND status = %s", $status, $ids, $wherStatus));
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d) AND status = %s", $status, $ids, $wherStatus));
             }
         }
 
@@ -734,6 +737,9 @@ public static function updateRuleJobDataStatusWhere($status = 'queued', $ids = [
 
         global $wpdb;
 
+        // explicit requeue: clear retry state and any backoff
+        $reset = $status === 'queued' ? ", attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "'" : '';
+
         if (!empty($ids)) {
             $ids = implode(",", array_map('intval', $ids));
         } else {
@@ -742,12 +748,12 @@ public static function updateRuleJobDataStatusWhere($status = 'queued', $ids = [
         }
 
         if (empty($wherStatus)) {
-            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s WHERE job_id IN (%d)", $status, $ids));
+            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d)", $status, $ids));
         } else {
             if($wherStatus === "success"){
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", $status, $ids, $wherStatus));
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", $status, $ids, $wherStatus));
             }else{
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s WHERE job_id IN (%d) AND status = %s", $status, $ids, $wherStatus));
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d) AND status = %s", $status, $ids, $wherStatus));
             }
         }
 
diff --git a/includes/RapidLoad_Job_Data.php b/includes/RapidLoad_Job_Data.php
index fba93b33d..186f01bb2 100644
--- a/includes/RapidLoad_Job_Data.php
+++ b/includes/RapidLoad_Job_Data.php
@@ -166,10 +166,45 @@ public function retry_or_fail($error){
             return false;
         }
 
+        $this->requeue_delayed();
+
+        return true;
+    }
+
+    /**
+     * Requeue that keeps counting attempts and waits for the exponential
+     * backoff before the queue may pick the row up again. Use for automatic
+     * (page view / retry) requeues. Explicit user or content-change requeues
+     * should call requeue(0) instead, which resets attempts and is eligible
+     * immediately.
+     */
+    public function requeue_delayed(){
+        $attempts = (int) $this->attempts + 1;
         $this->requeue($attempts);
         $this->created_at = gmdate( "Y-m-d H:i:s", time() + self::retry_delay($attempts) );
+    }
 
-        return true;
+    /**
+     * True for failures worth retrying (timeouts, transport errors, 5xx, 429);
+     * false for definitive API errors (auth, validation) which fail at once.
+     */
+    public static function is_transient_error($result, $error){
+
+        if(!isset($result) || is_string($result)){
+            return true;
+        }
+
+        $code = isset($error['code']) ? (int) $error['code'] : 0;
+
+        return $code >= 500 || $code === 429;
+    }
+
+    /**
+     * Status exposed to the admin UI: the internal 'submitting' claim state is
+     * shown as 'waiting'.
+     */
+    public static function display_status($status){
+        return $status === 'submitting' ? 'waiting' : $status;
     }
 
     /**
@@ -279,9 +314,6 @@ public function mark_as_success($data, $stats, $warnings, $status = 'success', $
             $this->status = isset($data) && (isset($data['mobile']) && !empty($data['mobile']) || isset($data['desktop']) && !empty($data['desktop'])) ? 'success' : 'failed';
         }
         $this->hits = 0;
-        // A genuine API success ends the retry cycle. (Page views must not reset
-        // attempts, see mark_as_successful_hit, or the retry cap is defeated.)
-        $this->attempts = 0;
         $this->stats = isset($stats) ? serialize($stats) : null;
         $this->warnings = isset($warnings) && count($warnings) > 0 ? $warnings : null;
         $this->error = null;
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
index 101a8dd2b..b84f8ca20 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
@@ -222,7 +222,7 @@ function clear_cache($job = null, $args = []){
                     'log' =>  'requeue-> cpcss clear cache by id manually',
                     'url' => $job_data->job->url,
                 ]);
-                $job_data->requeue();
+                $job_data->requeue(0);
                 $job_data->save();
 
             }
@@ -334,7 +334,7 @@ function update_link($link){
                         'id' => $job_data->id,
                         'job_id' => $job_data->job->id,
                         'queue_job_id' => $job_data->queue_job_id,
-                        'status' => $job_data->status,
+                        'status' => RapidLoad_Job_Data::display_status($job_data->status),
                         'job' => (array) $job_data->job,
                     ];
                     $link['meta'] = [
@@ -344,7 +344,7 @@ function update_link($link){
                     ];
                     $link['attempts'] = $job_data->attempts;
                     if($job->rule !== 'is_url'){
-                        $link['rule_status'] = $job_data->status;
+                        $link['rule_status'] = RapidLoad_Job_Data::display_status($job_data->status);
                         $link['rule_hits'] = $job_data->hits;
                         $link['applied_links'] = count($job->get_urls());
                     }
@@ -382,12 +382,16 @@ function cache_cpcss($job, $args = []){
             return false;
         }
 
-        if(!in_array($this->job_data->status, ['success', 'waiting', 'processing','queued']) || isset( $args['immediate']) || isset( $args['requeue'])){
+        if($this->job_data->status !== 'submitting' && (!in_array($this->job_data->status, ['success', 'waiting', 'processing','queued']) || isset( $args['immediate']) || isset( $args['requeue']))){
             self::log([
                 'log' =>  'requeue-> cpcss requeue manually',
                 'url' => $this->job_data->job->url,
             ]);
-            $this->job_data->requeue(isset( $args['immediate']) || isset( $args['requeue']) ? 1 : -1);
+            if(isset( $args['immediate']) || isset( $args['requeue'])){
+                $this->job_data->requeue(0);
+            }else{
+                $this->job_data->requeue_delayed();
+            }
             $this->job_data->save();
         }
 
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
index 7da5e540a..4692c414e 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
@@ -9,7 +9,7 @@ public static function clear_data($soft = false){
         global $wpdb;
 
         if($soft){
-            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0 WHERE job_type = %s", 'queued', 'cpcss'));
+            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type = %s", 'queued', 'cpcss'));
         }else{
             $wpdb->query( $wpdb->prepare("DELETE FROM {$wpdb->prefix}rapidload_job_data WHERE job_type = %s", 'cpcss'));
         }
@@ -28,21 +28,21 @@ public static function requeue_where_status($status = ''){
         if(empty($status)){
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0 WHERE job_type='cpcss'",
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='cpcss'",
                     'queued'
                 )
             );
         }else if($status === 'success'){
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0 WHERE job_type='cpcss' AND status = 'success' AND warnings IS NOT NULL",
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='cpcss' AND status = 'success' AND warnings IS NOT NULL",
                     'queued'
                 )
             );
         }else{
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0 WHERE job_type='cpcss' AND status = %s",
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='cpcss' AND status = %s",
                     'queued',
                     $status
                 )
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Enqueue.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Enqueue.php
index 2fbb07391..c5479c019 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Enqueue.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Enqueue.php
@@ -90,7 +90,7 @@ function update_content($state){
                 'log' =>  'requeue-> critical css file not found and attempts less than two or last generated days more than one',
                 'url' => $this->job_data->job->url,
             ]);
-            $this->job_data->requeue();
+            $this->job_data->requeue_delayed();
             $this->job_data->save();
             //$this->inject->successfully_injected = false;
             return [
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php
index 3ebd30f7c..1e4a5c293 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php
@@ -205,13 +205,13 @@ function update_link($link){
                 if(isset($job_data->id)){
 
                     if($job->rule !== 'is_url'){
-                        //$link['rule_status'] = $job_data->status;
+                        //$link['rule_status'] = RapidLoad_Job_Data::display_status($job_data->status);
                        // $link['rule_hits'] = $job_data->hits;
                         //$link['applied_links'] = count($job->get_urls());
                     }
 
                     if(!isset($link['status'])){
-                        $link['status'] = $job_data->status;
+                        $link['status'] = RapidLoad_Job_Data::display_status($job_data->status);
                     }
                     $link['success_count'] = $job_data->hits;
                     $link['files'] = $job_data->get_files();
@@ -219,7 +219,7 @@ function update_link($link){
                     $link['meta']['warnings'] = $job_data->get_warnings();
                     $link['meta']['stats'] = isset($job_data->stats) ? unserialize($job_data->stats) : null;
                     $link['meta']['error'] = isset($job_data->error) ? unserialize($job_data->error) : null;
-                    $link['meta']['status'] = isset( $job_data->status ) ? $job_data->status : null;
+                    $link['meta']['status'] = isset( $job_data->status ) ? RapidLoad_Job_Data::display_status($job_data->status) : null;
                     $link['time'] = isset( $job_data->created_at ) ? strtotime( $job_data->created_at ) : null;
                     $link['attempts'] = isset( $job_data->attempts ) ? $job_data->attempts : null;
                     $link['rule'] = $job_data->job->rule;
@@ -339,12 +339,16 @@ function cache_uucss($job, $args = []){
             return false;
         }
 
-        if(!in_array($this->job_data->status, ['success', 'waiting', 'processing','queued']) || isset( $args['immediate']) || isset( $args['requeue'])){
+        if($this->job_data->status !== 'submitting' && (!in_array($this->job_data->status, ['success', 'waiting', 'processing','queued']) || isset( $args['immediate']) || isset( $args['requeue']))){
             self::log([
                 'log' =>  'requeue-> uucss requeue manually',
                 'url' => $this->job_data->job->url,
             ]);
-            $this->job_data->requeue(isset( $args['immediate']) || isset( $args['requeue']) ? 1 : -1);
+            if(isset( $args['immediate']) || isset( $args['requeue'])){
+                $this->job_data->requeue(0);
+            }else{
+                $this->job_data->requeue_delayed();
+            }
             if(isset( $args['immediate'])){
                 $this->job_data->status = 'processing';
             }
@@ -486,7 +490,7 @@ function clear_cache($job = null, $args = []){
                     'log' =>  'requeue-> clear cache by job id manually',
                     'url' => $job_data->job->url,
                 ]);
-                $job_data->requeue();
+                $job_data->requeue(0);
                 $job_data->save();
 
             }
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
index 4b053c17c..b21e0a37b 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
@@ -11,21 +11,21 @@ public static function requeue_where_status($status = ''){
         if(empty($status)){
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0 WHERE job_type='uucss'",
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='uucss'",
                     'queued'
                 )
             );
         }else if($status === 'success'){
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0 WHERE job_type='uucss' AND status = 'success' AND warnings IS NOT NULL",
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='uucss' AND status = 'success' AND warnings IS NOT NULL",
                     'queued'
                 )
             );
         }else{
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0 WHERE job_type='uucss' AND status = %s",
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='uucss' AND status = %s",
                     'queued',
                     $status
                 )
@@ -44,7 +44,7 @@ public static function clear_data($soft = false){
         global $wpdb;
 
         if($soft){
-            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0 WHERE job_type = %s", 'queued', 'uucss'));
+            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type = %s", 'queued', 'uucss'));
         }else{
             $wpdb->query( $wpdb->prepare("DELETE FROM {$wpdb->prefix}rapidload_job_data WHERE job_type = %s", 'uucss'));
         }
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Enqueue.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Enqueue.php
index afc29503b..577e88496 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Enqueue.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Enqueue.php
@@ -375,7 +375,7 @@ public function enqueue_completed(){
                 'log' =>  'requeue-> uucss requeue due to warnings',
                 'url' => $this->job_data->job->url,
             ]);
-            $this->job_data->requeue();
+            $this->job_data->requeue_delayed();
 
         }else{
 
diff --git a/includes/modules/optimizer/RapidLoad_Optimizer.php b/includes/modules/optimizer/RapidLoad_Optimizer.php
index 176ee3147..8b25bf9dd 100644
--- a/includes/modules/optimizer/RapidLoad_Optimizer.php
+++ b/includes/modules/optimizer/RapidLoad_Optimizer.php
@@ -453,7 +453,7 @@ public function rapidload_css_job_status(){
                 case 'uucss' :{
                     $job_data_uucss = new RapidLoad_Job_Data($job,'uucss');
                     $response[$type] = [
-                        'status' => isset($job_data_uucss->id) ? $job_data_uucss->status : 'queued',
+                        'status' => isset($job_data_uucss->id) ? RapidLoad_Job_Data::display_status($job_data_uucss->status) : 'queued',
                         'error' => isset($job_data_uucss->id) && isset($job_data_uucss->error) ? unserialize($job_data_uucss->error) : null,
                         'meta' => [
                             'warnings' => isset($job_data_uucss->id) && isset($job_data_uucss->warnings) ? unserialize($job_data_uucss->warnings) : null,
@@ -466,7 +466,7 @@ public function rapidload_css_job_status(){
                     $job_data_cpcss = new RapidLoad_Job_Data($job,'cpcss');
                     $cpcss_data = $job_data_cpcss->get_cpcss_data();
                     $response[$type] = [
-                        'status' => isset($job_data_cpcss->id) ? $job_data_cpcss->status : 'queued',
+                        'status' => isset($job_data_cpcss->id) ? RapidLoad_Job_Data::display_status($job_data_cpcss->status) : 'queued',
                         'error' => isset($job_data_cpcss->id) && isset($job_data_cpcss->error) ? unserialize($job_data_cpcss->error) : null,
                         'meta' => [
                             'warnings' => isset($job_data_cpcss->id) && isset($job_data_cpcss->warnings) ? unserialize($job_data_cpcss->warnings) : null,
@@ -1501,7 +1501,7 @@ function get_settings_with_inputs($url , $keys, $settings, $options = array()) {
                 }else if($input['key'] === "uucss_enable_uucss"){
                     $data = new RapidLoad_Job_Data(self::$job, 'uucss');
                     $settings['status'] =  isset($options[$input['key']]) && $options[$input['key']] === "1" ? [
-                        'status' => isset($data->id) ? $data->status : 'queued',
+                        'status' => isset($data->id) ? RapidLoad_Job_Data::display_status($data->status) : 'queued',
                         'error' =>  isset($data->id) ? $data->get_error() : null,
                         'meta' => [
                             'stats' =>  isset($data->id) ? $data->get_stats() : null,
@@ -1515,7 +1515,7 @@ function get_settings_with_inputs($url , $keys, $settings, $options = array()) {
                     $data = new RapidLoad_Job_Data(self::$job, 'cpcss');
                     $cpcss_data = $data->get_cpcss_data();
                     $settings['status'] = isset($options[$input['key']]) && $options[$input['key']] === "1" ? [
-                        'status' => isset($data->id) ? $data->status : 'queued',
+                        'status' => isset($data->id) ? RapidLoad_Job_Data::display_status($data->status) : 'queued',
                         'error' => isset($data->id) ? $data->get_error() : null,
                         'meta' => [
                             'desktop' => isset($data->id) && isset($cpcss_data['desktop']) && !empty($cpcss_data['desktop']) ? $cpcss_data['desktop'] : null,

From 52d24f1f4913593393db3b2ef9c3d9ef030dc5df Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 21:01:56 +0530
Subject: [PATCH 10/14] Use placeholders for requeue reset SQL (phpcs
 PreparedSQL)

---
 includes/RapidLoad_DB.php                      | 18 ++++++++++--------
 .../critical-css/RapidLoad_CriticalCSS_DB.php  | 15 +++++++++------
 .../css/unused-css/RapidLoad_UnusedCSS_DB.php  | 15 +++++++++------
 3 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/includes/RapidLoad_DB.php b/includes/RapidLoad_DB.php
index 27d4a257e..bde04c590 100644
--- a/includes/RapidLoad_DB.php
+++ b/includes/RapidLoad_DB.php
@@ -705,7 +705,8 @@ public static function updateUrlJobDataStatusWhere($status = 'queued', $ids = []
         global $wpdb;
 
         // explicit requeue: clear retry state and any backoff
-        $reset = $status === 'queued' ? ", attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "'" : '';
+        $reset = $status === 'queued' ? ', attempts = 0, created_at = %s' : '';
+        $reset_args = $status === 'queued' ? [ gmdate( 'Y-m-d H:i:s' ) ] : [];
 
         if (!empty($ids)) {
             $ids = implode(",", array_map('intval', $ids));
@@ -715,12 +716,12 @@ public static function updateUrlJobDataStatusWhere($status = 'queued', $ids = []
         }
 
         if (empty($wherStatus)) {
-            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d)", $status, $ids));
+            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d)", array_merge( [ $status ], $reset_args, [ $ids ] ) ) );
         } else {
             if($wherStatus === "success"){
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", $status, $ids, $wherStatus));
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) );
             }else{
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d) AND status = %s", $status, $ids, $wherStatus));
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) );
             }
         }
 
@@ -738,7 +739,8 @@ public static function updateRuleJobDataStatusWhere($status = 'queued', $ids = [
         global $wpdb;
 
         // explicit requeue: clear retry state and any backoff
-        $reset = $status === 'queued' ? ", attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "'" : '';
+        $reset = $status === 'queued' ? ', attempts = 0, created_at = %s' : '';
+        $reset_args = $status === 'queued' ? [ gmdate( 'Y-m-d H:i:s' ) ] : [];
 
         if (!empty($ids)) {
             $ids = implode(",", array_map('intval', $ids));
@@ -748,12 +750,12 @@ public static function updateRuleJobDataStatusWhere($status = 'queued', $ids = [
         }
 
         if (empty($wherStatus)) {
-            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d)", $status, $ids));
+            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d)", array_merge( [ $status ], $reset_args, [ $ids ] ) ) );
         } else {
             if($wherStatus === "success"){
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", $status, $ids, $wherStatus));
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) );
             }else{
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s{$reset} WHERE job_id IN (%d) AND status = %s", $status, $ids, $wherStatus));
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) );
             }
         }
 
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
index 4692c414e..20238f9aa 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
@@ -9,7 +9,7 @@ public static function clear_data($soft = false){
         global $wpdb;
 
         if($soft){
-            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type = %s", 'queued', 'cpcss'));
+            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type = %s", 'queued', gmdate( 'Y-m-d H:i:s' ), 'cpcss'));
         }else{
             $wpdb->query( $wpdb->prepare("DELETE FROM {$wpdb->prefix}rapidload_job_data WHERE job_type = %s", 'cpcss'));
         }
@@ -28,22 +28,25 @@ public static function requeue_where_status($status = ''){
         if(empty($status)){
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='cpcss'",
-                    'queued'
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type='cpcss'",
+                    'queued',
+                    gmdate( 'Y-m-d H:i:s' )
                 )
             );
         }else if($status === 'success'){
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='cpcss' AND status = 'success' AND warnings IS NOT NULL",
-                    'queued'
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type='cpcss' AND status = 'success' AND warnings IS NOT NULL",
+                    'queued',
+                    gmdate( 'Y-m-d H:i:s' )
                 )
             );
         }else{
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='cpcss' AND status = %s",
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type='cpcss' AND status = %s",
                     'queued',
+                    gmdate( 'Y-m-d H:i:s' ),
                     $status
                 )
             );
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
index b21e0a37b..0d585abcb 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
@@ -11,22 +11,25 @@ public static function requeue_where_status($status = ''){
         if(empty($status)){
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='uucss'",
-                    'queued'
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type='uucss'",
+                    'queued',
+                    gmdate( 'Y-m-d H:i:s' )
                 )
             );
         }else if($status === 'success'){
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='uucss' AND status = 'success' AND warnings IS NOT NULL",
-                    'queued'
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type='uucss' AND status = 'success' AND warnings IS NOT NULL",
+                    'queued',
+                    gmdate( 'Y-m-d H:i:s' )
                 )
             );
         }else{
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type='uucss' AND status = %s",
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type='uucss' AND status = %s",
                     'queued',
+                    gmdate( 'Y-m-d H:i:s' ),
                     $status
                 )
             );
@@ -44,7 +47,7 @@ public static function clear_data($soft = false){
         global $wpdb;
 
         if($soft){
-            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = '" . gmdate( 'Y-m-d H:i:s' ) . "' WHERE job_type = %s", 'queued', 'uucss'));
+            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type = %s", 'queued', gmdate( 'Y-m-d H:i:s' ), 'uucss'));
         }else{
             $wpdb->query( $wpdb->prepare("DELETE FROM {$wpdb->prefix}rapidload_job_data WHERE job_type = %s", 'uucss'));
         }

From 8f9147cecb03c32e39183cfc9305a1158038293b Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 21:02:03 +0530
Subject: [PATCH 11/14] phpcs: annotate fixed SQL fragment

---
 includes/RapidLoad_DB.php | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/includes/RapidLoad_DB.php b/includes/RapidLoad_DB.php
index bde04c590..aa1f2c8e5 100644
--- a/includes/RapidLoad_DB.php
+++ b/includes/RapidLoad_DB.php
@@ -716,12 +716,12 @@ public static function updateUrlJobDataStatusWhere($status = 'queued', $ids = []
         }
 
         if (empty($wherStatus)) {
-            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d)", array_merge( [ $status ], $reset_args, [ $ids ] ) ) );
+            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d)", array_merge( [ $status ], $reset_args, [ $ids ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
         } else {
             if($wherStatus === "success"){
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) );
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
             }else{
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) );
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
             }
         }
 
@@ -750,12 +750,12 @@ public static function updateRuleJobDataStatusWhere($status = 'queued', $ids = [
         }
 
         if (empty($wherStatus)) {
-            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d)", array_merge( [ $status ], $reset_args, [ $ids ] ) ) );
+            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d)", array_merge( [ $status ], $reset_args, [ $ids ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
         } else {
             if($wherStatus === "success"){
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) );
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
             }else{
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) );
+                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
             }
         }
 

From 2a9bb0c1c2973f6bb77a9c46a1a4397c61bf5a2c Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 21:05:47 +0530
Subject: [PATCH 12/14] Fix update*JobDataStatusWhere binding an id list to a
 single %d

Only the first id was updated (including "requeue all"). Build an
IN (%d,%d,...) list from intval'd ids, pass them through prepare(), and
return early on an empty list.
---
 includes/RapidLoad_DB.php | 78 +++++++++++++++++++++++++--------------
 1 file changed, 50 insertions(+), 28 deletions(-)

diff --git a/includes/RapidLoad_DB.php b/includes/RapidLoad_DB.php
index aa1f2c8e5..bab51bcc1 100644
--- a/includes/RapidLoad_DB.php
+++ b/includes/RapidLoad_DB.php
@@ -704,27 +704,38 @@ public static function updateUrlJobDataStatusWhere($status = 'queued', $ids = []
 
         global $wpdb;
 
-        // explicit requeue: clear retry state and any backoff
-        $reset = $status === 'queued' ? ', attempts = 0, created_at = %s' : '';
-        $reset_args = $status === 'queued' ? [ gmdate( 'Y-m-d H:i:s' ) ] : [];
-
         if (!empty($ids)) {
-            $ids = implode(",", array_map('intval', $ids));
+            $ids = array_map('intval', (array) $ids);
         } else {
-            $ids = $wpdb->get_col($wpdb->prepare("SELECT id FROM {$wpdb->prefix}rapidload_job WHERE rule = %s", 'is_url'));
-            $ids = implode(',', array_map('intval', $ids));
+            $ids = array_map('intval', $wpdb->get_col($wpdb->prepare("SELECT id FROM {$wpdb->prefix}rapidload_job WHERE rule = %s", 'is_url')));
         }
 
-        if (empty($wherStatus)) {
-            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d)", array_merge( [ $status ], $reset_args, [ $ids ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
-        } else {
-            if($wherStatus === "success"){
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
-            }else{
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
+        if (empty($ids)) {
+            return true;
+        }
+
+        // explicit requeue: clear retry state and any backoff
+        $set = 'status = %s';
+        $args = [ $status ];
+        if ($status === 'queued') {
+            $set .= ', attempts = 0, created_at = %s';
+            $args[] = gmdate( 'Y-m-d H:i:s' );
+        }
+
+        $where = 'job_id IN (' . implode(',', array_fill(0, count($ids), '%d')) . ')';
+        $args = array_merge($args, $ids);
+
+        if (!empty($wherStatus)) {
+            $where .= ' AND status = %s';
+            $args[] = $wherStatus;
+            if ($wherStatus === "success") {
+                $where .= ' AND warnings IS NOT NULL';
             }
         }
 
+        // $set and $where are built only from fixed fragments and %s/%d placeholders
+        $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET $set WHERE $where", $args ) ); // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared
+
         $error = $wpdb->last_error;
 
         if(!empty($error)){
@@ -738,27 +749,38 @@ public static function updateRuleJobDataStatusWhere($status = 'queued', $ids = [
 
         global $wpdb;
 
-        // explicit requeue: clear retry state and any backoff
-        $reset = $status === 'queued' ? ', attempts = 0, created_at = %s' : '';
-        $reset_args = $status === 'queued' ? [ gmdate( 'Y-m-d H:i:s' ) ] : [];
-
         if (!empty($ids)) {
-            $ids = implode(",", array_map('intval', $ids));
+            $ids = array_map('intval', (array) $ids);
         } else {
-            $ids = $wpdb->get_col($wpdb->prepare("SELECT id FROM {$wpdb->prefix}rapidload_job WHERE rule != %s", 'is_url'));
-            $ids = implode(',', array_map('intval', $ids));
+            $ids = array_map('intval', $wpdb->get_col($wpdb->prepare("SELECT id FROM {$wpdb->prefix}rapidload_job WHERE rule != %s", 'is_url')));
         }
 
-        if (empty($wherStatus)) {
-            $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d)", array_merge( [ $status ], $reset_args, [ $ids ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
-        } else {
-            if($wherStatus === "success"){
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s AND warnings IS NOT NULL", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
-            }else{
-                $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s" . $reset . " WHERE job_id IN (%d) AND status = %s", array_merge( [ $status ], $reset_args, [ $ids, $wherStatus ] ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- $reset is a fixed literal fragment
+        if (empty($ids)) {
+            return true;
+        }
+
+        // explicit requeue: clear retry state and any backoff
+        $set = 'status = %s';
+        $args = [ $status ];
+        if ($status === 'queued') {
+            $set .= ', attempts = 0, created_at = %s';
+            $args[] = gmdate( 'Y-m-d H:i:s' );
+        }
+
+        $where = 'job_id IN (' . implode(',', array_fill(0, count($ids), '%d')) . ')';
+        $args = array_merge($args, $ids);
+
+        if (!empty($wherStatus)) {
+            $where .= ' AND status = %s';
+            $args[] = $wherStatus;
+            if ($wherStatus === "success") {
+                $where .= ' AND warnings IS NOT NULL';
             }
         }
 
+        // $set and $where are built only from fixed fragments and %s/%d placeholders
+        $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET $set WHERE $where", $args ) ); // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared
+
         $error = $wpdb->last_error;
 
         if(!empty($error)){

From a043ee6690f5cbeed621078a7926b882ff9c3265 Mon Sep 17 00:00:00 2001
From: Shakeeb Sadikeen <shakee.zats@gmail.com>
Date: Sun, 11 Oct 2026 21:05:47 +0530
Subject: [PATCH 13/14] Skip clear_cache requeue while submitting; throttle
 save_post requeues

- clear_cache(job) no longer requeues a row that is 'submitting' (a
  save_post/manual purge mid-POST could flip it to queued and allow a
  duplicate claim). It skips and logs; the in-flight result lands normally.
  Chosen over a dirty marker because no existing field fits without schema
  change and the next change/purge requeues as usual.
- The save_post/untrash/trash path (clear_on_actions -> clear_cache with
  throttle) skips the requeue when the row was (re)queued or claimed less
  than rapidload/job/save_post_min_interval minutes ago (default 10), so a
  WooCommerce/importer storm yields at most ~6 submissions/hour/URL. Files
  are kept when skipping. Manual purge and immediate/requeue args are not
  throttled.
---
 includes/RapidLoad_Job_Data.php               | 21 ++++++++++++++++
 .../critical-css/RapidLoad_CriticalCSS.php    | 24 ++++++++++++++++++-
 .../css/unused-css/RapidLoad_UnusedCSS.php    | 24 ++++++++++++++++++-
 3 files changed, 67 insertions(+), 2 deletions(-)

diff --git a/includes/RapidLoad_Job_Data.php b/includes/RapidLoad_Job_Data.php
index 186f01bb2..48b8b8759 100644
--- a/includes/RapidLoad_Job_Data.php
+++ b/includes/RapidLoad_Job_Data.php
@@ -294,6 +294,27 @@ public static function release_stale_claims($job_type){
         }
     }
 
+    /**
+     * Minimum seconds between save_post-driven requeues of the same URL
+     * (default 10 minutes, filter rapidload/job/save_post_min_interval, in minutes).
+     */
+    public static function save_post_min_interval(){
+        $minutes = (int) apply_filters('rapidload/job/save_post_min_interval', 10);
+        return max(0, $minutes) * 60;
+    }
+
+    /**
+     * True when the row was (re)queued or claimed less than $seconds ago.
+     * created_at is refreshed by requeue() and claim(); a future value
+     * (backoff pending) also counts as recent.
+     */
+    public function queued_within($seconds){
+        if($seconds <= 0 || empty($this->created_at)){
+            return false;
+        }
+        return (time() - strtotime($this->created_at)) < $seconds;
+    }
+
     public function clearFiles(){
 
     }
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
index b84f8ca20..c54332408 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
@@ -178,7 +178,8 @@ public function clear_on_actions($post_id)
 
             if(isset($job->id)){
 
-                $this->clear_cache($job);
+                // content-change path: throttled, see clear_cache()
+                $this->clear_cache($job, ['throttle' => true]);
 
             }
         }
@@ -217,6 +218,27 @@ function clear_cache($job = null, $args = []){
 
             if(isset($job_data->id) && (!isset($job_data->job->rule_id) && $job_data->job->rule === "is_url" || $job_data->job->rule !== "is_url")){
 
+                if($job_data->status === 'submitting'){
+                    // A submit is in flight; requeueing now would let a second runner
+                    // claim the row and send a duplicate. Skip: the in-flight result
+                    // lands normally and the next change/purge requeues as usual.
+                    self::log([
+                        'log' =>  'skip requeue-> cpcss clear cache while submitting',
+                        'url' => $job_data->job->url,
+                    ]);
+                    return;
+                }
+
+                if(!empty($args['throttle']) && $job_data->queued_within(RapidLoad_Job_Data::save_post_min_interval())){
+                    // save_post / importer storms: at most one requeue per interval per URL.
+                    // Files are kept (no clear_files) and the current job stays as is.
+                    self::log([
+                        'log' =>  'skip requeue-> cpcss clear cache throttled',
+                        'url' => $job_data->job->url,
+                    ]);
+                    return;
+                }
+
                 $this->clear_files($job_data);
                 self::log([
                     'log' =>  'requeue-> cpcss clear cache by id manually',
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php
index 1e4a5c293..4a3c113bc 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php
@@ -471,7 +471,8 @@ public function clear_on_actions($post_id)
 
             if(isset($job->id)){
 
-                $this->clear_cache($job);
+                // content-change path: throttled, see clear_cache()
+                $this->clear_cache($job, ['throttle' => true]);
 
             }
         }
@@ -485,6 +486,27 @@ function clear_cache($job = null, $args = []){
 
             if(isset($job_data->id) && (!isset($job_data->job->rule_id) && $job_data->job->rule === "is_url" || $job_data->job->rule !== "is_url")){
 
+                if($job_data->status === 'submitting'){
+                    // A submit is in flight; requeueing now would let a second runner
+                    // claim the row and send a duplicate. Skip: the in-flight result
+                    // lands normally and the next change/purge requeues as usual.
+                    self::log([
+                        'log' =>  'skip requeue-> uucss clear cache while submitting',
+                        'url' => $job_data->job->url,
+                    ]);
+                    return;
+                }
+
+                if(!empty($args['throttle']) && $job_data->queued_within(RapidLoad_Job_Data::save_post_min_interval())){
+                    // save_post / importer storms: at most one requeue per interval per URL.
+                    // Files are kept (no clear_files) and the current job stays as is.
+                    self::log([
+                        'log' =>  'skip requeue-> uucss clear cache throttled',
+                        'url' => $job_data->job->url,
+                    ]);
+                    return;
+                }
+
                 $this->clear_files($job_data);
                 self::log([
                     'log' =>  'requeue-> clear cache by job id manually',

From 551e1d7bbf096476e389ce2fb6dcd10afbeb44c2 Mon Sep 17 00:00:00 2001
From: Abdul Azeez <azeezs2012@gmail.com>
Date: Mon, 12 Oct 2026 11:21:40 +0530
Subject: [PATCH 14/14] Address review: per-episode retry cap, 429 deferral,
 deferred save_post requeue

- retry_or_fail caps consecutive failures (tracked in a transient keyed by
  job data id + attempts) instead of lifetime attempts, so a long-lived URL
  whose attempts grew from page-view requeues is not failed on its first
  transient error. Success, explicit resets and page-view requeues end the
  episode. Backoff follows the retry step.
- 429 with Retry-After defers the row until the API window resets without
  counting a retry (RapidLoad_Api now records Retry-After). Clamped 60s..1d.
- save_post throttle default 60 min (<= 24 content-change submits/URL/day,
  matching the API per-URL limit). Throttled changes and changes arriving
  while a submit is in flight are no longer dropped: one deferred requeue
  (single WP-Cron event per job) replays clear_cache afterwards.
- Titan's second CPCSS strategy claims the row from any status except
  'submitting', so it is not dropped when the row is not 'queued'.
- release_stale_claims deletes orphaned rows (job gone), orders by age and
  fires uucss/cache_cleared when giving up.
- Bulk requeue SQL skips rows that are 'submitting'.
- Parenthesise OR in UnusedCSS waiting/processing queries (counted and
  polled cpcss rows as uucss).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 includes/RapidLoad_Api.php                    |   9 +
 includes/RapidLoad_DB.php                     |  12 +-
 includes/RapidLoad_Job_Data.php               | 164 ++++++++++++++++--
 .../critical-css/RapidLoad_CriticalCSS.php    |  28 ++-
 .../critical-css/RapidLoad_CriticalCSS_DB.php |   4 +-
 .../RapidLoad_CriticalCSS_Store.php           |  16 +-
 .../css/unused-css/RapidLoad_UnusedCSS.php    |  28 ++-
 .../css/unused-css/RapidLoad_UnusedCSS_DB.php |   8 +-
 .../unused-css/RapidLoad_UnusedCSS_Store.php  |  12 +-
 9 files changed, 238 insertions(+), 43 deletions(-)

diff --git a/includes/RapidLoad_Api.php b/includes/RapidLoad_Api.php
index 27103bc13..ae7f29a76 100644
--- a/includes/RapidLoad_Api.php
+++ b/includes/RapidLoad_Api.php
@@ -11,6 +11,11 @@ class RapidLoad_Api
 
     public $apiKey = null;
 
+    /**
+     * Retry-After (seconds) of the last response, 0 when absent.
+     */
+    public $retry_after = 0;
+
 
     /**
      * RapidLoad_Api constructor.
@@ -73,8 +78,12 @@ function post( $endpoint, $data = [] ) {
 	 */
 	public function handle_response( $response , $data = null) {
 
+		$this->retry_after = 0;
+
 		if ( is_array( $response ) && ! is_wp_error( $response ) ) {
 
+			$this->retry_after = max( 0, (int) wp_remote_retrieve_header( $response, 'retry-after' ) );
+
 			if ( $response['response']['code'] === 200 ) {
 				$body = $response['body'];
 
diff --git a/includes/RapidLoad_DB.php b/includes/RapidLoad_DB.php
index bab51bcc1..eb93d3cc1 100644
--- a/includes/RapidLoad_DB.php
+++ b/includes/RapidLoad_DB.php
@@ -689,7 +689,7 @@ public static function requeueJob($id){
 
         global $wpdb;
 
-        $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, attempts = 0, created_at = %s WHERE job_id = %d", 'queued', gmdate( 'Y-m-d H:i:s' ), $id ) );
+        $wpdb->query( $wpdb->prepare( "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, attempts = 0, created_at = %s WHERE job_id = %d AND status <> 'submitting'", 'queued', gmdate( 'Y-m-d H:i:s' ), $id ) );
 
         $error = $wpdb->last_error;
 
@@ -725,6 +725,11 @@ public static function updateUrlJobDataStatusWhere($status = 'queued', $ids = []
         $where = 'job_id IN (' . implode(',', array_fill(0, count($ids), '%d')) . ')';
         $args = array_merge($args, $ids);
 
+        if ($status === 'queued') {
+            // rows mid-submit keep their claim; the in-flight result lands normally
+            $where .= " AND status <> 'submitting'";
+        }
+
         if (!empty($wherStatus)) {
             $where .= ' AND status = %s';
             $args[] = $wherStatus;
@@ -770,6 +775,11 @@ public static function updateRuleJobDataStatusWhere($status = 'queued', $ids = [
         $where = 'job_id IN (' . implode(',', array_fill(0, count($ids), '%d')) . ')';
         $args = array_merge($args, $ids);
 
+        if ($status === 'queued') {
+            // rows mid-submit keep their claim; the in-flight result lands normally
+            $where .= " AND status <> 'submitting'";
+        }
+
         if (!empty($wherStatus)) {
             $where .= ' AND status = %s';
             $args[] = $wherStatus;
diff --git a/includes/RapidLoad_Job_Data.php b/includes/RapidLoad_Job_Data.php
index 48b8b8759..7eab84d70 100644
--- a/includes/RapidLoad_Job_Data.php
+++ b/includes/RapidLoad_Job_Data.php
@@ -147,9 +147,14 @@ public static function retry_delay($attempts){
 
     /**
      * Counts one failed attempt. Requeues the job (not eligible for the queue
-     * until the backoff has elapsed) while attempts are left, otherwise marks
+     * until the backoff has elapsed) while retries are left, otherwise marks
      * it as failed with $error.
      *
+     * The cap applies to consecutive failures (see consecutive_retries()), not
+     * to the lifetime attempts counter: attempts also grows with page-view
+     * requeues and is never reset by a success, so capping on it would fail a
+     * long-lived URL on its first transient error.
+     *
      * The backoff is stored as a future created_at; the queue only picks up
      * rows with attempts > 0 once created_at <= now (see the *_DB
      * get_current_queued_tasks_job_ids methods).
@@ -158,15 +163,17 @@ public static function retry_delay($attempts){
      */
     public function retry_or_fail($error){
 
-        $attempts = (int) $this->attempts + 1;
+        $retries = $this->consecutive_retries() + 1;
 
-        if($attempts >= self::max_attempts()){
+        if($retries >= self::max_attempts()){
+            $this->forget_retries();
             $this->mark_as_failed($error);
-            $this->attempts = $attempts;
+            $this->attempts = (int) $this->attempts + 1;
             return false;
         }
 
-        $this->requeue_delayed();
+        $this->requeue_delayed($retries);
+        $this->remember_retries($retries);
 
         return true;
     }
@@ -177,11 +184,91 @@ public function retry_or_fail($error){
      * (page view / retry) requeues. Explicit user or content-change requeues
      * should call requeue(0) instead, which resets attempts and is eligible
      * immediately.
+     *
+     * @param int|null $step backoff step; defaults to the new attempts count
      */
-    public function requeue_delayed(){
+    public function requeue_delayed($step = null){
         $attempts = (int) $this->attempts + 1;
         $this->requeue($attempts);
-        $this->created_at = gmdate( "Y-m-d H:i:s", time() + self::retry_delay($attempts) );
+        $this->created_at = gmdate( "Y-m-d H:i:s", time() + self::retry_delay(isset($step) ? $step : $attempts) );
+    }
+
+    /**
+     * Requeue that waits $seconds without counting as a failed retry (e.g. the
+     * API asked us to come back later with 429 + Retry-After). attempts still
+     * grows so the queue honours the future created_at.
+     */
+    public function defer($seconds){
+        $this->requeue((int) $this->attempts + 1);
+        $this->created_at = gmdate( "Y-m-d H:i:s", time() + max(60, (int) $seconds) );
+    }
+
+    /**
+     * Handles a failed submit (s/criticalcss, s/unusedcss):
+     * - 429 with Retry-After: deferred until the API window resets, not counted as a retry
+     * - timeouts / transport errors / 5xx / other 429: retried with backoff (retry_or_fail)
+     * - definitive API errors (auth, validation): failed at once
+     *
+     * @return bool true when the job stays queued, false when marked as failed
+     */
+    public function handle_submit_error($result, $error, $retry_after = 0){
+
+        $retry_after = (int) $retry_after;
+
+        if(isset($error['code']) && (int) $error['code'] === 429 && $retry_after > 0){
+            $this->defer(min($retry_after, DAY_IN_SECONDS));
+            return true;
+        }
+
+        if(self::is_transient_error($result, $error)){
+            return $this->retry_or_fail($error);
+        }
+
+        $this->mark_as_failed($error);
+
+        return false;
+    }
+
+    /**
+     * Number of consecutive failed retries in the current failure episode.
+     *
+     * Kept in a transient (no schema change) together with the attempts value
+     * it was recorded at. Any other change to attempts in between (explicit
+     * reset, page-view requeue, deferral) or a success ends the episode.
+     * If the transient is lost (object cache eviction) the count restarts; the
+     * backoff still grows with attempts, so this stays bounded.
+     */
+    public function consecutive_retries(){
+
+        if(!isset($this->id)){
+            return 0;
+        }
+
+        $value = get_transient($this->retries_key());
+
+        if(!is_string($value) || strpos($value, ':') === false){
+            return 0;
+        }
+
+        list($at_attempts, $retries) = explode(':', $value, 2);
+
+        return (int) $at_attempts === (int) $this->attempts ? (int) $retries : 0;
+    }
+
+    private function remember_retries($retries){
+        if(isset($this->id)){
+            set_transient($this->retries_key(), (int) $this->attempts . ':' . (int) $retries, DAY_IN_SECONDS);
+        }
+    }
+
+    private function forget_retries(){
+        if(isset($this->id)){
+            delete_transient($this->retries_key());
+        }
+    }
+
+    private function retries_key(){
+        return 'rapidload_job_retries_' . (int) $this->id;
     }
 
     /**
@@ -217,9 +304,13 @@ public static function display_status($status){
      * Atomically moves this row out of 'queued' so only one queue run submits it.
      * created_at is set to now and doubles as the claim time.
      *
+     * @param bool $any_status claim from any status except 'submitting'; for
+     *                         explicit submits (titan) that may run on a row
+     *                         that is not 'queued' (e.g. the second strategy
+     *                         after the immediate one succeeded or failed)
      * @return bool true when this process won the claim
      */
-    public function claim(){
+    public function claim($any_status = false){
 
         if(!isset($this->id)){
             return true;
@@ -229,9 +320,11 @@ public function claim(){
 
         $now = gmdate( "Y-m-d H:i:s", time() );
 
+        $status_sql = $any_status ? "status <> 'submitting'" : "status = 'queued'";
+
         $affected = $wpdb->query(
             $wpdb->prepare(
-                "UPDATE {$wpdb->prefix}rapidload_job_data SET status = 'submitting', created_at = %s WHERE id = %d AND status = 'queued'",
+                "UPDATE {$wpdb->prefix}rapidload_job_data SET status = 'submitting', created_at = %s WHERE id = %d AND $status_sql", // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- fixed fragment
                 $now,
                 $this->id
             )
@@ -261,7 +354,7 @@ public static function release_stale_claims($job_type){
 
         $rows = $wpdb->get_results(
             $wpdb->prepare(
-                "SELECT job_id FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'submitting' AND job_type = %s AND created_at <= %s LIMIT 50",
+                "SELECT job_id FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'submitting' AND job_type = %s AND created_at <= %s ORDER BY created_at ASC LIMIT 50",
                 $job_type,
                 $cutoff
             )
@@ -276,6 +369,15 @@ public static function release_stale_claims($job_type){
             $job = RapidLoad_Job::find_or_fail($row->job_id);
 
             if(!$job){
+                // orphaned row (job deleted): drop it, like the queue fetchers do,
+                // so it cannot be selected again on every tick
+                $wpdb->query(
+                    $wpdb->prepare(
+                        "DELETE FROM {$wpdb->prefix}rapidload_job_data WHERE job_type = %s AND job_id = %d",
+                        $job_type,
+                        $row->job_id
+                    )
+                );
                 continue;
             }
 
@@ -286,23 +388,58 @@ public static function release_stale_claims($job_type){
                 continue;
             }
 
-            $job_data->retry_or_fail([
+            $requeued = $job_data->retry_or_fail([
                 'code' => 524,
                 'message' => 'Request was interrupted before the API responded'
             ]);
             $job_data->save();
+
+            if(!$requeued){
+                do_action( 'uucss/cache_cleared', [
+                    'url' => $job->url
+                ]);
+            }
         }
     }
 
     /**
      * Minimum seconds between save_post-driven requeues of the same URL
-     * (default 10 minutes, filter rapidload/job/save_post_min_interval, in minutes).
+     * (default 60 minutes, filter rapidload/job/save_post_min_interval, in minutes).
+     * Keeps content-change submissions at <= 24/URL/day, within the API's
+     * per-URL daily limit. A change inside the interval is not dropped: it is
+     * replayed by a deferred requeue (see schedule_deferred_requeue()).
      */
     public static function save_post_min_interval(){
-        $minutes = (int) apply_filters('rapidload/job/save_post_min_interval', 10);
+        $minutes = (int) apply_filters('rapidload/job/save_post_min_interval', 60);
         return max(0, $minutes) * 60;
     }
 
+    const DEFERRED_REQUEUE_HOOK = 'rapidload/job/deferred_requeue';
+
+    /**
+     * Schedules one clear_cache replay for this URL once the throttle interval
+     * (counted from the last requeue / claim) has passed, or shortly after an
+     * in-flight submit. At most one event per job and type is pending, so a
+     * save storm still produces a single requeue that includes the latest
+     * content. Handled by RapidLoad_CriticalCSS / RapidLoad_UnusedCSS.
+     */
+    public function schedule_deferred_requeue(){
+
+        $args = [ $this->job_type, (int) $this->job_id ];
+
+        if(wp_next_scheduled(self::DEFERRED_REQUEUE_HOOK, $args)){
+            return;
+        }
+
+        $at = time() + 60;
+
+        if(!empty($this->created_at)){
+            $at = max($at, strtotime($this->created_at) + self::save_post_min_interval());
+        }
+
+        wp_schedule_single_event($at, self::DEFERRED_REQUEUE_HOOK, $args);
+    }
+
     /**
      * True when the row was (re)queued or claimed less than $seconds ago.
      * created_at is refreshed by requeue() and claim(); a future value
@@ -338,6 +475,7 @@ public function mark_as_success($data, $stats, $warnings, $status = 'success', $
         $this->stats = isset($stats) ? serialize($stats) : null;
         $this->warnings = isset($warnings) && count($warnings) > 0 ? $warnings : null;
         $this->error = null;
+        $this->forget_retries();
     }
 
     public function mark_as_successful_hit(){
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
index c54332408..ff10150ad 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS.php
@@ -53,6 +53,8 @@ public function __construct()
 
         add_action('rapidload/job/purge', [$this, 'cache_cpcss'], 10, 2);
 
+        add_action(RapidLoad_Job_Data::DEFERRED_REQUEUE_HOOK, [$this, 'handle_deferred_requeue'], 10, 2);
+
         add_action('rapidload/job/handle', [$this, 'cache_cpcss'], 10, 2);
 
         add_action('rapidload/job/handle', [$this, 'enqueue_cpcss'], 20, 2);
@@ -162,6 +164,23 @@ public function refresh( $url, $args = [] ) {
         $this->cache_cpcss( $job, $args );
     }
 
+    /**
+     * Replays a content change that was throttled or arrived while a submit
+     * was in flight (see RapidLoad_Job_Data::schedule_deferred_requeue()).
+     */
+    public function handle_deferred_requeue($job_type, $job_id){
+
+        if($job_type !== 'cpcss'){
+            return;
+        }
+
+        $job = RapidLoad_Job::find_or_fail($job_id);
+
+        if($job){
+            $this->clear_cache($job, ['throttle' => true]);
+        }
+    }
+
     public function clear_on_actions($post_id)
     {
         if(!$post_id){
@@ -220,8 +239,9 @@ function clear_cache($job = null, $args = []){
 
                 if($job_data->status === 'submitting'){
                     // A submit is in flight; requeueing now would let a second runner
-                    // claim the row and send a duplicate. Skip: the in-flight result
-                    // lands normally and the next change/purge requeues as usual.
+                    // claim the row and send a duplicate. Replay the change once the
+                    // submit is over instead of dropping it.
+                    $job_data->schedule_deferred_requeue();
                     self::log([
                         'log' =>  'skip requeue-> cpcss clear cache while submitting',
                         'url' => $job_data->job->url,
@@ -231,7 +251,9 @@ function clear_cache($job = null, $args = []){
 
                 if(!empty($args['throttle']) && $job_data->queued_within(RapidLoad_Job_Data::save_post_min_interval())){
                     // save_post / importer storms: at most one requeue per interval per URL.
-                    // Files are kept (no clear_files) and the current job stays as is.
+                    // Files are kept (no clear_files) and the current job stays as is;
+                    // a single deferred requeue picks up the latest content afterwards.
+                    $job_data->schedule_deferred_requeue();
                     self::log([
                         'log' =>  'skip requeue-> cpcss clear cache throttled',
                         'url' => $job_data->job->url,
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
index 20238f9aa..3f0ea0633 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_DB.php
@@ -9,7 +9,7 @@ public static function clear_data($soft = false){
         global $wpdb;
 
         if($soft){
-            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type = %s", 'queued', gmdate( 'Y-m-d H:i:s' ), 'cpcss'));
+            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type = %s AND status <> 'submitting'", 'queued', gmdate( 'Y-m-d H:i:s' ), 'cpcss'));
         }else{
             $wpdb->query( $wpdb->prepare("DELETE FROM {$wpdb->prefix}rapidload_job_data WHERE job_type = %s", 'cpcss'));
         }
@@ -28,7 +28,7 @@ public static function requeue_where_status($status = ''){
         if(empty($status)){
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type='cpcss'",
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type='cpcss' AND status <> 'submitting'",
                     'queued',
                     gmdate( 'Y-m-d H:i:s' )
                 )
diff --git a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
index 71619b871..37fcaaf7e 100644
--- a/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
+++ b/includes/modules/css/critical-css/RapidLoad_CriticalCSS_Store.php
@@ -103,7 +103,9 @@ function purge_css(){
 
             $cpcss_config = apply_filters('cpcss/purge/config', ( isset( $this->args['options'] ) ) ? $this->args['options'] : []);
 
-            if(!$this->job_data->claim()){
+            // titan submits explicitly (e.g. the second strategy right after the
+            // immediate one), so the row need not be 'queued'
+            if(!$this->job_data->claim(isset($this->args['titan']))){
                 // another queue run already took this job
                 return;
             }
@@ -127,17 +129,13 @@ function purge_css(){
 
                 $error = $uucss_api->extract_error( $result );
 
-                // timeouts / transport errors / 5xx / 429 are retried with backoff,
-                // definitive API errors fail at once
-                if(RapidLoad_Job_Data::is_transient_error($result, $error)){
-                    $this->job_data->retry_or_fail($error);
-                }else{
-                    $this->job_data->mark_as_failed($error);
-                }
+                // 429 + Retry-After waits for the API window, timeouts / transport
+                // errors / 5xx are retried with backoff, definitive API errors fail at once
+                $requeued = $this->job_data->handle_submit_error($result, $error, $uucss_api->retry_after);
                 $this->job_data->save();
 
                 $this->log( [
-                    'log' => 'fetched data stored status failed',
+                    'log' => $requeued ? 'submit failed, requeued (attempt ' . $this->job_data->attempts . ')' : 'fetched data stored status failed',
                     'url' => $this->job_data->job->url,
                     'type' => 'uucss-cron'
                 ] );
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php
index 4a3c113bc..bc8214cd1 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS.php
@@ -42,6 +42,8 @@ public function __construct()
 
         add_action('rapidload/job/purge', [$this, 'cache_uucss'], 10, 2);
 
+        add_action(RapidLoad_Job_Data::DEFERRED_REQUEUE_HOOK, [$this, 'handle_deferred_requeue'], 10, 2);
+
         add_action('uucss_async_queue', [$this, 'init_async_store'], 10, 2);
 
         if(apply_filters('uucss/enable/notfound_fallback', true)){
@@ -455,6 +457,23 @@ public function cleanCacheFiles(){
 
     }
 
+    /**
+     * Replays a content change that was throttled or arrived while a submit
+     * was in flight (see RapidLoad_Job_Data::schedule_deferred_requeue()).
+     */
+    public function handle_deferred_requeue($job_type, $job_id){
+
+        if($job_type !== 'uucss'){
+            return;
+        }
+
+        $job = RapidLoad_Job::find_or_fail($job_id);
+
+        if($job){
+            $this->clear_cache($job, ['throttle' => true]);
+        }
+    }
+
     public function clear_on_actions($post_id)
     {
         if(!$post_id){
@@ -488,8 +507,9 @@ function clear_cache($job = null, $args = []){
 
                 if($job_data->status === 'submitting'){
                     // A submit is in flight; requeueing now would let a second runner
-                    // claim the row and send a duplicate. Skip: the in-flight result
-                    // lands normally and the next change/purge requeues as usual.
+                    // claim the row and send a duplicate. Replay the change once the
+                    // submit is over instead of dropping it.
+                    $job_data->schedule_deferred_requeue();
                     self::log([
                         'log' =>  'skip requeue-> uucss clear cache while submitting',
                         'url' => $job_data->job->url,
@@ -499,7 +519,9 @@ function clear_cache($job = null, $args = []){
 
                 if(!empty($args['throttle']) && $job_data->queued_within(RapidLoad_Job_Data::save_post_min_interval())){
                     // save_post / importer storms: at most one requeue per interval per URL.
-                    // Files are kept (no clear_files) and the current job stays as is.
+                    // Files are kept (no clear_files) and the current job stays as is;
+                    // a single deferred requeue picks up the latest content afterwards.
+                    $job_data->schedule_deferred_requeue();
                     self::log([
                         'log' =>  'skip requeue-> uucss clear cache throttled',
                         'url' => $job_data->job->url,
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
index 0d585abcb..11a04b8bc 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_DB.php
@@ -11,7 +11,7 @@ public static function requeue_where_status($status = ''){
         if(empty($status)){
             $wpdb->query(
                 $wpdb->prepare(
-                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type='uucss'",
+                    "UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type='uucss' AND status <> 'submitting'",
                     'queued',
                     gmdate( 'Y-m-d H:i:s' )
                 )
@@ -47,7 +47,7 @@ public static function clear_data($soft = false){
         global $wpdb;
 
         if($soft){
-            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type = %s", 'queued', gmdate( 'Y-m-d H:i:s' ), 'uucss'));
+            $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->prefix}rapidload_job_data SET status = %s, queue_job_id = NULL, data = NULL, stats = NULL, warnings = NULL, error = NULL, hits = 0, attempts = 0, created_at = %s WHERE job_type = %s AND status <> 'submitting'", 'queued', gmdate( 'Y-m-d H:i:s' ), 'uucss'));
         }else{
             $wpdb->query( $wpdb->prepare("DELETE FROM {$wpdb->prefix}rapidload_job_data WHERE job_type = %s", 'uucss'));
         }
@@ -139,7 +139,7 @@ public static function get_current_waiting_tasks_count(){
 
         $count = $wpdb->get_var(
             $wpdb->prepare(
-                "SELECT COUNT(id) FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'processing' OR status = 'waiting' AND job_type = %s",
+                "SELECT COUNT(id) FROM {$wpdb->prefix}rapidload_job_data WHERE (status = 'processing' OR status = 'waiting') AND job_type = %s",
                 'uucss'
             )
         );
@@ -168,7 +168,7 @@ public static function get_current_processing_tasks_job_ids($limit = 1){
 
         $job_ids = $wpdb->get_results(
             $wpdb->prepare(
-                "SELECT job_id FROM {$wpdb->prefix}rapidload_job_data WHERE status = 'processing' OR status = 'waiting' AND job_type = %s ORDER BY id DESC LIMIT %d",  
+                "SELECT job_id FROM {$wpdb->prefix}rapidload_job_data WHERE (status = 'processing' OR status = 'waiting') AND job_type = %s ORDER BY id DESC LIMIT %d",  
                 'uucss',
                 $limit
             ),
diff --git a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
index 5de0b50df..bc66431fc 100644
--- a/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
+++ b/includes/modules/css/unused-css/RapidLoad_UnusedCSS_Store.php
@@ -109,17 +109,13 @@ public function purge_css() {
 
                 $error = $uucss_api->extract_error( $result );
 
-                // timeouts / transport errors / 5xx / 429 are retried with backoff,
-                // definitive API errors fail at once
-                if(RapidLoad_Job_Data::is_transient_error($result, $error)){
-                    $this->job_data->retry_or_fail($error);
-                }else{
-                    $this->job_data->mark_as_failed($error);
-                }
+                // 429 + Retry-After waits for the API window, timeouts / transport
+                // errors / 5xx are retried with backoff, definitive API errors fail at once
+                $requeued = $this->job_data->handle_submit_error($result, $error, $uucss_api->retry_after);
                 $this->job_data->save();
 
                 $this->log( [
-                    'log' => 'fetched data stored status failed',
+                    'log' => $requeued ? 'submit failed, requeued (attempt ' . $this->job_data->attempts . ')' : 'fetched data stored status failed',
                     'url' => $this->job_data->job->url,
                     'type' => 'uucss-cron'
                 ] );