plan-orchestrate
affaan-m/ECC
Lee un documento de plan, lo desglosa en pasos, diseña una cadena de agentes para cada paso a partir del catálogo de ECC y genera indicaciones personalizadas listas para pegar u orquestar sin ejecutarlas.
...Expandir todoPlanificar y coordinar
Conecta un documento de plan con /orchestrate custom generando una llamada lista para pegar por cada paso. La habilidad es únicamente generativa: nunca ejecuta /orchestrate. El usuario pega cada línea cuando esté listo.
Cuándo activarla
- El usuario tiene un documento de plan de varios pasos (PRD, RFC, plan de implementación) y quiere llevarlo a cabo mediante
/orchestrate. - El usuario dice «coordinar este plan», «muéstrame indicaciones de /orchestrate para cada paso» o «crea cadenas para este plan».
- Existe un plan paso a paso, pero el usuario no quiere seleccionar manualmente los agentes para cada paso.
Omitir cuando:
- El trabajo consiste en un único paso ad hoc → llamar directamente a
/orchestrate custom. - El plan es ilegible o está vacío. La mera ausencia de numeración explícita no es motivo para omitirlo; véase el caso extremo «Sin pasos claros» más abajo.
Entradas
[--lang=python|typescript|go|rust|cpp|java|kotlin|flutter|auto] [--scope=all|step:|range:-] [--dry-run]
— obligatorio; ruta relativa o absoluta (se acepta@docs/...).--lang— variante de idioma del revisor; el valor por defecto es«auto»(detectado a partir del proyecto).--scope— limita los pasos emitidos; por defecto,«all».--dry-run— muestra solo la descomposición y la justificación de la cadena; no emite las indicaciones finales.
Formato oficial de /orchestrate (no se debe desviar)
{ORCH_CMD} custom ",,...," ""
Donde {ORCH_CMD} se determina en la Fase 0 (véase más abajo). La cadena de comando en la salida emitida siempre utiliza una forma concreta: nunca ambas, nunca un marcador de posición.
«custom»es una cadena secuencial; el HANDOFF de cada agente alimenta al siguiente.- Lista de agentes separados por comas. Se prefiere que no haya espacios; se tolera un espacio.
- No existen los indicadores
--mode/--gate/--agents=...; nunca los inventes. - Los nombres de los agentes proceden del catálogo de esta habilidad. Las comillas dobles incrustadas en la descripción de la tarea se escapan como
\".
Formato de instalación de ECC y espacios de nombres
Dos formatos de instalación determinan el prefijo tanto del comando de barra como de cada nombre de agente. Ambos DEBEN estar sincronizados: un formato por salida, nunca mezclados:
Que denote el directorio de inicio de Claude Code: ~/.claude en macOS/Linux, %USERPROFILE%\.claude en Windows. Resuélvelo tal y como la plataforma anfitriona resuelve el directorio de inicio del usuario (no codifiques ~ de forma fija).
| Forma | Detección | {ORCH_CMD} |
Formato del nombre del agente |
|---|---|---|---|
| Instalación del complemento (1.9.0+) | /plugins/marketplaces/everything-claude-code/ |
/everything-claude-code:orchestrate |
everything-claude-code: |
| Instalación básica heredada | Lo anterior no existe; los archivos del agente se encuentran en |
/orchestrate |
|
Por qué es importante: en la instalación mediante plugin, los agentes se registran como everything-claude-code:tdd-guide. Los nombres sin prefijo obligan a realizar una coincidencia aproximada, lo que falla de forma intermitente en llamadas paralelas. En la instalación heredada, las formas con prefijo no se registran y fallan directamente.
Catálogo de agentes disponibles (hay que elegir entre estos)
General:
planificador— reformulación de requisitos, descomposición de riesgos, planificación de pasosarchitect— arquitectura, diseño del sistema, propuestas de refactorizacióntdd-guide— escribir pruebas → implementar → cobertura superior al 80 %revisor de código— revisión genérica del códigorevisor de seguridad: auditoría de seguridad, OWASP, fugas de información confidenciallimpiador de refactorización: código muerto, duplicados, limpieza de clases «knip»actualizador de documentación— documentación, mapa de código, READMEdocs-lookup— consultas a la API de bibliotecas de terceros (Context7)e2e-runner— orquestación de pruebas de extremo a extremodatabase-reviewer— esquema de PostgreSQL, migración, rendimientoharness-optimizer— configuración del entorno de pruebas de agentes localesloop-operator— bucles autónomos de larga duraciónchief-of-staff— clasificación multicanal (rara vez encaja en los pasos del plan)
Resolventes de errores de compilación:
build-error-resolver(genérico) /cpp-build-resolver/go-build-resolver/java-build-resolver/kotlin-build-resolver/rust-build-resolver/pytorch-build-resolver
Revisores de código:
python-reviewer/typescript-reviewer/go-reviewer/rust-reviewer/cpp-reviewer/java-reviewer/kotlin-reviewer/flutter-reviewer
Un nombre de agente mal escrito provoca un error en /orchestrate. Comprueba esta lista antes de enviarlo.
Cómo funciona
Fase 0: detección del modo ECC y del lenguaje
Leer
. Si falta o está vacío, informar y detener el proceso.Detectar el formulario de instalación de ECC una vez y fijarlo en
ECC_MODE. Algoritmo (ejecutar en orden, detenerse en la primera coincidencia):- Si existe
→/plugins/marketplaces/everything-claude-code/ ECC_MODE=plugin. - En caso contrario, si existe
y contiene al menos un archivo de agente ECC (p. ej.,/agents/ tdd-guide.md,code-reviewer.md) →ECC_MODE=legacy. - En caso contrario → se establece por defecto
ECC_MODE=legacyy se muestra una advertencia de una línea al principio de la salida:> Advertencia: no se ha podido detectar la instalación de ECC; se utiliza por defecto el modo legacy. Si utilizas la instalación del plugin, edita los prefijos manualmente. - Si existen ambos marcadores (instalación mixta), prevalece
el complemento: el espacio de nombres del complemento es el único que resuelve los nombres de los agentes sin coincidencia aproximada.
A partir de este momento, cada línea generada utiliza el prefijo correspondiente tanto en el comando de barra como en cada nombre de agente. Nunca se generarán ambas formas en la misma salida.
- Si existe
Resolver
--lang. Cuando sea«auto», ejecutar una detección compatible con múltiples lenguajes:- Marcadores de detección:
pyproject.toml/uv.lock/requirements.txt→ python;package.json→ typescript;go.mod→ go;Cargo.toml→ rust;CMakeLists.txtoarchivos *.cppde nivel superior → cpp;pom.xml/build.gradle(Java) → java;build.gradle.ktso Kotlin de nivel superior → kotlin;pubspec.yaml→ flutter. - Desempate en caso de poliglotismo: si coincide más de un marcador, elige el lenguaje cuyos archivos fuente superen en número a los demás (cuéntalos mediante
`git ls-files`, excluyendo`vendor/`,`node_modules/`,`dist/`,`build/`,`.venv/`, los archivos generados y los entornos de prueba evidentes). En caso de empate o cuando ningún lenguaje supere el 60 % de los archivos fuente, establecelang=unknown. - Si no coincide ningún marcador → establece
lang=unknown. lang=unknownes un indicador —no es un nombre de agente—. Las reglas 4 y 5 de la fase 2 lo convierten enrevisor de código/resolutor de errores de compilaciónen el momento de la composición de la cadena.
- Marcadores de detección:
Detectar un subperfil de PyTorch: cuando
lang=pythony cualquiera delos archivos pyproject.toml/requirements.txt/uv.lockdeclare una dependencia detorch, establecepytorch=true. Esto solo afecta a la selección de la cadenade compilación(regla de la Fase 2 más abajo); el revisor sigue siendopython-reviewer.Normaliza cualquier nombre de agente declarado en el plan: si el texto del plan hace referencia a los agentes mediante su forma con prefijo de complemento (p. ej.,
everything-claude-code:tdd-guide), elimina el prefijo para obtener el nombre básico del catálogo antes de validar o componer cadenas. La reasignación del prefijo solo se produce en el momento de la salida segúnECC_MODE(Fase 4). Nunca dejes que un nombre con prefijo previo entre en la composición de la cadena, ya que se produciría una doble asignación de prefijos en el modo plugin.
Fase 1 — Descomponer los pasos
Identifica las «unidades de paso» por orden de prioridad:
- Numeración explícita:
## Paso N/### Fase N/## N. .../ lista ordenada de nivel superior. - Una columna «Paso» en una tabla.
- ----bloques
separadoscon encabezados que comienzan por un verbo. - En caso contrario, trata cada H2 como un paso.
Por paso, extrae el ID (a partir de 1), el título (≤ 80 caracteres), la intención (1-3 frases) y las etiquetas.
Fase 2 — Etiquetar y seleccionar la cadena
Etiqueta por intención (se permiten varias etiquetas; la cadena se construye a partir de la principal más las secundarias apiladas):
Las palabras clave que figuran a continuación se comparan sin distinguir entre mayúsculas y minúsculas. Se admiten planes multilingües al comparar las raíces de las palabras en cualquier idioma, siempre que el significado coincida con las palabras clave en inglés enumeradas.
| Etiqueta | Palabras clave | Cadena predeterminada |
|---|---|---|
diseño |
arquitectura, diseño, elegir, evaluar, RFC | planificador, arquitecto |
plan |
plan, desglose, hito | planificador |
impl |
implementar, construir, añadir, crear, portar | guía de TDD, |
prueba |
prueba, cobertura, e2e, integración | guía-TDD, ejecutor-e2e |
refactorizar |
refactorización, limpieza, eliminación de duplicados, división | arquitecto, refactorizador-limpiador, |
migración |
migrar, actualizar, reescribir, portar | arquitecto, guía de TDD, |
b.d. |
esquema, migración, índice, SQL, Postgres, Alembic, SQLModel | revisor de bases de datos, |
seguridad |
cifrado, autenticación, secretos, OWASP, datos de carácter personal | revisor de seguridad, |
compilación |
compilación, compilación, error de lint, CI | (recurre a resolución-de-errores-de-compilación) |
documentación |
documentación, archivo «readme», mapa de código, registro de cambios | actualizador de documentación |
búsqueda |
búsqueda, referencia, uso de la API | búsqueda en la documentación |
revisión |
revisión, auditoría, verificación | |
bucle |
bucle, autónomo, watchdog | operador de bucle |
Reglas de composición de cadenas:
- Selección de la etiqueta principal: cuando un paso coincide con varias etiquetas, la primera en el orden de la tabla (la parte superior de la tabla = máxima prioridad) es la principal; el resto son secundarias. Las reglas de composición 2 y 3 que figuran a continuación tratan explícitamente combinaciones específicas de varias etiquetas; en los demás casos, se añaden cadenas secundarias en el orden de la tabla de etiquetas.
impl+security→tdd-guide,.-reviewer,security-reviewer impl+db→tdd-guide,database-reviewer,.-reviewer - Elimina los duplicados de la cadena resultante (conserva la primera aparición). Por ejemplo,
«review+lang=unknown»daría como resultado«code-reviewer,code-reviewer»tras aplicar la regla 5; la eliminación de duplicados lo reduce a«code-reviewer». se resuelve como-reviewer code-reviewercuandolang=unknown.se resuelve como-build-resolver build-error-resolvercuandolang=unknown. Caso especial: si en la Fase 0 se establecepytorch=true, utilicepytorch-build-resolverpara las cadenasde compilaciónindependientemente de. No existe«python-build-resolver»;«--lang=python» sin«pytorch=true»se resuelve como«build-error-resolver».- Pasos sin etiqueta: si no coincide ninguna palabra desencadenante, establece la cadena en
«code-reviewer»y escribe«no se ha encontrado ninguna etiqueta»; cadena predeterminada «solo revisión» según la «Justificación de la cadena». - Longitud de la cadena ≤ 4 tras la deduplicación. Si se supera, se descarta la etiqueta más débil (primero
«lookup»y«docs»). - No emparejes
«planner»y«architect»en una cadena«impl»(desperdicio de tokens). Emparejalos solo en pasosde diseño. - Los pasos etiquetados como
«impl»,«refactor» o«migration»terminan con un agente de clase «reviewer »: cualquiera de los siguientes:«,-reviewer» «code-reviewer»,«security-reviewer» o«database-reviewer». El revisor más específico del dominio ocupa la última posición (por ejemplo,«impl+security»de la regla 2 termina con«security-reviewer»;«impl+db»de la regla 3 termina con«, ya que-reviewer» «database-reviewer»ya controla la migración en una fase anterior de la cadena). Los pasosde pruebaycompilaciónestán controlados por sus propios validadores (e2e-runnery el resolutor de compilación, respectivamente) y no requieren un revisor adicional.
Fase 3 — Comprimir la descripción de la tarea
Cada debe:
- Ser autónoma (el primer agente no necesita tener abierto el documento del plan).
- Comenzar con
[Plan:.#step- ] - Incluir entre 1 y 3 criterios de aceptación verificables.
- Incluir una cláusula de alcance (
Fuera de alcance: ...) solo si el plan declara una para este paso. Heredarla tal cual. Si el plan no contiene ninguna declaración de fuera de alcance, omitir la cláusula por completo; no inventar ninguna. - Tenga entre 200 y 600 caracteres; una sola línea; el carácter
«»debe escaparse como«\»; no incluya saltos de línea literales.
Fase 4 — Salida
Genera Markdown utilizando el formato determinado por ECC_MODE. La salida utiliza un único formato en todo momento: cada {ORCH_CMD} y cada nombre de agente se representa con el prefijo correspondiente de la Fase 0. No emitas ambos formatos; no incluyas instrucciones del tipo «esta es la forma del complemento» o «elimina el prefijo» en la salida generada.
Reglas concretas de representación:
{ORCH_CMD}=/everything-claude-code:orchestrateenel plugin,/orchestrateenel modo heredado.{AGENT(nombre)}=everything-claude-code:enel plugin,en el modoheredado.- La columna «Chain» de la tabla de resumen utiliza la misma representación
{AGENT(name)}. - Los bloques bash por paso contienen únicamente el comando ejecutable. No hay comentarios
del tipo # plugin formni# legacy form: el formato es implícito y uniforme en toda la salida.
Estructura de la salida:
# Resultado de Plan-Orchestrate
**Plan**: ``
**Lenguaje**: ``
**Modo ECC**: ``
**Pasos**:
**Ámbito**:
## Resumen de los pasos
| # | Título | Etiquetas | Cadena |
|---|---|---|---|
| 1 | ... | impl, db | `{AGENT(tdd-guide)},{AGENT(database-reviewer)},{AGENT(python-reviewer)}` |
| ... | | | |
---
## Paso 1 —
**Objetivo**: <1–3 sentences>
**Etiquetas**:
**Justificación de la cadena**:
```bash
{ORCH_CMD} custom "{AGENT(tdd-guide)},{AGENT(database-reviewer)},{AGENT(python-reviewer)}" "[Plan: docs/foo.md#step-1] ; Aceptación: <1–3 items>; Fuera del alcance: <…>"
```
La notación
{ORCH_CMD}y{AGENT(...)}anterior describe la sustitución que realiza esta habilidad en tiempo de ejecución. El código Markdown emitido realmente contiene las cadenas resueltas, nunca los marcadores de posición.
Añade un bloque final de «Ejecución por lotes» que agrupe los comandos de cada paso en orden, para que el usuario pueda pegarlos todos a la vez. Omite el bloque de ejecución por lotes en el modo de solo resumen (véase el caso extremo «Plan extenso»): cuando solo se genera la tabla de resumen, no hay comandos por paso que agrupar.
Fase 5 — Autocomprobación (ejecutar antes de generar)
- Cada agente de cada cadena procede del catálogo (tras eliminar cualquier prefijo
«everything-claude-code:»que apareciera en el plan; véase la fase 0, paso 5). - Los
{ORCH_CMD}resueltos y todoslos {AGENT(...)}resueltos utilizan el mismo formato (complementooheredado); nunca se mezclan en una misma salida. - No quedan anotaciones del tipo
«# forma de plugin» o«# forma heredada», ni instrucciones de «eliminar el prefijo» en la salida generada. - No hay campos inventados como
--mode/--gate/--agents=... - Cada descripción de tarea ocupa una sola línea, entre comillas dobles, con el carácter
«»escapado. - Cada descripción de tarea comienza con
[Plan:e incluye Aceptación (1–3 elementos). La cláusula#step- ] «Fuera del alcance:»solo está presente cuando se hereda del plan. - No hay agentes duplicados en ninguna cadena tras la deduplicación de la Fase 2.
- Longitud de la cadena ≤ 4.
- Los pasos etiquetados como
«impl», «refactor»o«migration»terminan con un agente de clase «reviewer» (,-reviewer code-reviewer,security-reviewerodatabase-reviewer).«test»y«build»están exentos; véase la regla 10 de la Fase 2. - Los pasos sin etiqueta generan
un «code-reviewer»con la justificación«no se ha encontrado ninguna etiqueta que coincida»; cadena predeterminada de solo revisión. - La tabla de resumen enumera todos los pasos del plan, independientemente de
--scope. - El recuento de bloques de detalle por paso coincide con el
--scoperesuelto (plan completo cuando--scope=all; un bloque parael paso n; tamaño del rango parael rango a-b). En el modo de solo resumen, no se emiten bloques por paso ni el bloque «Batch».
Casos extremos
- Si no hay pasos claros: se prefiere la división H2/H3; si sigue habiendo ambigüedad, se informa de que «no se han detectado pasos estructurados» junto con el esquema del documento y se pide al usuario que confirme la ejecución según el esquema.
- Plan extenso (>1500 líneas): pasar al modo «solo resumen»; generar únicamente la tabla de resumen y pedir al usuario que acote el alcance con
--scopeantes de volver a ejecutar la tarea para obtener detalles. En este modo, omitir los bloques de detalles por paso y el bloque de ejecución por lotes. - Paso demasiado amplio (p. ej., «completar todo el trabajo de backend»): no forzar una única cadena. Sugerir la división en N.a y N.b y proponer dicha división.
- El plan declara agentes (poco frecuente): primero elimina cualquier prefijo
«everything-claude-code:»para obtener el nombre básico del catálogo (Fase 0, paso 5) y, a continuación, valida el resultado con el catálogo. Sustituye los agentes no válidos y explica el motivo en «Justificación de la cadena». El nombre básico se vuelve a prefijar en el momento de la salida segúnECC_MODE. - Proyecto políglota en el que
--lang=autono puede elegir un ganador: establecelang=unknown; el revisor se resuelve como«code-reviewer»y el resolutor de compilación como«build-error-resolver». Menciona la opción de reserva en «Justificación de la cadena».
Ejemplos
Ejemplo 1 — Modo de complemento, plan de Python
Entrada:
plan-orchestrate @docs/plan/example-feature.md --lang=python
Fragmento de la salida esperada:
## Paso 2 — Cifrar campos sensibles de UserProfile
**Objetivo**: Introducir un tipo `EncryptedString` de SQLAlchemy y cifrar con AES-GCM los campos `birth_datetime` y `location` antes de su almacenamiento; cargar la clave desde una variable de entorno.
**Etiquetas**: impl, seguridad, db
**Justificación de la cadena**: Ruta de escritura sensible desde el punto de vista de la seguridad, por lo que `security-reviewer` cierra la cadena; `database-reviewer` valida la migración de Alembic; `python-reviewer` se encarga de la tipificación y del cumplimiento de la 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] Implementar el tipo EncryptedString de SQLAlchemy y migrar las columnas UserProfile.birth_datetime/location; clave de ENV APP_DB_KEY; Aceptación: superadas las pruebas de cifrado/descifrado de ida y vuelta; actualización/reversión de Alembic sin errores en una base de datos vacía; ausencia de texto sin cifrar en la base de datos tras la migración; Fuera del alcance: lógica de uso compartido de perfiles entre inquilinos"
```
Ejemplo 2 — Modo heredado, mismo paso
Si se detectara ECC_MODE=legacy, se emitiría el mismo paso como un único comando uniforme (sin formas con prefijo de plugin en ninguna parte de la salida):
/orchestrate custom "tdd-guide,database-reviewer,python-reviewer,security-reviewer" "[Plan: docs/plan/example-feature.md#step-2] ..."
Los dos ejemplos anteriores ilustran las dos salidas posibles para dos entornos diferentes. Una única invocación de la skill produce solo una de ellas, de principio a fin.
Notas
- Solo generativo. Nunca invoques
/orchestratedesde dentro de esta habilidad. - Adapta el idioma del documento del plan para las descripciones de las tareas (los nombres de los agentes siempre se mantienen en inglés).
- No insertes líneas «Co-Authored-By» ni emojis en la salida, a menos que el usuario lo solicite explícitamente.
---
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.
Todos los archivos
1 archivosInstalar plan-orchestrate
Descarga y descomprime los archivos de habilidades en tu directorio .claude/skills/.
Descargar ZIPClona el repositorio y copia los archivos de la habilidad a tu proyecto.
git clone https://github.com/affaan-m/ECC/tree/main/skills/plan-orchestrate # Copy SKILL.md to your .claude/skills/ directory
Copiar





Hogar
