跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
开发与测试

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>.

bindingmeaningdefaulthow 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.jsonlknown-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 snapshotsbranchesdirty/non-git tree → snapshots
<pr_branch>branch the fixes land on and the PR opens frompurple-team/<tag>today's date as <tag>
<sandbox_root>where catalogues, snapshots, ledgers live./sandbox—
<cycle_budget>max find→fix→re-verify cycles4—
<find_budget>, <fix_budget>inner per-phase budgets passed to red / blue8—

<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), writing failures.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
阅读完整来源 ↗