Pentest

Synthesis skill for authorized offensive-security engagements. Produces scope-gated plans, checklists, and structured findings — never vendored C2, webshells, or autonomous exploit execution.

Scope: Pre-authorized penetration testing methodology and reporting. NOT for unauthorized testing, malware/C2 operations, static pre-deploy audits (security-scanner), or synthetic CTF-only puzzles (ctf-*).

Canonical Vocabulary

Term	Definition
ROE	Rules of Engagement — signed authorization document defining targets, dates, contacts, and prohibited actions
scope gate	Mandatory `scope_check.py` pass before any recon, web, API, or OSINT offensive planning
target	Host, URL, CIDR, or application explicitly listed in the signed ROE
phase	Engagement stage from `scripts/phases.py` — each requires an active scope gate
triage	Route a signal to canonical playbook + optional external skill via `methodology-router.md`
external index	Planning lock `pentest-external-skill-index.json` via manifest + `lookup_external_slug.py`
finding	Structured JSON record of a suspected issue with severity, evidence, and remediation guidance
playbook	Checklist-driven methodology loaded from `references/playbooks/` — planning only
synthesis	Agent-authored plan/checklist/report assembled from references and operator context
external runner	Optional third-party CLI (e.g. Strix) the operator runs manually — this skill does not install or invoke attacks
fail-closed	Deny all offensive planning when scope is missing, expired, or target-out-of-scope

Tier Boundaries

Tier	Skill	When to use	ROE required	Executes attacks
Static audit	security-scanner	Pre-deployment SAST, secrets, deps, compliance heuristics	No	No — read-only code scan
Authorized pentest	pentest (this skill)	Live apps/APIs under signed engagement	Yes	No — planning/checklists only; operator runs approved tools
CTF / lab	ctf-*	Isolated challenge boxes, training flags, synthetic vuln labs	No (lab policy instead)	Only inside designated lab scope

Redirect rules:

"Scan my repo for secrets/CVEs before merge" → security-scanner
"Hack this site without permission" → refuse — no ROE, no planning
"Solve this HTB/CTF box" → ctf-* skills — not production pentest
"We have signed ROE for staging.example.com" → pentest after scope gate

Scope Gate (Mandatory)

