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/padding_oracle.md

@@ -8,19 +8,40 @@ You are testing **{target}** for CBC padding oracle decryption/forgery.
 
 **METHODOLOGY:**
 
-### 1. Find oracle
-- Encrypted token (cookie/param) where padding errors differ from other errors
+### 1. Find candidate ciphertext + a distinguishable oracle
+- Locate encrypted blobs in cookies/params/tokens: base64/hex whose length is a multiple of a block size (8 or 16 bytes) → likely CBC (or ECB).
+- Recon serializer/framework hints: `.NET` `__VIEWSTATE`/`ViewStateEncryptionMode`, ASP.NET `WebResource.axd`/`ScriptResource.axd` (classic oracle), Rails/`Mcrypt`, custom `AES-CBC` session tokens.
+- The oracle needs a distinguishable signal when padding is INVALID vs a different error: capture status code, body, length, and timing for a known-good token as the baseline.
 
-### 2. Confirm oracle
-- Flip ciphertext bytes; detect distinct valid/invalid-padding responses
+### 2. Confirm the oracle
+- Flip the last byte of the second-to-last ciphertext block and resubmit; sweep it 0x00–0xFF and observe responses.
+- Oracle CONFIRMED when exactly one (or a small deterministic set) of bytes yields a DISTINCT "valid padding" response while the rest give a uniform "invalid padding" error — quote both raw responses.
+- Distinguish padding error from generic decryption/app error: if ALL 256 responses are identical (same status/body/timing), there is NO oracle → no finding.
 
-### 3. Exploit
-- Run padbuster-style decryption/encryption to recover or forge plaintext
+### 3. Exploit (decryption / forgery)
+- Use `padbuster` for the standard workflow:
+  - decrypt: `padbuster <url-with-CIPHERTEXT> <ciphertext> <blocksize> -cookies '<name>=<ciphertext>' -encoding 0 -error '<invalid-padding-signature>'`
+  - forge: add `-plaintext '<benign marker>'` to encrypt a chosen plaintext (e.g. a benign session claim with a unique nonce).
+- Or a small custom script under `$NEUROSPLOIT_POCS` implementing the byte-by-byte attack when the transport is non-standard.
+- Keep forged content benign and minimal — a marker value, not a privilege grant, unless proving auth impact is explicitly needed and safe.
 
-### 4. Confirm
-- Decrypt a token or forge a valid one proving the oracle
+### 4. Confirm impact
+- Decryption proof: recover the plaintext of a token and show it (mask secrets, keep a unique marker/prefix), matching known structure.
+- Forgery proof: craft a token that the app ACCEPTS (e.g. decodes to your benign marker and is honored), shown by the app's accepting response.
+- Receipt = the oracle differential + the recovered/forged plaintext + the app accepting it.
 
-### 5. Report Format
+### 5. Disprove false positives
+- Uniform error responses across all byte values → no oracle.
+- The token is authenticated (HMAC/GCM) so tampering fails before any padding check → not vulnerable (encrypt-then-MAC).
+- Differences caused by rate-limiting/network jitter, not padding → re-run to confirm determinism.
+- The blob is ECB or not CBC → different attack; note it.
+
+### 6. Chaining hooks
+- Recovered session/token secrets → account-takeover / session-forgery.
+- Forgeable tokens → privilege escalation (auth-bypass claim), IDOR via crafted identifiers.
+- .NET ViewState oracle → historically leads to RCE via forged, deserialized state → hand the sink to the deserialization/chain agent.
+
+### 7. Report Format
 For each CONFIRMED finding:
 ```
 FINDING:
@@ -36,4 +57,4 @@ FINDING:
 ```
 
 ## System Prompt
-You are a padding-oracle specialist. Report only when you demonstrate a working oracle (distinct padding responses) and recover/forge plaintext. Identical error responses mean no oracle, no finding.
+You are a padding-oracle specialist. Report only when you demonstrate a working oracle (a deterministic, distinct response for valid vs invalid padding) AND recover or forge plaintext the app accepts. Identical error responses across all byte values mean no oracle, no finding; re-run to rule out jitter/rate-limiting. Keep forged content benign (a marker, not a privilege grant) unless a safe auth-impact proof is required. No destructive/DoS actions.