## TL;DR
Every found directory spawns a new recursion job, and deep or wildcard-y sites blow past the queue cap. Limit `-recursion-depth`, filter the wildcard responses that spawn junk jobs, and run recursion as a second targeted pass on real directories instead of all at once.

```text
job queue is full
```

## Use this when
- Ffuf recursion aborts with `job queue is full`.
- The site is large or returns wildcard responses.
- You want recursive coverage without the abort.

## Not for this skill when
- Recursion completes with no findings. Try deeper wordlists or manual passes.
- The queue fills on a tiny site. Something else is wrong; check for wildcard responses first.
- You do not need recursion. A single-level pass plus manual follow-up is often enough.

## Steps
1. Cap the depth: `ffuf -u YOUR_TARGET_HOST/FUZZ -w wordlist -recursion -recursion-depth 2`. Verify: the queue stops overflowing.
2. Kill the junk jobs at the source: filter wildcard responses (`-fs` on the wildcard size) so they never become recursion jobs. Verify: fewer nonsense directories are found.
3. Run recursion as a second pass: first a flat run, then `ffuf -u YOUR_TARGET_HOST/realdir/FUZZ` on each genuine directory. Verify: the job count stays controlled.
4. Only raise the queue cap after filtering; a bigger queue full of junk just takes longer to fail. Verify: the run completes.
5. Note which directories were recursed and to what depth. Verify: coverage is documented.

## Variant phrasings
### ffuf recursion job queue full
Compact phrasing.
### ffuf recursion-depth queue
Flag-oriented search.
### ffuf recursion aborts large site
Symptom-level search.

Compatibility: ffuf v1/v2. `-recursion` and `-recursion-depth` are stable flags.

## Why it happens
Recursion is multiplicative: 50 directories found at depth 1 become 50 new jobs, each of which can find more. On wildcard-responding apps every guess is a "directory", so the job count explodes combinatorially and hits the cap fast.

## Edge cases / pitfalls
- Wildcard responses are the usual root cause. Fix filtering before touching queue settings.
- Depth 3+ on a big app is rarely worth it; the interesting content is usually within 2 levels.
- The second-pass approach gives cleaner evidence anyway: each directory's findings are separated by target.
- Record recursion depth in the methodology; "recursive fuzzing" without a depth is not reproducible.

## Provenance

Resolved from the public thread: https://vectle.com/posts/pst_sV57fDC0EXXsYu46urL0Ww