# Hunt Core

> The discipline every hunt- skill assumes. Class-specific technique lives in the hunt skills and

- Skill: `encod3d-sec/hunt-core-2` (Agent Skill)
- Install (CLI): `npx get-skill add encod3d-sec/hunt-core-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/encod3d-sec/hunt-core-2/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: Encod3d-Sec (https://skillmd.com/u/encod3d-sec)
- Updated: 2026-11-16
- Page: https://skillmd.com/skills/encod3d-sec/hunt-core-2

---


# Hunt: Core

> Current emphasis (update on wiki harvest): clean-session re-verification and
> proven-observable channels for negative results over response-body inference
> - models over-index on over-represented old methods; the newest harvested
> technique leads the checklist until superseded.

The discipline every `hunt-*` skill assumes. Class-specific technique lives in the hunt skills and
the wiki; this file holds what is true regardless of which bug class you are chasing.

**Owned here, never repeated in a hunt skill:** the scope gate, two-account setup, confirmation
gate, enumeration limits, stop conditions, marker discipline, wiki query/self-heal protocol, FIND
output, Deadends, and distillation. A hunt skill that restates any of these will drift from this
one; reference it instead.

## Scope gate

Hunting means reading other people's data, escalating privileges, and creating accounts. Outside
an authorized engagement all of it is a crime. Before any request leaves the machine:

1. **Authorization** - a program with the target in scope, a signed agreement, your own lab, or a
   CTF. "Probably fine" is not authorization.
2. **Scope** - exact hosts. `*.target.com` does not cover `targetapp.io`, an acquisition, or
   `target.com.cdn.net`. Read `targets/<eng>/scope.md`. An in-scope entry may carry a trailing
   comment restricting it to a PATH (e.g. `events.example.com  # IN for the hub endpoint only`) -
   match the annotation, not just the host: a bare host-match against a path-restricted entry is
   out-of-scope traffic even though the shim passes it.
3. **Exclusions and forbidden techniques** - check `no_bruteforce`, scanning caps, DoS, social
   engineering, and any per-program rule before the technique that would violate it.
4. **Two accounts, both yours** - see below. Required for any authorization-class bug.
5. **Deadends** - read `targets/<eng>/Deadends.md` and skip what is already exhausted.

Unconfirmed on any of these: ask. Do not infer scope from the fact that a host resolved. Discovery
is not authorization. The `scope-guard` hook enforces the host check on Bash commands; it is a
backstop, not the gate.

Tool row: before Step 1 of any class hunt, read your class row in
`scripts/playbook.json` `classes` - it names the primary tools and the
payload page. Use those tools unless the target shape forbids it; note a
deviation in the run notes with one line of why.

## Two-account rule

Authorization findings are "account A reached account B's object." Without B you have two bad
options: test against a real user, or report a guess. Both are worse than not reporting.

- **User A** - resource owner. **User B** - attacker. Separate browser profiles so cookies never
  cross.
- Record both internal IDs in `targets/<eng>/identities.md` as you discover them.
- Cross-tenant work needs two *tenants*, not two users in one. Many apps isolate tenants correctly
  and users not at all.

## Confirmation gate

Nothing becomes a FIND on the strength of a response body. The gate is per class; the hunt skill
owns the specific "NOT confirmation / IS confirmation" list. Universal rules:

1. **Re-verify in a clean session.** Fresh token, new profile, no cached state. If the effect
   vanishes, you changed your own screen.
2. **Exercise the capability.** Not "the server accepted it" but perform the action only the new
   state permits.
3. **Rule out legitimate access.** Before claiming cross-account access, confirm A is not
   *supposed* to see it: shared teams, sharing links, public objects, org-wide visibility. The
   most common false positive in authorization testing.
4. **Blind classes need an OOB HIT.** No inference-only findings. The `oob.md` row must flip to
   HIT before a FIND is scaffolded.
