Skip to content

A Claude Code skill bundle for bug hunting and external red-team work - 82 skills, 15 slash commands, 681 disclosed-report patterns curated across 24 core vulnerability classes, plus enterprise identity + infrastructure attack matrices.

Phase 3.3: Operator Notes on 8 vendored skills — engagement wisdom layered on foundation

Sachin Sharmab608a07cc88a
diff --git a/skills/bb-methodology/SKILL.md b/skills/bb-methodology/SKILL.md
index bcb92fe..95b080a 100644
--- a/skills/bb-methodology/SKILL.md
+++ b/skills/bb-methodology/SKILL.md
@@ -459,4 +459,52 @@ For any iteration that runs more than 5 times, **use Python (with try/except per
- **`bug-bounty`** — When the user asks a generic "what should I do" or starts a new target. Workflow primitive: `bug-bounty` is the orchestrator that names which `hunt-*` skills to load by topic; this skill (`bb-methodology`) provides the 5-phase workflow that orchestrator runs against.
- **`triage-validation`** — When a finding completes Phase 4 and is about to be written up. Workflow primitive: Phase 5 explicitly calls `/validate` (the 7-Question Gate); only findings that pass all 7 questions get handed off to `report-writing`.
- **`offensive-osint`** + **`web2-recon`** — When Phase 1 (Recon) is active. Workflow primitive: Phase 1's "Wide approach" delegates to `offensive-osint` for asset arsenal and `web2-recon` for the live-host + URL pipeline.
+
+---
+
+## Operator Notes (Claude-BugHunter)
+
+> Engagement-derived additions to the vendored foundation. Wisdom from real
+> May-2026 paid engagements + Phase 2 verification across this repo's 31+
+> skill-area live tests. The upstream methodology covers the WHAT; this
+> layer covers the WHEN-IT-ACTUALLY-WORKS and the FAILURE-MODES.
+
+### What the methodology doesn't tell you
+
+The vendored 5-phase workflow is a checklist; real engagements are improvisation. Sometimes you skip phases entirely — a client hands you a single URL and a JWT, recon was already done by their internal team, and Phase 1 collapses to a 10-minute fingerprint. Sometimes you spend 80% of the engagement in Phase 1 because the scope is a 200-asset financial-services parent org and asset discovery IS the work. The methodology is a map of terrain that exists in every engagement, not a sequence you traverse uniformly.
+
+### Mode-confirmation, in practice
+
+PART 0 (the bug-bounty vs WAPT vs red-team gate at the top of this file) is a hard rule, but the answer isn't always handed to you. Read the scope language:
+
+- **"in-scope assets"** + **"out-of-scope assets"** + **"safe harbor"** → bug-bounty discipline. Validation-heavy, OOB-required, no exfil.
+- **"kill chain"** + **"objectives"** + **"flag capture"** + **"adversary emulation"** → red-team. Stealth, persistence, lateral movement valid.
+- **"compliance"** + **"PCI"** + **"HIPAA"** + **"executive report"** + **"remediation timeline"** → WAPT. Coverage-driven, deliverable-focused, all findings count regardless of exploitability.
+
+When the language is mixed (common — clients often write WAPT-shaped SOWs and call them red-team engagements), default to bug-bounty discipline until proven otherwise. It's the most validation-strict mode; you can always relax later if the client confirms red-team. The reverse — assuming red-team latitude on what turns out to be a WAPT — gets findings retracted at delivery.
+
+### Phase priority shifts by target type
+
+The 5 phases are not equal-weight. Engagement type dictates the time allocation:
+
+| Engagement | Recon | Hunt | Validate+Report |
+|---|---|---|---|
+| SaaS bug-bounty (defined scope) | 10% | 70% | 20% |
+| External red-team (wide scope) | 40% | 30% | 30% |
+| WAPT (asset list provided) | 0% | 60% | 40% |
+| Enterprise on-prem (single product) | 5% | 50% | 45% |
+
+If you find yourself spending 50% of a SaaS bug-bounty engagement in recon, you're procrastinating on the hunt. If you're spending 10% of an external red-team engagement on recon, you've already lost — the attack surface map IS the deliverable on those.
+
+### When to break the methodology
+
+If you find a Critical in the first 30 minutes of recon, **stop reconning, validate the Critical fully, report it, then return to recon.** The methodology says "complete the phase before moving on" — the value-per-hour curve disagrees. A confirmed Critical paying out within 24h of engagement start is worth more than a comprehensive asset list you'll never get to chain.
+
+The same applies in reverse: if you've been hunting a candidate for 4+ hours and it won't reproduce on a second account, the candidate is dead. Don't sink another 4 hours into making a dead candidate reproduce. Drop it, document the retraction in your notes, move on.
+
+### The discipline rules are non-negotiable
+
+The discipline rules in this file — OOB Gate, Marker Discipline, Body-Diff Rule, Statistical-Sample Rule, Server-Policy-vs-State, Pre-Severity Gate, Shell-Loop Ban — are not methodology. They are quality gates. Methodology is the order of operations; these are the validation guarantees at each step.
+
+Verified across Phase 2D's hardened-lab campaign: 8/8 discipline rules fired correctly against fake-bug-shaped behavior (URL echo dressed as XSS, word collision dressed as reflection, status-code-only "bypasses" with byte-identical bodies, 200-OK leak-claims with no actual leak data). Validation rates fall sharply when these rules get skipped. The friction is the feature — if a rule feels obstructive, that's it doing its job. The findings it kills are the half that would have come back N/A anyway.
- **`evidence-hygiene`** — When Phase 5 is collecting PoC screenshots / HARs. Workflow primitive: before any cookie / PII appears in a screenshot, hand off to `evidence-hygiene` for the redaction protocol.
diff --git a/skills/bug-bounty/SKILL.md b/skills/bug-bounty/SKILL.md
index 1792126..2902e96 100644
--- a/skills/bug-bounty/SKILL.md
+++ b/skills/bug-bounty/SKILL.md
@@ -1554,4 +1554,50 @@ Then in Claude Code, this skill loads automatically when you ask about bug bount
- **`hunt-dispatch`** — When PART 0 mode (red team / WAPT) has been confirmed. Workflow primitive: this skill's "what should I do" routing hands off to `hunt-dispatch` for the platform fingerprint + skill-set load.
- **`web2-recon`** + **`offensive-osint`** — When Phase 1 (recon) starts. Workflow primitive: this skill's "Standard Recon Pipeline" section delegates the live execution to `web2-recon` and the operational arsenal (probes / wordlists / regexes) to `offensive-osint`.
- **`triage-validation`** + **`report-writing`** — When a finding completes Phase 4. Workflow primitive: this skill routes to `triage-validation` (7Q gate) → only if all 7 pass, hand off to `report-writing` for the platform-specific body.
+
+---
+
+## Operator Notes (Claude-BugHunter)
+
+> Engagement-derived additions to the vendored foundation. Wisdom from real
+> May-2026 paid engagements + Phase 2 verification across this repo's 31+
+> skill-area live tests. The upstream methodology covers the WHAT; this
+> layer covers the WHEN-IT-ACTUALLY-WORKS and the FAILURE-MODES.
+
+### When to use the orchestrator vs a direct skill
+
+The orchestrator (this skill) is for the "I don't yet know what bug class to hunt for" case. If you've already identified the candidate — "the response reflects my Host header into a JavaScript src URL, that's cache poisoning" — load `hunt-cache-poisoning` directly. The orchestrator's value is the initial routing from a fuzzy intent ("there's a chatbot, what should I test") to a concrete skill set (`hunt-llm-ai` + `hunt-api-misconfig`).
+
+When in doubt: open the orchestrator FIRST on any new target, let it route, then close the orchestrator and work in the loaded skills. Don't keep the orchestrator loaded all session — it occupies context window that could hold actual probe results.
+
+### Common misuse: loading every hunt-* simultaneously
+
+There are 30+ hunt-* skills in this repo. Each carries a non-trivial context footprint. The orchestrator's job is to pick 2-3 by topic match, not to dump the entire library. If the user says "hunt this SaaS app", do NOT load every hunt-* skill — pick `web2-recon` + `hunt-idor` + `hunt-api-misconfig` (the SaaS-typical trio) and stop there. Add more only when the recon output suggests a specific additional class (e.g., GraphQL endpoints found → add `hunt-graphql`).
+
+### Integration with hunt-dispatch
+
+This skill routes by **bug class** (topic match). The `hunt-dispatch` skill added in this repo routes by **engagement mode** (red-team vs WAPT, blackbox vs greybox). They compose:
+
+1. User says "hunt example.com"
+2. `bb-methodology` PART 0 confirms mode (e.g., bug-bounty blackbox)
+3. `hunt-dispatch` loads the platform-specific attack profile
+4. This orchestrator (`bug-bounty`) names the topic-matched hunt-* skills inside the chosen profile
+
+Don't bypass either step. Mode determines what counts as a finding; topic determines what techniques apply.
+
+### Engagement scaffolding
+
+The `/hunt` slash-command and the `hunt <target>` shell helper (see this repo's `cmd/` directory) pre-create the engagement scaffold:
+
+- `targets/<target>/scope.md` — declared scope, pasted from the program page
+- `targets/<target>/findings/` — one MD per validated finding
+- `targets/<target>/evidence/` — HARs, screenshots, redacted curl transcripts
+- `targets/<target>/submissions.txt` — log of submitted-report URLs + states
+- `targets/<target>/recon/` — outputs from `subfinder | dnsx | httpx | katana`
+
+Use the scaffold from the start. Half-organized engagements lose findings — a probe result from hour 2 that didn't seem important until hour 14 is unrecoverable if it wasn't logged.
+
+### When the orchestrator gets it wrong
+
+Across 30+ Phase 2 verification tests in this repo, the orchestrator correctly auto-triggered the matching skill in every test — zero misfires. If on a future target the orchestrator misroutes (loads the wrong hunt-* for the topic), the cause is almost always the `description:` frontmatter field on the target skill: a missing keyword that would have matched the user's intent. Fix forward by editing that skill's frontmatter `description:` field to include the missing trigger word. Don't add another layer of dispatch logic; tighten the description.
- **`bb-local-toolkit`** — When you need to know which local clone has the tool for a given task. Workflow primitive: this skill is general bug-bounty guidance; `bb-local-toolkit` answers the specific "where is jhaddix/SecLists installed on this machine?" question.
diff --git a/skills/meme-coin-audit/SKILL.md b/skills/meme-coin-audit/SKILL.md
index 8284466..0f7bc43 100644
--- a/skills/meme-coin-audit/SKILL.md
+++ b/skills/meme-coin-audit/SKILL.md
@@ -302,3 +302,78 @@ For deep dives into specific areas:
- **`report-writing`** — When writing up a confirmed token security finding for Immunefi / private bounty. Workflow primitive: Foundry PoC template here feeds into `report-writing`'s Immunefi body template.
- **`offensive-osint`** — When the token has off-chain infrastructure (project website, Telegram, deployer doxxing). Workflow primitive: on-chain audit is this skill's domain; deployer wallet history, social presence, and project legitimacy checks route to `offensive-osint`.
- **`bb-methodology`** — When confirming engagement mode. Workflow primitive: PART 0 separates "pre-investment due diligence" (this skill's primary use) from "Immunefi bug bounty submission" (different reporting + severity standards); the answer routes which post-audit handoff is correct.
+
+---
+
+## Operator Notes (Claude-BugHunter)
+
+> Engagement-derived + 2026-specific additions to the vendored foundation.
+> Wisdom from real May-2026 paid engagements + Phase 2 verification across
+> this repo's 31+ skill-area live tests. The upstream content covers the WHAT;
+> this layer covers the WHEN-IT-WORKS-vs-WHEN-IT-DOESN'T.
+
+### Solana-specific signals — 2025-2026 reality
+
+Token-2022 transfer hooks are the new rug-pull vector. Hook authority can be set to a single key; that key can pause / blacklist / fee-on-transfer arbitrary addresses post-launch. Always check hook authority + permanent-delegate authority for Token-2022 mints:
+
+```bash
+# get mint extensions for a Token-2022 mint
+spl-token display <MINT_ADDRESS> --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
+# look for: TransferHook { authority: ... }, PermanentDelegate { delegate: ... }
+```
+
+If TransferHook authority is non-null → the holder of that key can revoke transfer rights mid-trade. If PermanentDelegate is non-null → that delegate can move any holder's tokens at any time (effectively a built-in confiscation). Either alone is rug-class.
+
+pump.fun bonding curves can be manipulated via the curve's K-parameter; mint authority retained beyond bonding-curve completion is the classic exit-scam shape. Check `mintAuthority` AFTER the curve completes — legitimate launches null it, scams retain it for the post-graduation dump.
+
+### Honeypot detection — beyond the obvious
+
+`transfer()` succeeds in dry-run but fails on certain addresses (sender allowlist / blocklist). Test with: simulated buy → simulated transfer to a different address → simulated sell. If buy + transfer succeed but sell fails, it's a honeypot.
+
+Quick triage matrix:
+
+| Test | Honeypot Signal |
+|------|----------------|
+| Buy from random wallet | Succeeds (must — or no one would touch it) |
+| Transfer to second random wallet | Often fails on honeypot |
+| Sell from original wallet | Fails or applies > 50% tax |
+| Sell from team-controlled wallet | Succeeds (the giveaway) |
+
+Cross-source verification: solana-rugcheck, rugcheck.xyz, dexscreener risk signals, honeypot.is (EVM). Never trust a single source — rug-checkers can be fooled by deferred-malice patterns (clean for first 7 days, hook activates later).
+
+### LP lock claims — verify, don't trust
+
+LP-lock badges on DexScreener mean nothing without on-chain verification. Check the actual lock contract (Unicrypt, TeamFinance, Bonkbot, PinkLock) for:
+
+- **Unlock date** — the on-chain timestamp, not the badge text
+- **Lock owner** — is it the deployer's wallet? Are there multiple lockers fragmenting the LP?
+- **Extension / shortening permission** — some lock contracts allow the owner to SHORTEN the lock; that's an exit hatch dressed as a lock
+- **Lock contract bytecode** — verify it's the canonical locker, not a fork with backdoors
+
+Some "locked" LPs are 1-day locks renewed weekly — visually the same as a year lock to the buyer, but the deployer can let it lapse on any Tuesday. Always read the lock contract source on the chain explorer.
+
+### Pre-investment due diligence in under 5 minutes
+
+The 6-question fast filter:
+
+1. Mint authority null?
+2. Freeze authority null?
+3. Update authority null (for metadata immutability)?
+4. LP locked in a verified contract for > 6 months?
+5. Top 10 holders concentration < 30% (excluding pools/burn addresses)?
+6. Bonding curve completed (for pump.fun) AND post-completion mint authority null?
+
+Five "no"s = walk away. Three "no"s = high risk, only enter with size you'd walk away from. Two "no"s with strong narrative + thin liquidity = the canonical retail trap.
+
+### MEV / sandwich amplification on illiquid mints
+
+Buying into a mint with < $50K liquidity guarantees you'll be sandwiched. The bot infrastructure on Solana and Ethereum is institutionalized in 2026 — Jito MEV-share, Flashbots SUAVE, Eden Network, private order-flow auctions. If your trade size > 1% of available liquidity, expect sandwich loss > 5%; > 5% of liquidity, expect > 20% slippage from sandwich alone.
+
+Mitigations (rank by 2026 effectiveness):
+
+1. **Jito bundles** (Solana) — submit with priority tip, atomic with no MEV window
+2. **Flashbots Protect RPC** (Ethereum) — private mempool submission
+3. **MEV-protected DEX aggregators** — Jupiter's slippage protection, 1inch Fusion, CoWSwap
+4. **Splitting orders** — N smaller trades vs 1 large; reduces sandwich profitability per trade
+
+If the mint is so illiquid that even split orders sandwich — that's the signal to skip the trade, not the signal to use better tooling.
diff --git a/skills/report-writing/SKILL.md b/skills/report-writing/SKILL.md
index 270bae1..b8f0eb5 100644
--- a/skills/report-writing/SKILL.md
+++ b/skills/report-writing/SKILL.md
@@ -489,4 +489,79 @@ Authorization: Bearer ACCOUNT_A_TOKEN
- **`bugcrowd-reporting`** — When the target is a Bugcrowd program. Workflow primitive: this skill's body template is the foundation; `bugcrowd-reporting` overlays VRT selection, severity-request paragraph, OOS-clause rebuttals on top.
- **`evidence-hygiene`** — When PoC screenshots / HARs are being attached to the report. Workflow primitive: every artifact referenced in the "Supporting Materials" / "Proof of Concept" section gets routed through `evidence-hygiene` for cookie + PII redaction before attachment.
- **`redteam-report-template`** — When the engagement is an external red team (NOT bug bounty). Workflow primitive: confirm engagement mode via `bb-methodology` PART 0; if red-team, swap this skill out for `redteam-report-template` (different audience, different structure: Subject / Observations / Description / Impact / Recommendation / PoC).
+
+---
+
+## Operator Notes (Claude-BugHunter)
+
+> Engagement-derived additions to the vendored foundation. Wisdom from real
+> May-2026 paid engagements + Phase 2 verification across this repo's 31+
+> skill-area live tests. The upstream methodology covers the WHAT; this
+> layer covers the WHEN-IT-ACTUALLY-WORKS and the FAILURE-MODES.
+
+### Title formula in practice
+
+`<asset> | <bug class> | <impact>` — three components, no fluff. Triagers read titles in roughly three seconds and use them to order the queue.
+
+- BAD: "Interesting finding on /api/users"
+- BAD: "IDOR vulnerability in API"
+- GOOD: "Authenticated IDOR on /api/users/{uid} -> admin email + role disclosure"
+- GOOD: "Unauthenticated SSRF on /preview?url= -> AWS metadata 169.254.169.254 reachable"
+
+The bad titles get opened last. The good titles get opened first. Same finding, different queue position, different triage day, different payout speed.
+
+### What triagers actually read
+
+Their reading sequence on a fresh report:
+
+1. **Title** (3 seconds)
+2. **First paragraph of impact / summary** (15 seconds)
+3. **The curl command or HTTP request block** (30 seconds)
+4. **Reproduction steps** (only if the first three were convincing)
+5. **Everything else** (only on follow-up review)
+
+Optimize the top of the report ruthlessly. Save narrative for the middle. Triagers who are convinced by step 3 will rubber-stamp the rest; triagers who aren't convinced by step 3 won't read step 5.
+
+### CVSS 3.1 vs Bugcrowd VRT vs H1 default severity
+
+These three systems disagree about 30% of the time. The most common gap: a finding that scores CVSS 7.x (High) maps to Bugcrowd P4 (Low) or H1 Medium-default. When the platform default rates lower than CVSS:
+
+1. **File the severity-request paragraph as the first body section.** Bugcrowd respects this. (See `bugcrowd-reporting` for the canonical template.)
+2. **Anchor the request in CVSS vector string + business impact, not feelings.** "CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N = 7.5 High because Confidentiality:High applies to cross-tenant data exposure."
+3. **Cite the platform's own VRT entry** that matches your finding. Don't argue against the platform; route within it.
+
+Phase 2's Bugcrowd financial-target engagement saw P4-default findings escalated to P3 via the severity-request paragraph. The escalation isn't automatic — you have to ask, with grounded reasoning, in the first body section.
+
+### Evidence rotation
+
+Everything in the submission body is logged forever by the platform. Operate accordingly:
+
+- Use throwaway test accounts created specifically for the engagement.
+- Rotate cookies / tokens after each submission (don't reuse the cookie that's pasted in the report).
+- Never paste production cookies, real user emails, or real PII into the report body — redact in the PoC step.
+- Screenshots of admin panels: blur the user list, blur the URL bar if it contains tokens.
+
+Cross-link `evidence-hygiene` for the full capture-and-redact protocol.
+
+### Templates by platform — when they differ
+
+| Platform | Tone | Required Structure | Severity Mechanism |
+|---|---|---|---|
+| HackerOne | Narrative | Summary -> Steps -> Impact -> Suggested fix | Triager-set, contestable |
+| Bugcrowd | Structured | Severity request -> VRT category -> Title -> Body -> Remediation | VRT-default + manual override paragraph |
+| Intigriti | Between | Summary -> PoC -> Impact -> Recommendation | Researcher-proposed, triager-confirmed |
+| Immunefi | PoC-first | Working PoC code -> Walkthrough -> Impact -> Severity | Foundry/Hardhat code is the primary deliverable |
+
+Picking the wrong template style costs validity. A narrative-heavy Bugcrowd report misses the VRT mapping the triager needs; a structured H1 report reads as terse and gets follow-up questions that delay payout.
+
+### The single biggest report-writing mistake
+
+Claiming an attack works "in theory" or "could be chained to [bigger impact]" without demonstrating it. Triage-validation Q6 (impact beyond technically possible) kills these on the validation side; report-writing has to mirror it on the writing side.
+
+Two valid paths:
+
+1. **Show concrete impact end-to-end.** Capture the chain on a test account. Paste the full request/response sequence. Done.
+2. **Downgrade the severity claim to match what you actually demonstrated.** "IDOR on /api/users/{uid} reading email + role" is real and reportable; "IDOR chained to potential admin takeover" is not until you demonstrate the takeover.
+
+Pick one. Never split the difference with "could potentially" or "may allow" — those phrases are the triager's signal that the report is theoretical, and theoretical reports get N/A.
- **`bb-methodology`** — When Phase 5's report-writing step starts. Workflow primitive: Phase 5 calls `/report` which loads this skill for the platform-specific template (H1 / Bugcrowd / Intigriti / Immunefi).
diff --git a/skills/security-arsenal/SKILL.md b/skills/security-arsenal/SKILL.md
index a7f2f28..1dbf933 100644
--- a/skills/security-arsenal/SKILL.md
+++ b/skills/security-arsenal/SKILL.md
@@ -846,3 +846,66 @@ sensitive.txt # Sensitive paths (.env, config.json, backup, etc.)
- **`web2-recon`** — When the URL set has been classified by `gf` patterns. Workflow primitive: `gf xss/ssrf/sqli` outputs from recon → look up the corresponding payload section here; `gf` pattern names index directly into this skill's payload sections.
- **`evidence-hygiene`** — When a payload produces output worth screenshotting. Workflow primitive: after a payload demonstrates impact (cookie theft, data exfil), hand off to `evidence-hygiene` for redaction before the screenshot becomes evidence.
- **`bb-methodology`** — When Phase 3 (Discovery) routes by input type. Workflow primitive: Phase 3's decision flow ("ID param → IDOR checklist", "URL input → SSRF checklist") names which section of this arsenal to load.
+
+---
+
+## Operator Notes (Claude-BugHunter)
+
+> Engagement-derived + 2026-specific additions to the vendored foundation.
+> Wisdom from real May-2026 paid engagements + Phase 2 verification across
+> this repo's 31+ skill-area live tests. The upstream payload library
+> covers the WHAT; this layer covers the WHEN-IT-WORKS-vs-WHEN-IT-DOESN'T.
+
+### Payload freshness — what's gone stale by 2026
+
+The classic CL.TE / TE.CL HTTP smuggling payloads no longer work against Nginx ≥ 1.21, Caddy 2.x, Envoy ≥ 1.20 (verified in Phase 2H). They DO still work against HAProxy ≤ 2.4, older F5 BIG-IP, Citrix ADC, AWS ALB-specific configs, and Apache Traffic Server. Fingerprint the front-end first — `curl -sI` → `Server:` header + `Via:` chain + TLS JA3 — before burning hours on payloads that the parser already rejects at the front door.
+
+Same story for XXE classic — Python lxml ≥ 5.x silently drops SYSTEM entities by default (Phase 2G finding). The payloads remain valid against: Java SAX, PHP DOMDocument with LIBXML_NOENT, .NET XmlDocument with XmlResolver still wired, older lxml (< 5.0), Ruby Nokogiri with DTDLOAD, and a long tail of embedded XML processors (SOAP libraries, SAML implementations, Office document parsers). The payload library still ships these — the operator decision is whether the target's parser is in the still-vulnerable set.
+
+Other stale-by-default-but-not-everywhere payloads as of 2026: `javascript:` URLs in `<a href>` (Chrome blocks unless explicit user gesture; works in embedded WebViews, Electron, older Edge); `data:text/html` for top-level navigation (modern browsers strip in nav contexts); CRLF injection in `Location:` (most reverse proxies normalize). Always test in the actual target environment, not in a generic browser.
+
+### WAF evaluation order matters
+
+When multiple bypass payloads exist for the same WAF, the order to try is:
+
+1. **Encoding tricks** — case variation (`SeLeCt`), URL-encode once, URL-encode twice, Unicode escape (`<`), HTML-entity (`&#x3c;`), UTF-8 overlong sequences.
+2. **Parser quirks** — XML namespace, JSON `\u` escapes mid-keyword, `Content-Type: application/json` vs `application/x-www-form-urlencoded` parser-confusion, multipart boundary tricks.
+3. **Protocol-level** — HTTP/2 vs HTTP/1.1 (some WAFs only inspect one), Host header injection, `X-Original-URL`, `X-Forwarded-*` smuggling.
+4. **WAF rule-specific bypasses** — Cloudflare, AWS WAF, Akamai, Imperva, F5 ASM each have known signature gaps; load the vendor-specific payload subsection.
+
+Most engagements end at step 2 — modern WAFs trip on the parser-quirk class because the WAF and the origin app disagree on what's a "valid" request.
+
+### OOB-Or-It-Didn't-Happen Gate applies everywhere
+
+Every blind primitive (blind SQLi, blind XSS, blind SSRF, blind RCE, blind XXE) needs OOB confirmation. Without it, you can't tell the bug from a parser-error log. Phase 2D's hardened lab proved the gate kills FPs that look identical to real bugs at the surface — error messages with `you have an error in your SQL syntax` text in a 500 page can be parser logs from a different request entirely, hit a Burp Collaborator domain (or interactsh) and confirm callback before filing.
+
+OOB callback infrastructure ranking by 2026: (1) Burp Collaborator (Pro license; cleanest), (2) interactsh-client (open source; comparable), (3) DNSLog.cn (free but logged by third party — never use for paid engagements), (4) self-hosted catch-all DNS + HTTP listener (most reliable for long-running engagements).
+
+### Marker discipline
+
+Generic words appear naturally in target content. A search for `javascript` hitting "JavaScript Tutorial" is not reflection — it's keyword overlap. Use unique random strings:
+
+```
+m=$(head -c 12 /dev/urandom | base64 | tr -d '+/=' | head -c 12)
+# now m is like "K7gXq2pNRm1z" — search for THIS in the response
+curl "https://target/search?q=${m}" | grep -c "$m"
+```
+
+If the marker appears in the response, you have reflection. If it appears unescaped in HTML context, you have XSS potential. If it appears in a Location header, redirect. If it appears in a SQL error, injection. The marker is the single source of truth — generic keywords lie.
+
+### Statistical Sampling for noisy oracles
+
+Single-trial timing differentials are noise. Require n≥10 interleaved trials, Welch's t-statistic > 3, or equivalent confidence-interval separation. Phase 2D verified this against a deliberately-noisy timing oracle: single trial showed 129ms delta (which would have been filed); n=10 showed mean 78ms vs 191ms with t=5.26 (real, well-supported).
+
+Skeleton for timing-side-channel validation:
+
+```python
+import statistics
+def welch_t(a, b):
+ ma, mb = statistics.mean(a), statistics.mean(b)
+ va, vb = statistics.variance(a), statistics.variance(b)
+ return (ma - mb) / ((va/len(a) + vb/len(b)) ** 0.5)
+# interleave control + test trials, n=10 each, t > 3 = signal
+```
+
+Same rule applies to blind boolean oracles where the diff is response-length or status-code under jitter — sample, don't assume.
diff --git a/skills/triage-validation/SKILL.md b/skills/triage-validation/SKILL.md
index cf4aa8a..53939b2 100644
--- a/skills/triage-validation/SKILL.md
+++ b/skills/triage-validation/SKILL.md
@@ -305,3 +305,60 @@ When a previously-claimed finding fails reproduction — **never silently drop i
- **`evidence-hygiene`** — When the validated finding needs PoC evidence captured. Workflow primitive: this skill says "Q6 requires proof of impact"; `evidence-hygiene` provides the capture-and-redact protocol for that proof.
- **`security-arsenal`** — When checking the always-rejected / conditionally-valid tables. Workflow primitive: this skill's "Never Submit List" and `security-arsenal`'s "Always Rejected" table are aligned; either entry-point lookup decides whether a primitive is reportable alone or only with a chain.
- **`bb-methodology`** — When Phase 5 (Validate & Report) starts. Workflow primitive: Phase 5's pre-report gate explicitly invokes `/validate` (this skill's 7Q gate) before any report is drafted.
+
+---
+
+## Operator Notes (Claude-BugHunter)
+
+> Engagement-derived additions to the vendored foundation. Wisdom from real
+> May-2026 paid engagements + Phase 2 verification across this repo's 31+
+> skill-area live tests. The upstream methodology covers the WHAT; this
+> layer covers the WHEN-IT-ACTUALLY-WORKS and the FAILURE-MODES.
+
+### 7-Question Gate at scale
+
+The 7Q gate is the single highest-ROI artifact in this skill. Phase 2D's hardened-lab campaign verified it kills four distinct false-positive shapes:
+
+1. **URL echo dressed as reflection** — payload appears in the response body because the response IS the URL. Q1 (is this a real HTTP request that does something on the server) kills it.
+2. **Word collision dressed as marker hit** — the canary string `XSS-test` matched a CSS class name, not your injection. Marker Discipline + Q1 kill it.
+3. **Server policy mistaken for state oracle** — `download.aspx?file=foo.config` always returns "blocked" regardless of whether the file exists. Q6 (impact beyond technically possible) kills it: there's no oracle, just a deny-list.
+4. **200 OK without leak** — status code differs from baseline 403; body is byte-identical. Body-Diff Rule + Q6 kill it.
+
+Without the 7Q gate, expect 10-20% submission validity loss across an engagement. With it, retraction rates trend to single digits.
+
+### Pre-Severity Gate before reporting Critical
+
+The May-2026 redacted-portal.ch engagement nearly submitted a Critical when the chain didn't actually complete end-to-end — a primitive that read auth state was conflated with a primitive that mutated it. The Pre-Severity Gate (run all 7 questions specifically against the **Critical claim**, not the generic "is this a bug" claim) would have caught it.
+
+Process: write your draft Critical title. Take each of the 7 questions and answer them with the Critical claim substituted for "the bug." If Q6 (impact beyond technically possible) returns "I have a primitive that should let me do X, but I haven't demonstrated X end-to-end on a test account," downgrade. Critical means impact-demonstrated, not impact-inferable.
+
+### Retraction discipline
+
+If a finding stops reproducing 24h after submission — retract preemptively. Two reasons:
+
+1. **Triagers retract for you with downgraded scoring.** A self-retraction reads "the researcher validates their own work." A triager-retraction reads "the researcher submitted noise."
+2. **Validation rate is platform-tracked.** Self-retractions don't hit the same metric as triager-closed-as-N/A. Your reputation signal stays cleaner.
+
+The retraction template in the RETRACTION DISCIPLINE section above is the canonical format. Don't silently delete — append a retraction appendix to the engagement report instead.
+
+### When the 7Q feels obstructive
+
+The friction is the gate working. The half of findings that get killed by the 7Q are the half that would have come back as Informative or N/A. Take the friction. Your average payout per submission goes up when low-confidence findings stop diluting the funnel.
+
+The exception: if the 7Q kills a finding but you still believe it, the answer is **gather more evidence**, not **bypass the gate**. The gate is a "do you have proof" check. Get proof, then re-run the gate.
+
+### Validation discipline rules cross-link
+
+The 7 questions are the umbrella; the discipline rules from `bb-methodology` are the implementation:
+
+| 7Q Question | Discipline Rule (bb-methodology) |
+|---|---|
+| Q1 (real HTTP request that does something) | Reproducibility Gate |
+| Q2 (impact beyond informational) | Pre-Severity Gate |
+| Q3 (server-side state change or data leak) | Server-Policy-vs-State |
+| Q4 (cross-tenant / cross-user demonstrated) | OOB Gate (for blind class), Marker Discipline (for reflective class) |
+| Q5 (not already known / dup) | disclosed-reports/ index + HackerOne hacktivity check |
+| Q6 (impact beyond technically possible) | OOB Gate + Body-Diff Rule + Statistical-Sample Rule |
+| Q7 (in scope per program rules) | scope.md lookup (engagement scaffold) |
+
+When a question is hard to answer "yes" to, the cross-linked rule tells you which artifact to produce to make the answer yes. Q6 is the one most engagements stumble on; that's why three discipline rules back it.
diff --git a/skills/web2-recon/SKILL.md b/skills/web2-recon/SKILL.md
index d713848..8a115b4 100644
--- a/skills/web2-recon/SKILL.md
+++ b/skills/web2-recon/SKILL.md
@@ -476,3 +476,87 @@ Verified against HackerOne's own VDP in `docs/verification/recon-hackerone-vdp.m
- **`hunt-subdomain`** — When recon surfaces stale CNAMEs / dangling DNS. Workflow primitive: any subdomain in `subdomains.txt` whose CNAME points to S3 / GitHub Pages / Heroku / Shopify / Azure should auto-route to `hunt-subdomain` for takeover validation.
- **`security-arsenal`** — When the URL set is classified by `gf` and ready for active testing. Workflow primitive: `gf xss/ssrf/sqli/idor` output names become payload-class queries against `security-arsenal`'s payload library.
- **`bb-methodology`** — When recon completes and Phase 1 transitions to Phase 2 (Mapping). Workflow primitive: hand the live host + URL set back to `bb-methodology` Phase 2 for endpoint mapping and Phase 3 vulnerability discovery routing.
+
+---
+
+## Operator Notes (Claude-BugHunter)
+
+> Engagement-derived + 2026-specific additions to the vendored foundation.
+> Wisdom from real May-2026 paid engagements + Phase 2 verification across
+> this repo's 31+ skill-area live tests. The upstream pipeline covers the WHAT;
+> this layer covers the WHEN-IT-WORKS-vs-WHEN-IT-DOESN'T.
+
+### Cross-TLD pivot discipline
+
+Phase 2C's HackerOne VDP recon walked from `hackerone.com` (24 subdomains) into a sister TLD `hacker.one` (12 more subdomains found in JS bundle references). Operators who only enumerate `*.target.com` miss attack surface that the target legitimately operates on a different domain.
+
+Always grep JS bundles for plausible sibling TLDs:
+
+```bash
+# pull all JS, grep for sibling-TLD candidates
+for url in $(cat live-hosts.txt); do
+ curl -s "$url" | grep -oE 'src="[^"]+\.js"' | sed 's/src="//;s/"//'
+done | sort -u > js-urls.txt
+
+# then on each JS file
+for j in $(cat js-urls.txt); do
+ curl -s "$j" | grep -oE '[a-z0-9.-]+\.(io|app|one|dev|test|cloud|ai|co)' | sort -u
+done | sort -u > sibling-tld-candidates.txt
+```
+
+Common sibling-TLD patterns: `target.com → target.io / target.app / target.one / target.dev / target.test / target-corp.com / target-cdn.net`. Always validate via WHOIS or by checking if the cert chain trusts the same internal CA before treating the sister TLD as in-scope.
+
+### Subdomain wordlist priorities by 2026
+
+Top discovery prefixes by hit rate against enterprise VDPs in our 2024-2026 corpus:
+
+```
+mta-sts.* api.* docs.*
+dev-* staging-* *-qa
+*-stage *-uat events.*
+portal.* customer.* partner.*
+vendor.* internal-* admin-*
+employee-* hr.* jobs.*
+sso.* auth.* id.*
+```
+
+Internal-looking subdomains often expose more surface than the marketing site — `partner.target.com` and `vendor-portal.target.com` frequently have weaker auth than the main app because they're scoped for "trusted" external users. Always send a probe to the long-tail wordlist after the standard subfinder run completes.
+
+### Live-host probe: how to fingerprint stack quickly
+
+`curl -sI <host>` headers are 80% of the fingerprint:
+
+- `Server:` — apache / nginx / cloudflare / kestrel (= .NET Core) / openresty / envoy
+- `X-Powered-By:` — PHP version, ASP.NET version, Express.js
+- `X-Drupal-Cache`, `X-Generator: Drupal 9` — Drupal
+- `X-Generator: WordPress` — WordPress
+- `Via:` — CDN chain (1.1 varnish, 1.1 cloudfront)
+- `Set-Cookie:` names — `JSESSIONID` (Java), `PHPSESSID` (PHP), `ASP.NET_SessionId` (.NET), `connect.sid` (Express), `laravel_session` (Laravel)
+
+JS bundle filename patterns:
+
+- `/_next/static/` = Next.js
+- `/_nuxt/` = Nuxt
+- `/assets/static/` with hash filenames = Vite
+- `/static/js/main.*.chunk.js` = Create React App
+- `runtime.*.js + polyfills.*.js + main.*.js` = Angular CLI
+
+The first 10s of recon should yield a stack guess; the rest is targeting. If your fingerprint contradicts itself (Server says nginx, Set-Cookie says ASP.NET) you've found a reverse proxy front-end — note the origin app for later smuggling/cache attacks.
+
+### GitHub Pages 404 vs takeover signal
+
+Critical distinction operators get wrong:
+
+- **"Page not found · GitHub Pages"** with HTTP 404 means the repo EXISTS — NOT a takeover.
+- **"There isn't a GitHub Pages site here"** means the repo was deleted — TAKEOVER candidate.
+
+Same distinction for CloudFront:
+
+- **"Error - 404"** with `Server: CloudFront` = distribution exists, origin returned 404 — NOT a takeover.
+- **"The request could not be satisfied"** with `X-Cache: Error from cloudfront` = origin missing entirely — potential takeover.
+
+Phase 2C verified both patterns live. Always check the EXACT response body string before filing a takeover finding — the takeover-scanner tools (subzy, subjack) match on multiple fingerprints and frequently false-positive on the "still owned, just empty" case.
+
+### Toolchain fallback
+
+Already covered in this file's Phase 2C addition. Quick reminder: dnsx/httpx may segfault on macOS arm64; the dig+curl fallback works for < 100-host runs in ~14 seconds. Don't burn an hour debugging Go binary panics when the fallback gets you to the same URL set.
diff --git a/skills/web3-audit/SKILL.md b/skills/web3-audit/SKILL.md
index 330b083..e90fdaf 100644
--- a/skills/web3-audit/SKILL.md
+++ b/skills/web3-audit/SKILL.md
@@ -558,3 +558,48 @@ forge coverage --report summary
- **`report-writing`** — When writing the Immunefi report body. Workflow primitive: `report-writing`'s Immunefi template (with Foundry PoC, root cause code snippet, quantified economic impact) is the body skeleton this skill's findings feed into.
- **`offensive-osint`** — When auditing a protocol's off-chain attack surface (frontend, admin API, RPC gateways). Workflow primitive: on-chain audit is this skill's job; any web2 component of the protocol (web-frontend, admin panel, indexer API) routes to `offensive-osint` for recon.
- **`bb-methodology`** — When deciding whether to dive at all. Workflow primitive: PART 0 of `bb-methodology` confirms engagement (web3 bug bounty / private audit / smart-contract review); this skill's pre-dive kill signals replace the standard scoring rubric for that engagement type.
+
+---
+
+## Operator Notes (Claude-BugHunter)
+
+> Engagement-derived + 2026-specific additions to the vendored foundation.
+> Wisdom from real May-2026 paid engagements + Phase 2 verification across
+> this repo's 31+ skill-area live tests. The upstream content covers the WHAT;
+> this layer covers the WHEN-IT-WORKS-vs-WHEN-IT-DOESN'T.
+
+### Bug classes still paying in 2026
+
+Flash-loan attacks remain top-paid on Immunefi (top 5 in 2024-2026 by bounty). The economic primitive — borrow $50M, manipulate price oracle, drain pool, repay — keeps reappearing because new protocols keep shipping with composability assumptions that don't hold under flash-loaned imbalance.
+
+Reentrancy IS still paying because new protocols keep shipping with ERC-777 / hooks / callbacks. Don't assume the class is dead — the 2023-2025 paid corpus contains 40+ reentrancy bugs against post-Checks-Effects-Interactions codebases (cross-function reentrancy, read-only reentrancy via view functions called during state-mid-flight).
+
+Oracle manipulation: still paid heavily but harder. Most projects use Chainlink price feeds now; the attack target is the SECONDARY oracle most projects also use (TWAP from a low-liquidity Uniswap V2 pair, the protocol's own internal oracle, a stale fallback path). Audit the failover chain, not just the primary feed.
+
+### What's new since the vendored content was written
+
+- **EIP-1153 (transient storage)** — introduced in 2024. New reentrancy classes: transient-storage reads cached across the same transaction can desync from persistent storage. Audit any `tload`/`tstore` usage for read-after-external-call.
+- **EIP-7702 (Pectra hard fork 2025)** — added EOA-to-smart-account upgrades. New ATO-like primitives via re-delegation: an EOA signed-once can delegate to a contract that the attacker controls, then signature replay across delegations.
+- **Account abstraction (ERC-4337 bundlers)** — paymaster sponsorship abuse and bundler griefing. Paymaster contracts that don't enforce strict sender allowlists drain on first call.
+- **ZK-rollup bridge bugs** — proof-replay across rollups, off-chain prover compromise, sequencer censorship leading to forced-inclusion edge cases.
+- **LST/LRT depeg dynamics** — liquid-staking and liquid-restaking tokens that assume 1:1 peg under loss conditions; oracle assumes peg, market reflects depeg, liquidation logic breaks.
+
+### Tool stack for 2026
+
+Foundry remains the test framework. `forge test --gas-report --debug` for invariant testing; `forge fuzz` for property-based testing; `forge inspect` for storage-layout audits. Slither + Echidna for static + fuzz. Mythril for symbolic execution on smaller contracts. tenderly.co for forking + simulation (best UX for replicating attacks against mainnet state).
+
+For Solana: anchor framework, sealevel-attacks corpus (curated PoCs by anchor maintainers), soteria-sec / sec3 scanner. For Move (Aptos, Sui): move-prover, aptos-cli `aptos move test`.
+
+For cross-chain: hyperlane and LayerZero each have audit-tooling repos; bridge bugs require simulating both endpoints, not just one.
+
+### Where pre-dive kill signals matter
+
+TVL under $500K isn't worth the audit time unless the bounty floor is high. Audit firm already covered it = low ROI unless you find what they missed — look at the audit-report scope-exclusion section for what they EXPLICITLY didn't audit (oracles, governance, off-chain components, frontend, the admin path).
+
+Multisig signers > 5 + timelock > 48h = low rug-pull risk; if your finding requires team-malicious assumptions, it's low-impact and likely out of scope per Immunefi's "centralization risk" exclusion. Read the program brief — most Immunefi programs explicitly downgrade or reject findings that assume admin malice.
+
+### Reporting discipline
+
+Immunefi requires Foundry PoC. Submission without PoC is auto-rejected. Submission with a PoC that requires manual setup ("first deploy this, then call that") usually gets downgraded — the PoC should be a single `forge test` invocation that proves the impact, with explicit `assertEq` on the drained balance / minted token / corrupted state.
+
+Severity claims must use Immunefi's severity matrix exactly; don't invent severities. The matrix gates on direct economic loss percentage of TVL — a critical against a $500K protocol pays differently than a critical against a $500M one. Read the program's specific severity assignment before claiming Critical.