purple-team
Use when the user wants to automatically harden a guardrail, classifier, content filter, prompt, or API they own by running attack and defense together as a closed loop, not just one or the other. It orchestrates the red-team and blue-team loops as independent agents: red finds distinct failure classes against the frozen target, blue patches the target to close them under a regression gate, then a fresh red pass re-verifies — confirming each class is closed and surfacing any new ones the fix introduced. The find→fix→re-verify cycle repeats until a fresh attack pass stays dry (the target is hardened) or a cycle budget is hit, then it opens a pull request with the patch set. Not for attacking a system the user is not authorized to test, and not for a one-shot scan — use red-team alone to only find, or blue-team alone to only fix.
gaasher · 已有 AI 审核记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add gaasher/Agent-Loop-Skills --skill purple-team技能说明
name: purple-team description: > Use when the user wants to automatically harden a guardrail, classifier, content filter, prompt, or API they own by running attack and defense together as a closed loop, not just one or the other. It orchestrates the red-team and blue-team loops as independent agents: red finds distinct failure classes against the frozen target, blue patches the target to close them under a regression gate, then a fresh red pass re-verifies — confirming each class is closed and surfacing any new ones the fix introduced. The find→fix→re-verify cycle repeats until a fresh attack pass stays dry (the target is hardened) or a cycle budget is hit, then it opens a pull request with the patch set. Not for attacking a system the user is not authorized to test, and not for a one-shot scan — use red-team alone to only find, or blue-team alone to only fix. compatibility: > Requires Python 3.9+ and the sibling red-team + blue-team skills installed. Real isolated subagents on Claude Code; runs the phases inline (serial) elsewhere. git + gh CLI for the PR handoff (degrades). metadata: version: "0.1.0"
Purple Team
The combined red+blue loop — the outer orchestration the red-team skill says "lives outside it."
The artifact is a target system (frozen within a phase, patched between phases); the feedback signal
is how many new failure classes a fresh attack pass finds against the patched target. Each cycle
runs three strictly separated phases — find (red-team), fix (blue-team), re-verify (a fresh
red-team pass) — and you repeat until a fresh find stays dry (zero new classes), meaning the target
is hardened. Red and blue run as independent agents so the attacker that wrote a catalogue never
grades its own patch. On stop it opens a pull request with the cycle history and the patch set.
When to use
Use to harden a guardrail/classifier/filter/prompt/API the user owns or is authorized to test, when the
goal is an actually-hardened target plus a reviewable patch — not just a catalogue (that is red-team
alone) and not just closing a pre-existing catalogue (that is blue-team alone). It needs a runnable
oracle for the objective signal, and the two sibling skills installed.
Default: spawn red and blue as separate subagents per phase. Escape hatch: on hosts without subagent dispatch, run each phase inline (serial) per the role files — still correct, but the same context plays both sides, so be deliberate about not letting the fix bias the re-verify. Not for unauthorized targets.
Setup
Resolve bindings interactively. If loop.run.yaml exists, load it, confirm the values in one line, and
skip to the loop. Otherwise: on Claude Code (the AskUserQuestion tool is available) infer a likely
value per binding and recommend it; on other hosts ask each as a quoted prompt. Then write
loop.run.yaml (format: examples/run.example.yaml) and confirm before creating any other files.
The phases reuse the sibling skills, so the bindings are their union — one shared loop.run.yaml drives
both. The same file is <target_files> to blue (writable) and the program behind <target_cmd> to red
(read-only); the same path is red's <failures_log> and blue's <catalogue>.
| binding | meaning | default | how to infer |
|---|---|---|---|
<target_cmd> | run the target on one stdin input → a verdict (what red attacks) | — | the guardrail/classifier/API entrypoint |
<target_files> | the source file(s) blue may edit to fix the target | — | the file(s) behind <target_cmd> |
<oracle_cmd> | ground-truth verdict for the same input (frozen) | — | a reference checker / policy impl |
<gate_cmd> | functional tests that must stay green through a fix (exits 0) | — | the target's test command; else rely on <holdout> |
<holdout> | benign + clearly-correct inputs blue must not break | <sandbox_root>/holdout.jsonl | known-good inputs the oracle agrees on |
<catalogue> | shared failures file: red writes it, blue closes it, JSONL {id,text,class,...} | <sandbox_root>/failures.jsonl | — |
<iter_strategy> | branches (commit per fix → PR) or snapshots | branches | dirty/non-git tree → snapshots |
<pr_branch> | branch the fixes land on and the PR opens from | purple-team/<tag> | today's date as <tag> |
<sandbox_root> | where catalogues, snapshots, ledgers live | ./sandbox | — |
<cycle_budget> | max find→fix→re-verify cycles | 4 | — |
<find_budget>, <fix_budget> | inner per-phase budgets passed to red / blue | 8 | — |
<skill_dir> is this skill's installed folder. The phases run the sibling skills' tools
(red-team/tools/harness.py, blue-team/tools/verify.py); the role files name them.
The loop
Copy this checklist and tick items off each cycle. Cycles are numbered from 0; per-cycle artifacts go in
<sandbox_root> with the cycle index in the name so nothing is overwritten: the find catalogue is
failures.cycle<N>.jsonl (cycle 0 may use <catalogue> directly) and the re-verify result is
failures.cycle<N>_reverify.jsonl. The catalogue blue fixes in cycle N is the failures file from that
cycle's find/re-verify pass — never append back into one shared file, so each cycle's accounting is clean.
- Cycle 0 — Find. Run the red-team phase against the frozen target (spawn-or-degrade,
roles/red-find.md), writingfailures.cycle0.jsonl. Read back its distinct failure classes. - If the catalogue is empty on cycle 0, stop — the target is already dry; report clean, no PR.
- Fix. Run the blue-team phase on this cycle's failures file (spawn-or-degrade,
roles/blue-fix.md): it patches<target_files>one class per iteration under the gate + regression guard, committing kept fixes on<pr_branch>. Read back the classes it closed and any residuals. - Re-verify. Run a fresh red-team phase against the patched ta