Option

plan-orchestrate

affaan-m/ECC 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 erweitern
9
Zeit aktualisiert 4. Oktober 2026

Planen 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 /orchestrate abarbeiten.
  • 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 custom auf.
  • 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+) /plugins/marketplaces/everything-claude-code/ existiert /everything-claude-code:orchestrate everything-claude-code:
Veraltete Basisinstallation Oben nicht vorhanden; Agent-Dateien unter /agents/ /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, Schrittplanung
  • architect — Architektur, Systemdesign, Refactoring-Vorschläge
  • tdd-guide – Tests schreiben → implementieren → 80 %+ Testabdeckung
  • Code-Reviewer – allgemeine Code-Überprüfung
  • Sicherheitsprüfer — Sicherheitsaudit, OWASP, Aufdeckung von Geheimnissen
  • Refactor-Cleaner – toter Code, Duplikate, Bereinigung der Knip-Klasse
  • Dok-Aktualisierer — Dokumentation, Codemap, README
  • docs-lookup – API-Abfragen für Bibliotheken von Drittanbietern (Context7)
  • e2e-runner – Koordination von End-to-End-Tests
  • database-reviewer – PostgreSQL-Schema, Migration, Leistung
  • harness-optimizer – Konfiguration des lokalen Agent-Harnesses
  • loop-operator – Lang laufende autonome Schleifen
  • chief-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

  1. Lesen . Falls fehlend oder leer, melden und abbrechen.

  2. Ermittle die ECC-Installationsform einmalig und lege sie als ECC_MODE fest. Algorithmus (der Reihe nach ausführen, bei erster Übereinstimmung anhalten):

    1. Wenn /plugins/marketplaces/everything-claude-code/ existiert → ECC_MODE=plugin.
    2. Andernfalls: Wenn /agents/ existiert und mindestens eine ECC-Agent-Datei enthält (z. B. tdd-guide.md, code-reviewer.md) → ECC_MODE=legacy.
    3. Andernfalls → Standardwert ECC_MODE=legacy und 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.
    4. Wenn beide Marker vorhanden sind (gemischte Installation), hat das Plugin Vorrang – 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.

  3. 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.txt oder *.cpp auf oberster Ebene → cpp; pom.xml / build.gradle (Java) → java; build.gradle.kts oder 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, setze lang=unknown.
    • Es wurde kein Marker gefunden → setze lang=unknown.
    • lang=unknown ist ein Sentinel – es handelt sich nicht um einen Agenten-Namen. Die Regeln 4 und 5 der Phase 2 wandeln ihn zum Zeitpunkt der Kettenzusammenstellung in einen Code-Reviewer bzw. Build-Fehler-Beheber um.
  4. Erkenne ein PyTorch-Unterprofil: Wenn lang=python gilt und in einer der Dateien pyproject.toml, requirements.txt oder uv.lock eine Abhängigkeit von torch deklariert ist, setze pytorch=true. Dies wirkt sich nur auf die Auswahl der Build-Kette aus (Regel der Phase 2 unten); der Prüfer bleibt python-reviewer.

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

  1. Explizite Nummerierung: ## Schritt N / ### Phase N / ## N. ... / geordnete Liste auf oberster Ebene.
  2. Eine Spalte „Schritt“ in einer Tabelle.
  3. ----getrennte Blöcke mit verbengeführten Überschriften.
  4. 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,-Reviewer
