groupmq-plus 1.1.0

package/dist/lua/is-empty.lua

@@ -0,0 +1,35 @@
+-- argv: ns
+local ns = KEYS[1]
+
+-- Check processing jobs
+local processingCount = redis.call("ZCARD", ns .. ":processing")
+if processingCount > 0 then
+  return 0
+end
+
+-- Check delayed jobs
+local delayedCount = redis.call("ZCARD", ns .. ":delayed")
+if delayedCount > 0 then
+  return 0
+end
+
+-- Check ready groups (jobs waiting)
+local readyCount = redis.call("ZCARD", ns .. ":ready")
+if readyCount > 0 then
+  return 0
+end
+
+
+-- Check all groups for waiting jobs
+local groups = redis.call("SMEMBERS", ns .. ":groups")
+for _, gid in ipairs(groups) do
+  local gZ = ns .. ":g:" .. gid
+  local jobCount = redis.call("ZCARD", gZ)
+  if jobCount > 0 then
+    return 0
+  end
+end
+
+-- Queue is completely empty
+return 1
+

package/dist/lua/promote-delayed-jobs.lua

@@ -0,0 +1,40 @@
+-- argv: ns, now
+local ns = KEYS[1]
+local now = tonumber(ARGV[1])
+
+local delayedKey = ns .. ":delayed"
+local readyKey = ns .. ":ready"
+
+local promotedCount = 0
+
+-- Get jobs that are ready (score <= now)
+local readyJobs = redis.call("ZRANGEBYSCORE", delayedKey, 0, now)
+
+for i = 1, #readyJobs do
+  local jobId = readyJobs[i]
+  local jobKey = ns .. ":job:" .. jobId
+  local groupId = redis.call("HGET", jobKey, "groupId")
+  
+  if groupId then
+    local gZ = ns .. ":g:" .. groupId
+    
+    -- Remove from delayed set
+    redis.call("ZREM", delayedKey, jobId)
+    
+    -- Check if this job is the head of its group (earliest in group)
+    local head = redis.call("ZRANGE", gZ, 0, 0)
+    if head and #head > 0 and head[1] == jobId then
+      -- This is the head job, so group should be ready
+      local headScore = redis.call("ZSCORE", gZ, jobId)
+      if headScore then
+        redis.call("ZADD", readyKey, headScore, groupId)
+      end
+    end
+    
+    promotedCount = promotedCount + 1
+  end
+end
+
+return promotedCount
+
+

package/dist/lua/promote-delayed-one.lua

@@ -0,0 +1,44 @@
+-- argv: ns, now
+local ns = KEYS[1]
+local now = tonumber(ARGV[1])
+
+local delayedKey = ns .. ":delayed"
+local readyKey = ns .. ":ready"
+
+-- Find one job that is due now
+local ids = redis.call("ZRANGEBYSCORE", delayedKey, 0, now, "LIMIT", 0, 1)
+if not ids or #ids == 0 then
+  return 0
+end
+
+local jobId = ids[1]
+
+-- Try to remove it atomically; if another scheduler raced, ZREM will return 0
+local removed = redis.call("ZREM", delayedKey, jobId)
+if removed == 0 then
+  return 0
+end
+
+-- Determine its group and update ready queue if it was the head
+local jobKey = ns .. ":job:" .. jobId
+local groupId = redis.call("HGET", jobKey, "groupId")
+if not groupId then
+  return 1 -- treat as moved even if metadata missing
+end
+
+-- Mark job as waiting (no longer delayed)
+redis.call("HSET", jobKey, "status", "waiting")
+redis.call("HDEL", jobKey, "runAt")
+
+local gZ = ns .. ":g:" .. groupId
+local head = redis.call("ZRANGE", gZ, 0, 0)
+if head and #head > 0 and head[1] == jobId then
+  local headScore = redis.call("ZSCORE", gZ, jobId)
+  if headScore then
+    redis.call("ZADD", readyKey, headScore, groupId)
+  end
+end
+
+return 1
+
+

package/dist/lua/promote-staged.lua

