elsabro 7.3.0 → 7.3.1

package/README.md

@@ -245,6 +245,40 @@ O desde Claude Code:
 /elsabro:update
 ```
 
+## Desinstalacion
+
+Si deseas eliminar ELSABRO completamente, puedes hacerlo de dos formas:
+
+### Con el CLI (Recomendado)
+
+```bash
+# Desinstalar instalacion global
+npx elsabro --global --uninstall
+
+# Desinstalar instalacion local
+npx elsabro --local --uninstall
+```
+
+Esto elimina todos los componentes del framework: comandos, agentes, skills, templates, workflows, referencias, flows y el flow engine.
+
+### Manual
+
+Si prefieres eliminar los archivos manualmente:
+
+```bash
+# 1. Eliminar componentes del framework (instalacion global)
+cd ~/.claude
+rm -rf commands/elsabro agents skills templates workflows references flows flow-engine
+
+# 2. Eliminar datos de sesion del proyecto (desde la raiz de tu proyecto)
+rm -rf .elsabro .planning
+
+# 3. Limpiar la entrada de ELSABRO en settings.json (opcional)
+# Editar ~/.claude/settings.json y eliminar la clave "elsabro"
+```
+
+> **Nota:** Los directorios `.elsabro/` y `.planning/` contienen el estado de sesion, checkpoints y planes de tu proyecto. El CLI no los elimina automaticamente porque son datos de tu trabajo. Revisalos antes de borrarlos si tienes informacion que quieras conservar.
+
 ## Version History
 
 | Version | Milestone | Cambio Principal |

package/agents/elsabro-orchestrator.md

@@ -387,6 +387,8 @@ Unlike parallel execution (waves), Party Mode is **sequential deliberation**:
 <agent_teams>
 ## Agent Teams Integration (v4.2.0 — Mandatory)
 
+**CLARIFICATION**: The orchestrator agent uses Agent Teams (TeamCreate, TeamDelete, SendMessage) for parallel execution coordination. This is **NOT related** to the elsabro-scrum-master agent, which is a separate utility agent for sprint planning and process management.
+
 ### Cuándo Usar Agent Teams
 
 Como orquestador, Agent Teams es **OBLIGATORIO** para todo trabajo paralelo con 2+ agentes (Rule 8):

package/commands/elsabro/execute.md

@@ -38,12 +38,99 @@ Verificar flujo en progreso. Actualizar phase a "stepping".
 FLOW="flows/development-flow.json"
 TASK="[descripcion de la tarea del usuario]"
 PROFILE="[default|yolo|careful|teams|bmad]"
+COMPLEXITY="[low|medium|high]"
 
-node flow-engine/src/cli.js init --flow "$FLOW" --task "$TASK" --profile "$PROFILE"
+# Initialize flow and create checkpoint
+node flow-engine/src/cli.js init --flow "$FLOW" --task "$TASK" --profile "$PROFILE" --complexity "$COMPLEXITY"
 ```
 
 Guardar el flowId del resultado para todos los comandos siguientes.
 