5. **Reproduce from scratch** against your own written steps.
6. **A negative result needs a proven-observable channel.** "No callback / no hits" only means
   something if the channel itself is proven to work: a listener that file-logs AND you have
   actually read, or a self-test hit on the same path. An unobservable channel (a tmux pane that
   captures empty, a log you never opened) produces false negatives that fossilize into dead-ends
   and "it was patched" verdicts.

Failed 1-3 is a Deadend, not a "probably real but hard to prove."

[[wiki/techniques/methodology/safe-probing-and-controls]] carries the other half of this gate: how to probe destructive or
sensitive surface without touching a real record (use an identifier proven not to exist), and how
to fire a control so a NEGATIVE result means something instead of being assumed.

When the hunt spans many hosts, sessions, or parallel agents, the coordination layer adds failure
modes this gate does not cover: claims nobody re-checked, requests nobody counted, the same finding
filed twice, and severity drifting upward as work is summarised. See
[[wiki/techniques/methodology/multi-agent-campaign-orchestration]].

## Request history discipline

(NOTE: hunt-core itself keeps NO request ledger or run checklist BY
DESIGN - it is the always-loaded discipline hub, not a dispatched lane;
the ledger contract below binds the hunt-* skills it loads.)

Lane contract (G9): a lane that recorded 2+ findings runs the triage skill's
Cross-tool correlation pass over nuclei + burp/caido + manual records before it
closes; an uncorrelated close is an UNCHECKED step, same standing as an
unchecked request-ledger row.

`$ENG_DIR/_requests.md` is the shared append-only HTTP history (doctrine-2026 G3);
`$ENG_DIR/identities.md` `## Auth profiles` holds the named auth postures its rows
reference (G4). ($ENG_DIR = the engagement tree in VMshare, double-nested
<eng>/<eng>; hunt skills append there - the repo tree targets/<eng> is
admin/ingest only.) Two hard rules in the lane contract:

- **Check the table before endpoint testing.** Before a lane (or the brain dispatching
  one) probes an endpoint, grep `requests.md` for the host/path prefix; a prior row -
  including a negative one - is a skip-or-differentiate decision, not a re-test.
  Cite the prior row in the lane brief.
- **Append rows before lane close.** One row per (lane, host, method, path) test, with
  `auth-profile-ref` naming a profile from identities.md (`-` if unauthenticated).
  A lane that closes without its rows appended has an UNCHECKED request ledger - same
  standing as an unchecked completion-gate step.

The table is the index; raw evidence stays in `ingest/` and lane capture dirs.

## Enumeration limits

**Prove the boundary is missing, not how much is behind it.**

The server does not check *any* object. Demonstrating that takes two or three identifiers. A
thousand-ID sweep does not raise severity; it collects real users' data and converts a critical
finding into an incident report naming you.

- **Default: 5 identifiers.** Enough to show a sequential pattern and a missing check.
- **Ceiling without explicit operator approval: 20.**
- **Beyond that, and for any range sweep: stop and ask.** State why the extra volume changes the
  finding. Usually it does not.
- **`no_bruteforce` in scope means range 0.** No sweep, no ffuf over an ID list, no exception.
- **Never enumerate writes.** Read at volume is a rate problem; write at volume is destruction.

For scale evidence, cite a `total` field, a pagination header, or a result count. "The response
reports 41,180 records; none beyond my two test accounts were retrieved" proves scale without
retrieving anything.