@@ -0,0 +1,70 @@
+-- Promote staged jobs that are now ready to be processed
+-- argv: ns, now, limit
+local ns = KEYS[1]
+local now = tonumber(ARGV[1])
+local limit = tonumber(ARGV[2]) or 100
+
+local stageKey = ns .. ":stage"
+local readyKey = ns .. ":ready"
+local timerKey = ns .. ":stage:timer"
+
+local promotedCount = 0
+
+-- Get jobs that are ready (score <= now)
+local readyJobs = redis.call("ZRANGEBYSCORE", stageKey, 0, now, "LIMIT", 0, limit)
+
+for i = 1, #readyJobs do
+  local jobId = readyJobs[i]
+  local jobKey = ns .. ":job:" .. jobId
+  
+  -- Get job metadata
+  local jobData = redis.call("HMGET", jobKey, "groupId", "score", "status")
+  local groupId = jobData[1]
+  local score = jobData[2]
+  local status = jobData[3]
+  
+  if groupId and score and status == "staged" then
+    local gZ = ns .. ":g:" .. groupId
+    
+    -- Remove from staging set
+    redis.call("ZREM", stageKey, jobId)
+    
+    -- Add to group ZSET with original score
+    redis.call("ZADD", gZ, tonumber(score), jobId)
+    
+    -- Update job status from "staged" to "waiting"
+    redis.call("HSET", jobKey, "status", "waiting")
+    
+    -- Check if group should be added to ready queue
+    -- Add group to ready if the head job is now waiting (not delayed or staged)
+    local head = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+    if head and #head >= 2 then
+      local headJobId = head[1]
+      local headScore = tonumber(head[2])
+      local headJobKey = ns .. ":job:" .. headJobId
+      local headStatus = redis.call("HGET", headJobKey, "status")
+      
+      -- Only add to ready if head is waiting (not delayed/staged)
+      if headStatus == "waiting" then
+        redis.call("ZADD", readyKey, headScore, groupId)
+      end
+    end
+    
+    promotedCount = promotedCount + 1
+  end
+end
+
+-- Recompute timer: set to the next earliest staged job
+local nextHead = redis.call("ZRANGE", stageKey, 0, 0, "WITHSCORES")
+if nextHead and #nextHead >= 2 then
+  local nextReleaseAt = tonumber(nextHead[2])
+  -- Set timer to expire when the next earliest job is ready
+  local ttlMs = math.max(1, nextReleaseAt - now)
+  redis.call("SET", timerKey, "1", "PX", ttlMs)
+else
+  -- No more staged jobs, delete the timer
+  redis.call("DEL", timerKey)
+end
+
+return promotedCount
+

package/dist/lua/record-job-result.lua