+**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`
+
+## 1.1. Stitch MCP Auto-Detection (Visual Projects)
+
+**AFTER initialization**, check if this is a visual project and suggest Stitch MCP if UI work is needed:
+
+```javascript
+// Detectar frameworks visuales y verificar si Stitch está configurado
+let isVisualProject = false;
+let detectedFrameworks = [];
+let hasStitchDesigns = false;
+
+try {
+  const packageJson = Read("package.json");
+  const pkg = JSON.parse(packageJson);
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+  // 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" }
+  ];
+
+  for (const framework of visualFrameworks) {
+    if (allDeps[framework.name]) {
+      detectedFrameworks.push(framework.display);
+      isVisualProject = true;
+    }
+  }
+
+  // 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
+}
+
+// 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;
+
+  // Actualizar estado
+  Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+  // 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`);
+
+  // 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
+  }
+}
+```
+
 ## 2. Loop Principal
 
 Ejecutar el siguiente loop hasta que `step` retorne `{ finished: true }`:
@@ -67,8 +154,125 @@ Ejecutar el siguiente loop hasta que `step` retorne `{ finished: true }`:
 
 6. Volver al paso 1.
 
+## 2.1. Error Handling: Runtime Status Validation
+
+The flow engine validates all nodes before execution via `checkRuntimeStatus()`. This catches:
+
+### NotImplementedError
+Thrown when a node has `runtime_status: "not_implemented"`:
+```javascript
+{
+  "id": "bmad_solution",
+  "type": "sequence",
+  "runtime_status": "not_implemented",
+  "gaps": ["BMAD solutioning logic not yet implemented", "Needs ADR generation"]
+}
+```
+
+**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"]
+}
+```
+
+**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
+{
+  "id": "legacy_team_node",
+  "type": "team",
+  "runtime_status": "deprecated",
+  "deprecated_reason": "Use parallel nodes with Agent Teams instead (Rule 8)"
+}
+```
+
+**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)"
+}
+```
+
+**Dispatcher action:**
+- STOP execution immediately
+- Display deprecation warning with reason
+- Suggest migration path if available in error
+- Offer "Abort workflow"
+
+### When to Continue vs Abort
+
+**Continue (skip node) only if:**
+- Node has `optional: true` explicitly set
+- AND user explicitly chooses "Skip" option
+
+**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)
+
+### Telemetry Signal
+
+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"
+}
+```
+
 ## 3. Dispatch por Tipo de Instruccion
 
+### type: "entry"
+```javascript
+// 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 }
+```
+
+### type: "exit"
+```javascript
+// 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" }
+```
+
+### type: "condition"
+```javascript
+// 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 }
+```
+
+### type: "router"
+```javascript
+// 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 }
+```
+
 ### type: "agent"
 ```javascript
 // instruction: { type: "agent", nodeId, agent, model, inputs }
@@ -115,6 +319,45 @@ TeamDelete()
 // result: team outputs aggregated
 ```
 
+### type: "team"
+```javascript
+// instruction: { type: "team", nodeId, team, coordinator, workers }
+// Dedicated team node with coordinator-worker pattern
+
+TeamCreate({ team_name: instruction.team.name, description: instruction.team.description })
+
+// 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}`
+})
+
+// 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}`
+  })
+}
+
+// Coordinator sends messages to workers via SendMessage
+// (handled internally by the agent - dispatcher just spawns them)
+
+// 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" })
+}
+TeamDelete()
+// result: { coordinatorOutput, workerOutputs }
+```
+
 ### type: "interrupt"
 ```javascript
 // instruction: { type: "interrupt", nodeId, display, routes }
@@ -127,12 +370,86 @@ const answer = AskUserQuestion({
 ### type: "sequence"
 ```javascript
 // instruction: { type: "sequence", nodeId, steps }
+// Execute each step sequentially, capturing outputs
+
+const stepOutputs = {};
+const context = getCurrentContext(); // From checkpoint
+
 for (const step of instruction.steps) {
-  if (step.action === "bash") Bash(step.command)
-  if (step.action === "agent") Task({ subagent_type: step.agent, prompt: step.inputs })
-  if (step.action === "read_files") Read(step.files)
+  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}`
+      });
+
+      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;
+    }
+
+    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;
+    }
+
+    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;
+    }
+
+    default:
+      // Unimplemented step actions: log warning
+      logWarn(`Step action "${step.action}" not implemented in dispatcher, skipping`);
+      stepOutputs[stepLabel] = { skipped: true, reason: `Action not implemented` };
+  }
 }
-// result: { steps: stepOutputs }
+
+// result: stepOutputs with all step execution results
 ```
 
 ## 4. Observabilidad (4 Senales)

package/commands/elsabro/quick.md

@@ -169,17 +169,6 @@ Task({
 })
 ```
 
-## Output
-
-```
-✓ Quick complete
-  Changed: src/components/RegisterForm.tsx
-  Added: src/components/__tests__/RegisterForm.email.test.ts
-  Tests: 1 passed
-
-  Commit? (y/n/edit message)
-```
-
 <code_review_gate>
 ## Code Review Gate (OBLIGATORIO - NO NEGOCIABLE)
 
