competition-queue-worker-drift
Helps your agent trace data flow in queues and async tasks. It allows understanding how an enqueued item connects to later actions, and how failures and retries are handled.
What it does
This tool helps understand how a task sent to a queue is processed by a 'worker' (a program that runs background tasks). It traces the complete path from submission to the final result, especially when background processing differs from expectations.
When to use it
- ✓When you want to know what happened to a task that was sent for processing.
- ✓To understand why a background process (worker) behaves differently than expected.
- ✓When investigating failures or retries of tasks in asynchronous systems.
Example of what to ask your AI
“Trace the processing of this task in the queue, from submission to the final outcome.”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
The tool maps the entire event chain: where the task was sent, how it was stored, who processed it (the worker), if there were retry attempts, and what the final effect was. It compares the normal path with the background path to find the differences.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add zhaoxuya520/reverse-skill --skill competition-queue-worker-driftOr download just the file:
curl -L https://raw.githubusercontent.com/zhaoxuya520/reverse-skill/main/CTF-Sandbox-Orchestrator/competition-queue-worker-drift/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Competition Queue Worker Drift
Use this skill only as a downstream specialization after $ctf-sandbox-orchestrator is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to $ctf-sandbox-orchestrator first.
Use this skill when the decisive effect happens after enqueue, inside a worker, or only under async runtime state that differs from the request path.
Reply in Simplified Chinese unless the user explicitly requests English.
Quick Start
- Map the async chain first: enqueue point, queue payload, worker consumer, retries, and final side effect.
- Keep request-time state separate from worker-time state.
- Record queue name, message shape, worker config, retry policy, and downstream store in one chain.
- Compare synchronous path and async path when behavior diverges.
- Reproduce the smallest enqueue-to-side-effect flow that proves the decisive async drift.
Workflow
1. Map Enqueue And Worker Identity
- Record queue names, topics, cron schedules, delayed jobs, dead-letter queues, worker processes, and consumer groups.
- Note which config, env vars, feature flags, or credentials exist only in the worker environment.
- Keep enqueue request, stored payload, and worker identity tied together.
2. Trace Worker-Only State And Retries
- Show how worker runtime differs from the request path: different env, files, mounts, caches, permissions, or clocks.
- Record retry count, backoff, dedupe keys, failure handling, dead-letter flow, and idempotency behavior.
- Distinguish immediate request success from eventual worker success or failure.
3. Reduce To The Decisive Async Chain
- Compress the result to the smallest sequence: enqueue -> worker runtime -> retry or branch -> resulting effect.
- State clearly whether the decisive difference lives in payload shape, worker config, retry path, or downstream consumer.
- If the issue is really about the file parser invoked by the worker, switch back to the tighter file-parser skill.
Read This Reference
- Load
references/queue-worker-drift.mdfor the queue checklist, retry checklist, and evidence packaging.
What To Preserve
- Queue names, payloads, worker identities, retry metadata, dead-letter edges, and downstream effects
- The exact worker-only config or state that changes behavior
- One minimal enqueue-to-side-effect reproduction chain
FAQ
What is a 'worker'?
It's a program that runs in the background to perform tasks that don't need to be done immediately, like processing an image or sending an email.
What does 'asynchronous processing' mean?
It means a task is sent, and the system continues doing other things without waiting for an immediate result. The result will come later, in the background.
What is a 'queue'?
It's a place where tasks are put on hold to be processed. Think of it like a bank queue, where tasks are handled in the order they arrive.
Details
Original description by the author
Internal downstream skill for ctf-sandbox-orchestrator. CTF-sandbox workflow for queues, async workers, cron jobs, delayed tasks, retry behavior, worker-only config drift, and payload-to-side-effect chains. Use when the user asks to trace a queue payload, inspect async job execution, explain worker-only behavior, follow retries or dead-letter handling, or connect an enqueued item to a later file,
Popularity
- GitHub stars
- 42k
- Ranking position
- #4731
- License
- MIT
- Updated
- 9/22/2026
Comments
- …
More skills from this repository
competition-ad-certificate-abuse
Helps your agent analyze attacks on digital certificate systems. It investigates how certificates can be misused to gain access.
zhaoxuya520/reverse-skill
competition-agent-cloud
Helps your agent analyze security challenges in AI and cloud systems. It investigates how prompts, tools, and the cloud can be exploited.
zhaoxuya520/reverse-skill
competition-android-hooking
Helps your agent investigate Android applications. It analyzes how apps work internally and how they might be modified or exploited.
zhaoxuya520/reverse-skill
competition-browser-persistence
Helps your agent analyze how websites store information in your browser. It investigates cookies and other data to understand how sessions work.
zhaoxuya520/reverse-skill
Similar skills
dashboard-builder
Helps your agent create useful monitoring dashboards. It turns data into charts that answer important system questions.
affaan-m/ECC
dev-team
Simulates a collaborative development team where different roles respond to a problem together. It's useful for getting multiple perspectives without manually switching agents.
affaan-m/ECC
ecc-council
Has your agent convene a four-voice council for difficult decisions. It's useful when there are multiple good options and debate is needed before choosing.
affaan-m/ECC