elsabro 7.2.0 → 7.3.1

package/commands/elsabro/execute.md

@@ -1,6 +1,6 @@
 ---
 name: execute
-description: Ejecutar un plan con TDD, verificación automática y commits atómicos
+description: Ejecutar un plan via CLI flow engine con observabilidad
 allowed-tools:
   - Read
   - Write
@@ -9,1615 +9,490 @@ allowed-tools:
   - Glob
   - Grep
   - Task
-  - TaskCreate
-  - TaskUpdate
-  - TaskList
-  - TaskGet
   - TeamCreate
   - TeamDelete
   - SendMessage
   - AskUserQuestion
-  - mcp__plugin_context7_context7__*
-argument-hint: "[número de fase]"
+argument-hint: "[numero de fase]"
 sync:
   reads: [".elsabro/state.json", ".planning/*-PLAN.md"]
-  writes: [".elsabro/state.json", ".elsabro/context.md"]
-  phases: ["initializing", "exploring", "executing_wave_N", "verifying", "done"]
+  writes: [".elsabro/state.json", ".elsabro/context.md", ".elsabro/telemetry/"]
+  phases: ["initializing", "stepping", "done"]
   passes_context_to: ["verify-work"]
-dispatcher:
-  exploration:
-    agents: [Explore, feature-dev:code-explorer, Plan]
-    model: haiku
-    parallel: true
-    min_agents: 3
-    method: "subagent"
-  implementation:
-    agents: [elsabro-executor, feature-dev:code-architect]
-    model: opus
-    parallel: true
-    min_agents: 2
-    method: "agent-team"
-    agent_team_config:
-      team_members: [elsabro-executor, elsabro-qa, elsabro-planner]
-      when: "always"  # v4.2.0: Agent Teams obligatorio para 2+ agentes (Rule 8)
-  verification:
-    agents: [pr-review-toolkit:code-reviewer, pr-review-toolkit:silent-failure-hunter, pr-review-toolkit:pr-test-analyzer]
-    model: opus
-    parallel: true
-    min_agents: 3
-    method: "agent-team"
-    blocking: true
-    max_review_iterations: 5
 ---
 
 # ELSABRO: Execute
 
-<state_sync>
-## SINCRONIZACIÓN DE ESTADO (OBLIGATORIO)
+Thin wrapper del CLI flow engine. Toda la logica de grafos, Agent Teams, y gates
+vive en el engine y en `flows/development-flow.json`. Este archivo solo define el loop.
 
-**IMPORTAR**: Este comando DEBE seguir `/references/state-sync.md` y `/references/enforcement-rules.md`.
+**Reglas**: @references/enforcement-rules.md
+**State sync**: @references/state-sync.md
 
-### Al Iniciar (ANTES de cualquier operación)
+## 1. Inicializar
 
-```javascript
-// 1. Crear task de inicialización
-TaskCreate({
-  subject: "Initialize execute command",
-  description: "Leer estado y preparar ejecución",
-  activeForm: "Inicializando..."
-})
-TaskUpdate(id, status: "in_progress")
-
-// 2. Leer estado existente
-const state = Read(".elsabro/state.json") || createInitialState();
-
-// 3. Verificar flujo en progreso
-if (state.current_flow && state.current_flow.command !== "execute") {
-  AskUserQuestion({
-    questions: [{
-      question: `Hay un flujo de "${state.current_flow.command}" en progreso. ¿Continuar ese o empezar execute?`,
-      header: "Flujo",
-      options: [
-        { label: "Continuar anterior", description: "Retomar " + state.current_flow.command },
-        { label: "Empezar execute", description: "Pausar anterior" }
-      ]
-    }]
-  });
-}
-
-// 4. Actualizar estado
-state.current_flow = { command: "execute", phase: "initializing", started_at: new Date().toISOString() };
-state.elsabro_mode = true;
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
-
-// 5. Completar task de inicialización
-TaskUpdate(id, status: "completed")
-```
+Leer `.elsabro/state.json` siguiendo el protocolo de @references/state-sync.md.
+Verificar flujo en progreso. Actualizar phase a "stepping".
 
-### Al Cambiar de Fase
-
-```javascript
-// Antes de exploración
-state.current_flow.phase = "exploring";
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
-
-// Antes de cada wave
-state.current_flow.phase = "executing_wave_" + waveNumber;
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```bash
+FLOW="flows/development-flow.json"
+TASK="[descripcion de la tarea del usuario]"
+PROFILE="[default|yolo|careful|teams|bmad]"
+COMPLEXITY="[low|medium|high]"
 
-// Antes de verificación
-state.current_flow.phase = "verifying";
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+# Initialize flow and create checkpoint
+node flow-engine/src/cli.js init --flow "$FLOW" --task "$TASK" --profile "$PROFILE" --complexity "$COMPLEXITY"
 ```
 
-### Al Completar
+Guardar el flowId del resultado para todos los comandos siguientes.
 
-```javascript
-// Registrar en historial
-state.history.push({
-  command: "execute",
-  completed_at: new Date().toISOString(),
-  result: "completed_phase_" + phaseNumber,
-  artifact: null
-});
-
-// Pasar contexto a verify-work
-state.context = state.context || {};
-state.context.changed_files = [...changedFiles];
-state.context.commits = [...commitIds];
-state.context.tests_added = [...testFiles];
-state.context.phase_completed = phaseNumber;
-
-// Limpiar flujo y sugerir siguiente
-state.current_flow = null;
-state.suggested_next = "verify-work";
-
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
-
-// Actualizar context.md legible
-Write(".elsabro/context.md", generateHumanReadableContext(state));
-```
-</state_sync>
+**Note on Skill Auto-Install:**
+The development-flow.json includes a `skill_discovery` node (second node after entry) that automatically:
+1. Calls `hooks/skill-discovery.sh` with task description and complexity
+2. Discovers installed skills and recommends relevant ones from the Vercel Agent Skills Registry
+3. Provides install commands for recommended skills
+4. All discovery output is captured and available in `context.steps.discovery`
 
-<skill_discovery>
-## Skill Discovery (Pre-Execution)
+## 1.1. Stitch MCP Auto-Detection (Visual Projects)
 
-**ANTES de ejecutar el plan**, descubrir skills para el stack:
+**AFTER initialization**, check if this is a visual project and suggest Stitch MCP if UI work is needed:
 
 ```javascript