Before recon, web, api, osint, or any extended phase mode (

network

cloud

mobile

wireless

llm

internal

binary

blockchain

post-exploit

Obtain
```
--target
```
,
```
--roe-file
```
, and the requested
```
--phase
```
from the operator.
Run:

bash

uv run python scripts/scope_check.py \
  --target "<host-or-url>" \
  --roe-file "<path-to-roe.json>" \
  --phase "<mode>"

Parse JSON stdout. If
```
ok
```
is false or exit code is non-zero → stop. Present
```
deny_reason
```
and load
```
references/scope-and-roe.md
```
for remediation.
Record
```
engagement_id
```
,
```
phase
```
, and
```
allowed_phases
```
from the scope result in session notes.
Never proceed to playbooks, external runners, or attack-sounding commands without a passing scope gate in the current session.

Empty or partial scope requests (target without ROE, ROE without target, expired ROE, out-of-scope host) are denied fail-closed.

Dispatch

$ARGUMENTS	Mode	Action
`doctor`	doctor	Run `scripts/doctor.py` — skill asset and policy readiness
`scope <target>`	scope	Run `scripts/scope_check.py` with `--roe-file` , `--target` , and `--phase` ; echo `restricted_phases` when ROE-gated
`triage <signal>`	triage	Load `references/methodology-router.md` ; map signal → playbook + external slug
`recon <target>`	recon	Scope gate → `references/playbooks/recon.md`
`web <target>`	web	Scope gate → `references/playbooks/web.md` (+ injection/auth playbooks as needed)
`api <target>`	api	Scope gate → `references/playbooks/api.md`
`osint <target>`	osint	Scope gate → `references/playbooks/osint.md` (passive only per ROE)
`network <target>`	network	Scope gate → `references/playbooks/network.md`
`cloud <target>`	cloud	Scope gate → `references/playbooks/cloud.md`
`mobile <target>`	mobile	Scope gate → `references/playbooks/mobile.md`
`wireless <target>`	wireless	Scope gate → `references/playbooks/wireless.md` (explicit ROE)
`llm <target>`	llm	Scope gate → `references/playbooks/llm.md`
`internal <target>`	internal	Scope gate → `references/playbooks/internal.md`
`binary <target>`	binary	Scope gate → `references/playbooks/binary.md`
`blockchain <target>`	blockchain	Scope gate → `references/playbooks/blockchain.md`
`post-exploit <target>`	post-exploit	Scope gate → `references/playbooks/post-exploit.md` (explicit ROE only)
`validate`	validate	Run `scripts/check.py` ; verify findings JSON against schema
`report`	report	Aggregate session findings via `scripts/findings_emit.py` patterns
`help` or (empty)	help	Show modes, scope gate, tier boundaries, reference index
Unrecognized	—	Ask for clarification; do not assume authorization

Mode: doctor

Read-only environment and policy checks. No offensive actions.

Run:

uv run python scripts/doctor.py --format json

When the skill is globally installed, set
```
WAGENTS_REPO_ROOT
```
to the agents clone so
```
repo-root
```
and lock-index checks can resolve
```
planning/research-lock/
```
.
Present checks grouped by
```
ok
```
,
```
warn
```
,
```
fail
```
.
If
```
forbidden-tooling
```
is
```
fail
```
, stop — engagement cannot use this skill until operator removes C2/webshell references from the request.
Load
```
references/external-runners.md
```
only when operator asks about optional CLIs.

Mode: scope

Validate authorization before any other offensive mode.

Require
```
--target
```
,
```
--roe-file
```
, and
```
--phase
```
. If any are missing, run
```
scope_check.py
```
without them to produce the deny JSON and explain required fields.

On pass: summarize

engagement_id

phase

allowed_phases

restricted_phases

expires_at

, and in-scope target match.

On deny: cite
```
deny_reason
```
; do not load playbooks.

Mode: triage

Route methodology depth without loading all upstream repos.

Parse signal from
```
$ARGUMENTS
```
(e.g.
```
sqli
```
,
```
xss
```
,
```
kerberos
```
,
```
llm-injection
```
).
Load
```
references/methodology-router.md
```
— resolve canonical slug from dedup table.
Load matching
```
references/playbooks/*.md
```
section (one file at a time).
Surface
```
install_command
```
via
```
scripts/lookup_external_slug.py
```
only when operator requests deeper upstream body.
Quarantine: EXT-084 entries are inspect-only — never auto-install.

Mode: recon

Post-authorization attack-surface planning only.

Pass scope gate (see Scope Gate).
Confirm
```
recon
```
is in
```
allowed_phases
```
from scope result.

Load

references/playbooks/recon.md

(and

references/osint.md

when passive).

Produce a phased plan: asset inventory hypotheses, DNS/WHOIS/certificate angles, technology fingerprinting commands the operator may run — do not run them from this skill's scripts.
Emit planned checkpoints as draft findings only after operator supplies evidence.

Mode: web

Web application testing planning only.

Pass scope gate; confirm
```
web
```
in
```
allowed_phases
```
.
Load
```
references/playbooks/web.md
```
one section at a time.
Build a prioritized test checklist mapped to OWASP categories — no exploit payloads executed by skill scripts.
For each confirmed issue the operator reports, emit via
```
findings_emit.py
```
(pass
```
--scope-json
```
from the current scope gate result when binding findings to engagement).

Mode: api

API security testing planning only.

Pass scope gate; confirm
```
api
```
in
```
allowed_phases
```
.
Load
```
references/playbooks/api.md
```
.
Produce authn/authz, input validation, rate-limit, and BOLA test matrices.
Reference OpenAPI/GraphQL discovery steps for the operator; never call live targets from bundled scripts.

Mode: osint

Passive open-source intelligence planning only.

Pass scope gate; confirm
```
osint
```
in
```
allowed_phases
```
.
Load
```
references/osint.md
```
.
Stay within ROE
```
prohibited_actions
```
— no social engineering, harassment, or out-of-scope third-party data collection.
Output source list, query templates, and verification steps for the operator.

Mode: post-exploit

Post-exploitation planning only when ROE explicitly allows it.

Pass scope gate; confirm
```
post-exploit
```
in
```
allowed_phases
```
(see
```
restricted_phases
```
in scope JSON).
Load
```
references/playbooks/post-exploit.md
```
.
Produce containment-aware persistence/lateral-movement planning matrices — no C2 install commands, implants, or live exploitation from bundled scripts.
Refuse C2/Havoc/Sliver/Cobalt Strike skill installs; document-only upstream references only.

Mode: validate

Deterministic skill and findings validation.

Run:
```
uv run python scripts/check.py
```
If validating ad-hoc findings JSON, compare against
```
references/findings-schema.md
```
.
Report validation status; do not mutate ROE or targets.

Mode: report

Session report synthesis.

Collect findings emitted during the engagement (JSON lines or array).
Validate each record against
```
references/findings-schema.md
```
.
Group by severity; include scope metadata (
```
engagement_id
```
,
```
target
```
, ROE hash).
Use
```
scripts/findings_emit.py --aggregate
```
when normalizing operator-supplied notes.
Executive summary must state authorization basis and prohibited actions respected.

Mode: help

Show dispatch table, scope gate steps, and tier boundary table.
List reference files with read-when guidance.
Remind: this skill does not install Strix or other runners — see
```
references/external-runners.md
```
.

Help (empty)

Show dispatch table, scope gate steps, tier boundaries, and reference index. Offer examples:

text

/pentest help
/pentest doctor
/pentest scope staging.example.com
/pentest recon staging.example.com
/pentest web https://staging.example.com/app
/pentest api https://staging.example.com/api
/pentest osint staging.example.com
/pentest validate
/pentest report

Reference File Index

Load ONE reference at a time. Do not preload all references.

File	Content	Read When
`references/scope-and-roe.md`	ROE format, scope gate policy, deny reasons	Scope deny or ROE questions
`references/findings-schema.md`	JSON finding fields and severity rules	Emitting or validating findings
`references/methodology-router.md`	Compact signal → playbook → slug routing	`triage` or depth routing
`references/external-skill-index.manifest.json`	Pointer to planning-lock full index	Operator requests upstream body
`references/playbooks/*.md`	Phase and technique checklists (22 files)	Matching phase after scope pass
`references/osint.md`	Passive OSINT templates (legacy index)	`recon` or `osint` after scope pass
`references/provenance.md`	Synthesis sources, hybrid repos, no C2 policy	Methodology questions or audit trail
`references/external-runners.md`	Optional external CLIs (Strix, etc.) — no install	Operator asks about tooling

Scripts

Script	When to Run
`scripts/phases.py`	SSOT for `VALID_PHASES` (imported by scope/findings)
`scripts/scope_check.py`	Always before offensive planning — fail-closed without ROE
`scripts/doctor.py`	`doctor` mode or pre-engagement readiness
`scripts/findings_emit.py`	Emit or aggregate structured findings JSON (schema v1.1)
`scripts/lookup_external_slug.py`	Resolve signal/slug install metadata from planning lock
`scripts/validate_external_index.py`	Maintainer check for planning-lock index policy
`scripts/check.py`	`validate` mode or CI/skill maintenance

Critical Rules

Scope gate first — no recon, web, api, or osint planning without passing
```
scope_check.py
```
Fail-closed — missing
```
--target
```
or
```
--roe-file
```
denies immediately
No attack execution in scripts — bundled Python is planning, validation, and JSON only
No C2 or webshell vendoring — refuse requests for implants, reverse shells, or malware staging
No unauthorized testing — without signed ROE, redirect to security-scanner (static) or refuse
CTF is not pentest — redirect synthetic lab work to ctf-* skills
Operator-run tools only — cite commands for the operator; skill scripts do not probe targets
Respect ROE phases — deny playbooks when phase not in
```
allowed_phases
```
Respect prohibited_actions — DOS, social engineering, production data exfiltration when banned

Structured findings — use

findings_emit.py

and

references/findings-schema.md

Load ONE reference at a time — progressive disclosure
Present plan before deep checklist — approval gate for invasive operator steps
Never store live credentials — redact secrets in findings and reports
External runners are optional — document in
```
external-runners.md
```
; never auto-install Strix
Read-only ROE — scripts validate ROE files; they do not create or modify authorization

pentest

NPX Install

Tags

SKILL.md Content