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.
Python ai-securityanthropicapplication-securitybug-bountybugbountybugcrowdclaudeclaude-codeclaude-skillsethical-hackinghackeroneoffensive-securitypentestingred-teamsecurity-toolsweb-security
feat: add hunt-fintech-graphql skill + doc-count CI, refresh counts (#61)
prithvee07f6944d673dbf
diff --git a/.github/workflows/doc-count-check.yml b/.github/workflows/doc-count-check.ymlnew file mode 100644index 0000000..41d91c1--- /dev/null+++ b/.github/workflows/doc-count-check.yml@@ -0,0 +1,44 @@+name: doc-count-check++# Keeps skill/command counts in docs honest against what's actually on disk.+# Catches stale numbers (e.g. "71 SKILL.md files" after the bundle grew to 82)+# before they merge. No external dependencies — stdlib Python only.++on:+ pull_request:+ paths:+ - "skills/**"+ - "commands/**"+ - "README.md"+ - "SECURITY.md"+ - "USAGE.md"+ - "INSTALL.md"+ - "docs/skills.md"+ - "docs/credits.md"+ - "docs/architecture.md"+ - "scripts/check_doc_counts.py"+ - ".github/workflows/doc-count-check.yml"+ push:+ branches: [main]+ paths:+ - "skills/**"+ - "commands/**"+ - "scripts/check_doc_counts.py"+ workflow_dispatch:++permissions:+ contents: read++jobs:+ check:+ name: Check doc counts+ runs-on: ubuntu-latest+ steps:+ - uses: actions/checkout@v4++ - uses: actions/setup-python@v5+ with:+ python-version: "3.12"++ - name: Verify skill/command counts in docs match disk+ run: python3 scripts/check_doc_counts.pydiff --git a/INSTALL.md b/INSTALL.mdindex 50b0a70..bdb8af5 100644--- a/INSTALL.md+++ b/INSTALL.md@@ -58,7 +58,7 @@ pwsh ./scripts/install.ps1> script aborts with a `syntax error` and cannot fix itself.This copies:-- All 82 skills → `~/.claude/skills/` (macOS/Linux) or `%USERPROFILE%\.claude\skills\` (Windows)+- All 83 skills → `~/.claude/skills/` (macOS/Linux) or `%USERPROFILE%\.claude\skills\` (Windows)- All 15 slash commands → `~/.claude/commands/`- The `hunt` scaffolder → `~/.claude/scripts/hunt.sh` (sourced from your `.zshrc`/`.bashrc`) on macOS/Linux, or `~\.claude\scripts\hunt.ps1` (dot-sourced from your PowerShell `$PROFILE`) on Windowsdiff --git a/README.md b/README.mdindex d8f8cda..d21dd41 100644--- a/README.md+++ b/README.md@@ -2,7 +2,7 @@# claude-bughunter-> A self-contained Claude skill bundle for bug hunting and external red-team work · **82 skills** · 15 slash commands · **681 disclosed-report patterns** across 24 core vulnerability classes · enterprise identity + infrastructure attack matrices · engagement-folder scaffolding · Burp MCP integration · battle-tested across authorized red-team and bug-hunting engagements, plus public training platforms (DVWA, OWASP Juice Shop, Hacker101, testphp.vulnweb.com).+> A self-contained Claude skill bundle for bug hunting and external red-team work · **83 skills** · 15 slash commands · **681 disclosed-report patterns** across 24 core vulnerability classes · enterprise identity + infrastructure attack matrices · engagement-folder scaffolding · Burp MCP integration · battle-tested across authorized red-team and bug-hunting engagements, plus public training platforms (DVWA, OWASP Juice Shop, Hacker101, testphp.vulnweb.com).Built by **[Sachin Sharma](https://www.linkedin.com/in/sachinsharma8080/)** — Bug Hunting & GenAI Security Research.@@ -26,7 +26,7 @@ Built by **[Sachin Sharma](https://www.linkedin.com/in/sachinsharma8080/)** —Four layers stack:- **Think** — `bb-methodology` + `redteam-mindset`: the 5-phase non-linear workflow, critical-thinking framework, and red-team operator discipline.-- **Hunt webapps** — 48 `hunt-*` skills curated from 681 disclosed HackerOne reports: per-class detection patterns, payloads, bypass tables, and chain templates.+- **Hunt webapps** — 58 `hunt-*` skills curated from 681 disclosed HackerOne reports: per-class detection patterns, payloads, bypass tables, and chain templates.- **Hit the perimeter** — enterprise platform chains (M365/Entra, Okta, vCenter, SSL-VPN appliances, SharePoint, cloud IAM): current 2024–2026 CVE chains + post-credential escalation.- **Ship it** — `triage-validation` + reporting + `evidence-hygiene`: the 7-Question Gate, VRT-aware severity, OOS rebuttals, PII redaction, and red-team deliverables.@@ -43,7 +43,7 @@ All triggered automatically by topic — describe what you're testing in plain E/plugin install claude-bughunter@elementalsouls```-All 82 skills + 15 commands load namespaced under `claude-bughunter:` and update when you bump the plugin version — no files copied into `~/.claude/`.+All 83 skills + 15 commands load namespaced under `claude-bughunter:` and update when you bump the plugin version — no files copied into `~/.claude/`.**Option B — copy install (no plugin system / pin to a clone):**@@ -64,7 +64,7 @@ Both copy the skills + commands into `~/.claude/` (macOS/Linux) or `%USERPROFILE**What each install path gives you:**-| Path | 82 skills + 15 slash commands | `cbh` CLI | `hunt` scaffolder |+| Path | 83 skills + 15 slash commands | `cbh` CLI | `hunt` scaffolder ||---|---|---|---|| **A — plugin** | ✅ namespaced under `claude-bughunter:` | ➕ separate `pipx install` | ❌ clone-only || **B — copy install** | ✅ copied into `~/.claude/` | ✅ from the clone | ✅ from the clone |@@ -158,20 +158,15 @@ If you're running an internal red team that includes domain-takeover chains via## What's inside-**82 skills**, auto-loaded by topic — no invocation by name. Coverage across the external attack surface:+**83 skills**, auto-loaded by topic — no invocation by name. Coverage across the external attack surface:| Category | # | Examples ||---|---|---|-| Web application hunting | 13 | XSS, SQLi, SSRF, IDOR, LFI, SSTI, XXE, CSRF, CORS, open-redirect |-| Authentication & identity | 7 | auth-bypass, session, OAuth, SAML, MFA-bypass, ATO |-| API & infrastructure | 15 | GraphQL, gRPC, WebSocket, API-misconfig, host-header, RCE |-| Advanced & concurrency | 6 | race-condition, HTTP smuggling, deserialization, cache-poison |-| Framework-specific | 4 | Next.js, Node.js, Laravel, Spring Boot |-| Enterprise identity & cloud ★ | 3 | M365/Entra, Okta, cloud-IAM-deep |-| Infrastructure & appliance ★ | 4 | VMware vCenter, enterprise VPN, SharePoint, ASP.NET/NTLM |-| Red-team tradecraft ★ | 4 | redteam-mindset, APK pipeline, supply-chain recon, mid-engagement IR |-| Recon & OSINT | 4 | web2-recon, offensive-osint, subdomain |-| Workflow, reporting & specialized | 11 | methodology, triage-validation, evidence-hygiene, VRT-aware reporting |+| Hunt — web app vuln classes | 58 | XSS, SQLi, SSRF, IDOR, LFI, SSTI, XXE, CSRF, CORS, open-redirect, SharePoint, ASP.NET/NTLM |+| Enterprise platform attack ★ | 10 | M365/Entra, Okta, cloud-IAM-deep, vCenter, enterprise VPN, APK/iOS red-team pipelines, supply-chain recon |+| Reporting & validation | 6 | triage-validation, evidence-hygiene, report-writing, bugcrowd-reporting |+| Recon & OSINT | 5 | web2-recon, offensive-osint, osint-methodology, recon-scope-triage |+| Methodology & mindset | 4 | bb-methodology, bug-bounty, redteam-mindset, bb-local-toolkit |Full searchable catalog → **[docs/skills.md](docs/skills.md)**. Also ships **15 slash commands** (`/hunt`, `/recon`, `/report`, …) and a deterministic **engagement engine** (`engine/`) that maps a target's attack surface and routes each finding to the skill that handles it.@@ -266,7 +261,7 @@ The per-class `hunt-*` skills address gap-zero (*"what should I look for in weba- [ ] HackerOne MCP integration (currently only Burp MCP wired in)- [ ] Per-engagement memory layer — pattern recall across targets-- [ ] Industry-specific hunt skills — `hunt-fintech-graphql`, `hunt-healthcare-fhir`, `hunt-gov-compliance`+- [x] Industry-specific hunt skills — `hunt-fintech-graphql` shipped; `hunt-healthcare-fhir`, `hunt-gov-compliance` still open- [ ] Program-rules-parser skill — auto-generate structured `scope.md` from program text- [ ] Refresh `hunt-*` skills with newer disclosed reports (re-run `public-skills-builder`)- [ ] Additional enterprise-platform skills — `citrix-netscaler-deep`, `f5-bigip-attack`, `ad-cs-attack` (AD Certificate Services)@@ -300,7 +295,7 @@ Operational tradecraft accumulated across bug-bounty engagements and authorized**Sister project:** [Claude-OSINT](https://github.com/elementalsouls/Claude-OSINT) — paired skills for the recon phase that this bundle picks up after. Its two recon skills (`offensive-osint`, `osint-methodology`) are **canonically maintained here** and re-exported there, so the two are byte-identical. **Installing both is safe:** each bundle's installer (`install.sh` on macOS/Linux, `install.ps1` on Windows) records a manifest, the script skips re-copying an identical skill, and `--uninstall` keeps any skill the other bundle still owns — uninstalling one never breaks the other.-**Vendored foundation:** [shuvonsec/claude-bug-bounty](https://github.com/shuvonsec/claude-bug-bounty) — methodology, validation, reporting, payload library (8 of 82 skills + 15 slash commands)+**Vendored foundation:** [shuvonsec/claude-bug-bounty](https://github.com/shuvonsec/claude-bug-bounty) — methodology, validation, reporting, payload library (8 of 83 skills + 15 slash commands)**Generator tool used (not vendored):** [shuvonsec/public-skills-builder](https://github.com/shuvonsec/public-skills-builder) — used to scaffold per-class skills from H1 disclosed reportsdiff --git a/SECURITY.md b/SECURITY.mdindex 1b69302..295e1ff 100644--- a/SECURITY.md+++ b/SECURITY.md@@ -50,7 +50,7 @@ If you reach domain-admin-class objectives during an engagement, the bundle's ex## Verifying what you install (supply-chain trust)-You are installing 71 `SKILL.md` files plus shell and Python helpers into your AI agent's context. Agent Skills are third-party code — treat them like any dependency you run. Independent research (Snyk "ToxicSkills", 2026) found prompt injection in a meaningful fraction of public skills, so verification matters.+You are installing 83 `SKILL.md` files plus shell and Python helpers into your AI agent's context. Agent Skills are third-party code — treat them like any dependency you run. Independent research (Snyk "ToxicSkills", 2026) found prompt injection in a meaningful fraction of public skills, so verification matters.**What we do on our side:**diff --git a/USAGE.md b/USAGE.mdindex e0d81c3..d58af4b 100644--- a/USAGE.md+++ b/USAGE.md@@ -1,6 +1,6 @@# Claude-BugHunter — Usage Guide-A practical guide to using the 82-skill Claude-BugHunter bundle for bug hunting (bounty programs, authorized pentesting, CTFs, vuln research) **and external red-team engagements** against enterprise targets. This document covers what's in the bundle, how it composes, and how to use it on a real engagement from intake through paid bounty (or final client deliverable).+A practical guide to using the 83-skill Claude-BugHunter bundle for bug hunting (bounty programs, authorized pentesting, CTFs, vuln research) **and external red-team engagements** against enterprise targets. This document covers what's in the bundle, how it composes, and how to use it on a real engagement from intake through paid bounty (or final client deliverable).> Built and validated through authorized red-team and bug-bounty engagements — exposed four bug-bounty capability gaps and five additional gaps around platform attack chains, mid-engagement IR detection, and client-facing reporting. The final stack documented here addresses both modes.@@ -12,7 +12,7 @@ This section is for people who have **never used the bundle before, never used C### What is this bundle, in plain English?-It's a collection of 82 markdown files (called **skills**) that turn Claude Code into a methodical bug-hunting assistant.+It's a collection of 83 markdown files (called **skills**) that turn Claude Code into a methodical bug-hunting assistant.Without the bundle, asking Claude *"is this XSS?"* gets you a generic answer. With the bundle installed, the same question loads the `hunt-xss` skill — which contains specific detection patterns from 681+ disclosed reports, the exact payloads that have worked, and a validation gate that prevents you from filing a false-positive bug report.@@ -31,7 +31,7 @@ You don't "learn" the bundle. You install it once, then describe what you're tes- ❌ You don't need to know how to write exploits. The skills include working payloads.- ❌ You don't need to know Burp Suite. It's optional. Skills work with curl + browser.- ❌ You don't need a bug bounty account yet. You can practice on OWASP Juice Shop first.-- ❌ You don't need to read all 82 skills. They auto-load when relevant.+- ❌ You don't need to read all 83 skills. They auto-load when relevant.- ❌ You don't need Python beyond `python --version` working (run `python3 --version` on macOS/Linux).### Your first 30 minutes@@ -45,7 +45,7 @@ mkdir -p ~/security-research && cd ~/security-researchgit clone https://github.com/elementalsouls/Claude-BugHunter.gitcd Claude-BugHunter-# 2. Install (copies 82 skills + 15 commands into Claude Code)+# 2. Install (copies 83 skills + 15 commands into Claude Code)bash scripts/install.sh# 3. Reload your shell so the 'hunt' command becomes available@@ -63,7 +63,7 @@ cd "$HOME\security-research"git clone https://github.com/elementalsouls/Claude-BugHunter.gitcd Claude-BugHunter-# 2. Install (copies 82 skills + 15 commands into Claude Code)+# 2. Install (copies 83 skills + 15 commands into Claude Code)pwsh ./scripts/install.ps1# 3. Reload your profile so the 'hunt' command becomes available@@ -159,7 +159,7 @@ The stack maps to a 6-phase bug-bounty workflow. Each phase has its own skill se|---|---|---|| **1. Scope** | Reading program rules, deciding what's in/out, scaffolding the engagement folder | `bug-bounty`, `bb-methodology`, `osint-methodology` + `hunt <target>` shell command || **2. Recon** | Asset discovery, subdomain enum, endpoint mapping, secret hunting | `offensive-osint`, `web2-recon`, `bb-local-toolkit` |-| **3. Hunt** | Active testing for bugs in specific vuln classes | 24 `hunt-*` skills + 7 enterprise-platform skills (M365/Okta/cloud-IAM/vCenter/VPN/SharePoint/APK) + `security-arsenal` |+| **3. Hunt** | Active testing for bugs in specific vuln classes | 58 `hunt-*` skills + 7 enterprise-platform skills (M365/Okta/cloud-IAM/vCenter/VPN/SharePoint/APK) + `security-arsenal` || **4. Validate** | Decide whether a lead is actually a reportable bug | `triage-validation` (7-Question Gate) via `/triage` or `/validate` || **5. Capture** | PoC screenshots, HAR files, evidence redaction | `evidence-hygiene` || **6. Report** | Draft and submit | `report-writing`, `bugcrowd-reporting` |@@ -168,7 +168,7 @@ See [docs/architecture.md](docs/architecture.md) for a more detailed breakdown.----## 2. Skill inventory (82 skills total)+## 2. Skill inventory (83 skills total)### Workflow skills — the spine of any engagement@@ -186,7 +186,7 @@ See [docs/architecture.md](docs/architecture.md) for a more detailed breakdown.| `web2-recon` | Subdomain enumeration, host discovery, URL crawling | "find all subdomains of X" || `bb-local-toolkit` | Router for local cloned bug-bounty repos | "which tool for X", refers to local stack |-### Hunt — 57 per-class web skills+### Hunt — 58 per-class web skillsEach focuses on one vulnerability class with detection patterns, payloads, bypass tables, and chain opportunities drawn from disclosed bug-bounty reports.@@ -219,6 +219,7 @@ Each focuses on one vulnerability class with detection patterns, payloads, bypas| `hunt-sharepoint` | SharePoint on-prem (ToolShell chain, anon SOAP, SafeControl enum, FormDigest) || `hunt-ntlm-info` | NTLM Type-2 anonymous AD topology disclosure || `hunt-misc` | Catch-all for less-common classes |+| `hunt-fintech-graphql` | Money-movement GraphQL mutations, ledger IDOR, decimal-precision abuse, idempotency-key bypass |Plus `hunt-dispatch` — the meta-router that the `/hunt` slash command uses to pick Red Team vs WAPT mode and load the right skill set.@@ -397,7 +398,7 @@ Cross-reference this UUID in any chained submissions you file later.If another pentester wants to replicate this stack, the install steps are in [INSTALL.md](INSTALL.md). The short version:1. Clone this repo-2. Run the installer — `bash scripts/install.sh` (macOS/Linux) or `pwsh ./scripts/install.ps1` (Windows) — installs all 82 skills, 15 commands, and the `hunt` scaffold in one step+2. Run the installer — `bash scripts/install.sh` (macOS/Linux) or `pwsh ./scripts/install.ps1` (Windows) — installs all 83 skills, 15 commands, and the `hunt` scaffold in one step3. Set up Burp MCP (BApp Store extension + `claude mcp add burp ...`)4. (Optional) Refresh upstream snapshots via `./scripts/install-community-skills.sh` (macOS/Linux) or `pwsh ./scripts/install-community-skills.ps1` (Windows)5. (Optional) Set up the skill regenerator with Anthropic + H1 API keysdiff --git a/docs/architecture.md b/docs/architecture.mdindex 6234ad2..19cc82b 100644--- a/docs/architecture.md+++ b/docs/architecture.md@@ -4,15 +4,15 @@ The Claude-BugHunter bundle maps to a 6-phase workflow that supports both bug hu## Primary view — phase-by-phase architecture-82 skills mapped to 6 phases, with a 57-skill `hunt-*` sub-stack, an 8-skill enterprise-platform attack layer, integration layer, and usage decision tree. This is the main reference for "which skill do I use when?".+83 skills mapped to 6 phases, with a 58-skill `hunt-*` sub-stack, an 8-skill enterprise-platform attack layer, integration layer, and usage decision tree. This is the main reference for "which skill do I use when?".-The "Source" column in the per-phase tables below tags each skill: **`original`** = author's work in this repo, `community` = community-contributed (v3), `vendored` = from [shuvonsec/claude-bug-bounty](https://github.com/shuvonsec/claude-bug-bounty) (MIT). Of 82 skills: 54 original, 20 community (v3), 8 vendored.+The "Source" column in the per-phase tables below tags each skill: **`original`** = author's work in this repo, `community` = community-contributed (v3), `vendored` = from [shuvonsec/claude-bug-bounty](https://github.com/shuvonsec/claude-bug-bounty) (MIT). Of 83 skills: 55 original, 20 community (v3), 8 vendored.## Alternate view — 3-layer capability stack-The same 82 skills, regrouped by **role in an engagement** rather than by phase. Methodology + Recon (bottom) feeds the Hunt Arsenal (middle), which produces findings that flow up through Ship It (top) to a paid submission or client deliverable.+The same 83 skills, regrouped by **role in an engagement** rather than by phase. Methodology + Recon (bottom) feeds the Hunt Arsenal (middle), which produces findings that flow up through Ship It (top) to a paid submission or client deliverable.@@ -55,12 +55,12 @@ The 6-phase workflow expanded into a pipeline showing per-phase active skills, t| Skill | Source | Purpose ||---|---|---|-| **57 `hunt-*` skills** | original + community | Per vuln class / framework, curated from disclosed H1 reports + v3 community expansion — auto-trigger by topic |+| **58 `hunt-*` skills** | original + community | Per vuln class / framework, curated from disclosed H1 reports + v3 community expansion — auto-trigger by topic || `security-arsenal` | vendored | Payload library (XSS / SSRF / SQLi / SSTI / etc.) || `web3-audit` | vendored | Smart-contract audit (10 bug classes, Foundry PoC) || `meme-coin-audit` | vendored | Token rug-pull detection |-### Per-class hunt skills (57)+### Per-class hunt skills (58)```hunt-api-misconfig hunt-mfa-bypass@@ -93,7 +93,7 @@ hunt-jwt-crypto hunt-forgot-passwordhunt-shadow-api hunt-exceptional-conditionshunt-spa-api hunt-captcha-bypasshunt-rag-vector hunt-clickjacking-hunt-html-injection+hunt-html-injection hunt-fintech-graphql```Plus alternates: `hunt-cache-poison`, `hunt-race-condition`, `hunt-subdomain`. Plus the meta-router `hunt-dispatch` (used internally by the `/hunt` slash command — not user-invoked).diff --git a/docs/credits.md b/docs/credits.mdindex 8c6b874..2192175 100644--- a/docs/credits.md+++ b/docs/credits.md@@ -10,11 +10,11 @@ This is a **bundle**: skills and commands are vendored directly into `skills/` a| Category | Count | Source ||---|---|---|-| **Original / personally-curated skills** | 54 | This repo |+| **Original / personally-curated skills** | 55 | This repo || Community-contributed skills (v3) | 20 | community PRs (e.g. #7) || Vendored foundation skills | 8 | shuvonsec/claude-bug-bounty (MIT) || Vendored slash commands | 12 | shuvonsec/claude-bug-bounty (MIT) |-| **Total** | 82 skills + 15 commands | |+| **Total** | 83 skills + 15 commands | |---@@ -79,7 +79,7 @@ Built from authorized red-team engagements (enterprise targets including on-prem### Tooling and docs- **`hunt <target>` command** — Engagement-folder scaffolding: creates `~/Targets/<name>/` with `CLAUDE.md`, `scope.md`, `findings/`, `evidence/`, `submissions.txt`, `notes.md`, and a sensible `.gitignore` for engagement artifacts. Ships as `scripts/hunt.sh` (bash) and `scripts/hunt.ps1` (PowerShell).-- **Bundle packaging** — Single-step installer that copies all 82 skills, 15 commands, and the hunt scaffold into `~/.claude/`: `scripts/install.sh` (macOS/Linux) and `scripts/install.ps1` (Windows/PowerShell).+- **Bundle packaging** — Single-step installer that copies all 83 skills, 15 commands, and the hunt scaffold into `~/.claude/`: `scripts/install.sh` (macOS/Linux) and `scripts/install.ps1` (Windows/PowerShell).- **Autopilot ledger (`engine/memory.py`) + the `/remember`, `/memory-gc`, `/pickup` commands** — Original design and implementation (cross-engagement capture + skip-decision for the engine hunt loop). Not derived from any external memory implementation.- **`assets/banner-v2.svg`** — Hand-coded SVG banner.- **Documentation** — `README.md`, `INSTALL.md`, `USAGE.md`, `CONTRIBUTING.md`, `docs/architecture.md`, this credits file.diff --git a/docs/index.md b/docs/index.mdindex 8867eff..a3b760c 100644--- a/docs/index.md+++ b/docs/index.md@@ -22,7 +22,7 @@ platform CVE chains, and the hygiene, and it stays in scope.## What you get-- **82 skills** across recon, 57 web-app vuln-class + framework skills, enterprise+- **83 skills** across recon, 58 web-app vuln-class + framework skills, enterpriseplatform attack, red-team tradecraft, and reporting — all **auto-loading by topic**,no invocation by name.- **681 disclosed-report patterns** curated from public HackerOne reports.diff --git a/docs/multi-harness.md b/docs/multi-harness.mdindex b9839c4..939f145 100644--- a/docs/multi-harness.md+++ b/docs/multi-harness.md@@ -6,9 +6,9 @@ description: Run the Claude-BugHunter skills on OpenCode, Codex, and Hermes Agen# Multi-harness install-The 82 skills are plain **Agent Skills** (`SKILL.md` = `name` + `description` frontmatter + Markdown). That format is an open standard, so the *knowledge* runs on more than Claude Code. This page shows how to install it on **OpenCode**, **OpenAI Codex CLI**, and **Hermes Agent**.+The 83 skills are plain **Agent Skills** (`SKILL.md` = `name` + `description` frontmatter + Markdown). That format is an open standard, so the *knowledge* runs on more than Claude Code. This page shows how to install it on **OpenCode**, **OpenAI Codex CLI**, and **Hermes Agent**.-> **What ports and what doesn't.** The **82 skills** (payloads, methodology, bypass tables, disclosed-report patterns) port to every harness below. The **`/hunt` slash commands, the plugin marketplace, and the `hunt-dispatch` subagent routing are Claude-Code-specific** and do **not** port — other harnesses get the knowledge, not the orchestration engine. **Burp MCP** ports to all of them (it's just an MCP server).+> **What ports and what doesn't.** The **83 skills** (payloads, methodology, bypass tables, disclosed-report patterns) port to every harness below. The **`/hunt` slash commands, the plugin marketplace, and the `hunt-dispatch` subagent routing are Claude-Code-specific** and do **not** port — other harnesses get the knowledge, not the orchestration engine. **Burp MCP** ports to all of them (it's just an MCP server).## Compatibility matrix (verified mid-2026)@@ -56,7 +56,7 @@ pwsh ./scripts/install.ps1 -Hermes # + Hermes Agent (~/.hermes/skills)```- **OpenCode** already reads `~/.claude/skills/`, so the plain installer (no flags) is enough for OpenCode — you don't need `--agents`/`-Agents` for it. That flag exists mainly for **Codex** (which reads only `~/.agents/skills/`).- - *Caveat (verified):* OpenCode reads **both** `~/.claude/skills/` and `~/.agents/skills/`. If both are populated (e.g. you ran `--all`/`-All` for Codex too), OpenCode logs harmless `duplicate skill name` warnings and loads one copy — all 82 skills still work. Only populate `~/.agents/skills/` if you actually use Codex.+ - *Caveat (verified):* OpenCode reads **both** `~/.claude/skills/` and `~/.agents/skills/`. If both are populated (e.g. you ran `--all`/`-All` for Codex too), OpenCode logs harmless `duplicate skill name` warnings and loads one copy — all 83 skills still work. Only populate `~/.agents/skills/` if you actually use Codex.- **Codex is the strict parser** (verified by testing): it hard-rejects descriptions > 1024 chars and invalid YAML, where Claude/OpenCode/Hermes are lenient. So the installer **auto-truncates** any description > 1024 to ≤1024 **only in the `~/.agents/skills` (Codex) copy** — your `~/.claude` and `~/.hermes` copies keep the full descriptions (incl. non-English trigger words). The install logs which were truncated (today: the 3 aggregator router skills). `--normalize-frontmatter` (`-NormalizeFrontmatter`) additionally strips the non-standard `sources:`/`report_count:` keys (optional — Codex tolerates them).## Burp MCP on other harnessesdiff --git a/docs/skills.md b/docs/skills.mdindex c1306a3..61a0dc9 100644--- a/docs/skills.md+++ b/docs/skills.md@@ -6,11 +6,11 @@ description: Searchable index of every skill in the bundle.# Skill catalog-All **82 skills** in the bundle, grouped by domain. Each auto-loads when your prompt matches its trigger keywords — no need to invoke by name. Use your browser's find (⌘/Ctrl-F) or the docs search box.+All **83 skills** in the bundle, grouped by domain. Each auto-loads when your prompt matches its trigger keywords — no need to invoke by name. Use your browser's find (⌘/Ctrl-F) or the docs search box.> Generated by `scripts/gen_skill_catalog.py` — do not edit by hand.-## Hunt — web app vuln classes (57)+## Hunt — web app vuln classes (58)| Skill | What it does | Reports ||---|---|---|@@ -32,6 +32,7 @@ All **82 skills** in the bundle, grouped by domain. Each auto-loads when your pr| `hunt-dom` | Hunt client-side DOM vulnerabilities — DOM Clobbering (overwrite JS globals via HTML injection), PostMessage hijacking (missing origin check), Service Worker abuse (intercept requests from same-origin script), CSS Injection/Exfiltration… | 17 || `hunt-exceptional-conditions` | Hunt mishandling of exceptional conditions — feed an endpoint malformed/unexpected input (wrong type, broken JSON, oversized field, null byte) and make it fail OPEN or leak internals: a verbose stack-trace / framework error page that… | — || `hunt-file-upload` | Hunt file upload bugs — RCE via webshell, XSS via SVG/HTML, SSRF via XXE in DOCX, path traversal via filename. | — |+| `hunt-fintech-graphql` | Hunt fintech-specific GraphQL vulnerabilities: money-movement mutations (transfers, redemptions, withdrawals, card top-ups), ledger/balance/portfolio query IDOR, decimal-precision and rounding abuse, idempotency-key bypass enabling… | 0 || `hunt-forgot-password` | Hunt Forgot Password / Account Recovery Authentication Flaws — 5 distinct patterns: (1) username enumeration via different responses for valid vs invalid email, (2) reset token exposed directly in the API response body, (3) reset token not… | — || `hunt-graphql` | Hunting skill for graphql vulnerabilities. | 12 || `hunt-grpc` | Hunt gRPC vulnerabilities — server reflection enabled (enumerate all services/methods), missing authentication / metadata-stripping on internal endpoints, plaintext gRPC over HTTP/2, internal endpoint disclosure, proto file leakage,… | 6 |diff --git a/scripts/check_doc_counts.py b/scripts/check_doc_counts.pynew file mode 100644index 0000000..c1c606c--- /dev/null+++ b/scripts/check_doc_counts.py@@ -0,0 +1,146 @@+#!/usr/bin/env python3+"""+check_doc_counts.py — verify skill/command counts in docs match what's on disk.++The bundle's skill/command counts have grown several times (skills: 51 -> 71 ->+82; hunt-* skills: 24 -> 48 -> 57) and each time, at least one doc's hardcoded+number didn't get updated along with the rest (see the 71/48/24 stale-count+fixes). This script computes the real counts from skills/ and commands/ on+disk, then checks every doc location that asserts one of those numbers in+prose, plus two places where a count is derived by summing a table/section+breakdown.++It deliberately does NOT try to reconcile every document's bespoke+sub-categorization (e.g. docs/architecture.md's narrower "enterprise-platform"+grouping vs. docs/skills.md's generated one) — only the three ground-truth+totals: all skills, hunt-* skills, and slash commands.++If a doc's wording changes, update CHECKS to match — a "pattern not found"+error is a prompt to update this script, not necessarily a doc bug.++Exit code 0 = all counts match, 1 = at least one mismatch.+Stdlib only — no pip install needed in CI.++Usage:+ python3 scripts/check_doc_counts.py+"""+import os+import re+import sys++REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))+SKILLS_DIR = os.path.join(REPO, "skills")+COMMANDS_DIR = os.path.join(REPO, "commands")+++def count_skills():+ total = 0+ hunt = 0+ for d in sorted(os.listdir(SKILLS_DIR)):+ if os.path.isfile(os.path.join(SKILLS_DIR, d, "SKILL.md")):+ total += 1+ if d.startswith("hunt-"):+ hunt += 1+ return total, hunt+++def count_commands():+ return len([f for f in os.listdir(COMMANDS_DIR) if f.endswith(".md")])+++def read(path):+ with open(os.path.join(REPO, path), encoding="utf-8") as fh:+ return fh.read()+++# (file, regex with one capture group per checked number, key or tuple of keys+# into the `actual` dict, human label for error messages)+CHECKS = [+ ("README.md", r"\*\*(\d+) skills\*\* · 15 slash commands", "total", "hero line skill count"),+ ("README.md", r"skills\*\* · (\d+) slash commands ·", "commands", "hero line command count"),+ ("README.md", r"\| (\d+) skills \+ (\d+) slash commands \|", ("total", "commands"), "install-path comparison table"),+ ("README.md", r"\*\*(\d+) skills\*\*, auto-loaded", "total", "'What's inside' intro"),+ ("README.md", r"(\d+) `hunt-\*` skills curated from", "hunt", "'Hunt webapps' bullet"),+ ("README.md", r"Also ships \*\*(\d+) slash commands\*\*", "commands", "documentation table footer"),+ ("README.md", r"\(8 of (\d+) skills \+ (\d+) slash commands\)", ("total", "commands"), "vendored-foundation credit"),+ ("SECURITY.md", r"installing (\d+) `SKILL\.md` files", "total", "supply-chain-trust intro"),+ ("USAGE.md", r"the (\d+)-skill Claude-BugHunter bundle", "total", "doc intro"),+ ("USAGE.md", r"copies (\d+) skills \+ (\d+) commands into Claude Code", ("total", "commands"), "quickstart code block"),+ ("USAGE.md", r"(\d+) `hunt-\*` skills \+ \d+ enterprise-platform skills", "hunt", "phase-3 architecture table row"),+ ("USAGE.md", r"### Hunt — (\d+) per-class web skills", "hunt", "skill-inventory section header"),+ ("USAGE.md", r"installs all (\d+) skills, (\d+) commands", ("total", "commands"), "setup-for-someone-new summary"),+ ("INSTALL.md", r"All (\d+) skills →", "total", "what-gets-installed list"),+ ("docs/skills.md", r"All \*\*(\d+) skills\*\* in the bundle", "total", "catalog intro"),+ ("docs/skills.md", r"## Hunt — web app vuln classes \((\d+)\)", "hunt", "catalog Hunt section header"),+ ("docs/credits.md", r"\| \*\*Total\*\* \| (\d+) skills \+ (\d+) commands \|", ("total", "commands"), "credits breakdown total row"),+ ("docs/architecture.md", r"(\d+) skills mapped to 6 phases", "total", "doc intro"),+ ("docs/architecture.md", r"a (\d+)-skill `hunt-\*` sub-stack", "hunt", "doc intro"),+ ("docs/architecture.md", r"Of (\d+) skills: \d+ original", "total", "source-breakdown sentence"),+ ("docs/architecture.md", r"\*\*(\d+) `hunt-\*` skills\*\* \| original \+ community", "hunt", "phase-3 detail table"),+]+++def check_assertions(actual):+ errors = []+ for file, pattern, key, label in CHECKS:+ text = read(file)+ m = re.search(pattern, text)+ if not m:+ errors.append(+ f"{file}: pattern not found for '{label}' ({pattern}) — "+ f"doc wording changed, update scripts/check_doc_counts.py"+ )+ continue+ keys = key if isinstance(key, tuple) else (key,)+ for i, k in enumerate(keys):+ got = int(m.group(i + 1))+ want = actual[k]+ if got != want:+ errors.append(f"{file}: '{label}' says {got} but actual {k} count is {want}")+ return errors+++def check_readme_table_sum(errors, actual):+ """README's 'What's inside' category table must sum to the total skill count."""+ text = read("README.md")+ m = re.search(r"\| Category \| # \| Examples \|\n\|[-| ]+\n((?:\|.*\n)+)", text)+ if not m:+ errors.append("README.md: could not locate 'What's inside' category table to sum")+ return+ total = 0+ for row in m.group(1).strip("\n").split("\n"):+ cells = [c.strip() for c in row.strip("|").split("|")]+ if len(cells) >= 2 and cells[1].isdigit():+ total += int(cells[1])+ if total != actual["total"]:+ errors.append(f"README.md: 'What's inside' category table sums to {total}, actual total is {actual['total']}")+++def check_catalog_section_sum(errors, actual):+ """docs/skills.md's generated section headers ('## Name (N)') must sum to the total."""+ text = read("docs/skills.md")+ counts = [int(n) for n in re.findall(r"^## .+\((\d+)\)\s*$", text, re.MULTILINE)]+ total = sum(counts)+ if total != actual["total"]:+ errors.append(f"docs/skills.md: section headers sum to {total}, actual total is {actual['total']}")+++def main():+ total, hunt = count_skills()+ commands = count_commands()+ actual = {"total": total, "hunt": hunt, "commands": commands}++ errors = check_assertions(actual)+ check_readme_table_sum(errors, actual)+ check_catalog_section_sum(errors, actual)++ for e in errors:+ print(f"::error:: {e}" if os.environ.get("GITHUB_ACTIONS") else f"ERROR {e}")++ print(f"\nGround truth: {total} skills ({hunt} hunt-*), {commands} slash commands.")+ print(f"Checked {len(CHECKS)} doc assertions + 2 structural sums: {len(errors)} error(s).")+ return 1 if errors else 0+++if __name__ == "__main__":+ sys.exit(main())diff --git a/skills/hunt-fintech-graphql/SKILL.md b/skills/hunt-fintech-graphql/SKILL.mdnew file mode 100644index 0000000..23a1cbc--- /dev/null+++ b/skills/hunt-fintech-graphql/SKILL.md@@ -0,0 +1,245 @@+---+name: hunt-fintech-graphql+description: "Hunt fintech-specific GraphQL vulnerabilities: money-movement mutations (transfers, redemptions, withdrawals, card top-ups), ledger/balance/portfolio query IDOR, decimal-precision and rounding abuse, idempotency-key bypass enabling double-spend, KYC/PII field-level authorization gaps, and admin-override mutations reachable via mass assignment. Distinct from hunt-graphql, which owns generic GraphQL discovery and IDOR/mutation methodology — this skill owns the delta introduced when a GraphQL layer sits in front of a ledger, wallet, payments, banking, brokerage, or lending backend, where a resolver bug moves real money instead of just leaking data. Use when hunting a fintech, banking, payments, wallet, neobank, brokerage, or lending target that exposes a GraphQL API, or when a schema/response includes balance, transfer, ledger, redeem, quote, KYC, or account-linking fields."+sources: owasp_api_top10_2023, public_research+report_count: 0+---++## Why Fintech GraphQL Is a Different Risk Class++Generic GraphQL bugs (IDOR, mass assignment, introspection, batching abuse — see `hunt-graphql`)+still apply here, but the blast radius changes completely: a resolver bug in a SaaS app leaks+data, the same class of bug in a ledger mutation **moves money**. Three properties make fintech+GraphQL backends a distinct hunting surface:++- **Money-movement mutations are almost always resolvers over a double-entry ledger.** A single+ GraphQL mutation (`transferFunds`, `redeemRewards`, `withdrawToBank`) can trigger multiple+ ledger writes (debit + credit + fee) that must be atomic. GraphQL's flexible input shape and+ alias batching make it easy to desynchronize those writes.+- **Decimals are attacker-controlled input, not display formatting.** Amounts, exchange rates,+ interest, and rewards points are usually passed as GraphQL scalars (`Float`, `String`, custom+ `Decimal`/`Money` scalar). How the resolver parses and rounds that value is exploitable surface+ in its own right — this barely exists in non-financial GraphQL APIs.+- **KYC/PII fields sit next to routine account fields in the same type.** `User` or `Account`+ types commonly expose `ssnLast4`, `routingNumber`, `kycStatus`, `governmentIdUrl`, or+ `linkedBankAccount` alongside `displayName` and `email` — one missing field-level authorization+ check on a type used everywhere in the schema fans out to every query that touches it.++---++## Attack Surface Signals++**URL / schema naming patterns (in addition to `hunt-graphql`'s generic `/graphql` list):**+```+/graphql/ledger+/graphql/payments+/api/wallet/graphql+/internal/ledger-graphql+/banking/graphql+```++**Field/type names worth grepping schema introspection or JS bundles for:**+```+balance, availableBalance, pendingBalance, ledgerEntry, ledgerEntries+transferFunds, withdraw, redeem, topUp, reverseTransaction, adjustBalance+kycStatus, ssnLast4, routingNumber, accountNumber, governmentIdUrl+quoteExchangeRate, interestAccrued, rewardsPoints, portfolioValue+idempotencyKey, clientMutationId+```++**Tech-stack tells specific to this vertical:**+- Plaid/Stripe/Dwolla/Marqeta wrapped behind an internal GraphQL gateway (`bankLink`, `plaidLinkToken` mutations)+- Apollo Federation with a dedicated `ledger` or `payments` subgraph — check for the subgraph's own introspection being reachable directly, bypassing the gateway's stitched-down schema+- Custom `Money`/`Decimal`/`BigDecimal` GraphQL scalar in the schema (`scalar Money`) — the parser for this scalar is worth fuzzing directly++Run `hunt-graphql`'s discovery + introspection methodology first to get the schema; everything+below assumes you already have (or have partially enumerated) a schema with money-movement types.++---++## Step-by-Step Hunting Methodology++1. **Map every mutation that touches balance, whether directly or as a side effect.** Not just+ `transfer*`/`withdraw*` — also `redeemRewards`, `applyCoupon`, `upgradeTier`,+ `closeAccount` (often refunds a balance), `disputeTransaction` (often provisionally credits).++2. **For each money-movement mutation, identify the ledger write shape.** Does one mutation call+ produce one ledger entry or several (debit sender, credit receiver, fee entry)? Multi-entry+ writes are the ones worth racing — see Stage 4.++3. **Test idempotency-key handling.** Send the identical mutation (same `idempotencyKey` /+ `clientMutationId`) twice, back-to-back and with a delay. A ledger write on the second call+ means idempotency isn't enforced server-side — replay = double-execute.++4. **Test decimal/precision edge cases** on every amount-accepting argument — see Payload section.+ Confirm server-side rounding matches client-displayed rounding; a mismatch is directly+ monetizable.++5. **Probe cross-account IDOR on account/portfolio node IDs**, same as `hunt-idor`/`hunt-graphql`,+ but specifically test whether a `transferFunds`-style mutation validates that the+ **source account belongs to the authenticated caller** — not just that *some* account with+ that ID exists. This is the fintech-specific IDOR: authz on the *source* of a debit is easy to+ forget when authz on the *destination* of a credit was correctly implemented (crediting an+ arbitrary account "looks safe" to a developer; debiting one clearly isn't, so it gets checked+ — but sometimes only one direction does).++6. **Check field-level authorization on KYC/PII fields** by querying the shared `User`/`Account`+ type from every context that returns it — not just the profile screen. A `transaction` type+ that embeds `counterparty { ssnLast4 }` is a common place for the check to be missing, because+ the developer authorized the top-level `transaction` query but didn't re-check field access on+ the nested `counterparty`.++7. **Look for admin-tier mutations reachable via mass assignment**, not just a missing auth+ check — e.g. an input object with a client-settable `status` or `override` field that a normal+ user's mutation shouldn't expose but that the resolver accepts anyway+ (`updateTransaction(input: {id, status: "COMPLETED", amount: "..."})`).++8. **Test currency-argument consistency.** Send a transfer/quote mutation with mismatched+ `sourceCurrency`/`targetCurrency` combinations the UI never generates (e.g. self-transfer with+ a currency conversion) and check whether the resolver's FX-rate lookup and the ledger write use+ the same rate — a TOCTOU window here is a direct arbitrage bug.++9. **Combine alias batching with money-movement mutations** to test for double-spend — see+ `hunt-race-condition` for the parallel-HTTP escalation once alias batching alone confirms the+ resolver isn't serializing writes per-account.++---++## Payload & Detection Patterns++**Idempotency-key replay test:**+```graphql+mutation {+ transferFunds(input: {+ idempotencyKey: "test-key-001"+ sourceAccountId: "acc_1"+ destAccountId: "acc_2"+ amount: "10.00"+ }) { transactionId status }+}+```+Send twice with the identical `idempotencyKey`. Two successful, distinct `transactionId` values+= idempotency not enforced.++**Decimal-precision / rounding probes:**+```graphql+mutation { transferFunds(input: {sourceAccountId:"acc_1", destAccountId:"acc_2", amount: "0.001"}) { transactionId } }+mutation { transferFunds(input: {sourceAccountId:"acc_1", destAccountId:"acc_2", amount: "9999999999999999.99"}) { transactionId } }+mutation { transferFunds(input: {sourceAccountId:"acc_1", destAccountId:"acc_2", amount: "1e2"}) { transactionId } }+mutation { transferFunds(input: {sourceAccountId:"acc_1", destAccountId:"acc_2", amount: "-50.00"}) { transactionId } }+```+Sub-cent amounts test truncate-vs-round handling (repeat N times to accumulate a rounding-error+balance drift); scientific notation and oversized values test whether the `Money`/`Decimal`+scalar parser falls back to a native float/int with overflow or precision-loss behavior; negative+amounts test whether the resolver assumes sign server-side or trusts the client's.++**Alias-batched double-spend probe (confirm before escalating to parallel HTTP):**+```graphql+mutation {+ r1: redeemRewards(input: {rewardId: "rwd_1", accountId: "acc_1"}) { success }+ r2: redeemRewards(input: {rewardId: "rwd_1", accountId: "acc_1"}) { success }+ r3: redeemRewards(input: {rewardId: "rwd_1", accountId: "acc_1"}) { success }+}+```+If more than one alias succeeds against a single-use reward/coupon, the resolver doesn't+serialize per-account/per-resource writes within a batched request — see `hunt-race-condition`+for combining this with parallel HTTP POSTs to confirm real double-spend impact.++**Source-account authorization probe (asymmetric IDOR check):**+```graphql+mutation {+ transferFunds(input: {+ sourceAccountId: "VICTIM_ACCOUNT_ID"+ destAccountId: "ATTACKER_CONTROLLED_ACCOUNT_ID"+ amount: "1.00"+ }) { transactionId status }+}+```+Run as the attacker's own session/token. Success = the resolver validated the destination is+attacker-controlled (obviously required) but never validated that the source belongs to the+caller.++**Nested field-level PII probe:**+```graphql+query {+ transaction(id: "txn_123") {+ amount+ counterparty { displayName ssnLast4 routingNumber kycStatus }+ }+}+```+Query as a user with no relationship to the counterparty beyond a shared transaction; success on+the nested PII fields is the finding even if the top-level `transaction` query correctly scoped+the transaction itself.++**Mass-assignment probe on admin-shaped input fields:**+```graphql+mutation {+ updateTransaction(input: {id: "txn_123", status: "COMPLETED", amount: "0.01"}) { id status }+}+```+Send as a non-admin user against a mutation the client UI never exposes these fields for; a+schema that accepts them anyway is mass assignment onto ledger state.++---++## Common Root Causes++1. **Client-side amount/fee validation only.** The UI computes and displays the correct amount;+ the resolver trusts whatever the GraphQL client actually sends, because "the app always sends+ the right value."+2. **Non-atomic multi-entry ledger writes.** Debit, credit, and fee entries are written as+ separate sequential statements instead of inside a single transaction/lock — the race window+ this creates is exactly what alias batching + parallel HTTP exploits.+3. **`Money`/`Decimal` scalar falls back to native float parsing** under edge-case input+ (scientific notation, oversized strings), reintroducing floating-point rounding error into a+ system that was supposed to guarantee fixed-point precision.+4. **Idempotency keys are stored but never checked before executing the write** — the key is+ logged for support/debugging purposes, not used as a dedup gate.+5. **Field-level authorization implemented per top-level query, not per type.** A `User`/`Account`+ type's sensitive fields are protected when queried directly (`me { ssnLast4 }`) but not when+ the same type is returned nested inside an unrelated query (`transaction { counterparty {...} }`).+6. **Source-account ownership check missing while destination-account existence check is+ present** — see methodology step 5. Debiting looks dangerous so it gets reviewed; the "does+ this account belong to the caller" check quietly only gets applied to the credited side.+7. **Admin/internal mutations reuse the same input type as the public mutation**, just with extra+ optional fields — nothing at the resolver layer strips those fields for non-admin callers.++---++## Gate 0 Validation++Money-movement findings need a stricter bar than a typical GraphQL IDOR — "the query returns+someone else's balance" is real impact; "I sent a malformed amount and got a 400" is not.++1. **Did an actual ledger write occur, and can you show it?** Query the account balance before+ and after — a state change (not just a `200`/success response body) is the proof.+2. **Is the win deterministic, not a timing fluke?** For race/double-spend findings, reproduce+ twice from a clean state. If it only works under specific load conditions, document the window+ honestly rather than claiming guaranteed exploitability.+3. **Does the finding move value the attacker didn't have, or reveal data they shouldn't see** —+ not just "the mutation accepted an unexpected input type and the API returned an error+ message." A verbose GraphQL error leaking a stack trace on a malformed `Money` scalar is a+ `hunt-source-leak`-class finding, not a fintech-logic one — don't conflate the two in a report.++---++## Related Skills & Chains++- **`hunt-graphql`** — parent skill for generic GraphQL discovery, introspection bypass, node-ID+ IDOR, and alias-batching mechanics. Load this skill first; `hunt-fintech-graphql` assumes that+ methodology and only adds the money-movement-specific delta.+- **`hunt-business-logic`** — coupon/reward double-redemption and other logic-flaw patterns+ generalize directly to `redeemRewards`/`applyCoupon`-style mutations here.+- **`hunt-race-condition`** — the escalation path once alias batching alone confirms a+ money-movement mutation doesn't serialize writes: combine with parallel-HTTP / single-packet+ attack for a deterministic double-spend PoC.+- **`hunt-api-misconfig`** — mass assignment and JWT-claim tampering patterns apply directly to+ admin-shaped GraphQL input objects reachable by normal users.+- **`hunt-idor`** — the source-account-vs-destination-account asymmetric authz pattern (step 5) is+ a fintech-specific instance of the general IDOR-on-mutation-argument class.+- **`evidence-hygiene`** — balance screenshots and ledger-entry PoCs need the same cookie/PII+ redaction discipline as any other capture, plus care that a real account number/balance from a+ live financial account is never included verbatim.+- **`triage-validation`** — apply Gate 0 above before drafting; a fintech program's triage team+ will kill anything without a demonstrated ledger state change immediately.