plan-orchestrate
affaan-m/ECC
Liest ein Plandokument ein, gliedert es in einzelne Schritte auf, entwirft aus dem ECC-Katalog eine schrittweise Agentenkette und gibt benutzerdefinierte Eingabeaufforderungen aus, die zum Einfügen bzw. zur Orchestrierung bereit sind, ohne diese auszuführen.
...Alle erweiternPlanen und Koordinieren
Verbinden Sie ein Planungsdokument mit /orchestrate custom, indem Sie pro Schritt einen einfügefertigen Aufruf ausgeben. Die Funktion ist rein generativ – sie führt /orchestrate niemals aus. Der Benutzer fügt jede Zeile ein, sobald er bereit ist.
Wann aktivieren?
- Der Benutzer verfügt über ein mehrstufiges Planungsdokument (PRD, RFC, Implementierungsplan) und möchte dieses über
/orchestrateabarbeiten. - Der Nutzer sagt: „Orchestrier diesen Plan“, „Gib mir Orchestrate-Eingabeaufforderungen für jeden Schritt“, „Erstelle Ketten für diesen Plan“.
- Es liegt ein Schritt-für-Schritt-Plan vor, aber der Benutzer möchte die Agenten nicht manuell für jeden Schritt auswählen.
Überspringen, wenn:
- Die Aufgabe besteht aus einem einzigen Ad-hoc-Schritt → Rufe direkt
/orchestrate customauf. - Der Plan ist unlesbar oder leer. Das Fehlen einer expliziten Nummerierung allein ist kein Grund zum Überspringen – siehe den Sonderfall „Keine klaren Schritte“ weiter unten.
Eingaben
[--lang=python|typescript|go|rust|cpp|java|kotlin|flutter|auto] [--scope=all|step:|range:-] [--dry-run]
— erforderlich; relativer oder absoluter Pfad (@docs/...wird akzeptiert).--lang— Sprachvariante des Prüfers; Standardwert ist„auto“(wird aus dem Projekt ermittelt).--scope— begrenzt die ausgegebenen Schritte; Standardwert ist„all“.--dry-run— gibt nur die Zerlegung und die Begründung der Kette aus; gibt keine abschließenden Eingabeaufforderungen aus.
Maßgebliche /orchestrate -Form (nicht abweichen)
{ORCH_CMD} custom ",,...," ""
Wobei {ORCH_CMD} in Phase 0 festgelegt wird (siehe unten). Die Befehlszeichenfolge in der ausgegebenen Ausgabe verwendet immer eine konkrete Form – niemals beide, niemals einen Platzhalter.
„custom“ist eine sequenzielle Kette; das HANDOFF jedes Agenten speist den nächsten.- Durch Kommas getrennte Agentenliste. Leerzeichen werden nicht bevorzugt; ein Leerzeichen wird toleriert.
- Es gibt keine Flags wie
--mode/--gate/--agents=...– erfinden Sie diese niemals. - Agentennamen stammen aus dem Katalog dieses Skills. Eingebettete doppelte Anführungszeichen in der Aufgabenbeschreibung werden als
\"maskiert.
ECC-Installationsform und Namensraum
Zwei Installationsformate bestimmen das Präfix sowohl für den Slash-Befehl als auch für jeden Agenten-Namen. Die beiden MÜSSEN synchron bleiben – ein Format pro Ausgabe, niemals gemischt:
Lassen Sie das Claude-Code-Home-Verzeichnis bezeichnen: ~/.claude unter macOS/Linux, %USERPROFILE%\.claude unter Windows. Lösen Sie es so auf, wie die Host-Plattform das Benutzer-Home-Verzeichnis auflöst ( ~ nicht fest codieren).
| Form | Erkennung | {ORCH_CMD} |
Format des Agentennamens |
|---|---|---|---|
| Plugin-Installation (1.9.0+) | existiert |
/everything-claude-code:orchestrate |
everything-claude-code: |
| Veraltete Basisinstallation | Oben nicht vorhanden; Agent-Dateien unter |
/orchestrate |
|
Warum das wichtig ist: Bei der Plugin-Installation registrieren sich Agenten als „everything-claude-code:tdd-guide“. Bare-Namen erzwingen einen unscharfen Abgleich, der bei parallelen Aufrufen zeitweise fehlschlägt. Bei der Legacy-Installation werden die Formen mit Präfix nicht registriert und schlagen sofort fehl.
Verfügbarer Agentenkatalog (Auswahl muss aus diesen erfolgen)
Allgemein:
Planner– Neuformulierung von Anforderungen, Risikozerlegung, Schrittplanungarchitect— Architektur, Systemdesign, Refactoring-Vorschlägetdd-guide– Tests schreiben → implementieren → 80 %+ TestabdeckungCode-Reviewer– allgemeine Code-ÜberprüfungSicherheitsprüfer— Sicherheitsaudit, OWASP, Aufdeckung von GeheimnissenRefactor-Cleaner– toter Code, Duplikate, Bereinigung der Knip-KlasseDok-Aktualisierer— Dokumentation, Codemap, READMEdocs-lookup– API-Abfragen für Bibliotheken von Drittanbietern (Context7)e2e-runner– Koordination von End-to-End-Testsdatabase-reviewer– PostgreSQL-Schema, Migration, Leistungharness-optimizer– Konfiguration des lokalen Agent-Harnessesloop-operator– Lang laufende autonome Schleifenchief-of-staff— Multi-Channel-Triage (selten für Plan-Schritte geeignet)
Lösungen für Build-Fehler:
build-error-resolver(generisch) /cpp-build-resolver/go-build-resolver/java-build-resolver/kotlin-build-resolver/rust-build-resolver/pytorch-build-resolver
Code-Reviewer:
Python-Reviewer/TypeScript-Reviewer/Go-Reviewer/Rust-Reviewer/C++-Reviewer/Java-Reviewer/Kotlin-Reviewer/Flutter-Reviewer
Ein falsch geschriebener Agentenname führt zu einem Fehler bei /orchestrate. Bitte vor der Ausgabe anhand dieser Liste überprüfen.
So funktioniert es
Phase 0 – ECC-Modus und Sprache erkennen
Lesen
. Falls fehlend oder leer, melden und abbrechen.Ermittle die ECC-Installationsform einmalig und lege sie als
ECC_MODEfest. Algorithmus (der Reihe nach ausführen, bei erster Übereinstimmung anhalten):- Wenn
existiert →/plugins/marketplaces/everything-claude-code/ ECC_MODE=plugin. - Andernfalls: Wenn
existiert und mindestens eine ECC-Agent-Datei enthält (z. B./agents/ tdd-guide.md,code-reviewer.md) →ECC_MODE=legacy. - Andernfalls → Standardwert
ECC_MODE=legacyund Ausgabe einer einzeiligen Warnung am Anfang der Ausgabe:> Warnung: ECC-Installation konnte nicht erkannt werden; Standardmäßig wird die Legacy-Form verwendet. Wenn Sie die Plugin-Installation verwenden, bearbeiten Sie die Präfixe manuell. - Wenn beide Marker vorhanden sind (gemischte Installation), hat
das PluginVorrang – der Plugin-Namespace ist der einzige, der Agentennamen ohne unscharfe Übereinstimmung auflöst.
Ab diesem Zeitpunkt verwendet jede ausgegebene Zeile das passende Präfix sowohl für den Slash-Befehl als auch für jeden Agentennamen. Es dürfen niemals beide Formen in derselben Ausgabe erscheinen.
- Wenn
Auflösung von
`--lang`. Bei der Einstellung„auto“wird eine polyglotte Erkennung durchgeführt:- Marker prüfen:
pyproject.toml/uv.lock/requirements.txt→ Python;package.json→ TypeScript;go.mod→ Go;Cargo.toml→ Rust;CMakeLists.txtoder*.cppauf oberster Ebene → cpp;pom.xml/build.gradle(Java) → java;build.gradle.ktsoder Kotlin auf oberster Ebene → kotlin;pubspec.yaml→ flutter. - Entscheidung bei mehreren Sprachen: Wenn mehr als ein Marker übereinstimmt, wähle die Sprache, deren Quelldateien die anderen zahlenmäßig übertreffen (Zählung über
`git ls-files`, unter Ausschluss von`vendor/`,`node_modules/`,`dist/`,`build/`,`.venv/`, generierten Dateien und offensichtlichen Test-Fixtures). Bei Gleichstand oder wenn keine Sprache mehr als 60 % der Quelldateien ausmacht, setzelang=unknown. - Es wurde kein Marker gefunden → setze
lang=unknown. lang=unknownist ein Sentinel – es handelt sich nicht um einen Agenten-Namen. Die Regeln 4 und 5 der Phase 2 wandeln ihn zum Zeitpunkt der Kettenzusammenstellung ineinen Code-Reviewerbzw.Build-Fehler-Beheberum.
- Marker prüfen:
Erkenne ein PyTorch-Unterprofil: Wenn
lang=pythongilt und in einer der Dateienpyproject.toml,requirements.txtoderuv.lockeine Abhängigkeit vontorchdeklariert ist, setzepytorch=true. Dies wirkt sich nur auf die Auswahlder Build-Ketteaus (Regel der Phase 2 unten); der Prüfer bleibtpython-reviewer.Normalisieren Sie alle im Plan deklarierten Agenten-Namen: Wenn der Plan-Text Agenten in ihrer mit einem Plugin-Präfix versehenen Form referenziert (z. B.
everything-claude-code:tdd-guide), entfernen Sie das Präfix, um den reinen Katalognamen zu erhalten, bevor Sie Ketten validieren oder zusammenstellen. Das erneute Voranstellen des Präfixes erfolgt erst zum Zeitpunkt der Ausgabe gemäßECC_MODE(Phase 4). Ein Name mit vorangestelltem Präfix darf niemals in die Kettenzusammenstellung gelangen – dies würde im Plugin-Modus zu einem doppelten Präfix führen.
Phase 1 – Schritte zerlegen
Identifizieren Sie „Schritteinheiten“ in der Reihenfolge ihrer Priorität:
- Explizite Nummerierung:
## Schritt N/### Phase N/## N. .../ geordnete Liste auf oberster Ebene. - Eine Spalte „Schritt“ in einer Tabelle.
----getrennteBlöcke mit verbengeführten Überschriften.- Andernfalls wird jede H2-Überschrift als ein Schritt behandelt.
Pro Schritt ID (1-basiert), Titel (≤ 80 Zeichen), Absicht (1–3 Sätze) und Tags extrahieren.
Phase 2 – Taggen und Kette bilden
Nach Absicht taggen (Mehrfach-Tags zulässig; Kette aus Primär-Tag und gestapelten Sekundär-Tags):
Die folgenden Auslösewörter werden groß-/kleinschreibungsunabhängig abgeglichen. Mehrsprachige Pläne werden unterstützt, indem die Wortstämme in jeder Sprache abgeglichen werden, solange die Bedeutung mit den aufgeführten englischen Auslösewörtern übereinstimmt.
| Tag | Triggerwörter | Standardkette |
|---|---|---|
Design |
Architektur, Design, auswählen, bewerten, RFC | Planer, Architekt |
Plan |
Plan, Aufschlüsselung, Meilenstein | Planer |
Umsetzung |
implementieren, erstellen, hinzufügen, entwickeln, portieren | TDD-Leitfaden, |
Test |
Test, Testabdeckung, E2E, Integration | tdd-guide, e2e-runner |
Umgestalten |
Refactoring, Bereinigung, Duplikate entfernen, Aufteilen | Architekt, Refactor-Cleaner, |
Migration |
Migration, Upgrade, Neuprogrammierung, Portierung | Architekt, TDD-Leitfaden, |
DB |
Schema, Migration, Index, SQL, Postgres, Alembic, SQLModel | Datenbank-Prüfer, |
Sicherheit |
Verschlüsselung, Authentifizierung, Geheimnisse, OWASP, personenbezogene Daten | Sicherheitsprüfer, |
Build |
Build, Kompilieren, Lint-Fehler, CI | (greift auf Build-Fehler-Resolver zurück) |
Dokumente |
Dokumentation, README, Codemap, Änderungsprotokoll | doc-updater |
Suche |
Lookup, Referenz, API-Verwendung | docs-lookup |
Überprüfung |
Überprüfung, Audit, Verifizierung | |
Schleife |
Schleife, autonom, Watchdog | Schleifenoperator |
Regeln für die Zusammensetzung von Ketten:
- Auswahl des primären Tags: Wenn ein Schritt mehreren Tags entspricht, ist das erste in der Reihenfolge der Tabelle (oben in der Tabelle = höchste Priorität) das primäre; die übrigen sind sekundär. Die folgenden Zusammensetzungsregeln 2 und 3 behandeln bestimmte Kombinationen mehrerer Tags explizit; andernfalls werden sekundäre Ketten in der Reihenfolge der Tag-Tabelle angehängt.
impl+security→tdd-guide,.-reviewer,security-reviewer impl+db→tdd-guide,database-reviewer,.-reviewer - Entdoppeln Sie die resultierende Kette (behalten Sie das erste Vorkommen bei). Beispielsweise würde
„review+lang=unknown“nach Regel 5 zu„code-reviewer,code-reviewer“führen; durch die Entdopplung wird dies zu„code-reviewer“zusammengefasst. wird zu-reviewer code-revieweraufgelöst, wennlang=unknownist.wird zu-build-resolver build-error-resolveraufgelöst, wennlang=unknownist. Sonderfall: Wenn in Phase 0pytorch=truegesetzt wurde, verwendepytorch-build-resolverfürBuild-Ketten, unabhängig von. Es gibt keinen„python-build-resolver“;„--lang=python“ohne„pytorch=true“wird zu„build-error-resolver“aufgelöst.- Schritte ohne Tag: Wenn kein Triggerwort übereinstimmt, setze die Kette auf
„code-reviewer“und schreibe„kein Tag gefunden“; Standardkette „review-only“gemäß „Begründung der Kette“. - Kettenlänge ≤ 4 nach Deduplizierung. Bei Überschreitung das schwächste Tag verwerfen (zuerst
LookupundDocs). PlanerundArchitektnicht in einer„impl“-Kettekombinieren (Tokenverschwendung). Kombiniere sie nur beiDesign-Schritten.- Schritte mit den Tags
„impl“,„refactor“ oder„migration“enden mit einem Agenten der Reviewer-Klasse – entweder„,-reviewer“ „code-reviewer“,„security-reviewer“ oder„database-reviewer“. Der domänenspezifischste Prüfer erhält die letzte Position (z. B. endet„impl+security“aus Regel 2 mit„security-reviewer“;„impl+db“aus Regel 3 endet mit„, da-reviewer“ „database-reviewer“die Migration bereits früher in der Kette abschließt).Test-undBuild-Schrittewerden durch ihre eigenen Validatoren (e2e-runnerbzw. den Build-Resolver) gesteuert und erfordern keinen zusätzlichen Prüfer.
Phase 3 – Aufgabenbeschreibung komprimieren
Jedes ausgegebene muss:
- In sich geschlossen sein (der erste Agent muss das Plandokument nicht geöffnet haben).
- mit
[Plan:beginnen.#step- ] - 1–3 überprüfbare Akzeptanzkriterien enthalten.
- Enthalten Sie eine Geltungsbereichsangabe (
Außerhalb des Geltungsbereichs: ...) nur, wenn der Plan eine solche für diesen Schritt festlegt. Übernehmen Sie diese wörtlich. Wenn der Plan keine Angabe zum Geltungsbereich enthält, lassen Sie die Klausel vollständig weg – erfinden Sie keine. - Umfang: 200–600 Zeichen; eine Zeile; eingebettete
„“als\“maskiert; keine literalen Zeilenumbrüche.
Phase 4 – Ausgabe
Geben Sie Markdown in der durch ECC_MODE festgelegten Form aus. Die Ausgabe verwendet durchgehend ein Format – jedes {ORCH_CMD} und jeder Agentenname wird mit dem entsprechenden Präfix aus Phase 0 dargestellt. Geben Sie nicht beide Formate aus; fügen Sie keine Anweisungen wie „dies ist das Plugin-Format“ oder „Präfix entfernen“ in die gerenderte Ausgabe ein.
Konkrete Darstellungsregeln:
{ORCH_CMD}=/everything-claude-code:orchestrateunter„Plugin“,/orchestrateunter„Legacy“.{AGENT(name)}=„everything-claude-code:“ unter„plugin“,unter„Legacy“.- Die Spalte „Chain“ der Übersichtstabelle verwendet dieselbe
{AGENT(name)}-Darstellung. - Die Bash-Blöcke pro Schritt enthalten nur den ausführbaren Befehl. Keine Kommentare
im Format# pluginoder# legacy– das Format ist implizit und einheitlich über die gesamte Ausgabe hinweg.
Ausgabestruktur:
# Plan-Orchestrate Ergebnis
**Plan**: ``
**Sprache**: ``
**ECC-Modus**: ``
**Schritte**:
**Umfang**:
## Übersicht über die Schritte
| # | Titel | Tags | Chain |
|---|---|---|---|
| 1 | ... | impl, db | `{AGENT(tdd-guide)},{AGENT(database-reviewer)},{AGENT(python-reviewer)}` |
| ... | | | |
---
## Schritt 1 – „ “
**Absicht**: <1–3 sentences>
**Tags**:
**Begründung für die Kette**:
```bash
{ORCH_CMD} custom "{AGENT(tdd-guide)},{AGENT(database-reviewer)},{AGENT(python-reviewer)}" "[Plan: docs/foo.md#step-1] ; Abnahme: <1–3 items>; Außerhalb des Umfangs: <…>"
```
Die obige Notation
{ORCH_CMD}und{AGENT(...)}beschreibt die Substitution, die diese Funktion zur Laufzeit durchführt. Das tatsächlich ausgegebene Markdown enthält die aufgelösten Zeichenfolgen, niemals die Platzhalter.
Füge einen abschließenden „Batch-Ausführungs“-Block hinzu, der die Befehle aller Schritte der Reihe nach zusammenfasst, damit der Benutzer sie alle auf einmal einfügen kann. Überspringe den Batch-Block im reinen Übersichtsmodus (siehe Randfall „Großer Plan“): Wenn nur die Übersichtstabelle ausgegeben wird, gibt es keine Befehle pro Schritt, die zusammengefasst werden müssen.
Phase 5 – Selbstprüfung (vor der Ausgabe ausführen)
- Jeder Agent in jeder Kette stammt aus dem Katalog (nachdem das Präfix
„everything-claude-code:“entfernt wurde, das im Plan vorkam; siehe Phase 0, Schritt 5). - Aufgelöste
{ORCH_CMD}und alle aufgelösten{AGENT(...)}verwenden dieselbe Form (PluginoderLegacy) – niemals gemischt in einer Ausgabe. - In der gerenderten Ausgabe verbleiben keine Anmerkungen
vom Typ „# Plugin-Form“bzw.„# Legacy-Form“und keine Anweisungen zum Entfernen des Präfixes. - Es gibt keine erfundenen Felder wie
--mode/--gate/--agents=... - Jede Aufgabenbeschreibung ist einzeilig, in doppelte Anführungszeichen gesetzt und enthält eingebettete
„-Zeichen, die mit„escaped sind. - Jede Aufgabenbeschreibung beginnt mit
[Plan:und enthält die Abnahme (1–3 Punkte). Die Klausel#step- ] „Out of scope:“ist nur vorhanden, wenn sie aus dem Plan übernommen wurde. - Nach der Duplikatsbereinigung in Phase 2 dürfen in keiner Kette doppelte Agenten vorkommen.
- Kettenlänge ≤ 4.
- Schritte mit den Tags
„impl“, „refactor“ oder „migration“enden mit einem Agenten der Reviewer-Klasse (,-reviewer code-reviewer,security-revieweroderdatabase-reviewer).„test“und„build“sind davon ausgenommen – siehe Regel 10 der Phase 2. - Schritte ohne Tag geben
„code-reviewer“mit der Begründung„kein Tag gefunden“aus; standardmäßig „review-only“-Kette. - Die Übersichtstabelle listet jeden Schritt im Plan auf, unabhängig von
--scope. - Die Anzahl der Detailblöcke pro Schritt entspricht dem festgelegten
`--scope`(vollständiger Plan bei`--scope=all`; ein Block fürSchritt:n; Bereichsgröße fürBereich:a-b). Im reinen Übersichtsmodus werden keine Blöcke pro Schritt und kein Batch-Block ausgegeben.
Randfälle
- Keine eindeutigen Schritte: Bevorzuge eine Aufteilung in H2/H3; falls weiterhin Unklarheit besteht, melde „keine strukturierten Schritte erkannt“ zusammen mit der Dokumentgliederung und bitte den Benutzer, die Ausführung anhand der Gliederung zu bestätigen.
- Großer Plan (>1500 Zeilen): Wechsle in den reinen Übersichtsmodus – gib nur die Übersichtstabelle aus und fordere den Benutzer auf, den Umfang mit
--scopeeinzugrenzen, bevor die Ausführung für Details erneut gestartet wird. In diesem Modus werden Detailblöcke pro Schritt sowie der Batch-Ausführungsblock übersprungen. - Schritt zu weit gefasst (z. B. „alle Backend-Arbeiten abschließen“): Keine einzelne Kette erzwingen. Eine Aufteilung in N.a und N.b vorschlagen und eine Aufteilung vorschlagen.
- Plan deklariert Agenten (selten): Entferne zunächst jegliches
„everything-claude-code:“-Präfix, um den reinen Katalognamen zu erhalten (Phase 0, Schritt 5), und überprüfe diesen anschließend anhand des Katalogs. Ersetze ungültige Agenten und erläutere dies unter „Begründung der Kette“. Der reine Name wird bei der Ausgabe entsprechendECC_MODEerneut mit einem Präfix versehen. - Polyglottes Projekt, bei dem
--lang=autokeinen Gewinner auswählen kann: Setzelang=unknown; „reviewer“ wird zu„code-reviewer“und „build-resolver“ zu„build-error-resolver“. Erwähne den Fallback unter „Begründung der Kette“.
Beispiele
Beispiel 1 – Plugin-Modus, Python-Plan
Eingabe:
plan-orchestrate @docs/plan/example-feature.md --lang=python
Auszug aus der erwarteten Ausgabe:
## Schritt 2 – Verschlüsselung sensibler „UserProfile“-Felder
**Ziel**: Einführung eines SQLAlchemy-Typs `EncryptedString` und AES-GCM-Verschlüsselung von `birth_datetime` / `location` vor der Persistenz; Laden des Schlüssels aus einer Umgebungsvariablen.
**Tags**: impl, security, db
**Begründung für die Kette**: Sicherheitsrelevanter Schreibpfad, daher schließt `security-reviewer` die Kette ab; `database-reviewer` validiert die Alembic-Migration; `python-reviewer` überprüft Typisierung und Einhaltung von PEP 8.
```bash
/everything-claude-code:orchestrate custom "everything-claude-code:tdd-guide,everything-claude-code:database-reviewer,everything-claude-code:python-reviewer,everything-claude-code:security-reviewer" „[Plan: docs/plan/example-feature.md#step-2] Implementierung des SQLAlchemy-Typs `EncryptedString` und Migration der Spalten `UserProfile.birth_datetime` und `location`; Schlüssel aus der Umgebungsvariable `APP_DB_KEY`; Abnahme: Roundtrip-Tests für Ver- und Entschlüsselung bestanden; Alembic-Upgrade/Downgrade läuft fehlerfrei bei leerer Datenbank; kein Klartext in der Datenbank nach der Migration; Außerhalb des Umfangs: Logik zur mandantenübergreifenden Profilfreigabe“
```
Beispiel 2 – Legacy-Modus, derselbe Schritt
Wenn ECC_MODE=legacy erkannt würde, würde derselbe Schritt als ein einziger einheitlicher Befehl ausgegeben (keine Formen mit Plugin-Präfix an irgendeiner Stelle in der Ausgabe):
/orchestrate custom „tdd-guide,database-reviewer,python-reviewer,security-reviewer“ „[Plan: docs/plan/example-feature.md#step-2] …“
Die beiden obigen Beispiele veranschaulichen die beiden möglichen Ausgaben für zwei unterschiedliche Umgebungen. Ein einzelner Skill-Aufruf erzeugt von Anfang bis Ende nur eine davon.
Hinweise
- Nur generativ. Rufen Sie
/orchestrateniemals aus diesem Skill heraus auf. - Passen Sie die Sprache der Aufgabenbeschreibungen an die des Plandokuments an (Agentennamen bleiben immer auf Englisch).
- Fügen Sie keine „Co-Authored-By“-Zeilen oder Emojis in die Ausgabe ein, es sei denn, der Benutzer fordert dies ausdrücklich an.
---
name: plan-orchestrate
description: Reads a plan document, decomposes it into steps, designs a per-step agent chain from the ECC catalogue, and emits ready-to-paste /orchestrate custom prompts without executing them.
---
# Plan Orchestrate
Bridge a plan document to `/orchestrate custom` by emitting one ready-to-paste invocation per step. The skill is generative only — it never executes `/orchestrate`. The user pastes each line when ready.
## When to Activate
- User has a multi-step plan document (PRD, RFC, implementation plan) and wants to drive it through `/orchestrate`.
- User says "orchestrate this plan", "give me orchestrate prompts for each step", "compose chains for this plan".
- A step-by-step plan exists but the user does not want to manually pick agents per step.
Skip when:
- The work is one ad-hoc step → call `/orchestrate custom` directly.
- The plan is unreadable or empty. Lack of explicit numbering alone is not a skip condition — see the "No clear steps" edge case below.
## Inputs
```
<plan-doc-path> [--lang=python|typescript|go|rust|cpp|java|kotlin|flutter|auto] [--scope=all|step:<n>|range:<a>-<b>] [--dry-run]
```
- `<plan-doc-path>` — required; relative or absolute path (`@docs/...` accepted).
- `--lang` — reviewer language variant; defaults to `auto` (detected from project).
- `--scope` — limits emitted steps; defaults to `all`.
- `--dry-run` — print decomposition + chain rationale only; do not emit final prompts.
## Authoritative `/orchestrate` shape (do not deviate)
```
{ORCH_CMD} custom "<agent1>,<agent2>,...,<agentN>" "<task description>"
```
Where `{ORCH_CMD}` is determined in Phase 0 (see below). The command string in the emitted output **always uses one concrete form** — never both, never a placeholder.
- `custom` is a sequential chain; each agent's HANDOFF feeds the next.
- Comma-separated agent list. No spaces preferred; one space tolerated.
- No `--mode` / `--gate` / `--agents=...` flags exist — never invent them.
- Agent names come from the catalogue in this skill. Embedded double quotes in the task description are escaped as `\"`.
## ECC install form and namespacing
Two install forms determine the prefix on **both** the slash command and every agent name. The two MUST stay in sync — one form per output, never mixed:
Let `<claude-home>` denote the Claude Code home directory: `~/.claude` on macOS/Linux, `%USERPROFILE%\.claude` on Windows. Resolve it the way the host platform resolves the user home directory (do not hardcode `~`).
| Form | Detection | `{ORCH_CMD}` | Agent name format |
|---|---|---|---|
| Plugin install (1.9.0+) | `<claude-home>/plugins/marketplaces/everything-claude-code/` exists | `/everything-claude-code:orchestrate` | `everything-claude-code:<name>` |
| Legacy bare install | Above absent; agent files under `<claude-home>/agents/` | `/orchestrate` | `<name>` |
Why this matters: under the plugin install, agents register as `everything-claude-code:tdd-guide`. Bare names force fuzzy matching, which fails intermittently under parallel calls. Under legacy, the prefixed forms are not registered and fail outright.
## Available agent catalogue (must pick from these)
General:
- `planner` — requirement restatement, risk decomposition, step planning
- `architect` — architecture, system design, refactor proposals
- `tdd-guide` — write tests → implement → 80%+ coverage
- `code-reviewer` — generic code review
- `security-reviewer` — security audit, OWASP, secret leakage
- `refactor-cleaner` — dead code, duplicates, knip-class cleanup
- `doc-updater` — documentation, codemap, README
- `docs-lookup` — third-party library API lookups (Context7)
- `e2e-runner` — end-to-end test orchestration
- `database-reviewer` — PostgreSQL schema, migration, performance
- `harness-optimizer` — local agent harness configuration
- `loop-operator` — long-running autonomous loops
- `chief-of-staff` — multi-channel triage (rarely a fit for plan steps)
Build error resolvers:
- `build-error-resolver` (generic) / `cpp-build-resolver` / `go-build-resolver` / `java-build-resolver` / `kotlin-build-resolver` / `rust-build-resolver` / `pytorch-build-resolver`
Code reviewers:
- `python-reviewer` / `typescript-reviewer` / `go-reviewer` / `rust-reviewer` / `cpp-reviewer` / `java-reviewer` / `kotlin-reviewer` / `flutter-reviewer`
A misspelled agent name fails `/orchestrate`. Cross-check against this list before emitting.
## How It Works
### Phase 0 — Detect ECC mode + language
1. Read `<plan-doc-path>`. If missing or empty, report and stop.
2. Detect ECC install form once and freeze it into `ECC_MODE`. Algorithm (run in order, stop at the first match):
1. If `<claude-home>/plugins/marketplaces/everything-claude-code/` exists → `ECC_MODE=plugin`.
2. Else if `<claude-home>/agents/` exists and contains at least one ECC agent file (e.g. `tdd-guide.md`, `code-reviewer.md`) → `ECC_MODE=legacy`.
3. Else → default to `ECC_MODE=legacy` and emit a one-line warning at the top of the output: `> Warning: could not detect ECC install; defaulting to legacy form. If you use the plugin install, edit the prefixes manually.`
4. If both markers exist (mixed install), `plugin` wins — the plugin namespace is the only one that resolves agent names without fuzzy matching.
From this point on, every emitted line uses the matching prefix on **both** the slash command and every agent name. **Never emit both forms in the same output.**
3. Resolve `--lang`. When `auto`, run a polyglot-aware detection:
- Probe markers: `pyproject.toml` / `uv.lock` / `requirements.txt` → python; `package.json` → typescript; `go.mod` → go; `Cargo.toml` → rust; `CMakeLists.txt` or top-level `*.cpp` → cpp; `pom.xml` / `build.gradle` (Java) → java; `build.gradle.kts` or top-level Kotlin → kotlin; `pubspec.yaml` → flutter.
- **Polyglot tie-break**: if more than one marker matches, pick the language whose source files outnumber the others (count via `git ls-files`, excluding `vendor/`, `node_modules/`, `dist/`, `build/`, `.venv/`, generated files, and obvious test fixtures). On a tie or when no language exceeds 60% of source files, set `lang=unknown`.
- No marker matched → set `lang=unknown`.
- `lang=unknown` is a sentinel — it is **not** an agent name. Phase 2 rules 4 and 5 turn it into `code-reviewer` / `build-error-resolver` at chain composition time.
4. Detect a **PyTorch sub-profile**: when `lang=python` and any of `pyproject.toml` / `requirements.txt` / `uv.lock` declares a dependency on `torch`, set `pytorch=true`. This only affects `build` chain selection (Phase 2 rule below); the reviewer remains `python-reviewer`.
5. **Normalize any agent names declared in the plan**: if the plan text references agents by their plugin-prefixed form (e.g. `everything-claude-code:tdd-guide`), strip the prefix to get the bare catalogue name before validating or composing chains. Re-prefixing happens only at output time per `ECC_MODE` (Phase 4). Never let a pre-prefixed name flow into chain composition — it would double-prefix in plugin mode.
### Phase 1 — Decompose steps
Identify "step units" in priority order:
1. Explicit numbering: `## Step N` / `### Phase N` / `## N. ...` / top-level ordered list.
2. A "Step" column in a table.
3. `---`-separated blocks with verb-led headings.
4. Otherwise treat each H2 as one step.
Per step extract `id` (1-based), `title` (≤ 80 chars), `intent` (1–3 sentences), `tags`.
### Phase 2 — Tag and pick chain
Tag by intent (multi-tag allowed; chain built from primary + stacked secondaries):
Trigger words below are matched case-insensitively. Multilingual plans are supported by matching the word stems in any language as long as the meaning aligns with the listed English trigger words.
| Tag | Trigger words | Default chain |
|---|---|---|
| `design` | architecture, design, choose, evaluate, RFC | `planner,architect` |
| `plan` | plan, breakdown, milestone | `planner` |
| `impl` | implement, build, add, create, port | `tdd-guide,<lang>-reviewer` |
| `test` | test, coverage, e2e, integration | `tdd-guide,e2e-runner` |
| `refactor` | refactor, cleanup, dedupe, split | `architect,refactor-cleaner,<lang>-reviewer` |
| `migration` | migrate, upgrade, rewrite, port | `architect,tdd-guide,<lang>-reviewer` |
| `db` | schema, migration, index, SQL, Postgres, alembic, sqlmodel | `database-reviewer,<lang>-reviewer` |
| `security` | encrypt, auth, secret, OWASP, PII | `security-reviewer,<lang>-reviewer` |
| `build` | build, compile, lint failure, CI | `<lang>-build-resolver` (falls back to `build-error-resolver`) |
| `docs` | docs, readme, codemap, changelog | `doc-updater` |
| `lookup` | lookup, reference, API usage | `docs-lookup` |
| `review` | review, audit, verify | `<lang>-reviewer,code-reviewer` |
| `loop` | loop, autonomous, watchdog | `loop-operator` |
Chain composition rules:
1. **Primary tag selection**: when a step matches multiple tags, the **first one in table order** (top of the table = highest priority) is the primary; the rest are secondaries. Composition rules 2 and 3 below handle specific multi-tag combinations explicitly; otherwise, append secondary chains in tag table order.
2. `impl` + `security` → `tdd-guide,<lang>-reviewer,security-reviewer`.
3. `impl` + `db` → `tdd-guide,database-reviewer,<lang>-reviewer`.
4. **Deduplicate** the resulting chain (preserve first occurrence). E.g. `review` + `lang=unknown` would yield `code-reviewer,code-reviewer` after rule 5; deduplication collapses it to `code-reviewer`.
5. `<lang>-reviewer` resolves to `code-reviewer` when `lang=unknown`.
6. `<lang>-build-resolver` resolves to `build-error-resolver` when `lang=unknown`. **Special case**: if Phase 0 set `pytorch=true`, use `pytorch-build-resolver` for `build` chains regardless of `<lang>`. There is no `python-build-resolver`; `--lang=python` without `pytorch=true` resolves to `build-error-resolver`.
7. **Zero-tag steps**: if no trigger word matches, set chain to `code-reviewer` and write `no tag matched; default review-only chain` under "Chain rationale".
8. Chain length ≤ 4 after deduplication. If exceeded, drop weakest tag (`lookup` and `docs` first).
9. Do not pair `planner` and `architect` in an `impl` chain (token waste). Pair them only on `design` steps.
10. Steps tagged `impl`, `refactor`, or `migration` end with a **reviewer-class** agent — any of `<lang>-reviewer`, `code-reviewer`, `security-reviewer`, or `database-reviewer`. The most domain-specific reviewer wins the tail position (e.g. rule 2's `impl+security` ends with `security-reviewer`; rule 3's `impl+db` ends with `<lang>-reviewer` because `database-reviewer` already gates the migration earlier in the chain). `test` and `build` steps are gated by their own validators (`e2e-runner` and the build resolver respectively) and do not require an additional reviewer.
### Phase 3 — Compress task description
Each emitted `<task description>` must:
- Be self-contained (the first agent does not need the plan document open).
- Start with `[Plan: <path>#step-<id>]`.
- Include 1–3 verifiable Acceptance criteria.
- Include a Scope guard (`Out of scope: ...`) **only if the plan declares one for this step**. Inherit verbatim. If the plan has no out-of-scope statement, omit the clause entirely — do not invent one.
- Be 200–600 characters; one line; embedded `"` escaped as `\"`; no literal newlines.
### Phase 4 — Output
Emit Markdown using **the form determined by `ECC_MODE`**. The output uses one form throughout — every `{ORCH_CMD}` and every agent name is rendered with the matching prefix from Phase 0. **Do not emit both forms; do not include "this is plugin form" / "strip the prefix" instructions in the rendered output.**
Concrete rendering rules:
- `{ORCH_CMD}` = `/everything-claude-code:orchestrate` under `plugin`, `/orchestrate` under `legacy`.
- `{AGENT(name)}` = `everything-claude-code:<name>` under `plugin`, `<name>` under `legacy`.
- The overview-table "Chain" column uses the same `{AGENT(name)}` rendering.
- Per-step bash blocks contain only the runnable command. **No `# plugin form` or `# legacy form` comments** — the form is implicit and uniform across the whole output.
Output structure:
````markdown
# Plan-Orchestrate Result
**Plan**: `<path>`
**Lang**: `<detected-or-given>`
**ECC mode**: `<plugin | legacy>`
**Steps**: <N>
**Scope**: <all | step:n | range:a-b>
## Steps overview
| # | Title | Tags | Chain |
|---|---|---|---|
| 1 | ... | impl, db | `{AGENT(tdd-guide)},{AGENT(database-reviewer)},{AGENT(python-reviewer)}` |
| ... | | | |
---
## Step 1 — <title>
**Intent**: <1–3 sentences>
**Tags**: <a, b>
**Chain rationale**: <why this chain; which agent closes the loop>
```bash
{ORCH_CMD} custom "{AGENT(tdd-guide)},{AGENT(database-reviewer)},{AGENT(python-reviewer)}" "[Plan: docs/foo.md#step-1] <compressed task description>; Acceptance: <1–3 items>; Out of scope: <…>"
```
````
> The `{ORCH_CMD}` and `{AGENT(...)}` notation above describes the substitution this skill performs at runtime. The actual emitted Markdown contains the resolved strings, never the placeholders.
Append a final "Batch execution" block aggregating every step's command in order so the user can paste them all at once. **Skip the Batch block in overview-only mode** (see "Large plan" edge case): when only the overview table is being emitted, there are no per-step commands to aggregate.
### Phase 5 — Self-check (run before emitting)
- [ ] Every agent in every chain comes from the catalogue (after stripping any `everything-claude-code:` prefix that appeared in the plan; see Phase 0 step 5).
- [ ] Resolved `{ORCH_CMD}` and every resolved `{AGENT(...)}` use the **same** form (`plugin` or `legacy`) — never mixed in one output.
- [ ] No `# plugin form` / `# legacy form` annotations and no "strip the prefix" instructions remain in the rendered output.
- [ ] No invented `--mode` / `--gate` / `--agents=...` fields.
- [ ] Each task description is single-line, double-quoted, with embedded `"` escaped.
- [ ] Each task description begins with `[Plan: <path>#step-<id>]` and includes Acceptance (1–3 items). The `Out of scope:` clause is present only when inherited from the plan.
- [ ] No duplicate agent in any chain after Phase 2 dedup.
- [ ] Chain length ≤ 4.
- [ ] Steps tagged `impl`/`refactor`/`migration` end with a reviewer-class agent (`<lang>-reviewer`, `code-reviewer`, `security-reviewer`, or `database-reviewer`). `test` and `build` are exempt — see Phase 2 rule 10.
- [ ] Zero-tag steps emit `code-reviewer` with the rationale `no tag matched; default review-only chain`.
- [ ] Overview table lists every step in the plan, regardless of `--scope`.
- [ ] Per-step detail block count matches the resolved `--scope` (full plan when `--scope=all`; one block for `step:n`; range size for `range:a-b`). In overview-only mode, no per-step blocks and no Batch block are emitted.
## Edge cases
- **No clear steps**: prefer H2/H3 splitting; if still ambiguous, report "no structured steps detected" with the document outline and ask the user to confirm running by outline.
- **Large plan (>1500 lines)**: enter **overview-only mode** — emit only the overview table and ask the user to narrow with `--scope` before re-running for details. In this mode, skip per-step detail blocks and skip the Batch execution block.
- **Step too broad** (e.g. "complete all backend work"): do not force a single chain. Suggest splitting into N.a and N.b and propose a split.
- **Plan declares agents** (rare): first **strip any `everything-claude-code:` prefix** to get the bare catalogue name (Phase 0 step 5), then validate against the catalogue. Replace invalid agents and explain under "Chain rationale". The bare name is re-prefixed at output time per `ECC_MODE`.
- **Polyglot project where `--lang=auto` cannot pick a winner**: set `lang=unknown`; reviewer resolves to `code-reviewer` and build resolver to `build-error-resolver`. Mention the fallback under "Chain rationale".
## Examples
### Example 1 — Plugin mode, Python plan
Input:
```
plan-orchestrate @docs/plan/example-feature.md --lang=python
```
Excerpt of expected output:
````markdown
## Step 2 — Encrypt sensitive UserProfile fields
**Intent**: Introduce an `EncryptedString` SQLAlchemy type and AES-GCM encrypt `birth_datetime` / `location` before persistence; load the key from an environment variable.
**Tags**: impl, security, db
**Chain rationale**: Security-sensitive write path, so `security-reviewer` closes the chain; `database-reviewer` validates the alembic migration; `python-reviewer` covers typing and PEP 8.
```bash
/everything-claude-code:orchestrate custom "everything-claude-code:tdd-guide,everything-claude-code:database-reviewer,everything-claude-code:python-reviewer,everything-claude-code:security-reviewer" "[Plan: docs/plan/example-feature.md#step-2] Implement EncryptedString SQLAlchemy type and migrate UserProfile.birth_datetime/location columns; key from ENV APP_DB_KEY; Acceptance: encrypt/decrypt roundtrip tests pass; alembic upgrade/downgrade clean on empty DB; no plaintext in DB after migrate; Out of scope: cross-tenant profile sharing logic"
```
````
### Example 2 — Legacy mode, same step
If `ECC_MODE=legacy` were detected, the same step would be emitted as a single uniform command (no plugin-prefixed forms anywhere in the output):
```bash
/orchestrate custom "tdd-guide,database-reviewer,python-reviewer,security-reviewer" "[Plan: docs/plan/example-feature.md#step-2] ..."
```
The two examples above illustrate **the two possible outputs** for two different environments. A single skill invocation produces only one of them, end to end.
## Notes
- Generative only. Never invoke `/orchestrate` from inside this skill.
- Match the language of the plan document for task descriptions (agent names always remain English).
- Do not insert "Co-Authored-By" lines or emoji in the output unless the user explicitly asks.
Alle Dateien
1 Dateienplan-orchestrate installieren
Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.
ZIP herunterladenKlonen Sie das Repository und kopieren Sie die Skill-Dateien in Ihr Projekt.
git clone https://github.com/affaan-m/ECC/tree/main/skills/plan-orchestrate # Copy SKILL.md to your .claude/skills/ directory
Kopieren





Heim
