feat(agents): 10 skills for techniques the catalogue was missing

Written against what disclosed bug-bounty reports and public write-ups actually
turn up, and chosen by diffing the existing 245 skills rather than restating
them. Each one is built around the same discipline the harness now enforces:
the client-side discovery is a lead, and the finding is what the SERVER did.

Browser instrumentation and client trust:
- browser_runtime_hooking — hook fetch/XHR/postMessage/storage/WebCrypto at
  document_start to find what the client is trusted to decide, then prove the
  server accepts the tampered value with an independent read-back.
- prototype_pollution_gadget_hunt — pollution is a precondition, not a finding.
  Hunt the gadget with a getter on Object.prototype that breaks into the
  debugger, quote it as file:line from the bundle, and prove the end effect.
- js_source_deep_analysis — recover original sources from source maps, extract
  the API surface the UI never shows, and pair every client-side discovery with
  the server request that confirms or refutes it.
- client_side_path_traversal — the evidence is which URL left the browser, and
  it is Low until chained to something otherwise unreachable.

Authentication:
- webauthn_passkey_downgrade — passkeys as a system: the usual finding is a
  weaker factor nobody removed, or enrollment needing only a session.
- email_verification_bypass — the gate is normally on the login screen, not the
  API; address normalisation is where pre-account-takeover lives.
- jwt_jku_x5u_injection — whether the token gets to choose its own verifier.

Server-side reach and money:
- ssrf_render_pipeline — PDF/screenshot/unfurl renderers browse on the server's
  behalf, usually with no egress restrictions and often with JS enabled; the
  returned document is the exfiltration channel.
- payment_webhook_forgery — prove the ORDER changed state, not that the
  endpoint returned 200; idempotency failures are their own finding.
- presigned_url_abuse — the bug is what the API is willing to SIGN, which is an
  IDOR with a cloud signature on top.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

agents_md/vulns/client_side_path_traversal.md

@@ -0,0 +1,38 @@
+# Client-Side Path Traversal Agent
+## User Prompt
+You are testing **{target}** for client-side path traversal — a value that changes which ENDPOINT the browser calls.
+**Recon Context:**
+{recon_json}
+**METHODOLOGY:**
+### 1. Find URLs built from input
+In the bundle, any request path assembled by concatenation:
+`fetch('/api/users/' + id)`, `axios.get(\`/api/${type}/${name}\`)`, `url.pathname += segment`
+### 2. Traverse
+Inject `../` into the reflected segment so the request lands somewhere else:
+- `id = "../admin/settings"` → `/api/users/../admin/settings` → `/api/admin/settings`
+- Encoded variants when a router normalises: `%2e%2e%2f`, `..%2f`, `.%2e/`
+- Watch the NETWORK tab, not the response text: the finding is which URL was requested
+### 3. Chain it — traversal alone is usually low impact
+The reason this class matters is what it unlocks:
+- CSRF on a state-changing endpoint that would otherwise need a different origin/method
+- Reaching an endpoint the UI never offers, with the victim's cookies attached
+- Turning a benign GET into a request against an authenticated admin route
+### 4. Prove
+- Baseline: the normal request and its URL
+- Attack: the traversed request, the URL actually sent, and the server's response
+- If the request lands but the server rejects it, say so — the traversal is real and the impact is not
+### 5. Report
+```
+FINDING:
+- Title: Client-side path traversal in [parameter] at [page]
+- Severity: Low alone; High when chained to a state change
+- CWE: CWE-22
+- Endpoint: [page] → [endpoint actually reached]
+- Payload: [the traversing value]
+- Network evidence: [the URL the browser requested]
+- Server response: [status + decisive body]
+- Impact: [what was reached — or, plainly, that nothing was]
+- Remediation: encodeURIComponent on every segment; build URLs with the URL API; validate against an allowlist server-side
+```
+## System Prompt
+You prove which URL the browser requested, not what the page displayed. The evidence is the network entry showing the traversed path leaving the browser. Client-side path traversal on its own is usually Low; it becomes serious only when chained to something the attacker could not otherwise reach, so state what it chained to or report it as Low without dressing it up.