@@ -0,0 +1,143 @@
+-- Record job completion or failure with retention management
+-- argv: ns, jobId, status ('completed' | 'failed'), timestamp, result/error (JSON), 
+--       keepCompleted, keepFailed, processedOn, finishedOn, attempts, maxAttempts
+local ns = KEYS[1]
+local jobId = ARGV[1]
+local status = ARGV[2]
+local timestamp = tonumber(ARGV[3])
+local resultOrError = ARGV[4]
+local keepCompleted = tonumber(ARGV[5])
+local keepFailed = tonumber(ARGV[6])
+local processedOn = ARGV[7]
+local finishedOn = ARGV[8]
+local attempts = ARGV[9]
+local maxAttempts = ARGV[10]
+
+local jobKey = ns .. ":job:" .. jobId
+
+-- [PHASE 3 MODIFICATION START: Get parentId before potentially deleting the job]
+local parentId = redis.call("HGET", jobKey, "parentId")
+-- [PHASE 3 MODIFICATION END]
+
+-- Verify job exists and check current status to prevent race conditions
+local currentStatus = redis.call("HGET", jobKey, "status")
+if not currentStatus then
+  -- Job doesn't exist, likely already cleaned up
+  return 0
+end
+
+-- If job is in "waiting" state, this might be a late completion after stalled recovery
+-- In this case, we should not overwrite the status or delete the job
+if currentStatus == "waiting" then
+  -- Job was recovered by stalled check and possibly being processed by another worker
+  -- Ignore this late completion to prevent corruption
+  return 0
+end
+
+-- [PHASE 3 MODIFICATION START: Update Flow Parent]
+-- Regardless of whether the job succeeded or failed, if it's finished, update parent
+if parentId then
+  local parentKey = ns .. ":job:" .. parentId
+  -- 1. Store child result in a separate hash to define parent's "childrenValues"
+  -- Key: flow:results:{parentId}, Field: {childId}
+  local flowResultsKey = ns .. ":flow:results:" .. parentId
+  redis.call("HSET", flowResultsKey, jobId, resultOrError)
+  
+  -- 2. Decrement remaining counter
+  local remaining = redis.call("HINCRBY", parentKey, "flowRemaining", -1)
+  
+  -- 3. If all children done, move parent to waiting
+  if remaining <= 0 then
+    local parentStatus = redis.call("HGET", parentKey, "status")
+    if parentStatus == "waiting-children" then
+      redis.call("HSET", parentKey, "status", "waiting")
+      
+      local parentGroupId = redis.call("HGET", parentKey, "groupId")
+      local parentScore = tonumber(redis.call("HGET", parentKey, "score")) or (tonumber(redis.call("TIME")[1]) * 1000)
+      
+      local pGZ = ns .. ":g:" .. parentGroupId
+      redis.call("ZADD", pGZ, parentScore, parentId)
+      redis.call("SADD", ns .. ":groups", parentGroupId)
+      
+      -- Add to ready if head
+      local pHead = redis.call("ZRANGE", pGZ, 0, 0, "WITHSCORES")
+      if pHead and #pHead >= 2 then
+         local pHeadScore = tonumber(pHead[2])
+         redis.call("ZADD", ns .. ":ready", pHeadScore, parentGroupId)
+      end
+    end
+  end
+end
+-- [PHASE 3 MODIFICATION END]
+
+if status == "completed" then
+  local completedKey = ns .. ":completed"
+  
+  if keepCompleted > 0 then
+    -- Store job metadata and add to completed set
+    redis.call("HSET", jobKey, 
+      "status", "completed",
+      "processedOn", processedOn,
+      "finishedOn", finishedOn,
+      "attempts", attempts,
+      "maxAttempts", maxAttempts,
+      "returnvalue", resultOrError
+    )
+    redis.call("ZADD", completedKey, timestamp, jobId)
+    -- Ensure idempotence mapping exists
+    redis.call("SET", ns .. ":unique:" .. jobId, jobId)
+    
+    -- Trim old entries atomically
+    local zcount = redis.call("ZCARD", completedKey)
+    local toRemove = zcount - keepCompleted
+    if toRemove > 0 then
+      local oldIds = redis.call("ZRANGE", completedKey, 0, toRemove - 1)
+      if #oldIds > 0 then
+        redis.call("ZREMRANGEBYRANK", completedKey, 0, toRemove - 1)
+        -- Batch delete old jobs and unique keys
+        local keysToDelete = {}
+        for i = 1, #oldIds do
+          local oldId = oldIds[i]
+          table.insert(keysToDelete, ns .. ":job:" .. oldId)
+          table.insert(keysToDelete, ns .. ":unique:" .. oldId)
+        end
+        if #keysToDelete > 0 then
+          redis.call("DEL", unpack(keysToDelete))
+        end
+      end
+    end
+  else
+    -- keepCompleted == 0: Delete immediately (batch operation)
+    redis.call("DEL", jobKey, ns .. ":unique:" .. jobId)
+  end
+  
+elseif status == "failed" then
+  local failedKey = ns .. ":failed"
+  
+  -- Parse error info from resultOrError JSON
+  -- Expected format: {"message":"...", "name":"...", "stack":"..."}
+  local errorInfo = cjson.decode(resultOrError)
+  
+  if keepFailed > 0 then
+    -- Store failure metadata
+    redis.call("HSET", jobKey,
+      "status", "failed",
+      "failedReason", errorInfo.message or "Error",
+      "failedName", errorInfo.name or "Error",
+      "stacktrace", errorInfo.stack or "",
+      "processedOn", processedOn,
+      "finishedOn", finishedOn,
+      "attempts", attempts,
+      "maxAttempts", maxAttempts
+    )
+    redis.call("ZADD", failedKey, timestamp, jobId)
+    
+    -- Note: No retention trimming for failed jobs (let clean() handle it)
+  else
+    -- keepFailed == 0: Delete immediately (batch operation)
+    redis.call("DEL", jobKey, ns .. ":unique:" .. jobId)
+  end
+end
+
+return 1
+

package/dist/lua/remove.lua

