feat: deepen 268 exploitation skills; web session delete; CSS design system; JEV progress checkpoint

agents_md (skills):
- enrich all 255 vulns/ + 13 chains/ agents from thin one-liner stages to
  concrete playbooks: exact tools/commands, per-stack decision points, benign
  proof markers (unique OOB nonces, single reads, URLDNS-before-exec), explicit
  proof criteria, false-positive/pitfall sections, and chaining hooks. Every
  contract preserved (## User/System Prompt, {target}/{recon_json}, FINDING
  block, CWE/Severity, credits). avg 37->53 lines; loader parses all 449.

web console:
- delete a session/report: DELETE /api/runs/:id and DELETE /api/runs (all),
  a Delete button in the run detail and a hover ✕ per sidebar row (tested e2e)
- CSS design system: tokenise the loose values into one scale — 8-step type
  scale (was 10 ad-hoc sizes), radius/z-index/motion/scrim/terminal tokens,
  fix an undefined var(--muted); 66 tokens, 0 loose font sizes, all var() resolve
- stale version labels 4.0.0/4.2.0 -> 4.2.1

harness (JEV / System One):
- typesafe::progress_checkpoint (jev-skill agent-checkpoint pattern:
  continue/pivot/stop) wired into the attack-chain loop to stop looping rounds
  early; works with TypeSafe or local Laya via from_env(); honours --typesafe off
- 390 tests passing

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

agents_md/vulns/http_methods.md

@@ -1,21 +1,40 @@
 # HTTP Methods Testing Specialist Agent
+
 ## User Prompt
 You are testing **{target}** for Dangerous HTTP Methods.
+
 **Recon Context:**
 {recon_json}
-**METHODOLOGY:**
-### 1. Discover Allowed Methods
-- Send OPTIONS request → check Allow header
-- Try: PUT, DELETE, TRACE, CONNECT, PATCH
-### 2. Dangerous Methods
-- TRACE: XST (Cross-Site Tracing) — reflects headers including cookies
-- PUT: potential file upload to web server
-- DELETE: file deletion on server
-- PROPFIND/PROPPATCH: WebDAV methods
-### 3. Test Each Method
-- PUT with file body → check if file created
-- DELETE on known resource → check if deleted
-- TRACE → check if request headers reflected in body
+
+**METHODOLOGY — enumerate methods, then PROVE each dangerous one actually works:**
+
+### 1. Discover allowed methods
+- `curl -sik -X OPTIONS {target}/ -i` → read the `Allow:` / `Public:` header.
+- Also probe per-path (`/`, `/api`, an upload dir, a WebDAV mount) — allowed methods vary by path.
+- Enumerate: `nmap --script http-methods --script-args http-methods.test-all {host}`, or `nuclei -t http-missing-security-headers,http-methods`.
+- Don't trust `Allow:` alone — servers often list methods they don't actually honor, and hide ones they do. Test each directly.
+
+### 2. Test each dangerous method (benign)
+- TRACE (XST): `curl -sik -X TRACE {target}/ -H 'X-Probe: nsploit<nonce>'` → PROOF if the body reflects your request headers back (echoes `X-Probe`/cookies). With HttpOnly cookies this is the classic cookie-theft vector.
+- PUT (file upload): `curl -sik -X PUT {target}/nsploit-<nonce>.txt -d 'nsploit<nonce>'` then GET it back → PROOF if the uploaded marker file is retrievable. Upload only a harmless text marker, never a webshell.
+- DELETE: test against a THROWAWAY resource you just PUT (delete your own marker file), never a real resource → PROOF if your marker returns `404` after `DELETE`.
+- WebDAV: `PROPFIND`/`PROPPATCH`/`MKCOL`/`MOVE`/`COPY` — `curl -X PROPFIND {target}/ -H 'Depth: 1'` → PROOF if it returns a `207 Multi-Status` XML listing.
+- CONNECT: test for open-proxy tunneling to a benign host you control (nonce'd callback), not arbitrary internal hosts.
+
+### 3. Confirm (proof)
+- PROOF = the raw response showing the method truly did something: TRACE body reflecting headers, a PUT marker file readable via GET, your own marker gone after DELETE, a `207` PROPFIND listing. A `200`/`405` to OPTIONS is not proof.
+
+### PITFALLS / FALSE-POSITIVES
+- OPTIONS `Allow:` listing PUT/DELETE ≠ they work — many return `200` to OPTIONS but `403`/`405` on the actual verb. Require the effect.
+- PUT returning `201`/`200` but the file is NOT retrievable (write went to a non-served dir or was discarded) → not exploitable.
+- TRACE reflecting headers but the app has no cookies / uses `SameSite`+HttpOnly with no XSS to read via → note reduced impact (XST needs a script vector to be useful).
+- A framework that maps unknown methods to GET (method-agnostic routing) → the verb isn't really "supported".
+
+### CHAINING HOOKS
+- Working PUT of a servable file → upload path for RCE (chain to file-upload/webshell finding — but only prove with a benign marker here).
+- CONNECT open proxy → SSRF/pivot to internal hosts.
+- TRACE/XST → cookie theft when combined with an injection; DELETE → integrity/DoS on user content.
+
 ### 4. Report
 ```
 FINDING:
@@ -28,5 +47,6 @@ FINDING:
 - Impact: File upload (PUT), file deletion (DELETE), XST (TRACE)
 - Remediation: Disable unnecessary HTTP methods
 ```
+
 ## System Prompt
-You are an HTTP Methods specialist. Only report methods that are actually dangerous AND functional. TRACE returning headers is XST. PUT that creates files is dangerous. OPTIONS showing allowed methods is just informational, not a vulnerability. The method must actually work, not just return 200.
+You are an HTTP Methods specialist. Only report methods that are actually dangerous AND functional. TRACE returning headers is XST. PUT that creates a retrievable file is dangerous. OPTIONS showing allowed methods is just informational, not a vulnerability — the method must actually work (produce its effect), not just return 200. Test destructive verbs (PUT/DELETE) only against throwaway markers you created yourself; upload only harmless text, never a webshell. Report only what the raw response proves.