@@ -203,6 +192,17 @@ Task({
 **VIOLACIÓN CRÍTICA**: Reportar resultado sin code review = ABORTAR OPERACIÓN
 </code_review_gate>
 
+## Output
+
+```
+✓ Quick complete
+  Changed: src/components/RegisterForm.tsx
+  Added: src/components/__tests__/RegisterForm.email.test.ts
+  Tests: 1 passed
+
+  Commit? (y/n/edit message)
+```
+
 <siguiente_paso>
 ## Siguiente Paso
 

package/commands/elsabro/start.md

@@ -72,6 +72,62 @@ Write(".elsabro/state.json", JSON.stringify(state, null, 2));
 Los skills descubiertos se pasan al comando siguiente (plan, execute, etc.) para informar patrones y configuraciones.
 </skill_discovery>
 
+<stitch_mcp_detection>
+## Stitch MCP Auto-Detection (Visual Projects)
+
+**DESPUÉS de skill discovery**, detectar si el proyecto usa frameworks visuales y sugerir Stitch MCP:
+
+```javascript
+// Detectar frameworks visuales en package.json
+let isVisualProject = false;
+let detectedFrameworks = [];
+
+try {
+  const packageJson = Read("package.json");
+  const pkg = JSON.parse(packageJson);
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+
+  // Frameworks visuales a detectar
+  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" }
+  ];
+
+  for (const framework of visualFrameworks) {
+    if (allDeps[framework.name]) {
+      detectedFrameworks.push(framework.display);
+      isVisualProject = true;
+    }
+  }
+} catch (e) {
+  // No package.json or parse error - not a visual project
+}
+
+// Guardar en estado
+if (isVisualProject) {
+  state.context = state.context || {};
+  state.context.is_visual_project = true;
+  state.context.visual_frameworks = detectedFrameworks;
+  state.context.stitch_available = true; // Flag para sugerir Stitch MCP
+
+  Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+  // Informar al usuario
+  output(`🎨 Proyecto visual detectado: ${detectedFrameworks.join(", ")}`);
+  output(`💡 Stitch MCP disponible para diseño de UI`);
+}
+```
+
+**Integración con greeting**: Si `state.context.stitch_available === true`, agregar opción de diseño UI prominentemente en el saludo.
+</stitch_mcp_detection>
+
 <objective>
 Eres el **orquestador principal** de ELSABRO. Tu trabajo es:
 
@@ -110,6 +166,47 @@ Si existe, leerlo:
 Read(".elsabro/state.json")
 ```
 
+### 0.2.1 Verificar permisos de .elsabro/
+
+**OBLIGATORIO**: Antes de continuar, verificar permisos de lectura/escritura:
+
+```bash
+# Si .elsabro/ existe, verificar permisos
+if [ -d .elsabro ]; then
+  # Intentar crear archivo de prueba
+  touch .elsabro/.permission_test 2>/dev/null
+  if [ $? -ne 0 ]; then
+    echo "ERROR: No hay permisos de escritura en .elsabro/"
+    exit 1
+  fi
+  rm -f .elsabro/.permission_test
+
+  # Verificar permisos de lectura si existe state.json
+  if [ -f .elsabro/state.json ]; then
+    cat .elsabro/state.json >/dev/null 2>&1
+    if [ $? -ne 0 ]; then
+      echo "ERROR: No hay permisos de lectura en .elsabro/state.json"
+      exit 1
+    fi
+  fi
+fi
+```
+
+Si hay error de permisos, informar al usuario:
+
+```
+⚠️ No puedo acceder a la carpeta .elsabro/ por falta de permisos.
+
+Opciones:
+1) Corregir permisos: chmod 755 .elsabro
+2) Continuar sin guardar estado (no recomendado)
+3) Salir y revisar el problema
+
+¿Qué prefieres?
+```
+
+Usar `AskUserQuestion` con estas opciones.
+
 ### 0.3 Detectar contexto con agentes paralelos
 
 **OBLIGATORIO**: Lanzar 2 agentes HAIKU en paralelo:
@@ -213,17 +310,33 @@ Veo que estás en una carpeta vacía. ¿Qué te gustaría crear?
 ```
 
 ### Para Brownfield (código existente):