Test Test, Testabdeckung, E2E, Integration tdd-guide, e2e-runner
Umgestalten Refactoring, Bereinigung, Duplikate entfernen, Aufteilen Architekt, Refactor-Cleaner,-Reviewer
Migration Migration, Upgrade, Neuprogrammierung, Portierung Architekt, TDD-Leitfaden, – Prüfer
DB Schema, Migration, Index, SQL, Postgres, Alembic, SQLModel Datenbank-Prüfer,-Prüfer
Sicherheit Verschlüsselung, Authentifizierung, Geheimnisse, OWASP, personenbezogene Daten Sicherheitsprüfer,-Prüfer
Build Build, Kompilieren, Lint-Fehler, CI -Build-Resolver (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 -Prüfer, Code-Prüfer
Schleife Schleife, autonom, Watchdog Schleifenoperator

Regeln für die Zusammensetzung von Ketten:

  1. 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.
  2. impl + security → tdd-guide,-reviewer,security-reviewer.
  3. impl + db → tdd-guide,database-reviewer,-reviewer.
  4. 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.
  5. -reviewer wird zu code-reviewer aufgelöst, wenn lang=unknown ist.
  6. -build-resolver wird zu build-error-resolver aufgelöst, wenn lang=unknown ist. Sonderfall: Wenn in Phase 0 pytorch=true gesetzt wurde, verwende pytorch-build-resolver für Build- Ketten, unabhängig von . Es gibt keinen „python-build-resolver“; „--lang=python“ ohne „pytorch=true“ wird zu „build-error-resolver“ aufgelöst.
  7. 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“.
  8. Kettenlänge ≤ 4 nach Deduplizierung. Bei Überschreitung das schwächste Tag verwerfen (zuerstLookup und Docs ).
  9. Planer und Architekt nicht in einer „impl“-Kette kombinieren (Tokenverschwendung). Kombiniere sie nur bei Design -Schritten.
  10. 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 „-reviewer“, da „database-reviewer“ die Migration bereits früher in der Kette abschließt). Test- und Build-Schritte werden durch ihre eigenen Validatoren (e2e-runner bzw. 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: #step-] beginnen.
  • 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:orchestrate unter „Plugin“, /orchestrate unter „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 # plugin oder # 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**: <a, b>
**Begründung für die Kette**: <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>; Abnahme: <1–3 items>; Außerhalb des Umfangs: <…>"
```
</code></pre>
<blockquote>
<p>Die obige Notation <code>{ORCH_CMD}</code> und <code>{AGENT(...)}</code> beschreibt die Substitution, die diese Funktion zur Laufzeit durchführt. Das tatsächlich ausgegebene Markdown enthält die aufgelösten Zeichenfolgen, niemals die Platzhalter.</p>
</blockquote>
<p>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. <strong>Überspringe den Batch-Block im reinen Übersichtsmodus</strong> (siehe Randfall „Großer Plan“): Wenn nur die Übersichtstabelle ausgegeben wird, gibt es keine Befehle pro Schritt, die zusammengefasst werden müssen.</p>
<h3>Phase 5 – Selbstprüfung (vor der Ausgabe ausführen)</h3>
<ul>
<li><input disabled="" type="checkbox"> Jeder Agent in jeder Kette stammt aus dem Katalog (nachdem das Präfix <code>„everything-claude-code:“</code> entfernt wurde, das im Plan vorkam; siehe Phase 0, Schritt 5).</li>
<li><input disabled="" type="checkbox"> Aufgelöste <code>{ORCH_CMD}</code> und alle aufgelösten <code>{AGENT(...)}</code> verwenden <strong>dieselbe</strong> Form (<code>Plugin</code> oder <code>Legacy</code>) – niemals gemischt in einer Ausgabe.</li>
<li><input disabled="" type="checkbox"> In der gerenderten Ausgabe verbleiben keine Anmerkungen <code> vom Typ „# Plugin-Form“</code> bzw. <code> „# Legacy-Form“</code> und keine Anweisungen zum Entfernen des Präfixes.</li>
<li><input disabled="" type="checkbox"> Es gibt keine erfundenen Felder wie <code>--mode</code> / <code>--gate</code> / <code>--agents=...</code> </li>
<li><input disabled="" type="checkbox"> Jede Aufgabenbeschreibung ist einzeilig, in doppelte Anführungszeichen gesetzt und enthält eingebettete <code> „-Zeichen</code>, die mit <code> „</code> escaped sind.</li>
<li><input disabled="" type="checkbox"> Jede Aufgabenbeschreibung beginnt mit <code>[Plan: <path>#step-<id>]</code> und enthält die Abnahme (1–3 Punkte). Die Klausel <code>„Out of scope:“</code> ist nur vorhanden, wenn sie aus dem Plan übernommen wurde.</li>
<li><input disabled="" type="checkbox"> Nach der Duplikatsbereinigung in Phase 2 dürfen in keiner Kette doppelte Agenten vorkommen.</li>
<li><input disabled="" type="checkbox"> Kettenlänge ≤ 4.</li>
<li><input disabled="" type="checkbox"> Schritte mit den Tags<code>„impl“, „refactor“ oder „migration“</code> enden mit einem Agenten der Reviewer-Klasse (<code><lang>-reviewer</code>, <code>code-reviewer</code>, <code>security-reviewer</code> oder <code>database-reviewer</code>). <code>„test“</code> und <code>„build“</code> sind davon ausgenommen – siehe Regel 10 der Phase 2.</li>
<li><input disabled="" type="checkbox"> Schritte ohne Tag geben <code>„code-reviewer“</code> mit der Begründung <code>„kein Tag gefunden“</code> aus <code>; standardmäßig „review-only“-Kette</code>.</li>
<li><input disabled="" type="checkbox"> Die Übersichtstabelle listet jeden Schritt im Plan auf, unabhängig von <code>--scope</code>.</li>
<li><input disabled="" type="checkbox"> Die Anzahl der Detailblöcke pro Schritt entspricht dem festgelegten <code>`--scope`</code> (vollständiger Plan bei <code>`--scope=all`</code>; ein Block für <code>Schritt:n</code>; Bereichsgröße für <code>Bereich:a-b</code>). Im reinen Übersichtsmodus werden keine Blöcke pro Schritt und kein Batch-Block ausgegeben.</li>
</ul>
<h2>Randfälle</h2>
<ul>
<li><strong>Keine eindeutigen Schritte</strong>: 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.</li>
<li><strong>Großer Plan (>1500 Zeilen)</strong>: Wechsle in <strong>den reinen Übersichtsmodus</strong> – gib nur die Übersichtstabelle aus und fordere den Benutzer auf, den Umfang mit <code>--scope</code> einzugrenzen, bevor die Ausführung für Details erneut gestartet wird. In diesem Modus werden Detailblöcke pro Schritt sowie der Batch-Ausführungsblock übersprungen.</li>
<li><strong>Schritt zu weit gefasst</strong> (z. B. „alle Backend-Arbeiten abschließen“): Keine einzelne Kette erzwingen. Eine Aufteilung in N.a und N.b vorschlagen und eine Aufteilung vorschlagen.</li>
<li><strong>Plan deklariert Agenten</strong> (selten): <strong>Entferne</strong> zunächst <strong>jegliches <code>„everything-claude-code:</code> “-Präfix</strong>, 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 entsprechend <code>ECC_MODE</code> erneut mit einem Präfix versehen.</li>
<li><strong>Polyglottes Projekt, bei dem <code>--lang=auto</code> keinen Gewinner auswählen kann</strong>: Setze <code>lang=unknown</code>; „reviewer“ wird zu <code>„code-reviewer“</code> und „build-resolver“ zu <code>„build-error-resolver</code>“. Erwähne den Fallback unter „Begründung der Kette“.</li>
</ul>
<h2>Beispiele</h2>
<h3>Beispiel 1 – Plugin-Modus, Python-Plan</h3>
<p>Eingabe:</p>
<pre><code>plan-orchestrate @docs/plan/example-feature.md --lang=python
</code></pre>
<p>Auszug aus der erwarteten Ausgabe:</p>
<pre><code class="language-markdown">## 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“
```
</code></pre>
<h3>Beispiel 2 – Legacy-Modus, derselbe Schritt</h3>
<p>Wenn <code>ECC_MODE=legacy</code> 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):</p>
<pre><code class="language-bash">/orchestrate custom „tdd-guide,database-reviewer,python-reviewer,security-reviewer“ „[Plan: docs/plan/example-feature.md#step-2] …“
</code></pre>
<p>Die beiden obigen Beispiele veranschaulichen <strong>die beiden möglichen Ausgaben</strong> für zwei unterschiedliche Umgebungen. Ein einzelner Skill-Aufruf erzeugt von Anfang bis Ende nur eine davon.</p>
<h2>Hinweise</h2>
<ul>
<li>Nur generativ. Rufen Sie <code>/orchestrate</code> niemals aus diesem Skill heraus auf.</li>
<li>Passen Sie die Sprache der Aufgabenbeschreibungen an die des Plandokuments an (Agentennamen bleiben immer auf Englisch).</li>
<li>Fügen Sie keine „Co-Authored-By“-Zeilen oder Emojis in die Ausgabe ein, es sei denn, der Benutzer fordert dies ausdrücklich an.</li>
</ul>                                </div>
                                <div class="skilldetailsL1_skillmd">
                                    <a href="https://github.com/affaan-m/ECC/tree/main/skills/plan-orchestrate" title="Auf GitHub ansehen" target="_blank" rel="nofollow"
                                        aria-label="Auf GitHub ansehen" class="skilldetails_toGitHub">
                                        <span>Auf GitHub ansehen</span>
                                        <b></b>
                                    </a>
                                    <pre><code>---
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.
</code></pre>                                </div>
                            </div>

                        </div>
                        <script>
                            layui.use(function () {
                                var element = layui.element;
                                element.tab({
                                    headerElem: "#skilldetailsL1_header>button",
                                    bodyElem: "#skilldetailsL1_body>div",
                                });
                            });
                        </script>
                        <div class="skilldetailsL2">
                            <div class="skilldetailsL2_title">
                                <h2>Alle Dateien</h2>
                                <span>1 Dateien</span>
                            </div>
                                                        <div class="skillFiles">
                                <div class="skillFilesL">
                                    <b></b>
                                    <a href="https://github.com/affaan-m/ECC/tree/main/skills/plan-orchestrate" title="plan-orchestrate.md" target="_blank"
                                        aria-label="plan-orchestrate.md"
                                        rel="nofollow">plan-orchestrate.md</a>
                                    <span>17.5k</span>
                                </div>
                                <a href="https://github.com/affaan-m/ECC/tree/main/skills/plan-orchestrate" title="Ansehen" target="_blank" aria-label="Ansehen"
                                    rel="nofollow">Ansehen</a>
                            </div>
                                                    </div>
                    </div>
                    <div class="skilldetailsR">
                        <div class="skilldetailsR1">
                            <div class="skilldetailsR1s">
                                <h2>plan-orchestrate installieren</h2>
                                <div class="skilldetailsR1s_header" id="skilldetailsR1s_header">
                                    <button class="layui-this">
                                        <b></b>
                                        <span>ZIP herunterladen</span>
                                    </button>
                                    <button class="">
                                        <b></b>
                                        <span>Git Clone</span>
                                    </button>
                                </div>
                                <div class="skilldetailsR1s_body" id="skilldetailsR1s_body">
                                    <div class="skilldetailsR1s_body1 layui-show">
                                        <p>Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.</p>
                                        <a href="javascript:;" title="ZIP herunterladen" data-source="TeeN26C1ni2ZDZRkOJVh9w"
                                            aria-label="ZIP herunterladen" role="button" class="skill_downloadzip">
                                            <b></b>
                                            <span>ZIP herunterladen</span>
                                        </a>
                                    </div>
                                    <div class="skilldetailsR1s_body2">
                                        <p>Klonen Sie das Repository und kopieren Sie die Skill-Dateien in Ihr Projekt.</p>
                                        <div class="skill_clone">
                                            <p>
                                                git clone https://github.com/affaan-m/ECC/tree/main/skills/plan-orchestrate
# Copy SKILL.md to your .claude/skills/ directory                                            </p>
                                            <a href="javascript:;" title="Kopieren" role="button" aria-label="Kopieren"
                                                class="skill_clone_copy">
                                                <img src="/assets/images/prompt_word2RMs_p_btn.png"
                                                    alt="Kopieren" />
                                                <span>Kopieren</span>
                                            </a>
                                        </div>
                                    </div>
                                </div>
                                <div class="skilldetailsR1s_info">
                                    <span>Schnelle Einrichtung: </span>
                                    Kopieren Sie den Skill-Ordner nach „.claude/skills/“.
Claude erkennt den Skill automatisch und nutzt ihn.                                </div>
                                <div class="skilldetailsR1s_repository">
                                    <span>Repository</span>
                                    <a href="https://github.com/affaan-m/ECC/tree/main/skills/plan-orchestrate" title="affaan-m/ECC" target="_blank"
                                        aria-label="Repository" rel="nofollow">affaan-m/ECC</a>
                                </div>
                            </div>
                        </div>
                        <div class="skilldetailsR2">
                            <h2>Ähnliche Skills</h2>
                            <div>
                                                                <div class="skilldetailsR2s">
                                    <a href="/de/skill/detail/airtableautomation.html" title="airtable-automation" aria-label="airtable-automation">airtable-automation</a>
                                    <div>
                                        <div class="skilldetailsR2s_time">
                                            <b></b>
                                            <span>Zeit aktualisiert                                                29. Juni 2026</span>
                                        </div>
                                        <button class="xix_star skill_datas"
                                            data-source="P_PqrAzxvKSebU4gaXatSw">
                                            <b></b>
                                            <span
                                                class="collectNums_P_PqrAzxvKSebU4gaXatSw">0</span>
                                        </button>
                                    </div>
                                </div>
                                                                <div class="skilldetailsR2s">
                                    <a href="/de/skill/detail/notionautomation.html" title="notion-automation" aria-label="notion-automation">notion-automation</a>
                                    <div>
                                        <div class="skilldetailsR2s_time">
                                            <b></b>
                                            <span>Zeit aktualisiert                                                29. Juni 2026</span>
                                        </div>
                                        <button class="xix_star skill_datas"
                                            data-source="yLOF7em0zgx36kG9EQmIAQ">
                                            <b></b>
                                            <span
                                                class="collectNums_yLOF7em0zgx36kG9EQmIAQ">0</span>
                                        </button>
                                    </div>
                                </div>
                                                                <div class="skilldetailsR2s">
                                    <a href="/de/skill/detail/seoprogrammatic.html" title="seo-programmatic" aria-label="seo-programmatic">seo-programmatic</a>
                                    <div>
                                        <div class="skilldetailsR2s_time">
                                            <b></b>
                                            <span>Zeit aktualisiert                                                29. Juni 2026</span>
                                        </div>
                                        <button class="xix_star skill_datas"
                                            data-source="qrlDZwmv4vNLPwqrODKcOQ">
                                            <b></b>
                                            <span
                                                class="collectNums_qrlDZwmv4vNLPwqrODKcOQ">0</span>
                                        </button>
                                    </div>
                                </div>
                                                                <div class="skilldetailsR2s">
                                    <a href="/de/skill/detail/revops.html" title="revops" aria-label="revops">revops</a>
                                    <div>
                                        <div class="skilldetailsR2s_time">
                                            <b></b>
                                            <span>Zeit aktualisiert                                                29. Juni 2026</span>
                                        </div>
                                        <button class="xix_star skill_datas"
                                            data-source="ZDIT-veTOzkFQQ0eUEoT-g">
                                            <b></b>
                                            <span
                                                class="collectNums_ZDIT-veTOzkFQQ0eUEoT-g">0</span>
                                        </button>
                                    </div>
                                </div>
                                
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </main>
        <footer>
  <div class="footer">
    <div class="footer1">
      <div class="footer11">
        <span class="footer11_title">Heiße KI -Werkzeuge</span>
        <div class="footer11info">
                    <a href="/de/tool/ai-clothes-remover.html" aria-label="AI Clothes Remover" class="footer11s">AI Clothes Remover</a>
                    <a href="/de/tool/deepnude-generator.html" aria-label="DeepNude generator" class="footer11s">DeepNude generator</a>
                    <a href="/de/tool/purechat.html" aria-label="PureChat" class="footer11s">PureChat</a>
                  </div>
      </div>
      <div class="footer12">
        <span class="footer11_title">KI -Werkzeuge mit Potenzial</span>
        <div class="footer11info">
                    <a href="/de/tool/idea-box-ai-tool.html" aria-label="Name Idea Box" class="footer11s">Name Idea Box</a>
                    <a href="/de/tool/qi-jing-ai-ai-tool.html" aria-label="奇境 AI" class="footer11s">奇境 AI</a>
                    <a href="/de/tool/ezaudio-ai-tool.html" aria-label="EZAudio" class="footer11s">EZAudio</a>
                  </div>
      </div>
      <div class="footer13">
        <span class="footer11_title">MEHR LESEN</span>
        <div class="footer11info">
                    <a href="/de/ainews/ai-hosts-notebooklm-podcast-interviews.html" aria-label="KI -Hosts des Notebooklm -Podcasts, das jetzt für Interviews verfügbar ist" class="footer11s">KI -Hosts des Notebooklm -Podcasts, das jetzt für Interviews verfügbar ist</a>
                    <a href="/de/ainews/corporate-ai-adoption-leveling-ramp-data.html" aria-label="Ramp-Daten zeigen, dass die Akzeptanz von KI in Unternehmen sinkt" class="footer11s">Ramp-Daten zeigen, dass die Akzeptanz von KI in Unternehmen sinkt</a>
                    <a href="/de/ainews/microsoft-unveils-businessfocused-copilot-surface-devices-powered-intel.html" aria-label="Microsoft enthüllt geschäftsorientierte Copilot+ Oberflächengeräte, die von Intel angetrieben werden" class="footer11s">Microsoft enthüllt geschäftsorientierte Copilot+ Oberflächengeräte, die von Intel angetrieben werden</a>
                  </div>
      </div>
      <div class="footer4">
        <span class="footer11_title">Folgen</span>
        <div class="footer11info">
          <a href="javascript:;" class="footer11s">Kontaktieren Sie uns</a>
          <a href="mailto:admin@xix.ai" role="button" aria-label="Kontaktieren Sie uns" class="footer11s">admin@xix.ai</a>
          <a href="/sitemap.xml" class="footer11s" aria-label="SiteMap">SiteMap</a>
        </div>
      </div>
    </div>
    <span class="footer2"></span>
    <div class="footer3">Copyright ©2025 xix.ai All Rights Reserved.</div>
  </div>
</footer>
<div class="ai_cookie" style="display: none">
      <div class="ai_cookie_b">
        <div class="icon_f ai_cookie_close">
          <svg class="icon" aria-hidden="true">
            <use xlink:href="#icon-guanbi1"></use>
          </svg>
        </div>
        <p>
          Durch das Klicken auf „Alle Cookies akzeptieren“ stimmen Sie zu, dass Cookies auf Ihrem Gerät gespeichert werden, um die Seitennavigation zu verbessern, die Seitennutzung zu analysieren und unsere Marketingbemühungen zu unterstützen.<span>Datenschutzerklärung</span> Hinweis        </p>
        <div class="cokiesetRight">
          <a href="javascript:;" class="cokieA ai_cookie_open"  role="button" aria-label="Cookie-Einstellungen">Cookie-Einstellungen</a>
          <a href="javascript:;" class="cokieA RefuseCookies" role="button" aria-label="Alle ablehnen">Alle ablehnen</a>
          <a href="javascript:;" class="cokieA cokieAall" role="button" aria-label="Alle Cookies akzeptieren">Alle Cookies akzeptieren</a>
        </div>
      </div>
    </div>
    <div class="ai_cookieSettings" style="display: none">
      <div class="layuiDivcokie layui-layer-wrap" id="layuiDivcokie" style="display: block">
        <div class="cokielayTop dlyflx">
          <img src="/assets/images/logo.png" alt="" />
          <div class="icon_f ai_cookie_close1">
            <svg class="icon" aria-hidden="true">
              <use xlink:href="#icon-guanbi"></use>
            </svg>
          </div>
        </div>
        <hr />
        <div class="cokielayDown dlyflx">
          <p class="cokielaydTop">Datenschutz-Einstellungen</p>
          <p class="cokielaydDesc">
            Beim Besuch einer Website kann diese Informationen in Ihrem Browser speichern oder abrufen, hauptsächlich in Form von Cookies. Diese Informationen können sich auf Sie, Ihre Präferenzen oder Ihr Gerät beziehen und dienen hauptsächlich dazu, dass die Website so funktioniert, wie Sie es erwarten. Die Informationen identifizieren Sie in der Regel nicht direkt, können Ihnen aber ein personalisierteres Web-Erlebnis bieten. Da wir Ihr Recht auf Privatsphäre respektieren, können Sie wählen, dass Sie bestimmte Arten von Cookies nicht zulassen. Klicken Sie auf die verschiedenen Kategorietitel, um mehr zu erfahren und unsere Standardeinstellungen zu ändern. Das Blockieren bestimmter Arten von Cookies kann jedoch Ihre Erfahrung auf der Website und die von uns angebotenen Dienste beeinträchtigen. <a href="#" title="Datenschutzerklärung" aria-label="Datenschutzerklärung"><span>Datenschutzerklärung</span></a> <b>Erklärung</b>          </p>

          <div class="cokielayDivdown">
            <p class="coklaydownP">Einstellungen verwalten</p>
            <ul class="cokidownUl">
              <li class="cokidownli dlyflx" style="padding: 25px 0px 25px">
                <div class="ckdTops">
                  <div class="ckdLeft">
                    <div class="icon_f">
                      <svg class="icon" aria-hidden="true">
                        <use xlink:href="#icon-add"></use>
                      </svg>
                      <svg class="icon icon_active" aria-hidden="true">
                        <use xlink:href="#icon-add1"></use>
                      </svg>
                    </div>
                    <p class="ckdlipmid">Unbedingt erforderliche Cookies</p>
                  </div>
                  <p class="ckdlipr">Immer aktiv</p>
                </div>
                <p class="ckdDowns">
                  Diese Cookies sind für die Funktionalität der Website erforderlich und können in unseren Systemen nicht deaktiviert werden. Sie werden normalerweise nur in Reaktion auf Ihre Aktionen gesetzt, die einer Dienstanfrage entsprechen, z. B. das Einstellen Ihrer Datenschutzpräferenzen, das Anmelden oder das Ausfüllen von Formularen. Sie können Ihren Browser so einstellen, dass diese Cookies blockiert oder Sie darüber benachrichtigt werden, aber einige Teile der Website werden dann nicht mehr funktionieren. Diese Cookies speichern keine personenbezogenen Daten.                </p>
              </li>
            </ul>
          </div>
        </div>
        <div class="cklyBtn">
          <a href="javascript:;" role="button" aria-label="Alle Cookies akzeptieren" class="active cokieAall">Alle Cookies akzeptieren</a>
        </div>
      </div>
      <script>
        $(document).on("click", ".ai_cookie_close", function () {
          $(".ai_cookie").hide();
        });
        $(document).on("click", ".ai_cookie_close1", function () {
          $(".ai_cookieSettings").hide();
        });
        $(document).on("click", ".ai_cookie_open", function () {
          $(".ai_cookieSettings").show();
        });
        $(document).on("click", ".ckdLeft", function () {
          var $li = $(this).closest("li"); 
          var $downs = $li.find(".ckdDowns"); 
          var $iconBox = $(this).find(".icon_f"); 

         
          $downs.slideToggle(200, function () {
            if ($downs.is(":visible")) {
              $iconBox.find(".icon").hide();
              $iconBox.find(".icon_active").show();
            } else {
              $iconBox.find(".icon").hide();
              $iconBox.find(".icon").first().show(); 
            }
          });
        });     
      </script>
    </div>
<link rel="stylesheet" type="text/css" href="https://accounts.google.com/gsi/style">
<div class="login_tab">
  <div class="login_mainC">
    <div class="login_tab_top">
      <div class="login_tab_top1">
        <a href="javascript:;" role="tab" aria-label="Anmelden" aria-selected="true" class="login_tab_top1a ">Anmelden</a>
        <a href="javascript:;" role="tab" aria-label="Melden Sie sich an" aria-selected="false" class="login_tab_top2a">Melden Sie sich an</a>
      </div>
      <div class="login_tab_top2">
        <a href="javascript:;"><img src="/assets/images/login_mainC_top_m_img.png" alt=""></a>
      </div>

    </div>
    <div class="forms_google">
      <div id="g_id_signin"></div>
    </div>
    <div class="forms_or">
      <div class="forms_line"></div>
      <span>OR</span>
      <div class="forms_line"></div>
    </div>
    <div class="login_tab_bottom">
      <div class="login_tab_top1a_bottom">

        <div class="login_form ">
          <div class="login_forms">
            <img src="/assets/images/login_email.png" alt="E-Mail">
            <input type="text" placeholder="Bitte geben Sie Ihre E -Mail -Adresse ein" class="login_forms_email">
            <span></span>
          </div>
          <div class="login_forms">
            <img src="/assets/images/login_password.png" alt="Passwort">
            <input type="password" placeholder="Bitte geben Sie Ihr Passwort ein" class="login_forms_password">
            <i style="cursor: pointer;" class="layui-icon layui-icon-eye-invisible toggle-password"
              id="toggleLoginPassword"></i>
            <span></span>
          </div>
          <div class="login_forms forms_code1">
            <input type="text" placeholder="Bitte geben Sie den Grafikverifizierungscode ein"
              class="login_forms_captcha">
            <img src="" alt="Bitte geben Sie den Grafikverifizierungscode ein" class="login-js-refresh-captcha">
            <span></span>
          </div>
          <div class="login_forms_bottom">
            <label class="login_remember">
              <input type="checkbox" aria-label="Erinnere dich an mich">
              <span>Erinnere dich an mich</span>
            </label>
            <a href="/de/account/forgetPassword.html" aria-label="Kennwort ändern" class="login_forget">Passwort vergessen</a>
          </div>
          <a href="javascript:;" type="button" role="button" aria-label="Anmelden" id="login_button" class="login_button">Anmelden</a>

        </div>
      </div>
      <div class="login_tab_top2a_bottom">
        <div class="login_form">
          <div class="login_forms">
            <img src="/assets/images/login_email.png" alt="E-Mail">
            <input type="text" placeholder="Bitte geben Sie Ihre E -Mail -Adresse ein" class="register_forms_email">
            <span></span>
          </div>
          <div class="login_forms">
            <img src="/assets/images/login_password.png" alt="Passwort">
            <input type="password" placeholder="Bitte geben Sie Ihr Passwort ein" class="register_forms_password">
            <i style="cursor: pointer;" class="layui-icon layui-icon-eye-invisible toggle-password"
              id="toggleRegisterPassword"></i>
            <span></span>
          </div>
          <div class="login_forms forms_code1">
            <input type="text" placeholder="Bitte geben Sie den Grafikverifizierungscode ein"
              class="register_forms_captcha">
            <img src="" alt="Bitte geben Sie den Grafikverifizierungscode ein" class="register-js-refresh-captcha" id="register_captcha">
            <span></span>
          </div>
          <div class="login_forms">
            <input type="text" class="verify-code-input" placeholder="Bitte geben Sie den Bestätigungscode ein">
            <button id="verifyCodeBtn" class="verify-code-btn" data-text="Bestätigungscode erhalten">Bestätigungscode erhalten</button>
            <span></span>
          </div>
          <a href="javascript:;" role="button" aria-label="Melden Sie sich an" class="login_button" id="register_button">Melden Sie sich an</a>
        </div>
      </div>

    </div>
  </div>
</div>
<script src="https://accounts.google.com/gsi/client" async defer></script>
<script>
  $(document).ready(function () {
    LoginRegister.init({
      selectors: {
        email: {
          login: '.login_forms_email',
          register: '.register_forms_email'
        },
        password: {
          login: '.login_forms_password',
          register: '.register_forms_password'
        },
        captcha: {
          login: '.login_forms_captcha',
          register: '.register_forms_captcha',
          verify: '.verify-code-input'
        },
        buttons: {
          login: '#login_button',
          register: '#register_button',
          verifyCode: '#verifyCodeBtn'
        },
        tabs: {
          login: '.login_tab_top1a',
          register: '.login_tab_top2a',
          close: '.login_tab_top2 a'
        }
      },
      messages: {
        email: "Das E -Mail -Format ist falsch",
        password: {
          empty: "Bitte geben Sie Ihr Passwort ein",
          invalid: "Das Passwort muss 6-18 Zeichen betragen und sowohl Buchstaben als auch Zahlen enthalten"
        },
        captcha: "Bitte geben Sie den Grafikverifizierungscode ein",
        verifyCode: "Bitte geben Sie den Bestätigungscode ein",
        operationInProgress: "Betrieb in Bearbeitung, bitte warten Sie",
        unexpectedError: "Ein unerwarteter Fehler trat auf"
      },
      urls: {
        login: "/de/account/dologin.html",
        register: "/de/account/register.html",
        getMailSign: "/de/account/getMailSign",
        sendMail: "/de/account/registerSendMail.html",
        redirctUrl:'pc'
      }
    });
  });
  function initializeGoogleSignIn() {
    if (typeof google === 'undefined' || !google.accounts) {
      setTimeout(initializeGoogleSignIn, 100);
     
      return;
    }

    google.accounts.id.initialize({
      client_id: "294584378011-s53466qiuig7d30tcqrpjv1ue3ni2gun.apps.googleusercontent.com",
      callback: handlePCCredentialResponse,
      auto_select: false,
      locale: 'de',
      
    });
    
    google.accounts.id.renderButton(
      document.getElementById("g_id_signin"),
      {
        theme: "outline",
        size: "large",
        type: "standard",
        shape: "rectangular",
        logo_alignment: "left",
        text: "signin_with",
        width: 400,
        locale: 'de',
      }
    );
    
  }
  document.addEventListener('DOMContentLoaded', initializeGoogleSignIn);
</script>
  <!-- Google tag (gtag.js) -->
  <script  async src="https://www.googletagmanager.com/gtag/js?id=G-LN407DS0B4"></script>
  <script>
    window.dataLayer = window.dataLayer || [];
    function gtag(){dataLayer.push(arguments);}
    gtag('js', new Date());
  
    gtag('config', 'G-LN407DS0B4');
  </script>
  <script src="/kukukuwl.js"   type="text/javascript"></script>
 <a href="javascript:void(0);" class="totop" role="button" aria-label="Zurück nach oben"><img src="/assets/images/totop.png" alt="" /></a>
        <script>
            layui.use(function () {
                var element = layui.element;
                element.tab({
                    headerElem: "#skilldetailsR1s_header>button",
                    bodyElem: "#skilldetailsR1s_body>div",
                });
            });
            function initSkillCloneCopy() {
                $(document)
                    .off("click.skillCloneCopy")
                    .on("click.skillCloneCopy", ".skill_clone .skill_clone_copy", function (e) {
                        e.preventDefault();

                        var $btn = $(this);
                        var $img = $btn.find("img");

                        var text = $.trim($btn.siblings("p").text());

                        var $temp = $("<textarea>");
                        $("body").append($temp);
                        $temp.val(text).select();

                        try {
                            document.execCommand("copy");

                            // 切换成功图标
                            $img.attr("src", "/assets/images/prompt_word2RMs_p_btn_ok.png");
                            $btn.addClass("active");
                            // 清除上一次定时器
                            clearTimeout($btn.data("copyTimer"));

                            // 3秒后恢复原图
                            var timer = setTimeout(function () {
                                $img.attr("src", "/assets/images/prompt_word2RMs_p_btn.png");
                                $btn.removeClass("active");
                            }, 3000);

                            $btn.data("copyTimer", timer);
                        } catch (err) {
                            alert("复制失败");
                        }

                        $temp.remove();
                    });
            }

            function initSkilldetailsFixed() {
                var $box = $(".skilldetailsR1");
                if (!$box.length) {
                    return;
                }
                var fixedTop = 20;
                var topOffset = $box.offset().top;
                var boxHeight = $box.outerHeight();
                var $placeholder = $("<div></div>").height(boxHeight).hide();
                $box.before($placeholder);
                function handleFixed() {
                    if ($(window).width() <= 1024) {
                        $placeholder.hide();
                        $box.css({
                            position: "",
                            top: "",
                            width: "",
                            zIndex: "",
                        });
                        return;
                    }
                    var scrollTop = $(window).scrollTop();
                    if (scrollTop >= topOffset - fixedTop) {
                        $placeholder.show();
                        $box.css({
                            position: "fixed",
                            top: fixedTop + "px",
                            width: $placeholder.width() + "px",
                            zIndex: 100,
                        });
                    } else {
                        $placeholder.hide();
                        $box.css({
                            position: "",
                            top: "",
                            width: "",
                            zIndex: "",
                        });
                    }
                }
                $(window).on("scroll.skilldetailsFixed resize.skilldetailsFixed", handleFixed);
                handleFixed();
            }
            function initSkilldetailsExpand() {
                $(".skilldetailsL_p").each(function () {
                    var $item = $(this);

                    $item.find(".skilldetailsL_p_expand").text($item.hasClass("active") ? "...Alle erweitern" : "Versteckt");
                });

                $(document)
                    .off("click.skilldetailsExpand")
                    .on("click.skilldetailsExpand", ".skilldetailsL_p_expand", function (e) {
                        e.preventDefault();

                        var $parent = $(this).closest(".skilldetailsL_p");

                        if ($parent.hasClass("active")) {
                            $parent.removeClass("active");
                            $(this).text("Versteckt");
                        } else {
                            $parent.addClass("active");
                            $(this).text("...Alle erweitern");
                        }
                    });
            }

            function checkFollow() {
                let dataSources = [];
                $('button.skill_datas').each(function () {
                    let source = $(this).data('source');
                    if (source) {
                        dataSources.push(String(source).trim());
                    }
                });
                dataSources = [...new Set(dataSources)];
                if (dataSources.length === 0) {
                    return;
                }
                $.post('/api/user/FindSkillFollow', {
                    source: dataSources
                }, function (res) {
                    if (res.code == 1 && res.data.length > 0) {
                        res.data.forEach(function (id) {
                            $('button.skill_datas[data-source="' + id + '"]').addClass('active');
                        });
                    }
                }, 'json');
            }
            $(function () {
                checkFollow();
                initSkillCloneCopy();
                initSkilldetailsFixed();
                initSkilldetailsExpand();
            });
            $(document).on('click', 'button.skill_datas', function (e) {
                e.preventDefault();
                const that = $(this);
                let source = that.data('source');
                if (!source || source === undefined || !CommonUtils.checkLogin()) return false;
                layer.load(2, {
                    shade: [0.3, "#000"],
                    time: 0,
                });
                var path = "/user/followSkill";
                var realPath = CommonUtils.getRealPath(path);
                $.post(realPath, { source: source }, function (result) {
                    layer.closeAll();
                    CommonUtils.showMsg(result.msg, result.code);
                    if (result.code == 1) {
                        var values = result.data.data_source;
                        var count = result.data.count;
                        var collected = result.data.collected;
                        var elements = $(".collectNums_" + values);
                        if (elements.length > 0) {
                            elements.each(function () {
                                $(this).parents('button').toggleClass('active', collected);
                                $(this).text(count);
                            });
                        }
                    }
                })
            })

            $(document).on('click', '.skill_downloadzip', function (e) {
                e.preventDefault();
                const url = $(this).data("source");
                if (!url) return;
                window.open("/api/index/download_zip?source=" + encodeURIComponent(url), "_blank");
            })

        </script>
    </body>

</html>