@@ -0,0 +1,55 @@
+-- argv: ns, jobId
+local ns = KEYS[1]
+local jobId = ARGV[1]
+
+local jobKey = ns .. ":job:" .. jobId
+local delayedKey = ns .. ":delayed"
+local readyKey = ns .. ":ready"
+local processingKey = ns .. ":processing"
+
+-- If job does not exist, return 0
+if redis.call("EXISTS", jobKey) == 0 then
+  return 0
+end
+
+local groupId = redis.call("HGET", jobKey, "groupId")
+
+-- Remove from delayed and processing structures
+redis.call("ZREM", delayedKey, jobId)
+redis.call("DEL", ns .. ":processing:" .. jobId)
+redis.call("ZREM", processingKey, jobId)
+
+-- Remove from completed/failed retention sets if present
+redis.call("ZREM", ns .. ":completed", jobId)
+redis.call("ZREM", ns .. ":failed", jobId)
+
+-- Delete idempotence mapping
+redis.call("DEL", ns .. ":unique:" .. jobId)
+
+-- If we have a group, update group zset and ready queue accordingly
+if groupId then
+  local gZ = ns .. ":g:" .. groupId
+  redis.call("ZREM", gZ, jobId)
+
+  local jobCount = redis.call("ZCARD", gZ)
+  if jobCount == 0 then
+    redis.call("ZREM", readyKey, groupId)
+    -- Clean up empty group
+    redis.call("DEL", gZ)
+    redis.call("SREM", ns .. ":groups", groupId)
+  else
+    local head = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+    if head and #head >= 2 then
+      local headScore = tonumber(head[2])
+      redis.call("ZADD", readyKey, headScore, groupId)
+    end
+  end
+end
+
+-- Finally, delete the job hash and flow results
+redis.call("DEL", jobKey)
+redis.call("DEL", ns .. ":flow:results:" .. jobId)
+
+return 1
+
+

package/dist/lua/reserve-atomic.lua