-// Ejecutar skill discovery con la tarea
-const discoveryResult = Bash(`bash ./hooks/skill-discovery.sh "${inputs.task || state.context.current_feature || ''}" "medium"`, { timeout: 30000 });
-
-// Guardar en estado
-state.context = state.context || {};
-state.context.available_skills = JSON.parse(discoveryResult).recommended || [];
-
-// Informar al usuario
-if (state.context.available_skills.length > 0) {
-  output(`Skills cargados: ${state.context.available_skills.map(s => s.name).join(", ")}`);
-}
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
-```
-
-Los skills proveen patrones de código verificados, configuraciones de setup, y guides de integración durante la implementación.
-</skill_discovery>
-
-<skill_injection>
-## Skill Injection (OBLIGATORIO despues de Discovery)
+// Detectar frameworks visuales y verificar si Stitch está configurado
+let isVisualProject = false;
+let detectedFrameworks = [];
+let hasStitchDesigns = false;
 
-**Si skill discovery encontro skills relevantes, CARGAR su contenido como contexto.**
+try {
+  const packageJson = Read("package.json");
+  const pkg = JSON.parse(packageJson);
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
 
-```javascript
-// 1. Obtener skills recomendados
-const recommendedSkills = state.context.available_skills || [];
-
-if (recommendedSkills.length > 0) {
-  // 2. Cargar contenido de los top-3 skills (local → global → install)
-  const loadedSkills = [];
-  let registryDown = false;
-  for (const skill of recommendedSkills.slice(0, 3)) {
-    // 2a. Try local ELSABRO skill first
-    let content = Read(`skills/${skill.id}.md`);
-
-    // 2b. Try global installed skill
-    if (!content) {
-      content = Read(`${HOME}/.claude/skills/${skill.id}.md`);
-    }
-
-    // 2c. If not found locally and has install_cmd → offer to install
-    if (!content && skill.install_cmd && skill.source === "skills-registry" && !registryDown) {
-      // Check registry accessibility
-      const checkResult = Bash(`bash ./hooks/skill-install.sh check`, { timeout: 20000 });
-      const check = JSON.parse(checkResult);
-
-      if (check.status === "ok") {
-        // Ask user permission
-        const answer = AskUserQuestion({
-          questions: [{
-            question: `Skill "${skill.id}" no esta instalado localmente pero esta disponible en el registry. Instalarlo?`,
-            header: "Skill Install",
-            options: [
-              { label: "Instalar", description: `Ejecuta: ${skill.install_cmd}` },
-              { label: "Omitir", description: "Continuar sin este skill" }
-            ],
-            multiSelect: false
-          }]
-        });
-
-        if (answer === "Instalar") {
-          // Execute install
-          const installResult = Bash(`bash ./hooks/skill-install.sh install "${skill.install_cmd}"`, { timeout: 45000 });
-          const install = JSON.parse(installResult);
-
-          if (install.status === "ok") {
-            // Validate installed file
-            const validateResult = Bash(`bash ./hooks/skill-install.sh validate "${skill.id}"`, { timeout: 5000 });
-            const validation = JSON.parse(validateResult);
-
-            if (validation.status === "ok") {
-              content = Read(validation.path);
-              output(`  + Skill "${skill.id}" instalado y cargado`);
-            } else {
-              output(`  ! Skill "${skill.id}" instalado pero formato invalido — omitido`);
-            }
-          } else {
-            output(`  ! Instalacion de "${skill.id}" fallo: ${install.message} — omitido`);
-          }
-        } else {
-          output(`  - Skill "${skill.id}" omitido por usuario`);
-        }
-      } else {
-        output(`  ! Registry no disponible — omitiendo instalacion de skills externos`);
-        registryDown = true; // Skip install attempts for remaining skills
-      }
-    }
+  // Frameworks visuales
+  const visualFrameworks = [
+    { name: "react", display: "React" },
+    { name: "next", display: "Next.js" },
+    { name: "vue", display: "Vue" },
+    { name: "nuxt", display: "Nuxt" },
+    { name: "@angular/core", display: "Angular" },
+    { name: "svelte", display: "Svelte" }
+  ];
 
-    // 2d. Load content if available (from any source)
-    if (content) {
-      loadedSkills.push({
-        name: skill.id,
-        content: content
-      });
+  for (const framework of visualFrameworks) {
+    if (allDeps[framework.name]) {
+      detectedFrameworks.push(framework.display);
+      isVisualProject = true;
     }
   }
 
-  // 3. Guardar skills cargados en state
-  state.context.loaded_skills = loadedSkills;
-  Write(".elsabro/state.json", JSON.stringify(state, null, 2));
-
-  // 4. Informar al usuario
-  output(`Skills cargados para esta ejecucion:`);
-  loadedSkills.forEach(s => output(`  - ${s.name}`));
+  // Verificar si ya hay diseños de Stitch
+  try {
+    const stitchDesigns = Read(".planning/ui-designs/UI-DESIGNS.md");
+    hasStitchDesigns = !!stitchDesigns;
+  } catch (e) {
+    hasStitchDesigns = false;
+  }
+} catch (e) {
+  // No package.json - continue without detection
 }
-```
-
-**GATE**: Cuando lances agentes executors, INCLUIR los skills en el prompt:
-```
-Si state.context.loaded_skills tiene contenido, agregar al prompt de CADA executor:
-
-"SKILLS DE REFERENCIA:
-[Para cada skill cargado:]
-### Skill: {name}
-{contenido del archivo .md}
-
-Usa estos skills como guia de patrones, estructura y mejores practicas."
-```
-</skill_injection>
-
-<objective>
-Ejecutar planes de una fase con:
-- **Sistema de Tasks para tracking real** de waves y dependencias
-- **Dispatcher inteligente con selección automática de modelo** (ver @references/task-dispatcher.md)
-- **Ejecución por subagentes en paralelo** según tipo de tarea
-- Investigación de patrones con Context7
-- TDD cuando sea apropiado
-- Commits atómicos por tarea
-- Verificación automática con agregador
-</objective>
-
-<dispatcher_integration>
-## Selección Automática de Modelo
-
-**REGLA CRÍTICA:** Cada tarea se ejecuta con el modelo óptimo para su tipo.
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                    MODELO SEGÚN FASE                                     │
-├─────────────────────────────────────────────────────────────────────────┤
-│  FASE              │  SUBAGENTES                        │  MODELO       │
-├────────────────────┼────────────────────────────────────┼───────────────┤
-│  Exploración       │  Explore                           │  HAIKU        │
-│  (pre-ejecución)   │  feature-dev:code-explorer         │  HAIKU        │
-│                    │  Plan                              │  HAIKU        │
-│                    │  (3 en paralelo obligatorio)       │               │
-├────────────────────┼────────────────────────────────────┼───────────────┤
-│  Implementación    │  elsabro-executor                  │  OPUS         │
-│  (waves)           │  feature-dev:code-architect        │  OPUS         │
-│                    │  (2+ en paralelo por wave)         │               │
-├────────────────────┼────────────────────────────────────┼───────────────┤
-│  Verificación      │  pr-review-toolkit:code-reviewer   │  OPUS         │
-│  (post-ejecución)  │  pr-review-toolkit:silent-...      │  OPUS         │
-│                    │  pr-review-toolkit:pr-test-...     │  OPUS         │
-│                    │  (3 en paralelo obligatorio)       │               │
-└────────────────────┴────────────────────────────────────┴───────────────┘
-```
-
-### Por qué esta distribución
 
-- **HAIKU para exploración:** Solo lee y mapea, no necesita razonamiento profundo
-- **OPUS para implementación:** Escribe código, necesita máxima calidad
-- **OPUS para verificación:** Análisis profundo de bugs y edge cases
-</dispatcher_integration>
+// Si es proyecto visual sin diseños, sugerir Stitch MCP
+if (isVisualProject && !hasStitchDesigns) {
+  state.context = state.context || {};
+  state.context.is_visual_project = true;
+  state.context.visual_frameworks = detectedFrameworks;
 
-<agent_teams_integration>
-## Agent Teams Integration (v4.0.0)
+  // Actualizar estado
+  Write(".elsabro/state.json", JSON.stringify(state, null, 2));
 
-### Agent Teams: Método Obligatorio (v4.2.0)
+  // Sugerir al usuario
+  output(`\n🎨 Proyecto ${detectedFrameworks.join("/")} detectado`);
+  output(`💡 Tip: Usa /elsabro:design-ui para generar diseños visuales con Stitch MCP antes de implementar\n`);
 
-**REGLA**: Agent Teams es OBLIGATORIO para todo trabajo paralelo de 2+ agentes.
-La única excepción es exploración read-only (HAIKU).
+  // Preguntar si quieren diseñar primero
+  const answer = AskUserQuestion({
+    questions: [{
+      question: "¿Quieres diseñar la UI visualmente antes de implementar?",
+      header: "Stitch MCP",
+      options: [
+        { label: "Continuar con ejecución", description: "Implementar sin diseño visual previo" },
+        { label: "Diseñar UI primero (Recomendado)", description: "Genera screens con Stitch MCP antes de codificar" }
+      ],
+      multiSelect: false
+    }]
+  });
 
+  if (answer.includes("Diseñar UI primero")) {
+    // Interrumpir execute y redirigir a design-ui
+    output("→ Redirigiendo a /elsabro:design-ui...\n");
+    Skill("elsabro:design-ui", TASK);
+    return; // Exit execute
+  }
+}
 ```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                    AGENT TEAMS — OBLIGATORIO (v4.2.0)                    │
-├─────────────────────────────────────────────────────────────────────────┤
-│  FASE                               │  MÉTODO                           │
-├─────────────────────────────────────┼───────────────────────────────────┤
-│  Exploración (HAIKU read-only)      │  SUBAGENTS (excepción)            │
-│  Implementación (2+ agentes)        │  AGENT TEAMS (obligatorio)        │
-│  Verificación/Review (2+ agentes)   │  AGENT TEAMS (obligatorio)        │
-│  Planning (2+ agentes opus)         │  AGENT TEAMS (obligatorio)        │
-│  Debugging (2+ agentes)             │  AGENT TEAMS (obligatorio)        │
-│  Agente único                       │  SUBAGENT (no aplica teams)       │
-└─────────────────────────────────────┴───────────────────────────────────┘
-```
-
-**VIOLACIÓN CRÍTICA**: Lanzar 2+ agentes sin TeamCreate = ABORTAR OPERACIÓN.
-Ver `/references/enforcement-rules.md` Regla 8.
-
-### Flujo con Agent Teams
-
-```javascript
-// 1. Crear team (API oficial Claude Code)
-TeamCreate({
-  team_name: "elsabro-impl",
-  description: "Implementation team for: " + task
-})
-
-// 2. Create tasks para el team
-TaskCreate({ subject: "Analyze requirements", ... })
-TaskCreate({ subject: "Implement core logic", ... })
-TaskCreate({ subject: "Write tests", ... })
-
-// 3. Spawn teammates
-Task({
-  subagent_type: "elsabro-executor",
-  team_name: "elsabro-impl",
-  name: "executor-1",
-  prompt: "Implement core logic following TDD..."
-})
-Task({
-  subagent_type: "elsabro-qa",
-  team_name: "elsabro-impl",
-  name: "qa-1",
-  prompt: "Write comprehensive tests..."
-})
 
-// 4. Teammates coordinate via SendMessage
-// 5. When done, shutdown teammates then cleanup
-SendMessage({ type: "shutdown_request", recipient: "executor-1", content: "Work complete" })
-SendMessage({ type: "shutdown_request", recipient: "qa-1", content: "Work complete" })
-TeamDelete()
-```
+## 2. Loop Principal
 
-### Limitations (Claude Code Official)
+Ejecutar el siguiente loop hasta que `step` retorne `{ finished: true }`:
 
-- **No session resumption**: `/resume` no restaura teammates in-process
-- **No nested teams**: Teammates NO pueden crear sus propios teams
-- **Lead es fijo**: La sesion que crea el team es el lead permanente
-- **Un team por sesion**: Cleanup del actual antes de crear nuevo
-- **Permissions at spawn**: Todos heredan permisos del lead
+1. **STEP**: Ejecutar con Bash y parsear el JSON:
+   ```bash
+   node flow-engine/src/cli.js step --flow "$FLOW"
+   ```
+   Capturar el output JSON. Parsear `instruction` del resultado.
 
-### Agentes que Migran a Agent Teams
+2. **CHECK**: Si `finished: true` -> ir a seccion 5. Si `error` -> mostrar al usuario, ofrecer retry/abort.
 
-| Agente | Rol en Team | Cuándo |
-|--------|-------------|--------|
-| elsabro-orchestrator | Team Lead | Siempre (coordina) |
-| elsabro-executor | Teammate | Implementación |
-| elsabro-planner | Teammate | Planning |
-| elsabro-analyst | Teammate | Análisis |
-| elsabro-qa | Teammate | Testing |
-| elsabro-verifier | Teammate | Verificación |
-| elsabro-debugger | Teammate | Debug (iter >= 2) |
+3. **DISPATCH**: Ejecutar segun `instruction.type` (ver seccion 3). Guardar el resultado.
 
-### Excepciones (Subagents permitidos)
+4. **OBSERVE**: Emitir senales de observabilidad (ver seccion 4).
 
-| Contexto | Razón |
-|----------|-------|
-| Exploración HAIKU (Paso 0) | Read-only, sin modificación de código |
-| Agente único (quick mode) | Sin paralelismo, no aplica teams |
-</agent_teams_integration>
+5. **COMPLETE**: Enviar resultado al CLI:
+   ```bash
+   node flow-engine/src/cli.js complete --flow "$FLOW" --result '{"output": "..."}'
+   ```
 
-<agent_teams_gate>
-## Agent Teams Gate (OBLIGATORIO - NO NEGOCIABLE)
+6. Volver al paso 1.
 
-**ANTES de lanzar 2+ agentes para implementación o review, VERIFICAR:**
+## 2.1. Error Handling: Runtime Status Validation
 
-```
-¿Se necesitan 2+ agentes en paralelo?
-│
-├─ SÍ → ¿Es exploración read-only (HAIKU)?
-│    │
-│    ├─ SÍ → Subagents OK (excepción)
-│    │
-│    └─ NO → ¿Se usó TeamCreate?
-│         │
-│         ├─ NO → EJECUTAR AHORA:
-│         │   TeamCreate({ team_name, description })
-│         │   Solo entonces: Task({ team_name, name, ... })
-│         │
-│         └─ SÍ → ¿Teammates spawned con team_name?
-│              │
-│              ├─ SÍ → Continuar con SendMessage para coordinación
-│              └─ NO → VIOLACIÓN: Usar team_name en Task()
-│
-└─ NO (agente único) → Subagent OK
-```
+The flow engine validates all nodes before execution via `checkRuntimeStatus()`. This catches:
 
+### NotImplementedError
+Thrown when a node has `runtime_status: "not_implemented"`:
 ```javascript
-// MARCAR: Agent Teams fue usado correctamente (para GATE CHECK en siguiente_paso)
-state.current_flow.parallel_agents_used = agentCount; // número de agentes lanzados
-state.current_flow.agent_teams_used = true;
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
-```
-
-**VIOLACIÓN CRÍTICA**: Lanzar 2+ agentes sin Agent Teams = ABORTAR OPERACIÓN
-</agent_teams_gate>
-
-<blocking_review_protocol>
-## Protocolo de Review Bloqueante (v4.0.0)
-
-**REGLA CRÍTICA:** El proceso NO PUEDE avanzar a post-mortem si hay issues de code review sin resolver.
-
-### Flujo
-
-```
-parallel_review (3 agentes)
-       ↓
-review_check: ¿hay issues?
-       ↓
-  ┌────┴────┐
-  │ NO      │ YES
-  │ issues  │ issues
-  ↓         ↓
-verify    fix_review_issues
-final     (max 5 iteraciones)
-              ↓
-          parallel_review (re-check)
-              ↓
-          ¿issues == 0?
-              ↓
-        ┌─────┴─────┐
-        │ SÍ        │ NO (5 iter agotadas)
-        ↓            ↓
-    verify_final  interrupt_blocked
-                  (SIN opción "continuar con errores")
-                      ↓
-                  ┌───┴───┐───────┐
-                  │       │       │
-                retry  manual  abort
-                  ↓       ↓       ↓
-              fix_review  wait   end_cancelled
-              _issues     _manual
-                          _review_fix
-                              ↓
-                          parallel_review (re-check)
+{
+  "id": "bmad_solution",
+  "type": "sequence",
+  "runtime_status": "not_implemented",
+  "gaps": ["BMAD solutioning logic not yet implemented", "Needs ADR generation"]
+}
 ```
 
-### Escape Hatches ELIMINADOS
-
-Los siguientes escape hatches han sido removidos en v4.0.0:
-
-1. ~~`onMaxIterations: "verify_final"`~~ → Ahora va a `interrupt_blocked` (sin opción de continuar)
-2. ~~`"skip": "Continuar sin fix"`~~ → Removido de `interrupt_manual_fix`
-3. ~~`"accept": "Aceptar con errores"`~~ → Removido de `interrupt_verification_failed`
-
-### Iteraciones de Review
-
-```javascript
-// Estado del review loop
-state.reviewIteration = state.reviewIteration || 0;
-state.reviewIteration++;
-
-// Log de cada iteración
-console.log(`[REVIEW] Iteración ${state.reviewIteration}/5`);
-console.log(`[REVIEW] Issues encontrados: ${issueCount}`);
-
-// Solo avanza cuando issues == 0
-if (issueCount === 0) {
-  state.reviewIteration = 0; // Reset
-  // → verify_final
-} else if (state.reviewIteration >= 5) {
-  // → interrupt_blocked (NO verify_final)
-} else {
-  // → fix_review_issues → parallel_review
+**Error format:**
+```json
+{
+  "error": "NotImplementedError",
+  "nodeId": "bmad_solution",
+  "message": "Node \"bmad_solution\" is not yet implemented. Gaps: BMAD solutioning logic not yet implemented; Needs ADR generation",
+  "gaps": ["BMAD solutioning logic not yet implemented", "Needs ADR generation"]
 }
 ```
-</blocking_review_protocol>
-
-<process>
-## Paso 0: Exploración Pre-Ejecución (HAIKU x3 paralelo)
 
-**OBLIGATORIO:** Antes de ejecutar, explorar el codebase para entender contexto.
+**Dispatcher action:**
+- STOP execution immediately
+- Display error to user with gap details
+- Offer options:
+  1. "Skip this node" (only if node has `optional: true`)
+  2. "Abort workflow"
+  3. "Report bug" (opens issue template with node info)
 
+### DeprecatedNodeError
+Thrown when a node has `runtime_status: "deprecated"`:
 ```javascript
-// Crear tasks de exploración
-TaskCreate({
-  subject: "Explore: Find related files",
-  description: "Buscar archivos relacionados con la fase",
-  activeForm: "Buscando archivos...",
-  metadata: { type: "exploration", model: "haiku" }
-})  // → explore-files-id
-
-TaskCreate({
-  subject: "Explore: Analyze patterns",
-  description: "Analizar patrones existentes en el codebase",
-  activeForm: "Analizando patrones...",
-  metadata: { type: "exploration", model: "haiku" }
-})  // → explore-patterns-id
-
-TaskCreate({
-  subject: "Explore: Map architecture",
-  description: "Mapear arquitectura del área afectada",
-  activeForm: "Mapeando arquitectura...",
-  metadata: { type: "exploration", model: "haiku" }
-})  // → explore-arch-id
-
-// Marcar todas como in_progress
-TaskUpdate({ taskId: "explore-files-id", status: "in_progress" })
-TaskUpdate({ taskId: "explore-patterns-id", status: "in_progress" })
-TaskUpdate({ taskId: "explore-arch-id", status: "in_progress" })
-
-// Lanzar 3 agentes HAIKU EN PARALELO (UN SOLO MENSAJE)
-Task({
-  subagent_type: "Explore",
-  model: "haiku",
-  description: "Buscar archivos relacionados",
-  prompt: "Busca archivos relacionados con la fase [N]. Lista los 10 más relevantes."
-}) |
-Task({
-  subagent_type: "feature-dev:code-explorer",
-  model: "haiku",
-  description: "Analizar patrones",
-  prompt: "Analiza patrones de arquitectura en el área de la fase [N]."
-}) |
-Task({
-  subagent_type: "Plan",
-  model: "haiku",
-  description: "Mapear arquitectura",
-  prompt: "Mapea componentes y flujo de datos del área afectada."
-})
-
-// Marcar completed
-TaskUpdate({ taskId: "explore-files-id", status: "completed" })
-TaskUpdate({ taskId: "explore-patterns-id", status: "completed" })
-TaskUpdate({ taskId: "explore-arch-id", status: "completed" })
-```
-
-**Resultado:** Contexto del codebase capturado antes de modificar nada.
-
-## Paso 1: Descubrir Planes
-
-```bash
-ls .planning/*-PLAN.md
+{
+  "id": "legacy_team_node",
+  "type": "team",
+  "runtime_status": "deprecated",
+  "deprecated_reason": "Use parallel nodes with Agent Teams instead (Rule 8)"
+}
 ```
 
-Encontrar planes para la fase especificada.
-
-## Paso 2: Crear Estructura de Tasks
-
-### 2.1 Crear Task coordinadora de fase
-```javascript
-TaskCreate({
-  subject: "Execute Phase [N]",
-  description: "Coordinar ejecución de todos los planes de la fase",
-  activeForm: "Ejecutando Fase [N]...",
-  metadata: { phase: N, type: "coordinator" }
-})  // → phase-coordinator-id
+**Error format:**
+```json
+{
+  "error": "DeprecatedNodeError",
+  "nodeId": "legacy_team_node",
+  "message": "Node \"legacy_team_node\" is deprecated: Use parallel nodes with Agent Teams instead (Rule 8)",
+  "reason": "Use parallel nodes with Agent Teams instead (Rule 8)"
+}
 ```
 
-### 2.2 Organizar por Waves y crear Tasks
-Leer frontmatter de cada plan para agrupar por `wave`:
+**Dispatcher action:**
+- STOP execution immediately
+- Display deprecation warning with reason
+- Suggest migration path if available in error
+- Offer "Abort workflow"
 
-```javascript
-// Para cada wave, crear task coordinadora
-TaskCreate({
-  subject: "Execute Wave [W]",
-  description: "Plans: A, B, C en paralelo",
-  activeForm: "Ejecutando Wave [W]...",
-  metadata: { wave: W, plans: ["A", "B", "C"] }
-})  // → wave-W-id
-
-// Wave 2+ tiene dependencia de wave anterior
-TaskUpdate({
-  taskId: "wave-2-id",
-  addBlockedBy: ["wave-1-id"]
-})
-```
+### When to Continue vs Abort
 
-### 2.3 Crear Tasks por plan dentro de cada wave
-```javascript
-TaskCreate({
-  subject: "Execute Plan [name]",
-  description: "TDD + commits para plan específico",
-  activeForm: "Ejecutando Plan [name]...",
-  metadata: { wave: W, plan: "name", type: "executor" }
-})  // → plan-X-id
-
-// Bloquear por wave coordinator
-TaskUpdate({
-  taskId: "plan-X-id",
-  addBlockedBy: ["wave-W-id"]
-})
-```
+**Continue (skip node) only if:**
+- Node has `optional: true` explicitly set
+- AND user explicitly chooses "Skip" option
 
-## Paso 3: Ejecutar Waves con Tracking
+**Always abort for:**
+- Deprecated nodes (never optional)
+- Not-implemented nodes without `optional: true`
+- Any runtime status error in critical path nodes (entry, exit, condition, router)
 
-Para cada wave:
+### Telemetry Signal
 
-### Marcar wave como in_progress
-```javascript
-TaskUpdate({ taskId: "wave-W-id", status: "in_progress" })
+When runtime status errors occur, emit:
+```json
+{
+  "ts": "2025-02-09T12:34:56Z",
+  "signal": "runtime_status_error",
+  "nodeId": "bmad_solution",
+  "error": "NotImplementedError",
+  "gaps": ["..."],
+  "action": "abort"
+}
 ```
 
-<IMPERATIVO_AGENT_TEAMS>
-## ⛔ STOP — LEER ANTES DE LANZAR AGENTES PARALELOS
-
-**REGLA NO NEGOCIABLE (Rule 8):** Si vas a lanzar 2+ Task() para implementacion o review:
+## 3. Dispatch por Tipo de Instruccion
 
-1. **PRIMERO** → `TeamCreate({ team_name: "elsabro-impl", description: "..." })`
-2. **DESPUES** → `Task({ ..., team_name: "elsabro-impl", name: "executor-1" })`
-3. **AL FINAL** → `SendMessage({ type: "shutdown_request", ... })` para CADA teammate
-4. **ULTIMO** → `TeamDelete()`
-
-**Si ya lanzaste Task() sin TeamCreate: DETENTE AHORA. No continúes.**
-Vuelve arriba, crea el team, y relanza los agentes CON team_name.
-
-**NUNCA hagas esto:**
+### type: "entry"
 ```javascript
-// ⛔ PROHIBIDO — bare Task() sin team
-Task({ subagent_type: "elsabro-executor", prompt: "..." })
-Task({ subagent_type: "elsabro-qa", prompt: "..." })
+// instruction: { type: "entry", nodeId, next }
+// Entry nodes are auto-resolved by the engine - no dispatcher action needed
+// The engine automatically transitions to the next node
+// result: { next: instruction.next }
 ```
 
-**SIEMPRE haz esto:**
+### type: "exit"
 ```javascript
-// ✅ CORRECTO — con Agent Team
-TeamCreate({ team_name: "elsabro-impl", description: "Implementation" })
-Task({ subagent_type: "elsabro-executor", team_name: "elsabro-impl", name: "executor-1", prompt: "..." })
-Task({ subagent_type: "elsabro-qa", team_name: "elsabro-impl", name: "qa-1", prompt: "..." })
-// ... al completar ...
-SendMessage({ type: "shutdown_request", recipient: "executor-1", content: "Done" })
-SendMessage({ type: "shutdown_request", recipient: "qa-1", content: "Done" })
-TeamDelete()
+// instruction: { type: "exit", nodeId, outputs, status }
+// Exit nodes are auto-resolved by the engine - no dispatcher action needed
+// The engine resolves output templates and terminates the flow
+// result: { outputs: resolvedOutputs, status: instruction.status || "completed" }
 ```
 
-**Excepcion UNICA:** Exploracion read-only con HAIKU (Paso 0) puede usar subagents sueltos.
-</IMPERATIVO_AGENT_TEAMS>
-
-### Si hay múltiples planes en la wave → Paralelo (OPUS)
+### type: "condition"
 ```javascript
-// Marcar todos los planes como in_progress
-TaskUpdate({ taskId: "plan-A-id", status: "in_progress" })
-TaskUpdate({ taskId: "plan-B-id", status: "in_progress" })
-TaskUpdate({ taskId: "plan-C-id", status: "in_progress" })
-
-// OBLIGATORIO: Crear Agent Team para implementación paralela (Rule 8)
-TeamCreate({
-  team_name: "elsabro-impl",
-  description: "Implementation team for wave " + waveNumber
-})
-
-// MARCAR: Agent Teams usado (para GATE CHECK en siguiente_paso)
-state.current_flow.parallel_agents_used = 3;
-state.current_flow.agent_teams_used = true;
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
-
-// Lanzar teammates OPUS en paralelo (UN SOLO MENSAJE)
-// MODELO: OPUS porque escriben código
-// SKILLS: Incluir loaded_skills en CADA prompt de executor
-const skillContext = state.context.loaded_skills?.length > 0
-  ? '\n\n## SKILLS DE REFERENCIA\n' + state.context.loaded_skills.map(s =>
-      '### Skill: ' + s.name + '\n' + s.content
-    ).join('\n\n---\n\n') + '\n\nUsa los skills como referencia de patrones y estructura de archivos.'
-  : '';
-
-Task({
-  subagent_type: "elsabro-executor",
-  model: "opus",  // ← OPUS para implementación
-  team_name: "elsabro-impl",
-  name: "executor-1",
-  description: "Ejecutar Plan A",
-  prompt: `Implementa el Plan A siguiendo TDD.${skillContext}`
-}) |
-Task({
-  subagent_type: "elsabro-executor",
-  model: "opus",  // ← OPUS para implementación
-  team_name: "elsabro-impl",
-  name: "executor-2",
-  description: "Ejecutar Plan B",
-  prompt: `Implementa el Plan B siguiendo TDD.${skillContext}`
-}) |
-Task({
-  subagent_type: "elsabro-executor",
-  model: "opus",  // ← OPUS para implementación
-  team_name: "elsabro-impl",
-  name: "executor-3",
-  description: "Ejecutar Plan C",
-  prompt: `Implementa el Plan C siguiendo TDD.${skillContext}`
-})
-
-// Al completar cada plan
-TaskUpdate({ taskId: "plan-A-id", status: "completed" })
+// instruction: { type: "condition", nodeId, conditionResult, next }
+// Condition nodes are auto-resolved by the engine - no dispatcher action needed
+// The engine evaluates the condition and determines the next node (true/false branch)
+// result: { next: instruction.next, conditionResult: instruction.conditionResult }
 ```
 
-### Validación arquitectónica en paralelo (OPUS x2)
+### type: "router"
 ```javascript
-// OBLIGATORIO: Crear Agent Team para validación arquitectónica (Rule 8)
-TeamCreate({
-  team_name: "elsabro-arch-validate",
-  description: "Architectural validation: implementation + architecture review"
-})
-
-// Spawn 2 teammates OPUS en paralelo
-Task({
-  subagent_type: "elsabro-executor",
-  model: "opus",
-  team_name: "elsabro-arch-validate",
-  name: "impl-1",
-  description: "Implementar cambios",
-  prompt: "..."
-}) |
-Task({
-  subagent_type: "feature-dev:code-architect",
-  model: "opus",  // ← OPUS para decisiones arquitectónicas
-  team_name: "elsabro-arch-validate",
-  name: "architect-1",
-  description: "Validar arquitectura",
-  prompt: "Verifica que la implementación sigue los patrones del codebase..."
-})
-
-// Shutdown y cleanup
-SendMessage({ type: "shutdown_request", recipient: "impl-1", content: "Validation complete" })
-SendMessage({ type: "shutdown_request", recipient: "architect-1", content: "Validation complete" })
-TeamDelete()
+// instruction: { type: "router", nodeId, routeKey, next }
+// Router nodes are auto-resolved by the engine - no dispatcher action needed
+// The engine evaluates the condition, matches against routes, and determines next node
+// result: { next: instruction.next, routeKey: instruction.routeKey }
 ```
 
-### Si solo hay un plan → Secuencial (OPUS)
+### type: "agent"
 ```javascript
-TaskUpdate({ taskId: "plan-X-id", status: "in_progress" })
+// instruction: { type: "agent", nodeId, agent, model, inputs }
 Task({
-  subagent_type: "elsabro-executor",
-  model: "opus",  // ← OPUS porque escribe código
-  description: "Ejecutar plan único",
-  prompt: "..."
-})
-TaskUpdate({ taskId: "plan-X-id", status: "completed" })
-```
-
-### Marcar wave como completed cuando todos sus planes terminen
-```javascript
-TaskUpdate({ taskId: "wave-W-id", status: "completed" })
-// → Wave W+1 se desbloquea automáticamente
-
-// MARCAR: código fue escrito (para code_review_gate)
-state.current_flow.code_written = true;
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
-```
-
-## Paso 4: Verificar Fase (con Agregador)
-
-### 4.1 Crear tasks de verificación
-```javascript
-TaskCreate({
-  subject: "Verify Functional Requirements",
-  activeForm: "Verificando funcionalidad...",
-  metadata: { type: "verifier", area: "functional" }
-})  // → verify-functional-id
-
-TaskCreate({
-  subject: "Verify Quality Metrics",
-  activeForm: "Verificando calidad...",
-  metadata: { type: "verifier", area: "quality" }
-})  // → verify-quality-id
-
-TaskCreate({
-  subject: "Verify Phase Completion",
-  activeForm: "Agregando resultados...",
-  metadata: { type: "aggregator" }
-})  // → verify-aggregate-id
-
-// Agregador espera a todos los verificadores
-TaskUpdate({
-  taskId: "verify-aggregate-id",
-  addBlockedBy: ["verify-functional-id", "verify-quality-id"]
+  subagent_type: instruction.agent,
+  model: instruction.model,
+  prompt: JSON.stringify(instruction.inputs)
 })
+// result: { output: agentOutput }
 ```
 
-### 4.2 Ejecutar verificación en paralelo (OPUS x3)
-
-**OBLIGATORIO:** Usar 3 agentes OPUS para verificación profunda.
-
+### type: "parallel" con useAgentTeams: false
 ```javascript
-// Crear task adicional de seguridad
-TaskCreate({
-  subject: "Verify Security & Edge Cases",
-  activeForm: "Verificando seguridad...",
-  metadata: { type: "verifier", area: "security", model: "opus" }
-})  // → verify-security-id
-
-// Actualizar agregador para esperar los 3
-TaskUpdate({
-  taskId: "verify-aggregate-id",
-  addBlockedBy: ["verify-functional-id", "verify-quality-id", "verify-security-id"]
-})
-
-// Marcar todos como in_progress
-TaskUpdate({ taskId: "verify-functional-id", status: "in_progress" })
-TaskUpdate({ taskId: "verify-quality-id", status: "in_progress" })
-TaskUpdate({ taskId: "verify-security-id", status: "in_progress" })
-
-// NOTA: El Agent Team "elsabro-impl" ya fue creado en Paso 3.
-// Reusar el mismo team para la fase de review (un team por sesión).
-// Si el team fue eliminado, crear uno nuevo:
-// TeamCreate({ team_name: "elsabro-review", description: "Review team" })
-
-// Lanzar 3 reviewers como teammates EN PARALELO (UN SOLO MENSAJE)
-Task({
-  subagent_type: "pr-review-toolkit:code-reviewer",
-  model: "opus",  // ← OPUS para análisis profundo
-  team_name: "elsabro-impl",
-  name: "reviewer-1",
-  description: "Code review completo",
-  prompt: "Revisa los cambios buscando bugs, code smells, mejores prácticas..."
-}) |
-Task({
-  subagent_type: "pr-review-toolkit:silent-failure-hunter",
-  model: "opus",  // ← OPUS para edge cases
-  team_name: "elsabro-impl",
-  name: "reviewer-2",
-  description: "Buscar errores ocultos",
-  prompt: "Busca errores silenciosos, try/catch que ocultan errores, fallbacks problemáticos..."
-}) |
-Task({
-  subagent_type: "pr-review-toolkit:pr-test-analyzer",
-  model: "opus",  // ← OPUS para análisis de tests
-  team_name: "elsabro-impl",
-  name: "reviewer-3",
-  description: "Analizar cobertura de tests",
-  prompt: "Verifica que los tests cubren los cambios, busca casos críticos sin test..."
-})
-
-// Marcar completed al terminar
-TaskUpdate({ taskId: "verify-functional-id", status: "completed" })
-TaskUpdate({ taskId: "verify-quality-id", status: "completed" })
-TaskUpdate({ taskId: "verify-security-id", status: "completed" })
-
-// Agregador se desbloquea y genera reporte final
-TaskUpdate({ taskId: "verify-aggregate-id", status: "in_progress" })
-// ... genera VERIFICATION.md ...
-TaskUpdate({ taskId: "verify-aggregate-id", status: "completed" })
-
-// MARCAR: code review pasó (para code_review_gate en siguiente_paso)
-if (reviewIssuesCount === 0) {
-  state.current_flow.code_review_passed = true;
-  Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+// instruction: { type: "parallel", nodeId, useAgentTeams: false, branches }
+// Todos haiku -> subagents sueltos (excepcion Rule 8)
+for (const branch of instruction.branches) {
+  Task({ subagent_type: branch.agent, model: "haiku", prompt: JSON.stringify(branch.inputs) })
 }
+// result: branches.map(b => ({ id: b.id, output: branchOutput }))
 ```
 
-## Paso 5: Manejar Resultados
-
-### Si passed:
-```
-✓ Fase [N] completada
-
-Lo que se hizo:
-- [Resumen de tareas]
-
-Archivos modificados:
-- [Lista de archivos]
-
-Commits creados:
-- [Lista de commits]
-
-¿Siguiente paso?
-- Continuar con fase [N+1]: /elsabro:plan [N+1]
-- Verificar manualmente: /elsabro:verify [N]
-```
-
-### Si gaps_found:
-```
-⚠ Fase [N] tiene gaps
-
-Problemas encontrados:
-- [Gap 1]
-- [Gap 2]
-
-Opciones:
-1. Crear planes de corrección: /elsabro:plan [N] --gaps
-2. Ver detalles: cat .planning/[N]-VERIFICATION.md
-3. Continuar de todas formas
-```
-
-### Si human_needed:
-```
-👤 Se necesita verificación manual
-
-Por favor prueba:
-1. [Instrucción]
-2. [Instrucción]
-
-Cuando termines, dime si funcionó o qué problemas encontraste.
-```
-
-</process>
-
-<agent_teams_cleanup>
-## Agent Teams Cleanup (OBLIGATORIO)
-
-**Al completar TODAS las fases de implementacion y review:**
-
+### type: "parallel" con useAgentTeams: true
 ```javascript
-// 1. Shutdown CADA teammate por nombre
-const teammates = ["executor-1", "executor-2", "executor-3", "reviewer-1", "reviewer-2", "reviewer-3"];
-for (const name of teammates) {
-  SendMessage({ type: "shutdown_request", recipient: name, content: "All phases complete" });
-}
-
-// 2. Eliminar team
-TeamDelete();
-
-// 3. Registrar en state
-state.current_flow.agent_teams_cleanup = true;
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
-```
-
-**GATE**: No mostrar "Siguiente Paso" si agent_teams_cleanup !== true y hubo 2+ agentes.
-</agent_teams_cleanup>
-
-<code_review_gate>
-## Code Review Gate (OBLIGATORIO - NO NEGOCIABLE)
-
-**ANTES de mostrar "Siguiente Paso" o ofrecer commit, VERIFICAR:**
-
-```
-¿Se escribió/modificó código en este comando?
-│
-├─ NO → Continuar a Siguiente Paso
-│
-└─ SÍ → ¿Se ejecutó code review (Paso 4)?
-     │
-     ├─ NO → ABORTAR. Volver a Paso 4.
-     │
-     └─ SÍ, issues == 0 → Continuar a Siguiente Paso
-```
-
-**VIOLACIÓN CRÍTICA**: Mostrar siguiente paso sin code review = ABORTAR OPERACIÓN
-</code_review_gate>
-
-<siguiente_paso>
-## Siguiente Paso
+// instruction: { type: "parallel", nodeId, useAgentTeams: true, team, branches }
+// El engine ya compuso team de 5+ miembros via callbacks.js
 
-### Self-Check (OBLIGATORIO antes de reportar resultado)
+TeamCreate({ team_name: instruction.team.name, description: instruction.team.description })
 
-Antes de mostrar "Siguiente Paso", verifica CADA UNO de estos items:
-
-```
-[ ] Si lance 2+ Task() en paralelo → ¿use TeamCreate primero?
-    SI: Continuar
-    NO: DETENERME. Crear team y relanzar.
-
-[ ] Si descubri skills relevantes → ¿los cargue con Read() y los pase al executor?
-    SI: Continuar
-    NO: DETENERME. Cargar skills y re-ejecutar.
-
-[ ] Si escribi/modifique codigo → ¿ejecute code review?
-    SI: Continuar
-    NO: DETENERME. Ejecutar code review.
-
-[ ] Si use Agent Teams → ¿ejecute SendMessage(shutdown) + TeamDelete?
-    SI: Continuar
-    NO: DETENERME. Hacer cleanup.
-```
-
-**Si alguna respuesta es NO: NO mostrar siguiente paso. Corregir primero.**
-
-Al completar, establecer en state.json:
-```javascript
-// GATE CHECK 1: No escribir suggested_next sin code review
-if (state.current_flow?.code_written && !state.current_flow?.code_review_passed) {
-  // VIOLACIÓN CRÍTICA — ABORTAR. Volver a code_review_gate.
-  throw new Error("CODE_REVIEW_GATE: Cannot proceed without code review");
-}
-// GATE CHECK 2: No proceder sin Agent Teams para fases con 2+ agentes
-if (state.current_flow?.parallel_agents_used >= 2 && !state.current_flow?.agent_teams_used) {
-  // VIOLACIÓN CRÍTICA — ABORTAR. Volver a agent_teams_gate.
-  throw new Error("AGENT_TEAMS_GATE: Cannot proceed without Agent Teams for 2+ agents");
+for (const member of instruction.team.members) {
+  Task({
+    subagent_type: member.agent,
+    model: member.model,
+    team_name: instruction.team.name,
+    name: member.name,
+    prompt: `Role: ${member.role}. Execute: ${instruction.nodeId}`
+  })
 }
-state.suggested_next = "verify-work";
-Write(".elsabro/state.json", JSON.stringify(state, null, 2));
-```
-
-Mostrar al usuario:
-```
-## Siguiente Paso
-
-→ /elsabro:verify-work — verificar el trabajo completado
-→ /elsabro:progress — ver el progreso general del proyecto
-```
-</siguiente_paso>
-
-<execution_protocol>
-## Protocolo de Ejecución
-
-### Para Cada Tarea
 
-1. **¿Necesita Context7?**
-   - Si usa librería específica → Verificar patrón actual
-
-2. **¿Es candidata para TDD?**
-   - Lógica de negocio → SÍ
-   - Endpoints API → SÍ
-   - Configuración → NO
-   - UI simple → NO
-
-3. **Si TDD:**
-   ```
-   a. Escribir test que falla
-   b. Verificar que falla por razón correcta
-   c. Implementar código mínimo
-   d. Verificar que test pasa
-   e. Refactorizar si necesario
-   f. Commit
-   ```
-
-4. **Si no TDD:**
-   ```
-   a. Implementar código
-   b. Ejecutar <verify>
-   c. Confirmar resultado esperado
-   d. Commit
-   ```
-
-### Commit por Tarea
-
-```bash
-git add [archivos]
-git commit -m "feat([fase]-[plan]): [descripción]"
+// Al completar todos:
+for (const member of instruction.team.members) {
+  SendMessage({ type: "shutdown_request", recipient: member.name, content: "Done" })
+}
+TeamDelete()
+// result: team outputs aggregated
 ```
-</execution_protocol>
-
-<parallel_execution>
-## Ejecución Paralela con Tasks
 
-### Cuándo usar paralelo
-- Múltiples planes en la misma wave
-- Tareas independientes (sin dependencias)
-
-### Cómo paralelizar CON TRACKING
+### type: "team"
 ```javascript
-// 1. Crear tasks para cada plan
-const planATask = TaskCreate({ subject: "Plan A", activeForm: "Ejecutando Plan A..." })
-const planBTask = TaskCreate({ subject: "Plan B", activeForm: "Ejecutando Plan B..." })
-const planCTask = TaskCreate({ subject: "Plan C", activeForm: "Ejecutando Plan C..." })
-
-// 2. Marcar todas como in_progress
-TaskUpdate({ taskId: planATask.id, status: "in_progress" })
-TaskUpdate({ taskId: planBTask.id, status: "in_progress" })
-TaskUpdate({ taskId: planCTask.id, status: "in_progress" })
-
-// 3. Lanzar agentes EN UN SOLO MENSAJE
-Task(elsabro-executor) Plan A |
-Task(elsabro-executor) Plan B |
-Task(elsabro-executor) Plan C
-
-// 4. Al completar cada uno
-TaskUpdate({ taskId: planATask.id, status: "completed" })
-// ...
-```
-
-### Visualización automática (Ctrl+T)
-```
-📋 Execute Phase 3:
-  ✅ Wave 1 - Completed (3/3 plans)
-  🔧 Wave 2 - Executing Plan D... (1/2 plans done)
-      ✅ Plan D - Completed
-      ⏳ Plan E - In Progress
-  ⏳ Wave 3 - Blocked by Wave 2
-  ⏳ Verification - Blocked by Wave 3
-```
+// instruction: { type: "team", nodeId, team, coordinator, workers }
+// Dedicated team node with coordinator-worker pattern
 
-### Cuándo NO paralelizar
-- Planes con dependencias entre sí (usar `blockedBy`)
-- Plan 2 necesita output de Plan 1
-- Modifican los mismos archivos
+TeamCreate({ team_name: instruction.team.name, description: instruction.team.description })
 
-### Expresar dependencias entre planes
-```javascript
-// Plan B depende de Plan A
-TaskUpdate({
-  taskId: "plan-B-id",
-  addBlockedBy: ["plan-A-id"]
+// Spawn coordinator
+Task({
+  subagent_type: instruction.coordinator.agent,
+  model: instruction.coordinator.model,
+  team_name: instruction.team.name,
+  name: instruction.coordinator.name,
+  prompt: `Role: Coordinator. ${instruction.coordinator.instructions}`
 })
-// Plan B no puede empezar hasta que Plan A complete
-```
-</parallel_execution>
 
-<worktrees_integration>
-## Integración con Worktrees Paralelos
-
-**IMPORTAR**: En waves con múltiples agentes, usar worktrees para aislamiento.
-
-### Cuándo Usar Worktrees
-
-- Profile "careful": SIEMPRE usar worktrees
-- Más de 2 agentes en wave: Considerar worktrees
-- Archivos compartidos entre agentes: OBLIGATORIO usar worktrees
-
-### Flujo con Worktrees
-
-```javascript
-// Antes de ejecutar wave paralela
-if (shouldUseWorktrees(wave, profile)) {
-  const agents = wave.plans.map(p => p.agent);
-
-  // Crear worktrees
-  Bash(`./scripts/setup-parallel-worktrees.sh create ${agents.join(' ')}`);
-
-  // OBLIGATORIO: Crear Agent Team para worktree paralelo (Rule 8)
-  TeamCreate({
-    team_name: "elsabro-worktree",
-    description: "Parallel worktree execution for wave " + wave.id
+// Spawn workers
+for (const worker of instruction.workers) {
+  Task({
+    subagent_type: worker.agent,
+    model: worker.model,
+    team_name: instruction.team.name,
+    name: worker.name,
+    prompt: `Role: ${worker.role}. ${worker.instructions}`
   })
-
-  // Ejecutar agentes como teammates en sus worktrees
-  for (let i = 0; i < agents.length; i++) {
-    Task({
-      subagent_type: agents[i],
-      team_name: "elsabro-worktree",
-      name: `wt-agent-${i + 1}`,
-      prompt: `Trabaja en worktree: ../elsabro-worktrees/${agents[i]}-wt/`
-    });
-  }
-
-  // Shutdown teammates y cleanup team
-  for (let i = 0; i < agents.length; i++) {
-    SendMessage({
-      type: "shutdown_request",
-      recipient: `wt-agent-${i + 1}`,
-      content: "Worktree work complete"
-    });
-  }
-  TeamDelete();
-
-  // Merge y cleanup worktrees al completar
-  Bash(`./scripts/setup-parallel-worktrees.sh complete ${agents.join(' ')}`);
 }
-```
-
-### Resolución de Conflictos
-
-Si hay conflictos en el merge:
-1. Pausar ejecución
-2. Mostrar conflictos al usuario
-3. Opciones: resolver manual, descartar branch, o abortar
-</worktrees_integration>
 
-<error_handling>
-## Manejo de Errores en Ejecucion Paralela
+// Coordinator sends messages to workers via SendMessage
+// (handled internally by the agent - dispatcher just spawns them)
 
-**IMPORTAR**: Este comando DEBE seguir `/references/error-contracts.md`.
-
-### Inicializacion con Contratos
-
-```javascript
-// Antes de cualquier wave, inicializar contratos
-const registryValidator = new ContractRegistryValidator();
-const sessionValidator = new ContractSessionValidator();
-const timeoutHandler = new ContractTimeoutHandler();
-const retryPolicy = new ContractRetryPolicy({
-  maxAttempts: 3,
-  baseDelayMs: 1000,
-  backoffMultiplier: 2
-});
-const errorAggregator = new ContractErrorAggregator("quorum");
-const severityClassifier = new ContractSeverityClassifier();
-
-// 1. Validar registry
-const agentsNeeded = dispatcher.exploration.agents;
-const batch = await registryValidator.validateBatch(agentsNeeded);
-if (!batch.canProceed) {
-  return handleCriticalError("REGISTRY_MISSING", batch.details);
+// Al completar:
+SendMessage({ type: "shutdown_request", recipient: instruction.coordinator.name, content: "Done" })
+for (const worker of instruction.workers) {
+  SendMessage({ type: "shutdown_request", recipient: worker.name, content: "Done" })
 }
-
-// 2. Validar sesion
-const session = await sessionValidator.load();
-if (!session.success) {
-  return handleCriticalError("SESSION_INVALID", session);
-}
-```
-
-### Error Handling por Fase
-
-#### Fase Exploracion (HAIKU x3)
-```javascript
-// Policy: continue_all (exploracion es best-effort)
-errorAggregator.setPolicy("continue_all");
-
-const results = await Promise.all([
-  executeWithRetry("explore-1", () => Task(Explore)),
-  executeWithRetry("explore-2", () => Task(CodeExplorer)),
-  executeWithRetry("explore-3", () => Task(Plan))
-]);
-
-const summary = await errorAggregator.aggregate("exploration", results);
-// continue_all: siempre continua, reporta al final
+TeamDelete()
+// result: { coordinatorOutput, workerOutputs }
 ```
 
-#### Fase Implementacion (OPUS x2 por wave)
+### type: "interrupt"
 ```javascript
-// Policy: quorum (>50% debe tener exito)
-errorAggregator.setPolicy("quorum");
-
-for (const wave of waves) {
-  timeoutHandler.startTimeout(wave.id, 60 * 60 * 1000); // 60min por wave
-
-  // OBLIGATORIO: Crear Agent Team para wave de implementacion (Rule 8)
-  TeamCreate({
-    team_name: "elsabro-wave-impl",
-    description: "Implementation wave " + wave.id
-  })
-
-  const results = await Promise.all(
-    wave.plans.map((plan, i) =>
-      executeWithRetry(plan.id, () => Task({
-        subagent_type: "elsabro-executor",
-        team_name: "elsabro-wave-impl",
-        name: `wave-executor-${i + 1}`,
-        prompt: plan
-      }))
-    )
-  );
-
-  // Shutdown teammates y cleanup team
-  wave.plans.forEach((_, i) => {
-    SendMessage({
-      type: "shutdown_request",
-      recipient: `wave-executor-${i + 1}`,
-      content: "Wave complete"
-    });
-  });
-  TeamDelete();
-
-  const summary = await errorAggregator.aggregate(wave.id, results);
-
-  if (summary.decision === "STOP") {
-    // Quorum no alcanzado
-    await notifyUserImmediately({
-      severity: "CRITICAL",
-      message: `Wave ${wave.id} fallo: ${summary.reason}`,
-      options: ["retry", "debug", "abort"]
-    });
-    return;
-  }
-
-  timeoutHandler.completeTimeout(wave.id);
-}
+// instruction: { type: "interrupt", nodeId, display, routes }
+const answer = AskUserQuestion({
+  questions: [{ question: instruction.display.title, options: instruction.display.options }]
+})
+// result: routeKey seleccionado por usuario (maps to instruction.routes)
 ```
 
-#### Fase Verificacion (OPUS x3)
+### type: "sequence"
 ```javascript
-// Policy: fail_fast (verificacion debe pasar completa)
-errorAggregator.setPolicy("fail_fast");
-
-const verificationResults = await Promise.all([
-  executeWithRetry("verify-code", () => Task(CodeReviewer)),
-  executeWithRetry("verify-silent", () => Task(SilentFailureHunter)),
-  executeWithRetry("verify-tests", () => Task(TestAnalyzer))
-]);
-
-const summary = await errorAggregator.aggregate("verification", verificationResults);
-
-if (summary.decision === "STOP") {
-  // Cualquier fallo en verificacion es critico
-  await displayVerificationFailure(summary);
-  return;
-}
-```
-
-### Escalamiento de Errores
+// instruction: { type: "sequence", nodeId, steps }
+// Execute each step sequentially, capturing outputs
 
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│             ESCALAMIENTO DE ERRORES                                 │
-├─────────────────────────────────────────────────────────────────────┤
-│                                                                     │
-│  Error detectado                                                    │
-│        ↓                                                            │
-│  SeverityClassifier.classify(error)                                 │
-│        ↓                                                            │
-│  ┌─────────────────────────────────────────────────────────────┐   │
-│  │ CRITICAL: Notificar inmediatamente, STOP                    │   │
-│  │ HIGH:     Notificar, ofrecer opciones [fix/debug/abort]      │   │
-│  │ MEDIUM:   Agregar a resumen, continuar                      │   │
-│  │ LOW:      Log para debugging, continuar                     │   │
-│  └─────────────────────────────────────────────────────────────┘   │
-│                                                                     │
-└─────────────────────────────────────────────────────────────────────┘
-```
+const stepOutputs = {};
+const context = getCurrentContext(); // From checkpoint
 
-### Retry Automatico con Backoff
+for (const step of instruction.steps) {
+  const stepLabel = step.as || step.action || 'unnamed';
+
+  switch (step.action) {
+    case 'bash': {
+      // Resolve template variables in command (e.g., {{inputs.task}})
+      const resolvedCommand = resolveTemplate(step.command, context);
+
+      // Execute bash command with timeout
+      const bashResult = Bash({
+        command: resolvedCommand,
+        timeout: step.timeout || 120000,
+        description: `Execute ${stepLabel} - ${step.action}`
+      });
 
-```javascript
-async function executeWithRetry(operationId, operation) {
-  return await retryPolicy.executeWithRetry(
-    operationId,
-    operation,
-    {
-      onAttempt: (attempt) => {
-        console.log(`[RETRY] ${operationId}: Intento ${attempt}/3`);
-      },
-      onSuccess: (result, attempts) => {
-        if (attempts > 1) {
-          console.log(`[RECOVERED] ${operationId}: Exitoso en intento ${attempts}`);
-        }
-      },
-      onFailure: (error, attempts) => {
-        console.error(`[FAILED] ${operationId}: Fallo despues de ${attempts} intentos`);
-
-        // Clasificar para decidir siguiente accion
-        const classification = severityClassifier.classify(error.message);
-        if (classification.severity === "CRITICAL") {
-          throw new CriticalError(error, classification);
+      stepOutputs[stepLabel] = {
+        output: bashResult.stdout,
+        exitCode: bashResult.exitCode || 0,
+        stderr: bashResult.stderr || ''
+      };
+
+      // Special handling for skill-discovery: parse JSON output
+      if (resolvedCommand.includes('skill-discovery.sh')) {
+        try {
+          const discoveryData = JSON.parse(bashResult.stdout);
+          stepOutputs[stepLabel].discovered = discoveryData.discovered || [];
+          stepOutputs[stepLabel].recommended = discoveryData.recommended || {};
+
+          // Log skill discovery execution
+          logInfo(`Skill discovery found ${discoveryData.discovered?.length || 0} installed skills`);
+          if (discoveryData.recommended?.skills?.length > 0) {
+            logInfo(`Recommended skills: ${discoveryData.recommended.skills.join(', ')}`);
+          }
+        } catch (e) {
+          logWarn(`Failed to parse skill-discovery output: ${e.message}`);
         }
       }
+      break;
     }
-  );
-}
-```
-
-### Guardar Estado de Errores
-
-Al completar cada wave (exito o fallo):
-
-```javascript
-// Actualizar state.json con errores para recovery
-state.errors = {
-  count: allErrors.length,
-  lastError: allErrors[allErrors.length - 1],
-  byWave: errorsByWave,
-  bySeverity: {
-    CRITICAL: criticalErrors,
-    HIGH: highErrors,
-    MEDIUM: mediumErrors,
-    LOW: lowErrors
-  }
-};
 
-state.parallelExecution = {
-  policy: currentPolicy,
-  activeAgents: [],
-  completedAgents: completedAgentIds,
-  failedAgents: failedAgentIds
-};
-
-await sessionValidator.save(state);
-```
-
-### Clasificacion de Errores (Referencia Rapida)
-
-| Severity | Emoji | Accion |
-|----------|-------|--------|
-| CRITICAL | Parar | No puede continuar de ninguna forma |
-| HIGH | Preguntar | Ofrecer opciones: fix/debug/abort |
-| MEDIUM | Warning | Mostrar y continuar |
-| LOW | Info | Log y continuar |
-
-### Reglas de Desviacion
-
-| Situacion | Severity | Accion |
-|-----------|----------|--------|
-| Bug que impide continuar | HIGH | Auto-fix (3 intentos) |
-| Falta validacion critica | HIGH | Auto-add |
-| Falta dependencia | HIGH | Auto-install |
-| Cambio arquitectonico | HIGH | CHECKPOINT |
-| Tests fallan | HIGH | Auto-fix (5 intentos) |
-| Lint warnings | HIGH | Auto-fix (incluido en quality gate) |
-
-### Actualizar Estado con Tasks
-
-Despues de errores, actualizar tanto SESSION-STATE.json como Tasks:
-
-```javascript
-// 1. Actualizar task con metadata de error
-TaskUpdate({
-  taskId: "plan-X-id",
-  metadata: {
-    error: {
-      code: "TESTS_FAILED",
-      severity: "HIGH",
-      at: "2024-01-20T15:25:00Z",
-      attempt: 3,
-      maxAttempts: 3
+    case 'agent': {
+      const resolvedInputs = resolveTemplate(step.inputs || {}, context);
+      const agentResult = Task({
+        subagent_type: step.agent,
+        model: step.model || 'sonnet',
+        prompt: JSON.stringify(resolvedInputs)
+      });
+      stepOutputs[stepLabel] = { result: agentResult };
+      break;
     }
-  }
-})
-
-// 2. Si retry exhausted, NO marcar completed
-// Crear subtask de fix
-TaskCreate({
-  subject: "Fix: Tests failing in Plan X",
-  description: "3 retry attempts exhausted, needs manual fix",
-  activeForm: "Fixing test failures...",
-  metadata: { type: "bugfix", parentPlan: "plan-X-id" }
-})  // → bugfix-id
-
-// 3. Bloquear verificacion hasta que bugfix complete
-TaskUpdate({
-  taskId: "verify-aggregate-id",
-  addBlockedBy: ["bugfix-id"]
-})
-
-// 4. Tambien actualizar SESSION-STATE.json para compatibilidad
-```
-
-### Rollback de Estado con Tasks
 
-Si necesitas volver a ejecutar un plan:
-
-```javascript
-// Volver plan a in_progress (no crear nuevo)
-TaskUpdate({ taskId: "plan-X-id", status: "in_progress" })
+    case 'read_files': {
+      const files = resolveTemplate(step.files, context);
+      const fileContents = [];
+      for (const filePath of files) {
+        try {
+          const content = Read({ file_path: filePath });
+          fileContents.push({ path: filePath, content });
+        } catch (e) {
+          if (!step.optional) throw e;
+          fileContents.push({ path: filePath, content: null, error: e.message });
+        }
+      }
+      stepOutputs[stepLabel] = { content: fileContents };
+      break;
+    }
 
-// Re-ejecutar
-Task(elsabro-executor) para Plan X
+    default:
+      // Unimplemented step actions: log warning
+      logWarn(`Step action "${step.action}" not implemented in dispatcher, skipping`);
+      stepOutputs[stepLabel] = { skipped: true, reason: `Action not implemented` };
+  }
+}
 
-// Marcar completed cuando funcione
-TaskUpdate({ taskId: "plan-X-id", status: "completed" })
+// result: stepOutputs with all step execution results
 ```
 
-### Ver Estado Actual
+## 4. Observabilidad (4 Senales)
 
-```javascript
-// Listar todas las tasks
-TaskList()
+Despues de cada `step` y `complete`, emitir al log:
 
-// Ver detalles de una task especifica
-TaskGet({ taskId: "plan-X-id" })
 ```
-</error_handling>
-
-<summary_creation>
-## Creación de Summary
-
-Al completar un plan:
-
-```markdown
-# Summary: [Nombre del Plan]
-
-## Completado
-- [x] Tarea 1
-- [x] Tarea 2
-
-## Archivos
-- path/to/file.ts
-- path/to/another.ts
-
-## Commits
-- abc1234: feat(01-01): [descripción]
-- def5678: feat(01-01): [descripción]
-
-## Verificación
-- [x] Build: npm run build
-- [x] Tests: npm run test
+.elsabro/telemetry/execution-{flowId}.jsonl
 ```
-</summary_creation>
 
-<engine_integration>
-## Flow Engine (v7.0.0) + CLI
+| Senal | Cuando | Datos |
+|---|---|---|
+| `node_skip_counter` | step auto-resuelve N nodos | `{ signal: "node_skip", skipped: N, nodeId }` (NOTE: requires cli.js patch to include nodesVisited in step output) |
+| `gate_bypass_detector` | step resuelve condition/router | `{ signal: "gate_check", nodeId, result: true/false }` |
+| `execution_time_anomaly` | complete tarda >120s | `{ signal: "time_anomaly", nodeId, duration_ms }` |
+| `diff_size_vs_review_ratio` | complete de parallel_review | `{ signal: "review_ratio", files, comments }` |
 
-The flow engine runtime is at `flow-engine/src/index.js`.
-The CLI is at `flow-engine/src/cli.js` (also `npm run flow` or `elsabro-flow`).
-
-### Quick Reference
+Formato: una linea JSON por evento (JSON Lines). Append-only.
 
 ```bash
-# Validate flow + see team compositions
-node flow-engine/src/cli.js validate --flow flows/development-flow.json
-
-# Dry-run (full path, mock callbacks)
-node flow-engine/src/cli.js dry-run --flow flows/development-flow.json --task "feature" --profile default
-
-# Step-based execution
-node flow-engine/src/cli.js init --flow flows/development-flow.json --task "build auth" --profile default
-node flow-engine/src/cli.js step --flow flows/development-flow.json
-node flow-engine/src/cli.js complete --flow flows/development-flow.json --result '{"output": "done"}'
-node flow-engine/src/cli.js status --flow flows/development-flow.json
+echo '{"ts":"'$(date -u +%FT%TZ)'","signal":"node_skip","nodeId":"...","skipped":3}' >> .elsabro/telemetry/execution-${FLOW_ID}.jsonl
 ```
-</engine_integration>
 
-<cli_driven_execution>
-## CLI-Driven Execution (v7.0.0)
+## 5. Finalizar
 
-The CLI manages graph traversal. It auto-resolves simple nodes (entry, condition, router, exit)
-and stops at actionable nodes, emitting a JSON instruction. Claude follows the instruction,
-then calls `complete` to advance.
+Cuando el loop retorna `{ finished: true }`:
 
-### Main Loop
+1. Actualizar `.elsabro/state.json` siguiendo @references/state-sync.md:
+   - Agregar a `history`
+   - Pasar `context.changed_files`, `context.commits`, `context.tests_added` para verify-work
+   - Limpiar `current_flow`
+   - Establecer `suggested_next: "verify-work"`
+2. Actualizar `.elsabro/context.md` con resumen legible
 
-```
-init → [step → execute instruction → complete]* → step (finished)
-```
-
-1. **init**: Creates checkpoint at entry node
-2. **step**: Auto-resolves through conditions/routers, stops at actionable node, returns instruction JSON
-3. **execute instruction**: Claude executes based on instruction type (see below)
-4. **complete**: Stores result, advances checkpoint to next node
-5. Repeat step→execute→complete until `step` returns `{ finished: true }`
-
-### Instruction Types
-
-#### `type: "agent"` → Launch single subagent
-```javascript
-// instruction: { type: "agent", nodeId, agent, model, inputs }
-Task({
-  subagent_type: instruction.agent,
-  model: instruction.model,
-  prompt: `Execute task with inputs: ${JSON.stringify(instruction.inputs)}`
-})
-```
-
-#### `type: "parallel"` with `useAgentTeams: false` → Launch subagents (haiku exploration)
-```javascript
-// instruction: { type: "parallel", nodeId, useAgentTeams: false, branches }
-// All-haiku branches → regular subagents, no team needed
-for (const branch of instruction.branches) {
-  Task({
-    subagent_type: branch.agent,
-    model: "haiku",
-    prompt: `Execute: ${JSON.stringify(branch.inputs)}`
-  })
-}
-```
-
-#### `type: "parallel"` with `useAgentTeams: true` → Use Agent Teams (min 5 members)
-```javascript
-// instruction: { type: "parallel", nodeId, useAgentTeams: true, team: { name, members[5+] }, branches }
-//
-// The engine composed a team of 5+ members:
-// - Core branch agents (from flow definition)
-// - Support agents (verifier, qa, debugger, etc.) padded to minimum 5
-//
-// Claude Code handles team lifecycle automatically:
-
-TeamCreate({
-  team_name: instruction.team.name,
-  description: instruction.team.description
-})
+## 6. Siguiente Paso
 
-// Launch ALL team members (not just branches — the full team of 5+)
-for (const member of instruction.team.members) {
-  Task({
-    subagent_type: member.agent,
-    model: member.model,
-    team_name: instruction.team.name,
-    name: member.name,
-    prompt: `Role: ${member.role}. Execute your part of ${instruction.nodeId}.`
-  })
-}
-
-// When all complete:
-for (const member of instruction.team.members) {
-  SendMessage({ type: "shutdown_request", recipient: member.name, content: "Done" })
-}
-TeamDelete()
-```
+**Gate checks** (por referencia a @references/enforcement-rules.md):
+- Rule 7: Si se escribio codigo -> code review debe haber pasado (el flow lo garantiza via parallel_review)
+- Rule 8: Si se usaron 2+ agentes -> Agent Teams debe haberse usado (callbacks.js lo garantiza)
 
-#### `type: "interrupt"` → Ask user
-```javascript
-// instruction: { type: "interrupt", nodeId, display, routes, reason }
-AskUserQuestion({
-  questions: [{
-    question: instruction.display.title,
-    options: instruction.display.options.map(o => ({ label: o.label, description: o.id }))
-  }]
-})
-// User's selection maps to a route key → pass as result to complete
 ```
+Siguiente Paso
 
-#### `type: "sequence"` → Execute steps inline
-```javascript
-// instruction: { type: "sequence", nodeId, steps }
-for (const step of instruction.steps) {
-  if (step.action === "bash") Bash(step.command)
-  if (step.action === "agent") Task({ subagent_type: step.agent, ... })
-  if (step.action === "read_files") Read(step.files)
-}
+-> /elsabro:verify-work -- verificar el trabajo completado
+-> /elsabro:progress -- ver el progreso general del proyecto
 ```
-
-### Team Compositions (from validate)
-
-| Node | Core | Padded to 5 with | Total |
-|------|------|-------------------|-------|
-| `standard_analyze` | 4 haiku | NO TEAM (subagents) | 4 subagents |
-| `parallel_implementation` | executor, qa | + verifier, analyst, debugger | 5 |
-| `fix_issues` | debugger, error-detective, refactor | + verifier, qa | 5 |
-| `parallel_review` | code-reviewer, silent-failure, staff | + verifier, qa | 5 |
-
-### Rules
-
-1. **Minimum 5 teammates** — Every Agent Team has at least 5 members
-2. **Haiku exception** — All-haiku parallel nodes use subagents, not teams
-3. **One team at a time** — Cleanup before creating next team
-4. **Cleanup required** — SendMessage shutdown + TeamDelete after each team
-</cli_driven_execution>