-```
-¡Hola! Veo que ya tienes un proyecto con [tech_stack].
+```javascript
+// Personalizar saludo basado en detección de framework visual
+const greeting = `¡Hola! Veo que ya tienes un proyecto con ${tech_stack.join(", ")}.`;
+const options = [
+  { label: "➕ Agregar una nueva funcionalidad", value: "add_feature" },
+  { label: "🐛 Arreglar algo que no funciona", value: "debug" },
+  { label: "📖 Entender cómo funciona el código", value: "understand" },
+  { label: "🔄 Refactorizar o mejorar algo", value: "refactor" }
+];
 
-¿Qué te gustaría hacer?
+// Si es proyecto visual, promover opción de Stitch MCP
+if (state.context.is_visual_project) {
+  options.splice(1, 0, {
+    label: `🎨 Diseñar UI con Stitch MCP (${state.context.visual_frameworks.join("/")})`,
+    value: "design_ui",
+    description: "Genera screens visuales profesionales desde descripciones"
+  });
+  output(`${greeting}\n\n🎨 Detectado: ${state.context.visual_frameworks.join(", ")} - Stitch MCP disponible para diseño visual\n`);
+} else {
+  options.push({ label: "🎨 Diseñar o rediseñar la interfaz", value: "design_ui" });
+}
 
-1) ➕ Agregar una nueva funcionalidad
-2) 🐛 Arreglar algo que no funciona
-3) 📖 Entender cómo funciona el código
-4) 🔄 Refactorizar o mejorar algo
-5) 🎨 Diseñar o rediseñar la interfaz
-6) ❓ Otra cosa (cuéntame)
+options.push({ label: "❓ Otra cosa (cuéntame)", value: "other" });
+
+// Mostrar opciones
+output("¿Qué te gustaría hacer?\n");
+options.forEach((opt, i) => output(`${i + 1}) ${opt.label}`));
 ```
 
 ### Para Continuation (proyecto ELSABRO existente):
@@ -409,7 +522,22 @@ Al final de cada respuesta, agregar:
 ### Crear .elsabro/ si no existe
 
 ```bash
-mkdir -p .elsabro
+# Crear directorio con verificación de permisos
+mkdir -p .elsabro 2>/dev/null
+
+# Verificar que se creó correctamente
+if [ ! -d .elsabro ]; then
+  echo "ERROR: No se pudo crear .elsabro/ - verifica permisos del directorio actual"
+  exit 1
+fi
+
+# Verificar permisos de escritura
+touch .elsabro/.permission_test 2>/dev/null
+if [ $? -ne 0 ]; then
+  echo "ERROR: .elsabro/ existe pero no tiene permisos de escritura"
+  exit 1
+fi
+rm -f .elsabro/.permission_test
 ```
 
 ### Estructura de .elsabro/
@@ -517,14 +645,28 @@ Y actualizar automáticamente `.planning/mistakes.md` o `.planning/patterns.md`.
 ### Si no hay permisos para crear .elsabro/
 
 ```
-No puedo crear la carpeta de estado. ¿Puedes verificar los permisos?
+⚠️ No puedo crear o acceder a la carpeta .elsabro/ por permisos insuficientes.
+
+Diagnóstico:
+- Directorio actual: [pwd]
+- Permisos del directorio: [ls -ld .]
+- Usuario actual: [whoami]
 
-Mientras tanto, puedo ayudarte sin guardar estado, pero no podré
-recordar el progreso entre sesiones.
+Soluciones:
+1) Corregir permisos: chmod 755 .elsabro (si existe)
+2) Cambiar propietario: sudo chown $(whoami) .elsabro (si es necesario)
+3) Continuar sin guardar estado (no recordaré progreso entre sesiones)
 
-¿Continuar de todas formas?
+¿Qué prefieres hacer?
 ```
 
+Usar `AskUserQuestion` para elegir solución.
+
+Si elige continuar sin estado:
+- Establecer flag `state.no_persistence = true`
+- Advertir en cada transición que no se guardará progreso
+- Sugerir corregir permisos al finalizar
+
 ### Si state.json está corrupto
 
 ```