@@ -0,0 +1,114 @@
+-- Atomic reserve operation that checks lock/limit and reserves in one operation
+-- argv: ns, nowEpochMs, vtMs, targetGroupId, allowedJobId (optional)
+local ns = KEYS[1]
+local now = tonumber(ARGV[1])
+local vt = tonumber(ARGV[2])
+local targetGroupId = ARGV[3]
+local allowedJobId = ARGV[4] -- If provided, allow reserve if matches active job (chaining)
+
+local readyKey = ns .. ":ready"
+local gZ = ns .. ":g:" .. targetGroupId
+local groupActiveKey = ns .. ":g:" .. targetGroupId .. ":active"
+local configKey = ns .. ":config:" .. targetGroupId
+
+-- Respect paused state
+if redis.call("GET", ns .. ":paused") then
+  return nil
+end
+
+-- [PHASE 2 MODIFICATION START]
+-- Fetch concurrency limit (default 1)
+local limit = tonumber(redis.call("HGET", configKey, "concurrency")) or 1
+local activeCount = redis.call("LLEN", groupActiveKey)
+
+-- Logic: Can we reserve?
+local canReserve = false
+
+if activeCount < limit then
+  -- Case 1: Slots available
+  canReserve = true
+elseif allowedJobId then
+  -- Case 2: Group is full, BUT we are explicitly allowed to chain from a specific job
+  -- Check if allowedJobId is actually in the active list (reclaiming its own slot)
+  -- Note: We scan the list. Since limits are usually small (e.g., <100), this O(N) is acceptable.
+  -- For strict O(1), we would need a Set, but List is used for queuing order.
+  local items = redis.call("LRANGE", groupActiveKey, 0, -1)
+  for _, id in ipairs(items) do
+    if id == allowedJobId then
+      canReserve = true
+      break
+    end
+  end
+end
+
+if not canReserve then
+  -- Group is full and no special access granted
+  -- If head matches our allowedJobId but we failed (shouldn't happen logic-wise but safe-guard),
+  -- ensure ready queue is correct.
+  local head = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+  if head and #head >= 2 then
+    local headScore = tonumber(head[2])
+    redis.call("ZADD", readyKey, headScore, targetGroupId)
+  end
+  return nil
+end
+-- [PHASE 2 MODIFICATION END]
+
+-- Try to get a job from the group
+local head = redis.call("ZRANGE", gZ, 0, 0)
+if not head or #head == 0 then
+  return nil
+end
+local headJobId = head[1]
+local jobKey = ns .. ":job:" .. headJobId
+
+-- Skip if head job is delayed
+local jobStatus = redis.call("HGET", jobKey, "status")
+if jobStatus == "delayed" then
+  return nil
+end
+
+-- Pop the job
+local zpop = redis.call("ZPOPMIN", gZ, 1)
+if not zpop or #zpop == 0 then
+  return nil
+end
+headJobId = zpop[1]
+
+local job = redis.call("HMGET", jobKey, "id","groupId","data","attempts","maxAttempts","seq","timestamp","orderMs","score")
+local id, groupId, payload, attempts, maxAttempts, seq, enq, orderMs, score = job[1], job[2], job[3], job[4], job[5], job[6], job[7], job[8], job[9]
+
+if not id or id == false then
+  -- Corruption handling
+  local nextHead = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+  if nextHead and #nextHead >= 2 then
+    local nextScore = tonumber(nextHead[2])
+    redis.call("ZADD", readyKey, nextScore, targetGroupId)
+  end
+  return nil
+end
+
+-- [PHASE 2 MODIFICATION START]
+-- Push to group active list
+-- If we are chaining (allowedJobId matched), we should technically verify we aren't adding a duplicate
+-- if the previous one wasn't removed yet. But typically complete-with-metadata removes the old one.
+-- Just strictly push.
+redis.call("LPUSH", groupActiveKey, id)
+-- [PHASE 2 MODIFICATION END]
+
+local procKey = ns .. ":processing:" .. id
+local deadline = now + vt
+redis.call("HSET", procKey, "groupId", groupId, "deadlineAt", tostring(deadline))
+
+local processingKey = ns .. ":processing"
+redis.call("ZADD", processingKey, deadline, id)
+
+redis.call("HSET", jobKey, "status", "processing")
+
+local nextHead = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+if nextHead and #nextHead >= 2 then
+  local nextScore = tonumber(nextHead[2])
+  redis.call("ZADD", readyKey, nextScore, groupId)
+end
+
+return id .. "|||" .. groupId .. "|||" .. payload .. "|||" .. attempts .. "|||" .. maxAttempts .. "|||" .. seq .. "|||" .. enq .. "|||" .. orderMs .. "|||" .. score .. "|||" .. deadline

package/dist/lua/reserve-batch.lua

@@ -0,0 +1,141 @@
+-- argv: ns, nowEpochMs, vtMs, maxBatch
+local ns = KEYS[1]
+local now = tonumber(ARGV[1])
+local vt = tonumber(ARGV[2])
+local maxBatch = tonumber(ARGV[3]) or 16
+
+local readyKey = ns .. ":ready"
+local processingKey = ns .. ":processing"
+
+-- Early exit if paused
+if redis.call("GET", ns .. ":paused") then
+  return {}
+end
+
+local out = {}
+
+-- STALLED JOB RECOVERY WITH THROTTLING
+-- Check for stalled jobs periodically to avoid overhead in hot path
+-- This ensures stalled jobs are recovered even in high-load systems where ready queue is never empty
+-- Check interval is adaptive: 1/4 of jobTimeout (to check 4x during visibility window), max 5s
+local stalledCheckKey = ns .. ":stalled:lastcheck"
+local lastCheck = tonumber(redis.call("GET", stalledCheckKey)) or 0
+local stalledCheckInterval = math.min(math.floor(vt / 4), 5000)
+
+if (now - lastCheck) >= stalledCheckInterval then
+  -- Update last check timestamp
+  redis.call("SET", stalledCheckKey, tostring(now))
+  
+  -- Check for expired jobs and recover them
+  local expiredJobs = redis.call("ZRANGEBYSCORE", processingKey, 0, now)
+  if #expiredJobs > 0 then
+    for _, jobId in ipairs(expiredJobs) do
+      local procKey = ns .. ":processing:" .. jobId
+      local procData = redis.call("HMGET", procKey, "groupId", "deadlineAt")
+      local gid = procData[1]
+      local deadlineAt = tonumber(procData[2])
+      if gid and deadlineAt and now > deadlineAt then
+        local jobKey = ns .. ":job:" .. jobId
+        local jobScore = redis.call("HGET", jobKey, "score")
+        if jobScore then
+          local gZ = ns .. ":g:" .. gid
+          redis.call("ZADD", gZ, tonumber(jobScore), jobId)
+          local head = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+          if head and #head >= 2 then
+            local headScore = tonumber(head[2])
+            redis.call("ZADD", readyKey, headScore, gid)
+          end
+          redis.call("DEL", ns .. ":lock:" .. gid)
+          redis.call("DEL", procKey)
+          redis.call("ZREM", processingKey, jobId)
+        end
+      end
+    end
+  end
+end
+
+-- Pop up to maxBatch groups from ready set (lowest score first)
+local groups = redis.call("ZRANGE", readyKey, 0, maxBatch - 1, "WITHSCORES")
+if not groups or #groups == 0 then
+  return {}
+end
+
+local processedGroups = {}
+-- BullMQ-style: use per-group active list instead of group locks
+for i = 1, #groups, 2 do
+  local gid = groups[i]
+  local gZ = ns .. ":g:" .. gid
+  local groupActiveKey = ns .. ":g:" .. gid .. ":active"
+  local configKey = ns .. ":config:" .. gid
+
+  -- [PHASE 2 MODIFICATION START]
+  -- Check concurrency limit
+  local activeCount = redis.call("LLEN", groupActiveKey)
+  local limit = tonumber(redis.call("HGET", configKey, "concurrency")) or 1
+  
+  if activeCount < limit then
+    local head = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+    if head and #head >= 2 then
+      local headJobId = head[1]
+      local headScore = tonumber(head[2])
+      local headJobKey = ns .. ":job:" .. headJobId
+      
+      -- Skip if head job is delayed (will be promoted later)
+      local jobStatus = redis.call("HGET", headJobKey, "status")
+      if jobStatus ~= "delayed" then
+        -- Pop the job and push to active list atomically
+        local zpop = redis.call("ZPOPMIN", gZ, 1)
+        if zpop and #zpop > 0 then
+          local jobId = zpop[1]
+          
+          local jobKey = ns .. ":job:" .. jobId
+          local job = redis.call("HMGET", jobKey, "id","groupId","data","attempts","maxAttempts","seq","timestamp","orderMs","score")
+          local id, groupId, payload, attempts, maxAttempts, seq, enq, orderMs, score = job[1], job[2], job[3], job[4], job[5], job[6], job[7], job[8], job[9]
+
+          -- Validate job data exists (handle corrupted/missing job hash)
+          if not id or id == false then
+            -- Job hash is missing/corrupted, skip this job and continue
+            -- Re-add next job to ready queue if exists
+            local nextHead = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+            if nextHead and #nextHead >= 2 then
+              local nextScore = tonumber(nextHead[2])
+              redis.call("ZADD", readyKey, nextScore, gid)
+            end
+          else
+            -- Push to group active list
+            redis.call("LPUSH", groupActiveKey, jobId)
+            
+            -- Mark job as processing
+            redis.call("HSET", jobKey, "status", "processing")
+            
+            local procKey = ns .. ":processing:" .. id
+            local deadline = now + vt
+            redis.call("HSET", procKey, "groupId", gid, "deadlineAt", tostring(deadline))
+            redis.call("ZADD", processingKey, deadline, id)
+
+            -- Re-add group if there is a new head job (next oldest)
+            local nextHead = redis.call("ZRANGE", gZ, 0, 0, "WITHSCORES")
+            if nextHead and #nextHead >= 2 then
+              local nextScore = tonumber(nextHead[2])
+              redis.call("ZADD", readyKey, nextScore, gid)
+            end
+
+            table.insert(out, id .. "|||" .. groupId .. "|||" .. payload .. "|||" .. attempts .. "|||" .. maxAttempts .. "|||" .. seq .. "|||" .. enq .. "|||" .. orderMs .. "|||" .. score .. "|||" .. deadline)
+            table.insert(processedGroups, gid)
+          end
+        end
+      end
+    end
+  end
+  -- [PHASE 2 MODIFICATION END]
+  -- Note: Groups with active jobs will be skipped
+end
+
+-- Remove only the groups that were actually processed from ready queue
+for _, gid in ipairs(processedGroups) do
+  redis.call("ZREM", readyKey, gid)
+end
+
+return out
+
+