elsabro 4.0.0 → 4.2.0

package/references/flow-orchestration.md

@@ -1,7 +1,7 @@
 ---
 name: flow-orchestration
 description: Sistema de orquestacion basado en grafos inspirado en LangGraph
-version: 1.0.0
+version: 4.0.0
 ---
 
 # ELSABRO Flow-Based Orchestration
@@ -628,14 +628,15 @@ class FlowEngine {
   async executeTeamNode(node) {
     const config = this.resolveTemplate(node.config);
     const phaseOutputs = {};
+    let teamCreated = false;
 
     try {
-      // 1. Crear equipo
-      await this.callTool('Teammate', {
-        operation: 'spawnTeam',
+      // 1. Crear equipo (API oficial Claude Code)
+      await this.callTool('TeamCreate', {
         team_name: config.team_name,
         description: config.description
       });
+      teamCreated = true;
 
       // 2. Ejecutar fases secuencialmente
       for (const phase of node.phases) {
@@ -643,42 +644,66 @@ class FlowEngine {
           phase.active_members.includes(m.name)
         );
 
-        // Spawn miembros activos en paralelo
-        const memberPromises = activeMembers.map(member =>
-          this.callTool('Task', {
-            subagent_type: member.agent,
-            team_name: config.team_name,
-            name: member.name,
-            model: member.model,
-            description: `${phase.name}: ${member.role}`,
-            prompt: this.resolveTemplate(phase.tasks)
-          })
-        );
-
-        // Capturar resultados de cada fase
-        const results = await Promise.all(memberPromises);
-        phaseOutputs[phase.id] = results;
+        // Spawn miembros activos en paralelo (with per-member error context)
+        const memberPromises = activeMembers.map(async (member) => {
+          try {
+            return await this.callTool('Task', {
+              subagent_type: member.agent,
+              team_name: config.team_name,
+              name: member.name,
+              model: member.model,
+              description: `${phase.name}: ${member.role}`,
+              prompt: this.resolveTemplate(phase.tasks)
+            });
+          } catch (error) {
+            this.state.history.push({
+              nodeId: node.id,
+              event: 'member_spawn_failed',
+              phase: phase.id,
+              member: member.name,
+              agent: member.agent,
+              error: error.message,
+              timestamp: new Date().toISOString()
+            });
+            throw new Error(
+              `Failed to spawn '${member.name}' (${member.agent}) in phase '${phase.id}': ${error.message}`
+            );
+          }
+        });
+
+        // Capturar resultados de cada fase (with phase context on failure)
+        try {
+          const results = await Promise.all(memberPromises);
+          phaseOutputs[phase.id] = results;
+        } catch (error) {
+          throw new Error(`Phase '${phase.id}' failed: ${error.message}`);
+        }
       }
 
       // 3. Cleanup si configurado
       if (node.cleanup) {
-        // Shutdown todos los miembros
-        for (const member of node.members) {
-          await this.callTool('SendMessage', {
-            type: 'shutdown_request',
-            recipient: member.name,
-            content: 'Phase complete, shutting down'
-          });
-        }
-        await this.callTool('Teammate', { operation: 'cleanup' });
+        await this.cleanupTeam(node, config);
       }
 
-      // 4. Almacenar outputs para nodos downstream
-      this.state.nodeOutputs[node.id] = { phases: phaseOutputs };
-
-      return { next: node.next };
+      // 4. Return phases in result so executeNode stores them in nodeOutputs
+      return { next: node.next, phases: phaseOutputs };
 
     } catch (error) {
+      // Attempt cleanup only if team was successfully created
+      try {
+        if (node.cleanup && teamCreated) {
+          await this.cleanupTeam(node, config);
+        }
+      } catch (cleanupError) {
+        // Log cleanup failure but don't mask the original error
+        this.state.history.push({
+          nodeId: node.id,
+          event: 'cleanup_failed',
+          error: cleanupError.message,
+          timestamp: new Date().toISOString()
+        });
+      }
+
       // Si hay onError definido, redirigir
       if (node.onError) {
         this.state.lastError = error.message;
@@ -688,6 +713,71 @@ class FlowEngine {
     }
   }
 
+  /**
+   * Cleanup: shutdown all teammates and delete team
+   * Waits for each shutdown acknowledgment before proceeding to TeamDelete
+   */
+  async cleanupTeam(node, config) {
+    const shutdownResults = [];
+
+    // Send shutdown requests and track each result
+    for (const member of node.members) {
+      try {
+        const result = await this.callTool('SendMessage', {
+          type: 'shutdown_request',
+          recipient: member.name,
+          content: 'Phase complete, shutting down'
+        });
+
+        const wasApproved = !(result && result.approved === false);
+        shutdownResults.push({ member: member.name, approved: wasApproved });
+
+        if (!wasApproved) {
+          this.state.history.push({
+            nodeId: node.id,
+            event: 'shutdown_rejected',
+            member: member.name,
+            reason: result.content || 'No reason provided',
+            timestamp: new Date().toISOString()
+          });
+        }
+      } catch (error) {
+        shutdownResults.push({ member: member.name, approved: false, error: error.message });
+        this.state.history.push({
+          nodeId: node.id,
+          event: 'shutdown_request_failed',
+          member: member.name,
+          error: error.message,
+          timestamp: new Date().toISOString()
+        });
+      }
+    }
+
+    // Check if any shutdowns failed - TeamDelete requires all members inactive
+    const failed = shutdownResults.filter(r => !r.approved);
+    if (failed.length > 0) {
+      const names = failed.map(r => r.member).join(', ');
+      throw new Error(
+        `Cannot delete team '${config.team_name}': ${failed.length} member(s) did not shut down: ${names}`
+      );
+    }
+
+    // All teammates acknowledged shutdown - safe to delete
+    try {
+      await this.callTool('TeamDelete');
+      this.state.history.push({
+        nodeId: node.id,
+        event: 'team_deleted',
+        teamName: config.team_name,
+        timestamp: new Date().toISOString()
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to delete team '${config.team_name}' after successful shutdown: ${error.message}`
+      );
+    }
+  }
+
   /**
    * Ejecuta nodo de agente
    */
@@ -927,6 +1017,11 @@ class FlowEngine {
       return this.graph.getNode(nextId);
     }
 
+    // Team node: use result.next for dynamic routing
+    if (currentNode.type === 'team') {
+      return result.next ? this.graph.getNode(result.next) : null;
+    }
+
     // Exit no tiene siguiente
     if (currentNode.type === 'exit') {
       return null;

package/references/next-step-engine.md

@@ -0,0 +1,134 @@
+# Next Step Engine - Sistema Universal de Sugerencias
+
+## Objetivo
+
+Cada comando ELSABRO que escribe a `state.json` DEBE sugerir al usuario qué hacer después de completar. Esto crea un flujo guiado que reduce la fricción y ayuda a usuarios sin experiencia.
+
+## Implementación
+
+### 1. state.json: Campo `suggested_next`
+
+Al completar cualquier comando, establecer:
+
+```javascript
+state.suggested_next = "[comando]";  // o null si es terminal
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+### 2. Output: Bloque "Siguiente Paso"
+
+Al final de cada `<process>`, mostrar:
+
+```
+## Siguiente Paso
+
+→ /elsabro:[primary-suggestion] — [razón contextual]
+→ /elsabro:[alternative] — [razón alternativa]
+```
+
+## Decision Matrix
+
+| Comando | suggested_next | Sugerencia Primaria | Alternativa |
+|---------|---------------|---------------------|-------------|
+| start | "map-codebase" | → /elsabro:map-codebase — explorar el proyecto | → /elsabro:plan — planificar directamente |
+| new | "plan" | → /elsabro:plan 1 — planificar primera fase | → /elsabro:map-codebase — explorar lo creado |
+| plan | "execute" | → /elsabro:execute — ejecutar el plan | → /elsabro:discuss-phase — discutir antes |
+| execute | "verify-work" | → /elsabro:verify-work — verificar el trabajo | → /elsabro:progress — ver progreso |
+| verify-work | conditional | → /elsabro:plan [N+1] (si PASS) | → /elsabro:execute (si gaps) |
+| debug | "verify-work" | → /elsabro:verify-work — verificar el fix | → /elsabro:progress — ver estado |
+| quick | "progress" | → /elsabro:progress — ver estado | → commit si hay cambios |
+| map-codebase | "plan" | → /elsabro:plan — planificar basado en hallazgos | → /elsabro:discuss-phase — discutir |
+| resume-work | context-dependent | → /elsabro:[paused_command] — continuar | → /elsabro:progress — ver estado |
+| pause-work | "resume-work" | → /elsabro:resume-work — cuando estés listo | |
+| verify | "progress" | → /elsabro:progress — ver estado general | → /elsabro:plan [N+1] — siguiente fase |
+| new-milestone | "plan" | → /elsabro:plan 1 — planificar primera fase | → /elsabro:add-phase — agregar fases |
+| complete-milestone | "new-milestone" | → /elsabro:new-milestone — siguiente milestone | → /elsabro:progress — ver estado |
+| audit-milestone | "plan-milestone-gaps" | → /elsabro:plan-milestone-gaps — cerrar gaps | → /elsabro:discuss-phase — discutir |
+| plan-milestone-gaps | "execute" | → /elsabro:execute — corregir los gaps | → /elsabro:quick — fix rápido |
+| add-phase | "plan" | → /elsabro:plan [N] — planificar la nueva fase | → /elsabro:progress — ver estado |
+| insert-phase | "plan" | → /elsabro:plan [N] — planificar fase insertada | → /elsabro:progress — ver estado |
+| remove-phase | "progress" | → /elsabro:progress — ver estado actualizado | → /elsabro:plan — replanificar |
+| discuss-phase | "plan" | → /elsabro:plan — planificar la fase discutida | → /elsabro:execute — ejecutar directamente |
+| research-phase | "plan" | → /elsabro:plan — planificar con los hallazgos | → /elsabro:discuss-phase — discutir |
+| list-phase-assumptions | "discuss-phase" | → /elsabro:discuss-phase — discutir asunciones | → /elsabro:plan — planificar |
+| add-todo | "check-todos" | → /elsabro:check-todos — ver lista completa | → /elsabro:quick — resolver ahora |
+| check-todos | "quick" | → /elsabro:quick — resolver un TODO | → /elsabro:execute — trabajo mayor |
+| settings | previous_flow | → volver al flujo anterior | → /elsabro:start — empezar nuevo |
+| set-profile | previous_flow | → volver al flujo anterior | → /elsabro:start — empezar nuevo |
+| update | "start" | → /elsabro:start — usar nueva versión | |
+| design-ui | "execute" | → /elsabro:execute — implementar los diseños | → /elsabro:design-ui — refinar o agregar más |
+| progress | context-dependent | → /elsabro:execute — continuar trabajo activo | → /elsabro:check-todos — revisar pendientes |
+| exit | "resume-work" | → /elsabro:resume-work — cuando vuelvas | |
+
+## Contextual Overrides
+
+The suggested_next can be overridden based on context:
+
+### Si hay pending_tasks bloqueadas
+```javascript
+if (state.pending_tasks?.some(t => t.blocked)) {
+  // Override: suggest debugging the blocker
+  state.suggested_next = "debug";
+}
+```
+
+### Si hay TODOs de alta prioridad
+```javascript
+if (state.context?.high_priority_todos > 0) {
+  // Alternative: suggest checking todos
+  alternativeSuggestion = "check-todos";
+}
+```
+
+### Si verify-work encontró gaps
+```javascript
+if (state.context?.verification_result === "FAIL") {
+  state.suggested_next = "execute"; // re-execute to fix
+}
+```
+
+### Si es flujo nuevo (greenfield)
+```javascript
+if (state.context?.project_type === "greenfield" && !state.context?.plan_file) {
+  state.suggested_next = "new"; // create project first
+}
+```
+
+## Output Template
+
+### Formato Estándar
+```
+## Siguiente Paso
+
+→ /elsabro:[comando] — [razón]
+→ /elsabro:[alternativa] — [razón]
+```
+
+### Con Contexto Dinámico
+```
+## Siguiente Paso
+
+→ /elsabro:execute — ejecutar el plan creado
+  [Si prefieres revisar primero: /elsabro:discuss-phase]
+```
+
+## Fallback Rule
+
+When uncertain about what to suggest:
+```javascript
+state.suggested_next = "progress"; // safe fallback
+```
+
+The `progress` command always shows current state and its own suggestions.
+
+## Integration with Persistent Mode
+
+When `elsabro_mode` is true, the routing hook can use `suggested_next` to provide smarter routing:
+
+```javascript
+// In hook, if user message is ambiguous but suggested_next exists:
+if (state.suggested_next && isAmbiguous(userMessage)) {
+  // Route to suggested_next instead of asking for clarification
+  Skill(`elsabro:${state.suggested_next}`);
+}
+```

package/skills/stitch-ui-design.md

@@ -0,0 +1,242 @@
+---
+name: stitch-ui-design
+description: Skill para diseño de UI con Stitch AI - genera screens y mockups profesionales desde descripciones de texto
+tags:
+  - design
+  - ui
+  - stitch
+  - screens
+  - mockups
+  - wireframes
+  - ux
+difficulty: intermediate
+estimated_time: 15-30 min
+---
+
+# Skill: Diseño de UI con Stitch AI
+
+<when_to_use>
+Usar cuando el usuario menciona:
+- "diseñar interfaz"
+- "crear mockup"
+- "wireframe"
+- "diseño de pantalla"
+- "UI design"
+- "cómo se va a ver"
+- "diseño visual"
+- "generar screens"
+- "prototipo visual"
+</when_to_use>
+
+<pre_requisites>
+## Pre-requisitos
+
+### Conocimientos
+- Conceptos básicos de UI/UX (no obligatorio - ELSABRO guía)
+- Idea general de qué pantallas necesita la app
+
+### Software/Configuración
+- Stitch MCP configurado y funcionando
+- Proyecto ELSABRO inicializado (.elsabro/state.json)
+
+### Verificación
+```javascript
+// Verificar que Stitch está disponible
+mcp__stitch__list_projects()
+// Si responde → OK
+// Si error → Verificar configuración MCP
+```
+</pre_requisites>
+
+<project_structure>
+## Estructura de Archivos
+
+```
+.planning/
+├── ui-designs/
+│   ├── UI-DESIGNS.md          # Índice de diseños
+│   ├── screen-login.md        # Spec de pantalla login
+│   ├── screen-dashboard.md    # Spec de pantalla dashboard
+│   └── screen-settings.md     # Spec de pantalla settings
+```
+
+### UI-DESIGNS.md Template
+```markdown
+# UI Designs - [Nombre del Proyecto]
+
+## Stitch Project
+- **ID:** [project_id]
+- **Created:** [fecha]
+- **Screens:** [cantidad]
+
+## Screen Index
+| # | Screen | Status | Stitch ID |
+|---|--------|--------|-----------|
+| 1 | Login | ✅ Generated | [id] |
+| 2 | Dashboard | ✅ Generated | [id] |
+| 3 | Settings | 🟡 Draft | [id] |
+```
+</project_structure>
+
+<process>
+## Proceso (6 Pasos)
+
+### Paso 1: Descubrimiento
+Entender qué screens necesita la app.
+
+```javascript
+// Si hay plan de fase, extraer UI requirements
+const plans = Glob(".planning/*-PLAN.md");
+const uiRequirements = plans.flatMap(p => extractUIRequirements(Read(p)));
+
+// Si no hay plan, preguntar al usuario
+if (uiRequirements.length === 0) {
+  AskUserQuestion({
+    questions: [{
+      question: "¿Qué pantallas necesita tu app?",
+      header: "Screens",
+      options: [
+        { label: "Auth flow", description: "Login, Register, Forgot Password" },
+        { label: "Dashboard", description: "Overview con cards y stats" },
+        { label: "CRUD pages", description: "List, Detail, Create, Edit" },
+        { label: "Custom", description: "Describir las pantallas" }
+      ],
+      multiSelect: true
+    }]
+  });
+}
+```
+
+### Paso 2: Proyecto Stitch
+Crear o reutilizar proyecto en Stitch.
+
+```javascript
+const projects = mcp__stitch__list_projects();
+const existing = projects.find(p => p.name.includes(projectName));
+
+if (!existing) {
+  const project = mcp__stitch__create_project({
+    name: projectName + " - UI Design"
+  });
+}
+```
+
+### Paso 3: Generación de Screens
+Generar cada screen con Stitch AI.
+
+```javascript
+for (const screen of screensToGenerate) {
+  const result = mcp__stitch__generate_screen_from_text({
+    project_id: projectId,
+    text: screen.description
+  });
+
+  // Guardar referencia
+  screens.push({
+    name: screen.name,
+    id: result.id,
+    description: screen.description
+  });
+}
+```
+
+### Paso 4: Revisión
+Revisar screens generados con el usuario.
+
+```javascript
+// Listar todos los screens del proyecto
+const allScreens = mcp__stitch__list_screens({ project_id: projectId });
+
+// Mostrar resumen al usuario
+// Obtener detalle de cada screen si necesario
+const screenDetail = mcp__stitch__get_screen({
+  project_id: projectId,
+  screen_id: screenId
+});
+```
+
+### Paso 5: Refinamiento
+Iterar sobre screens según feedback.
+
+```javascript
+// Regenerar con ajustes
+mcp__stitch__generate_screen_from_text({
+  project_id: projectId,
+  text: originalDescription + "\n\nAdjustments:\n" + feedback
+});
+```
+
+### Paso 6: Documentación
+Guardar todo en .planning/ui-designs/.
+
+```javascript
+// Crear índice de diseños
+Write(".planning/ui-designs/UI-DESIGNS.md", designIndex);
+
+// Crear spec por screen
+for (const screen of screens) {
+  Write(`.planning/ui-designs/screen-${screen.slug}.md`, screenSpec);
+}
+```
+</process>
+
+<verification>
+## Verificación
+
+### Automática
+```javascript
+// 1. Verificar proyecto existe en Stitch
+const project = mcp__stitch__get_project({ project_id: projectId });
+assert(project, "Proyecto Stitch existe");
+
+// 2. Verificar screens generados
+const screens = mcp__stitch__list_screens({ project_id: projectId });
+assert(screens.length > 0, "Al menos 1 screen generado");
+
+// 3. Verificar documentación local
+assert(Read(".planning/ui-designs/UI-DESIGNS.md"), "Índice de diseños existe");
+```
+
+### Manual (con usuario)
+```
+Verificación:
+
+1. Revisa los screens generados en el proyecto Stitch
+2. ¿Los diseños representan lo que necesitas?
+3. ¿Falta alguna pantalla importante?
+4. ¿Los colores y estilo son apropiados?
+
+¿Todo correcto? (sí/ajustar/regenerar)
+```
+</verification>
+
+<common_issues>
+## Problemas Comunes
+
+### Stitch no responde
+```
+Causa: MCP server no está corriendo o configurado
+Solución: Verificar configuración MCP en settings.json
+```
+
+### Screens genéricos
+```
+Causa: Descripción muy vaga
+Solución: Agregar más detalles: colores, estilo, contenido de ejemplo
+```
+
+### Proyecto duplicado
+```
+Causa: Ya existe un proyecto con el mismo nombre
+Solución: Usar list_projects para encontrar el existente y reutilizarlo
+```
+</common_issues>
+
+<next_steps>
+## Siguiente Paso
+
+Después de completar el diseño:
+- **Implementar:** `/elsabro:execute` para codificar los diseños
+- **Refinar:** `/elsabro:design-ui` para ajustar screens
+- **Componentes:** Sally (elsabro-ux-designer) puede generar componentes con 21st.dev
+</next_steps>

package/templates/session-state.json

@@ -53,7 +53,9 @@
       "lastSuccessfulStep": "",
       "resumeFrom": "",
       "notes": ""
-    }
+    },
+
+    "elsabro_mode": false
   },
 
   "validation": {