**Scope of these limits.** They govern OBJECT and RECORD enumeration (guessing identifiers to pull
other users' data). They do NOT cap legitimate service discovery: an SSRF internal port sweep or a
network map is bounded by the engagement RoE (`no_dos`, scan-rate caps), not by the 5-to-20 object
ceiling. Thread it and honor the cap; do not clamp a port sweep to 20.

## Stop conditions

Stop and report rather than continuing when:

- **You received real user data.** An ID you guessed belonged to someone real, a cache served
  another session, a beacon fired in a live employee context. Do not re-request to confirm, do not
  save it, do not use anything in it. Report immediately, state what you received and that you
  destroyed it, and note it in the FIND rather than hiding it.
- **The next step is destructive or persistent** - deleting objects, modifying another tenant's
  config, planting content that outlives the session.
- **You have a traffic-affecting primitive** - desync, cache poisoning, connection-pool effects.
  The mechanism is the finding.
- **The last step needs volume** beyond the limits above.
- **You already have the severity ceiling.** More escalation, more risk, no more payout. Post-ex
  serves one of two purposes, proving impact or feeding the next hop; if it is impact, the minimum
  that demonstrates it is the ceiling.
- **You left scope.** Even one hop. Especially one hop.

Stopping is not failure. "Confirmed and did not exploit" is worth more than a forfeited payout.

**Blocked-handling ladder (403/429/WAF/timeout).** Climb in order, one rung per attempt:
change UA -> reader proxy -> page cache -> archive (web.archive.org) -> alt engine ->
SOCKS5 (if provisioned). Retrying the same conditions twice unchanged is the named
violation `gave-up-by-repetition`. Exhausted after the full ladder: write the negative
fact (state.md `## Facts`, `negative/` key) plus one Deadends.md row carrying
`ladder: <steps executed>` (e.g. `ladder: UA,proxy,archive`), then switch domain - a
Deadends row without the ladder field reads as an early give and the close-out
drift-count separates them.

**Violation vocabulary** (drift taxonomy, used by the Stop-hook close-out count and
log.md skip-reason lines): `hallucination` (claim with no test), `gave-up` (blocked and
not switched), `omission` (creds in hand, not sprayed/reused).

## Published chains: exact-first

When a writeup / published chain exists for the box or the vuln class, fire its EXACT form first:
same payload, same framing, same delivery channel (chat UI vs raw API, browser vs curl). An
adaptation is a one-variable experiment that needs a known-good baseline; adapt before the baseline
exists and every failure is unattributable (payload? delivery? box version?). Transcribe EVERY
writeup artifact, not just prose (screenshots carry source-IP / UA / Origin ground truth about
where execution happens), and re-test a published chain verbatim on each new instance before
believing it was patched. Method: [[wiki/techniques/methodology/writeup-reproduction]].

**Wrong-vector tells (switch the vector, do not tune the tooling).** A vector is exhausted the
moment it starts fighting you; grinding harder is the sunk-cost trap. Two mechanical signals mean the
current vector is the wrong door, not that your tooling needs another pass:

- **The target starves under your own exploit loop** (repeated `000` / connection-timeout /
  empty-reply while you hammer one endpoint). A vector that DoSes a lab box is almost never the
  intended one. Stop, let it drain, and enumerate a DIFFERENT class (source-read: LFI /
  alias-traversal / `.git` / backup; a second service or vhost's own app; OOB creds) before returning.
- **Two verified hashes in a row fail the primary wordlist.** The passwords are not wordlist
  material - they are delivered out-of-band (an email/note/KeePass, a config, a second service). Stop
  cracking and re-enumerate for where the creds are HANDED OUT; do not extract a third hash. (Engineering
  around a hostile channel - per-char verify-fix, min-of-2 sampling, gentler pacing - is the tell you
  are on the wrong vector, not a reason to keep going.)

Both signals fire MECHANICALLY: count them yourself from this session's own captured output
(last 6+ curl failures against one host -> starvation verdict; 2+ hashcat runs Exhausted
with nothing cracked -> stop-cracking verdict). The count surfacing in front of you is this
section firing - act on it, do not re-run the tool.

When a wrong-vector tell fires and the next door is not obvious, **call `Skill(redteamlead)`** before
grinding further - it reads the engagement state + evidence + wiki and returns ranked directions with
an explicit STOP. That is exactly what it is for ("I'm stuck / which vector / should I keep hammering
this"); one RTL call at the first sign a vector is fighting back beats hours of sunk-cost grind.

## Marker discipline

Any class where you inject a value and look for it later (xss, ssti, sqli error strings, crlf, log
injection, open redirect): use a unique 8+ char alphanumeric canary (e.g. `x4hd2k9pq`), never
`test`/`marker`/`evil`/`payload`. Check the baseline response for the canary BEFORE claiming
reflection; a value already present is not proof you put it there.

## Small tells (battery before the big read)

Before reading a big source file / JS bundle / saved response tree end to end, run the
curated tell battery over it: `python3 scripts/tells.py <path>` prints `path:line [class]
snippet -> Skill(x)` for every small indicator it knows (raw-HTML sinks, command-exec
sinks, string-built SQL, deser calls, keys/JWTs, comment hints, version banners). Read
the hit blocks FIRST, then the full read where the read-first mandate applies
(post-foothold source review). The pattern table is `scripts/tells.json` - the single
machine-readable source; learned a new tell (an indicator that would have saved you
time)? Add a row there. High precision only: a noisy tell trains the eye to ignore the
battery. This locates, it never replaces the read.

## Wiki lookup (reference-map first, qmd on a hint)

`mcp__wiki-search__query` is powerful but ~15-30s per call, so it is a TARGETED deepen, not a pre-attack ritual.
Three tiers, in order:

1. **Reference map FIRST (instant `Read`).** Your hunt skill's `## Wiki` section names the class's
   domain MOC + primary page + a few anchors. `Read` those directly, and one-hop from the MOC for a
   sibling technique. This answers the anticipated case with zero qmd latency.
2. **`mcp__wiki-search__query` ONLY on a concrete hint the map does not cover** - a specific sink/function (an
   SSRF-reaching `requests.get(user_input)`), an observed escape (a `<script>` context that could be
   XSS), a fingerprinted version/CVE, or a service the MOC does not list:
   `mcp__wiki-search__query (lex) "<the specific thing>" via wiki-search MCP`. It auto-surfaces pages added since the
   skill was written. Do NOT blanket-qmd every action (too slow); do NOT hand-roll from memory when a
   targeted qmd would answer (that is the opposite failure). Fire it when you have the hint, then act.
3. **Self-heal** only if neither the map nor a targeted qmd has it: stub
   `wiki/techniques/<area>/<slug>.md` (frontmatter + `## Observed during <engagement>`) so the gap fills.

Payload arsenals live in `wiki/payloads/`. If the MCP is down, `bash scripts/wiki-query.sh "<terms>"`
wraps the same qmd index (`-k` for an exact CVE/string).

Volume reconciliation: this tiered lookup IS the `wiki-first` rule below - the reference-map read
(or one targeted `qmd`) per new attack-path lane satisfies it; `qmd` is a targeted deepen, not a
pre-attack ritual, and never a per-action step.

## Hunt approaches (which skill for the signal)

Usage order: load this index first, load the per-surface skill on demand, keep three
permanent rules always on:

1. **wiki-first** - consult the class page/MOC before dispatching a new attack-path lane.
2. **OOB gate** - blind claims (SSRF/SSTI/SQLi-blind/deser) need an out-of-band callback,
   never inference.
3. **verification before status change** - a status only advances with the evidence the
   ladder demands (see FIND output + find-lint).

`hunt-core` is the hub: route from the observed signal to the class skill, load it, then use that
skill's `## Wiki` map. The `recon-capture` fingerprint router auto-suggests many of these from tool
output; this table is the manual reference when it does not fire or you are reasoning about approach.

| Signal / surface | Skill |
|---|---|
| reflected/stored input, `<script>` / `onerror` / `javascript:` / a DOM sink | `Skill(hunt-xss)` |
| a stored field rendered in an admin/moderation/approval panel; a reviewer bot | `Skill(hunt-xss-blind)` |
| a param/body reaching a DB; an error / boolean / time oracle | `Skill(hunt-sqli)` |
| a URL/host param, a fetch/preview/import sink, `?url=` | `Skill(hunt-ssrf)` |
| an object id, `/users/{id}`, two-account cross-access | `Skill(hunt-idor)` |
| template `{{ }}` render, XXE (SVG/DOCX/SAML), GraphQL | `Skill(hunt-injection)` |
| a command sink, template-injection-to-exec, a version+CVE | `Skill(hunt-rce)` |
| a serialized blob (`rO0` / `AAEAAAD` / `O:`), viewstate, a signed cookie | `Skill(hunt-deserialization)` |
| login / reset / session / JWT, a legacy-protocol endpoint | `Skill(hunt-auth)` |
| OAuth / SAML redirect_uri or assertion | `Skill(hunt-federation)` |
| file upload / avatar / document import | `Skill(hunt-upload)` |
| REST/GraphQL/gRPC, BOLA / BFLA / mass-assignment | `Skill(hunt-api)` |
| checkout / price / coupon / workflow logic, a race | `Skill(hunt-bizlogic)` |
| CL.TE / TE.CL / HTTP-2 downgrade desync | `Skill(hunt-smuggling)` |
| an unkeyed header/param reaching a cache | `Skill(hunt-cache)` |
| exposed `.git` / `.env` / keys, secrets in a JS bundle | `Skill(hunt-secrets)` |
| LLM prompt-injection / excessive agency | `Skill(hunt-llm)` |
| MCP tool-poisoning / indirect injection | `Skill(hunt-mcp)` |
| a handed-out binary / a socket service that crashes on crafted input (stack-heap corruption, format string, ROP, seccomp jail) | `Skill(hunt-pwn)` |
| AD: kerberoast / AS-REP / ADCS / DCSync / delegation (dotted-FQDN domain / a DC) | `Skill(hunt-ad)` |
| AD expert depth: certificate templates / ESC1-16 | `Skill(hunt-ad-adcs)` |
| AD expert depth: roasting, delegation, tickets | `Skill(hunt-ad-kerberos)` |
| AD expert depth: ACL edges, GPO, ADIDNS | `Skill(hunt-ad-acl)` |
| Windows LOCAL privesc: service misconfig / autologon reg / SeImpersonate-Potato / scheduled-task / DLL hijack (standalone/workgroup box, or a local shell on a member) | `Skill(hunt-windows)` |
| AWS/Azure/GCP metadata or IAM | `Skill(hunt-cloud)` |
| Microsoft 365 / Entra tenant | `Skill(hunt-m365)` |
| CI/CD pipeline (Actions / runners / OIDC) | `Skill(hunt-cicd)` |
| macOS TCC / SIP / keychain / XPC | `Skill(hunt-macos)` |
| SSL-VPN appliance (Fortinet/Citrix/Ivanti/Cisco/PAN) | `Skill(hunt-vpn)` |
| Modbus / S7 / EtherNet-IP / PLC / HMI | `Skill(hunt-ics)` |

Process skills (not vuln classes): `Skill(ctf-box)` boot-to-root, `Skill(wiki-recon)` external recon,
`Skill(wiki-arsenal)` tool+payload lookup, `Skill(triage)` -> `Skill(evidence)`
finding validation, `Skill(hunt-burp)` drive Burp. Coverage gaps and move ranking come from the
driver itself (`scripts/offensive.py coverage` / `offensive.py next`).

- At board time, list the attacks the scope implies that no board row exercises,
  cross-checked against the Approach.md 4a coverage table; a gap gets a row or a
  Ruling for why not.
- Dynamic threat modeling (cloudflare adopt 2026-11-12): the static class table is
  the floor, not the ceiling. After the surface map, derive 1-3 TARGET-SPECIFIC
  attack classes the generic table has no row for (a site with a file-conversion
  pipeline gets a "conversion-worker abuse" class; a staging host with a debug
  panel gets its own row) and add them as normal 4a board rows with skill
  `hunt-core` + a one-line method note. Do not force-fit a target-specific vector
  into a generic class name that will never route to it again.
- Cross-model second look (cloudflare adopt 2026-11-12): a single pass by one
  model finds roughly half of what repeated passes find, skewed to the simpler
  bugs. Before declaring a HIGH-value surface exhausted, re-hunt it ONCE from a
  different tier than the lanes that covered it (flash-covered surface gets a
  glm-5.3 lane; glm-5.3-covered gets opus on exploit-shaped surfaces) - different
  weights see different vectors. One bounded re-hunt lane per surface, not a
  fleet sweep; skip on LOW-value surfaces where the tier cost is not worth it.

## Routing table (machine-readable)

The fingerprint -> {class, skill, wiki, arsenal} parse contract `offensive.py index` reads
lives in `scripts/routing.json` - edit the JSON, not this file. Key order is load-bearing
(the first key per class wins); extend it there (not `playbook.json`) when a driver-side
signal is added, then recompile: `python3 scripts/offensive.py --eng <eng> index` - the G1
lint refuses a malformed row by name. An empty `skill` value is a legal G2-skipping state
(vector-baseline rows with no doctrine match).

## FIND output

On confirmation:

```
Create Vulns/Research/FIND-XXX-SEVERITY-<class>-<host>[-<resource>].md
Add row to Vuln-index.md
```

**Severity is rated on demonstrated impact, not theoretical maximum.** Preconditions lower it
(victim interaction, an unguessable identifier you cannot show leaking, a race you win one time in
twenty). Scale raises it, when you can show the identifier is enumerable without enumerating. State
impact in the program's terms (customer data, account security, financial exposure), not in
vulnerability classes.

**Escalating a rating is a capture task, not an argument.** When a finding looks like it could rate
higher: name the ONE artifact that would prove the upgrade (an event payload carrying PII, a
cross-account write, a state change on an unowned object), dispatch lanes for exactly that artifact,
and if they return empty, the rating stands on an evidence-complete negative - record what was
probed, the negative, and the concrete re-test triggers in the index row. Never write up the
theoretical chain as the finding while the missing link is uncaptured; a chain argument without
the captured link reads as speculation to a triager and buries the real finding.

Each card ends with a `## Recommended next` line (template field): one line naming the
next class/skill plus the evidence input it needs. The triage skill reads it as a
ranking hint; find-lint does not gate on it.

On exhaustion:

```
Append to Deadends.md table: | <host> | <class> | <what was tried> | <typed fail-class>: <why ruled out + the named control> | <date> | <reopen-if> |
```

The reason matters more than the entry. `technical: 403 on cross-account, authorization enforced` stops you
retesting; a bare entry does not. (Table rows only - the audit parses the table; stray `- [ ]` bullet blocks
above/below it are unparseable and get flagged.)

**Machine-quality contract for Deadends rows** (the close-out audit checks this; a row that
fails it gets re-served as unverified):

- One row per asset x class pair - never two. When a second row lands for the same pair, fold
  its evidence into the richer row and drop the other; parallel rows for the same class drift
  apart and one always rots.
- The `why exhausted` cell is one sentence carrying a TYPED fail-class from the fixed
  vocabulary `technical | environmental | conceptual | external` - e.g. `technical: no
  URL-fetch sink exists (op map carries zero url= params)`. A bare `exhausted` placeholder is
  an unverified claim.
- A "secure/safe/hardened" claim must NAME the control that proved it (rotation enforced,
  single-use replay rejected, captcha fires before the email check) - a safety verdict without
  its control is unfalsifiable and reads as not-tested.
- Before recording a dead-end on a masked-error gateway (uniform ISE/PQNF), retry the exact
  request once - probabilistic defenses intermittently reject valid requests, and a
  single-shot negative fossilizes into a wrong dead-end row.

Before recording a class exhausted app-wide, diff the endpoints you actually probed against the
app's full route/parameter inventory; the verdict covers only the endpoints in it, and the one
route never touched (a pre-auth register/dup-check path is the classic) is usually where the class
was actually live.

## Run completion gate

A dispatched run is COMPLETE only when its checklist says so - never on the
lane's narrative. Author a run ledger at dispatch
(`python3 scripts/completion-gate.py init <lane-dir> --title "<vector>"`,
steps from the hunt skill's checklist, artifacts declared inline after ` @ `),
and on return verify mechanically
(`python3 scripts/completion-gate.py check <lane-dir> --capture <dir>`):
UNCHECKED / MISSING / EMPTY verdicts mean the run is not done; re-dispatch
with the printed generic nudge rather than a re-written brief. An empty
capture dir is a failed lane, not a quiet success.

## Distillation

When a confirmed finding is a reusable technique rather than a target quirk, stage it:

```
python3 scripts/wiki-stage.py --kind technique --slug <slug> --target-page <area>/<page>.md
```

**GENERIC only - no client host, no real identifier, no customer data.** Promote later via
`scripts/wiki-promote.py`. Run `scripts/check-leaks.sh` before any push. Engagement data lives
under `targets/` and is git-ignored. Technique know-how that is NOT finding-derived (a mailbox
relay recipe, a seat-bridge quirk proven across engagements) stages the same way the iteration
it is learned - do not stockpile staging for close-out.

## Validation

- Meta-contract for every class: a CONFIRMED names its proof artifact AND the negative
  control that failed; the FIND carries counterevidence / confidence /
  severity_change_conditions (find-lint enforces non-empty on CONFIRMED+).
- Re-derive one claimed negative before it reaches Deadends.md; a subagent's negative
  is a hypothesis until the brain re-verifies it.

## False Positives

- The five cross-class false-positive families:
  1. encoded reflection read as XSS (`&lt;script&gt;` in the body);
  2. empty 200 read as access (no other-account content);
  3. self-effect read as cross-user (no second session);
  4. an error page read as a vuln (it is the control doing its job);
  5. the SPA fallback shell read as a routed API hit - a JSON API probe answered
     by `200 text/html` (the app shell) means the gateway never routed the request,
     not that the endpoint accepted it. Distinguish by content-type + the app's JSON
     error envelope; before declaring a route 404, vary the shape the router keys on:
     send `Accept: application/json` (gateways route on it), and check the id segment
     type (numeric ids often route while UUIDs fall through) and for missing path
     segments between the base and the leaf (`/v1/access/{id}/x`, not `/v1/{id}/x`).
- The single control that kills all four: re-send the request WITHOUT the attack input
  and diff; identical response = no finding.

## Cross-routing

- The 'Hunt approaches' table below is the router; when a signal names two candidate
  skills, run the cheap distinguishing probe and negative-route the loser in one line.
- Load the paired skill when a confirmed finding changes class (SSRF hits metadata ->
  hunt-cloud; SSTI executes -> hunt-rce).

### Depth walk (mandatory)

Walk EVERY applicable row of the payload arsenal page cited above.
Record each row in `$RUN/coverage-depth.md` as a table
`| row | state | evidence |` where state is `probed`, `blocked`, or
`N/A`, and evidence is a probe-pair path or a Deadends.md line. A bare
`probed` with no evidence reference fails the completion gate
(NEEDS-REVIEW). N/A rows cite why (surface shape forbids it).

Blocked implies research: before any Deadend is claimable on a blocked
row, (a) walk the arsenal page's bypass-ladder rows for that control
class, and (b) run one wiki query AND one `mcp__wigolo__search` for the
specific tech-plus-control bypass. Results, or a genuine null, land in
`coverage-depth.md`. "No research tried" is not a claimable state.


