elsabro 7.3.1 → 7.4.0

package/README.md

@@ -1,17 +1,18 @@
-# ELSABRO v7.1.0
+# ELSABRO v7.4.0
 
-**Tu asistente AI para crear apps increibles** — Orquestacion de agentes con flow engine, checkpointing y ejecucion paralela.
+**Tu asistente AI para crear apps increibles** — Orquestacion de agentes con flow engine, checkpointing, ejecucion paralela y skill auto-discovery.
 
-ELSABRO es un sistema de desarrollo AI-powered para Claude Code que te guia paso a paso en la creacion de aplicaciones. Incluye un flow engine con 44 nodos, 12 agentes especializados, un CLI para control de flujo, y un sistema de checkpoints para recuperacion automatica.
+ELSABRO es un sistema de desarrollo AI-powered para Claude Code que te guia paso a paso en la creacion de aplicaciones. Incluye un flow engine con 47 nodos, 12 agentes especializados, un CLI para control de flujo, un sistema de checkpoints para recuperacion automatica, y un pipeline completo de skill discovery e invocacion.
 
-## Que Hay de Nuevo en v7.1.0
+## Que Hay de Nuevo en v7.4
 
-- **Flow Engine Runtime** — Motor de ejecucion basado en grafos con 9 tipos de nodos, resolución de templates, y checkpointing automatico
-- **CLI de 6 comandos** — validate, dry-run, init, step, complete, status
-- **PartyEngine** — Discusiones multi-agente con seleccion automatica de participantes
-- **CallbackProtocol** — Composicion automatica de Agent Teams (minimo 5 miembros)
-- **279 tests** — Zero dependencias externas, Node 18+
-- **Design-UI Routing** — Integracion con Stitch AI para generar pantallas desde texto
+- **Skill Invocation Protocol** — Los agentes reciben `availableSkills` en sus inputs y siguen prioridad: skills instalados > recomendados > implementacion manual
+- **Skill Auto-Install Flow** — 2 nodos nuevos descubren top 5 skills relevantes, preguntan al usuario, y batch-instalan en paralelo
+- **Review Gate Enforcement** — Hooks reales en Claude Code bloquean git commit/push si hay codigo sin code review
+- **Auto-Sync Validation** — Hook que valida 6 archivos criticos despues de cada implementacion con modo `--fix`
+- **Agent Teams Cleanup** — Verificacion con 30s timeout antes de TeamDelete, telemetria de anomalias
+- **Context7 Integration** — Consulta silenciosa de documentacion antes de tocar codigo con librerias externas
+- **399 tests** — Zero dependencias externas, Node 18+
 
 ## Para Quien es ELSABRO?
 
@@ -110,13 +111,13 @@ ELSABRO incluye un motor de ejecucion de flujos basado en grafos. El engine es u
 ### Arquitectura
 
 ```
-JSON Flow Definition (44 nodos)
+JSON Flow Definition (47 nodos)
         |
         v
   graph.js — Construye Map + valida referencias
         |
         v
-  runner.js — While-loop: nodo → executor → checkpoint → siguiente
+  runner.js — While-loop: nodo -> executor -> checkpoint -> siguiente
         |
         v
   executors.js — 9 tipos de nodos (entry, exit, condition, router,
@@ -127,9 +128,9 @@ JSON Flow Definition (44 nodos)
               (inyectados en runtime, el engine no sabe de Claude Code)
 ```
 
-- **279 tests**, 75 suites, 0 dependencias externas
+- **399 tests**, 92 suites, 0 dependencias externas
 - **Checkpoint despues de cada nodo** — recuperacion automatica desde cualquier punto
-- **Template resolver** — 7 tipos de expresiones `{{...}}` sin `eval()`
+- **Template resolver** — 7 tipos de expresiones sin code execution
 
 Para mas detalles ver [ARCHITECTURE.md](ARCHITECTURE.md).
 
@@ -154,9 +155,52 @@ node flow-engine/src/cli.js status --flow flows/development-flow.json
 ### Flow Definitions
 
 ELSABRO incluye 2 flow definitions:
-- `flows/development-flow.json` — Flujo completo de desarrollo (44 nodos, ~1080 lineas)
+- `flows/development-flow.json` — Flujo completo de desarrollo (47 nodos, ~1200 lineas)
 - `flows/quick-flow.json` — Flujo rapido para tareas simples (8 nodos)
 
+## Hooks System
+
+ELSABRO incluye hooks automaticos que se integran con Claude Code:
+
+| Hook | Evento | Funcion |
+|------|--------|---------|
+| `review-gate.sh` | PostToolUse (Write/Edit) | Bloquea git commit si hay codigo sin code review |
+| `auto-sync-check.sh` | PostCommand | Valida sincronizacion de 6 archivos criticos |
+| `check-review-skills.sh` | Pre-review | Verifica que skills de review estan instalados |
+| `skill-discovery.sh` | PreFlow | Descubre y recomienda skills relevantes |
+
+### Review Gate
+
+Cada vez que se modifica codigo, el review gate se activa automaticamente:
+```
+Write/Edit -> flag set -> code review -> fix issues -> repeat until clean -> flag clear -> commit allowed
+```
+
+### Auto-Sync Validation
+
+Valida que archivos criticos esten sincronizados:
+```bash
+# Verificar sincronizacion
+bash hooks/auto-sync-check.sh
+
+# Auto-corregir desyncs simples
+bash hooks/auto-sync-check.sh --fix
+```
+
+## Skill Discovery
+
+ELSABRO descubre automaticamente skills relevantes antes de cada ejecucion:
+
+1. **Descubrimiento** — Escanea skills instalados (`~/.claude/skills/`), skills ELSABRO (`./skills/`), y el registry externo
+2. **Ranking** — Ordena por relevancia usando keyword matching con pesos
+3. **Presentacion** — Muestra top 5 al usuario con opcion de instalar
+4. **Inyeccion** — Skills disponibles se pasan como `availableSkills` a todos los agentes
+
+Los agentes siguen el **Skill Invocation Protocol** (seccion 3.1 de execute.md):
+- Prioridad: skills instalados > recomendados > implementacion manual
+- Context7 se consulta silenciosamente para documentacion de librerias externas
+- Skills que fallan no bloquean la ejecucion
+
 ## Agentes Especializados
 
 12 agentes con personalidades distintas, basados en BMAD-METHOD:
@@ -176,6 +220,8 @@ ELSABRO incluye 2 flow definitions:
 | `elsabro-quick-dev` | Barry | Desarrollo rapido con minima ceremonia |
 | `elsabro-yolo-dev` | Flash | Desarrollo ultra-rapido, maximo riesgo |
 
+Cada agente tiene una seccion `<skills_usage>` personalizada que define que tipos de skills debe buscar y como usarlos segun su rol.
+
 ## PartyEngine
 
 Sistema de discusion multi-agente. Selecciona 2-3 agentes relevantes para un tema y ejecuta rondas de debate con sintesis automatica.
@@ -193,6 +239,9 @@ El engine usa un mapa de relevancia (18 categorias de keywords) para elegir los
 | `default` | Balance entre velocidad y seguridad |
 | `yolo` | Maximo velocidad, minima ceremonia |
 | `careful` | Maximo seguridad, verificacion exhaustiva |
+| `teams` | Agent Teams con coordinacion peer-to-peer |
+| `persistent-teams` | Persistent mode + Agent Teams + blocking review |
+| `bmad` | Spec-Driven Development con PRD y Solution Design |
 
 Cambiar perfil:
 ```
@@ -202,10 +251,10 @@ Cambiar perfil:
 ## Como Funciona
 
 ```
-1. Describes tu idea          →  ELSABRO analiza y pregunta
-2. Planifica las fases        →  Crea planes atomicos con TDD
-3. Ejecuta con agentes        →  Parallel execution + checkpointing
-4. Verifica automaticamente   →  3 reviewers + quality gates
+1. Describes tu idea          ->  ELSABRO analiza y pregunta
+2. Planifica las fases        ->  Crea planes atomicos con TDD
+3. Ejecuta con agentes        ->  Parallel execution + checkpointing
+4. Verifica automaticamente   ->  3 reviewers + quality gates
 ```
 
 Persistent mode mantiene ELSABRO activo entre mensajes — escribe naturalmente y ELSABRO rutea al comando correcto.
@@ -226,12 +275,18 @@ Persistent mode mantiene ELSABRO activo entre mensajes — escribe naturalmente
 flow-engine/
   src/                    — 9 modulos del engine (index, graph, template,
                             executors, runner, checkpoint, callbacks, cli, party)
-  tests/                  — 9 archivos de tests (279 tests, 75 suites)
+  tests/                  — 10 archivos de tests (399 tests, 92 suites)
   src/agent-cards.json    — 9 personalidades de agentes
 
 flows/
-  development-flow.json   — Flujo completo (44 nodos)
+  development-flow.json   — Flujo completo (47 nodos)
   quick-flow.json         — Flujo rapido (8 nodos)
+
+hooks/
+  review-gate.sh          — Review gate (set/check/clear/status)
+  auto-sync-check.sh      — Validacion de sincronizacion
+  check-review-skills.sh  — Verificacion de skills de review
+  skill-discovery.sh      — Discovery de skills pre-flow
 ```
 
 ## Actualizacion
@@ -283,6 +338,10 @@ rm -rf .elsabro .planning
 
 | Version | Milestone | Cambio Principal |
 |---------|-----------|-----------------|
+| 7.4.0 | M7+ | Skill invocation protocol, review gate enforcement, auto-sync hook, 47 nodos, 399 tests |
+| 7.3.2 | M7 | Validation errors/warnings separation, case-insensitive hasCriticalIssues |
+| 7.3.1 | M7 | PR #1: 23 critical fixes, skill auto-install hooks, deprecated teams bypass |
+| 7.3.0 | M7 | Execute.md reescrito (-89%), observabilidad JSONL, limpieza codigo fantasma |
 | 7.1.0 | M5 + M6 | AT compliance, design-ui routing, 279 failure mode tests |
 | 7.0.0 | M4 | Feature completeness — 42/42 nodos, CLI, 257 tests |
 | 6.0.0 | M3 | Flow engine runtime — 6 source files, 109 tests |

package/agents/elsabro-executor.md

@@ -94,6 +94,38 @@ CHECKPOINT (preguntar):
 - payments/stripe → skills/payments-setup.md
 </skill_awareness>
 
+<skills_usage>
+## Uso de Skills en Implementacion
+
+### Deteccion Automatica de Skills
+Cuando `availableSkills` esta presente en los inputs del contexto:
+1. **Escanear tech stack** — Identificar frameworks, lenguajes y librerias del plan
+2. **Matchear con skills disponibles** — Buscar skills que cubran el stack detectado
+3. **Priorizar skill especializado > implementacion manual** — Si existe un skill verificado, usarlo
+
+### Skills Prioritarios para Executor
+| Tech Stack | Skill Recomendado | Uso |
+|------------|-------------------|-----|
+| React Native | react-native-best-practices | Patrones de componentes, navegacion, performance |
+| Supabase/Postgres | supabase-postgres-best-practices | Queries, RLS, migrations, edge functions |
+| TypeScript | typescript-pro | Tipos avanzados, generics, utility types |
+| JavaScript | javascript-pro | Patrones modernos, async patterns |
+| APIs REST | api-designer | Endpoints, validacion, error handling |
+
+### Context7 Obligatorio
+**ANTES de tocar codigo de librerias externas**, consultar Context7 silenciosamente:
+- Buscar documentacion actualizada del paquete
+- Verificar API signatures y breaking changes
+- No mostrar la consulta al usuario, solo aplicar el conocimiento
+
+### Reportar Skills Usados
+En cada output de tarea completada, incluir:
+```
+Skills aplicados: [nombre-skill-1], [nombre-skill-2]
+Patrones usados: [patron-del-skill aplicado]
+```
+</skills_usage>
+
 <execution_flow>
 ## Flujo de Ejecución
 

package/agents/elsabro-orchestrator.md

@@ -38,6 +38,45 @@ Soy **Quantum**, el orquestador de ejecución paralela. Como un director de orqu
 5. **Reportar en tiempo real** - El usuario sabe qué está pasando
 </principles>
 
+<skills_usage>
+## Uso de Skills en Orquestacion
+
+### Deteccion y Distribucion de Skills
+Cuando `availableSkills` esta presente en los inputs del contexto:
+1. **Inventariar skills disponibles** — Listar todos los skills relevantes para la tarea
+2. **Matchear skills con teammates** — Asignar skills especializados a cada agente
+3. **Distribuir en el prompt de spawn** — Incluir skills relevantes al lanzar cada teammate
+
+### Skills Prioritarios para Orchestrator
+| Area | Skill Recomendado | Uso |
+|------|-------------------|-----|
+| Debugging paralelo | parallel-debugging | Coordinar multiples debuggers simultaneos |
+| Task management | task-coordination-strategies | Dependencias, prioridades, conflict resolution |
+| Team comms | team-communication-protocols | Patrones de comunicacion entre teammates |
+| Architecture | architecture-designer | Decisiones de splitting y paralelizacion |
+
+### Distribucion de Skills a Teammates
+Al crear un team o lanzar agentes, recomendar skills por rol:
+- **executor teammates** → react-native-best-practices, supabase-postgres, typescript-pro
+- **qa teammates** → playwright-expert, test-master, debugging-wizard
+- **reviewer teammates** → code-reviewer, security-reviewer, secure-code-guardian
+- **analyst teammates** → architecture-designer, database-optimizer
+
+### Tracking de Skills por Teammate
+Durante la ejecucion paralela, registrar:
+- Que skills uso cada teammate y en que tareas
+- Si algun skill causo problemas o errores
+- Efectividad del skill vs implementacion manual
+
+### Post-Mortem de Skills
+Al generar el reporte final de ejecucion paralela, incluir:
+```
+Skills distribuidos: [total]
+Skills efectivos: [lista con resultado positivo]
+Skills problematicos: [lista con issues encontrados]
+```
+</skills_usage>
+
 <workflows>
 ## Workflows Disponibles
 

package/agents/elsabro-qa.md

@@ -34,6 +34,43 @@ Soy **Murat**, Master Test Architect. Me especializo en API testing, backend ser
 7. **API tests are first-class citizens** - No solo UI
 </principles>
 
+<skills_usage>
+## Uso de Skills en Testing y QA
+
+### Deteccion Automatica de Skills
+Cuando `availableSkills` esta presente en los inputs del contexto:
+1. **Identificar framework de testing** — Jest, Vitest, Pytest, Playwright, etc.
+2. **Buscar skills de testing** — Matchear con skills disponibles para ese framework
+3. **Priorizar patrones del skill > patrones genericos** — Skills contienen best practices verificadas
+
+### Skills Prioritarios para QA
+| Area | Skill Recomendado | Uso |
+|------|-------------------|-----|
+| E2E Browser | playwright-expert | Selectores, page objects, fixtures, paralelismo |
+| Test Design | test-master | Estrategias de coverage, test doubles, TDD patterns |
+| Debugging Tests | debugging-wizard | Diagnostico de flaky tests, race conditions |
+| Security Testing | secure-code-guardian | OWASP testing, injection tests, auth bypass checks |
+
+### Consultar Skills para Patrones Especificos
+Antes de escribir tests para un framework o libreria:
+- Verificar si el skill tiene patrones de test recomendados
+- Usar fixtures y helpers sugeridos por el skill
+- Aplicar la estructura de archivos de test del skill
+
+### Integracion con CI/CD Skills
+Cuando se configura pipeline de CI:
+- Consultar devops-engineer para configuracion de stages
+- Aplicar quality gates recomendados por el skill
+- Configurar test reporters y coverage thresholds segun best practices
+
+### Reportar Skills Consultados
+En cada test plan o suite generada, documentar:
+```
+Skills consultados: [skill-1], [skill-2]
+Patrones de testing aplicados: [patron-especifico]
+```
+</skills_usage>
+
 <workflows>
 ## Workflows Disponibles
 

package/agents/elsabro-verifier.md

@@ -29,6 +29,43 @@ El executor puede decir "completado", pero debes verificar:
 4. ¿Hace lo que se pidió?
 </critical_rule>
 
+<skills_usage>
+## Uso de Skills en Verificacion y Review
+
+### Deteccion Automatica de Skills
+Cuando `availableSkills` esta presente en los inputs del contexto:
+1. **Identificar areas de review** — Calidad, seguridad, performance, tipos
+2. **Matchear con skills de review** — Buscar skills especializados para cada area
+3. **Priorizar skill de review especializado > checklist manual** — Skills profundizan mas
+
+### Skills Prioritarios para Verifier
+| Area de Review | Skill Recomendado | Uso |
+|----------------|-------------------|-----|
+| Code Quality | code-reviewer | Naming, DRY, SOLID, complejidad ciclomatica |
+| Security | security-reviewer | OWASP top 10, secrets exposure, auth flaws |
+| Security Deep | secure-code-guardian | Injection, XSS, CSRF, dependency vulnerabilities |
+| Architecture | architecture-designer | Patrones, separation of concerns, coupling |
+
+### Cross-Reference con Security Skills
+Para verificacion de seguridad OWASP:
+- Usar secure-code-guardian para analisis de vulnerabilidades
+- Verificar contra checklist OWASP del skill
+- Reportar findings con severidad clasificada por el skill
+
+### Verificacion Profunda con Skills
+En Etapa 2 (Code Quality), si hay skills disponibles:
+- Ejecutar analisis del skill ADEMAS del checklist standard
+- El skill puede detectar anti-patterns especificos del framework
+- Combinar findings del skill con findings manuales en reporte unificado
+
+### Reportar Skills Aplicados
+En cada VERIFICATION.md generado, incluir:
+```
+Skills de review usados: [skill-1], [skill-2]
+Findings adicionales por skills: [cantidad]
+```
+</skills_usage>
+
 <two_stage_review>
 ## Revisión de 2 Etapas
 

package/commands/elsabro/execute.md

@@ -311,10 +311,39 @@ for (const member of instruction.team.members) {
   })
 }
 
-// Al completar todos:
+// Al completar todos - shutdown con verificacion:
 for (const member of instruction.team.members) {
-  SendMessage({ type: "shutdown_request", recipient: member.name, content: "Done" })
+  SendMessage({ type: "shutdown_request", recipient: member.name, content: "Task complete" })
 }
+
+// Verificar que todos los teammates terminaron (max 30s timeout)
+// Nota: sleep() es pseudocodigo. Implementar como: const sleep = ms => new Promise(r => setTimeout(r, ms));
+const TEAM_SHUTDOWN_TIMEOUT = 30000;
+const POLL_INTERVAL = 3000;
+let elapsed = 0;
+let allShutdown = false;
+
+while (!allShutdown && elapsed < TEAM_SHUTDOWN_TIMEOUT) {
+  await sleep(POLL_INTERVAL); // ver nota arriba
+  elapsed += POLL_INTERVAL;
+  // Check if all members responded to shutdown
+  const teamStatus = TaskList(); // Check remaining active tasks
+  allShutdown = instruction.team.members.every(m =>
+    !teamStatus.some(t => t.owner === m.name && t.status === 'in_progress')
+  );
+}
+
+if (!allShutdown) {
+  // Emit telemetry for team lifecycle anomaly
+  emit_telemetry({
+    signal: "team_lifecycle_anomaly",
+    teamName: instruction.team.name,
+    timeout: TEAM_SHUTDOWN_TIMEOUT,
+    activeMembers: instruction.team.members.filter(m => /* still active */).map(m => m.name)
+  });
+  log_warn(`Team ${instruction.team.name}: ${elapsed}ms timeout - forcing cleanup`);
+}
+
 TeamDelete()
 // result: team outputs aggregated
 ```
@@ -452,6 +481,41 @@ for (const step of instruction.steps) {
 // result: stepOutputs with all step execution results
 ```
 
+## 3.1. Skill Invocation Protocol
+
+Cuando un agente recibe `availableSkills` en sus inputs, DEBE seguir este protocolo:
+
+### Prioridad de Uso
+1. **Skills instalados relevantes** — Usar primero los que ya estan instalados y matchean la tarea
+2. **Skills recomendados** — Si `recommendedSkills` incluye skills no instalados pero criticos, sugerir instalacion
+3. **Implementacion manual** — Solo si no hay skill apropiado disponible
+
+### Reglas
+- **Top 5**: Solo considerar los 5 skills mas relevantes para la tarea actual
+- **Silencioso**: No mostrar al usuario la consulta de skills - solo usarlos
+- **Fallback**: Si un skill falla o no aplica, continuar con implementacion manual sin bloquear
+- **Context7**: SIEMPRE consultar Context7 silenciosamente antes de tocar codigo que use librerias externas
+- **Reportar**: Al final, incluir lista de skills usados en el output del agente
+
+### Context7 Integration
+Antes de implementar codigo que use APIs externas:
+1. Resolver library ID: `mcp__context7__resolve-library-id` con el nombre de la libreria
+2. Consultar docs: `mcp__context7__query-docs` con la query relevante
+3. Aplicar patterns encontrados — si difieren de lo que se conoce, ALERTAR
+4. Todo esto es silencioso — el usuario no ve estas consultas
+
+### Telemetria
+Emitir signal despues de cada agente que use skills:
+```json
+{
+  "signal": "skill_usage",
+  "nodeId": "{{instruction.nodeId}}",
+  "skills_available": ["..."],
+  "skills_used": ["..."],
+  "skills_failed": ["..."]
+}
+```
+
 ## 4. Observabilidad (4 Senales)
 
 Despues de cada `step` y `complete`, emitir al log:

package/flow-engine/src/graph.js

@@ -66,11 +66,16 @@ function buildGraph(flowDefinition) {
  * Validate that all node references (next, routes, true, false, onMaxIterations,
  * onError) point to existing nodes, and detect orphaned nodes.
  *
+ * Returns errors (dangling references — fatal) and warnings (orphaned nodes —
+ * informational). Deprecated and standalone nodes are reported as warnings,
+ * not errors, since they are intentionally disconnected.
+ *
  * @param {{ nodes: Map<string, object>, entryNode: string }} graph
- * @returns {{ valid: boolean, errors: string[] }}
+ * @returns {{ valid: boolean, errors: string[], warnings: string[] }}
  */
 function validateGraph(graph) {
   const errors = [];
+  const warnings = [];
   const nodeIds = new Set(graph.nodes.keys());
 
   // 1. Check for dangling references (invalid routes)
@@ -103,14 +108,21 @@ function validateGraph(graph) {
     }
   }
 
-  // Find orphaned nodes
+  // Classify orphaned nodes: deprecated/standalone → warning, others → warning too
+  // (orphaned nodes are informational, not fatal — dangling refs are fatal)
   for (const nodeId of nodeIds) {
     if (!reachable.has(nodeId)) {
-      errors.push(`Orphaned node "${nodeId}" is unreachable from entry point`);
+      const node = graph.nodes.get(nodeId);
+      const status = node?.runtime_status || '';
+      if (status === 'deprecated') {
+        warnings.push(`Deprecated node "${nodeId}" is unreachable from entry point`);
+      } else {
+        warnings.push(`Orphaned node "${nodeId}" is unreachable from entry point`);
+      }
     }
   }
 
-  return { valid: errors.length === 0, errors };
+  return { valid: errors.length === 0, errors, warnings };
 }
 
 /**

package/flow-engine/src/index.js

@@ -50,9 +50,19 @@ class FlowEngine {
       );
     }
 
+    this._validationWarnings = validation.warnings || [];
     return this;
   }
 
+  /**
+   * Get validation warnings from the last loadFlow() call.
+   * Warnings are informational (e.g. orphaned nodes) and do not prevent flow execution.
+   * @returns {string[]}
+   */
+  getValidationWarnings() {
+    return this._validationWarnings || [];
+  }
+
   /**
    * Get a node by ID.
    * @param {string} id

package/flow-engine/src/template.js

@@ -73,17 +73,18 @@ registerFunction('collectErrors', (context) => {
 registerFunction('hasCriticalIssues', (context, obj) => {
   if (!obj) return false;
   const json = typeof obj === 'string' ? obj : JSON.stringify(obj);
+  const jsonLower = json.toLowerCase();
 
-  // Enhanced pattern detection for critical issues
+  // Case-insensitive pattern detection for critical issues
   const criticalPatterns = [
     '"critical"',
     '"blocking"',
-    '"P0"',
-    '"MUST_FIX"',
-    '"URGENT"'
+    '"p0"',
+    '"must_fix"',
+    '"urgent"'
   ];
 
-  return criticalPatterns.some(pattern => json.includes(pattern));
+  return criticalPatterns.some(pattern => jsonLower.includes(pattern));
 });
 
 registerFunction('generateSummary', (context) => {

package/flow-engine/tests/cli.test.js

@@ -48,10 +48,11 @@ describe('CLI: helpers', () => {
 // ---------- validate ----------
 
 describe('CLI: validate', () => {
-  it('reports valid flow with 44 nodes', async () => {
+  it('reports valid flow with correct node count', async () => {
     const result = await main(['node', 'cli.js', 'validate', '--flow', FLOW_PATH]);
+    const flow = require('../../flows/development-flow.json');
     assert.equal(result.valid, true);
-    assert.equal(result.nodeCount, 44);
+    assert.equal(result.nodeCount, flow.nodes.length);
     assert.ok(result.parallelNodes.length >= 4);
   });
 

package/flow-engine/tests/execute-dispatcher.test.js

@@ -385,7 +385,8 @@ describe('Execute Dispatcher: Error Handling', () => {
 
   it('condition node throws when branch is missing', async () => {
     const executor = getExecutor('condition');
-    const ctx = makeContext({ inputs: { val: true } });
+    // Condition evaluates to false, but no "false" branch is defined
+    const ctx = makeContext({ inputs: { val: false } });
     await assert.rejects(
       executor(
         { id: 'cond', type: 'condition', condition: '{{inputs.val}}', true: 'next' },

package/flow-engine/tests/graph.test.js

@@ -160,8 +160,8 @@ describe('flow validation enhancements', () => {
       ]
     });
     const result = validateGraph(graph);
-    assert.equal(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('orphan') && e.includes('unreachable')));
+    assert.equal(result.valid, true); // orphans are warnings, not errors
+    assert.ok(result.warnings.some(e => e.includes('orphan') && e.includes('unreachable')));
   });
 
   it('detects orphaned nodes in complex branching', () => {
@@ -175,9 +175,9 @@ describe('flow validation enhancements', () => {
       ]
     });
     const result = validateGraph(graph);
-    assert.equal(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('isolated_branch') && e.includes('unreachable')));
-    assert.ok(result.errors.some(e => e.includes('isolated_end') && e.includes('unreachable')));
+    assert.equal(result.valid, true); // orphans are warnings, not errors
+    assert.ok(result.warnings.some(e => e.includes('isolated_branch') && e.includes('unreachable')));
+    assert.ok(result.warnings.some(e => e.includes('isolated_end') && e.includes('unreachable')));
   });
 
   it('validates onMaxIterations handler references', () => {
@@ -229,11 +229,11 @@ describe('flow validation enhancements', () => {
       ]
     });
     const result = validateGraph(graph);
-    assert.equal(result.valid, false);
+    assert.equal(result.valid, false); // dangling ref is a real error
     // Should have dangling reference error (missing_next)
     assert.ok(result.errors.some(e => e.includes('missing_next')));
-    // Should have orphaned node errors
-    assert.ok(result.errors.some(e => e.includes('orphan')));
+    // Orphaned nodes are warnings, not errors
+    assert.ok(result.warnings.some(e => e.includes('orphan')));
   });
 
   it('passes validation for graph with all error handlers', () => {
@@ -276,9 +276,9 @@ describe('flow validation enhancements', () => {
       ]
     });
     const result = validateGraph(graph);
-    assert.equal(result.valid, false);
-    assert.ok(result.errors.some(e => e.includes('circular_a') && e.includes('unreachable')));
-    assert.ok(result.errors.some(e => e.includes('circular_b') && e.includes('unreachable')));
+    assert.equal(result.valid, true); // orphans are warnings, not errors
+    assert.ok(result.warnings.some(e => e.includes('circular_a') && e.includes('unreachable')));
+    assert.ok(result.warnings.some(e => e.includes('circular_b') && e.includes('unreachable')));
   });
 
   it('validates condition node with both branches pointing to same target', () => {
@@ -316,12 +316,15 @@ describe('flow validation enhancements', () => {
       ]
     });
     const result = validateGraph(graph);
-    assert.equal(result.valid, false);
-    // Check error message format includes node IDs and issue type
+    assert.equal(result.valid, false); // dangling refs are real errors
+    // Check error message format for dangling references
+    assert.ok(result.errors.length > 0);
     result.errors.forEach(err => {
       assert.ok(typeof err === 'string');
       assert.ok(err.length > 0);
     });
+    // Orphaned node reported as warning
+    assert.ok(result.warnings.some(w => w.includes('orphan')));
   });
 });
 
@@ -329,7 +332,7 @@ describe('real flow loading', () => {
   it('loads the full development-flow.json', () => {
     const flow = require('../../flows/development-flow.json');
     const graph = buildGraph(flow);
-    assert.equal(graph.nodes.size, 44);
+    assert.equal(graph.nodes.size, flow.nodes.length);
     assert.equal(graph.entryNode, 'start');
     assert.equal(graph.meta.version, '5.3.0');
   });
@@ -338,17 +341,15 @@ describe('real flow loading', () => {
     const flow = require('../../flows/development-flow.json');
     const graph = buildGraph(flow);
     const result = validateGraph(graph);
-    // Development flow has known orphaned nodes (P0.3 - teams mode deprecated nodes)
-    // Expected orphaned nodes: teams_spawn, interrupt_teams_failed, design_ui, interrupt_design_complete
-    if (!result.valid) {
-      const orphanedNodes = result.errors.filter(e => e.includes('unreachable'));
-      assert.ok(orphanedNodes.length > 0, 'Should detect orphaned nodes');
-      // Verify these are the known teams mode orphaned nodes
-      const hasTeamsNodes = orphanedNodes.some(e =>
-        e.includes('teams_spawn') || e.includes('interrupt_teams') ||
-        e.includes('design_ui') || e.includes('interrupt_design')
-      );
-      assert.ok(hasTeamsNodes, 'Orphaned nodes should include known teams mode nodes');
-    }
+    // Flow should be valid (no dangling references)
+    assert.equal(result.valid, true, 'Flow should have no dangling reference errors');
+    assert.equal(result.errors.length, 0);
+    // Known orphaned nodes reported as warnings (deprecated + standalone subflows)
+    assert.ok(result.warnings.length > 0, 'Should have warnings for orphaned nodes');
+    const hasKnownOrphans = result.warnings.some(w =>
+      w.includes('teams_spawn') || w.includes('interrupt_teams') ||
+      w.includes('design_ui') || w.includes('interrupt_design')
+    );
+    assert.ok(hasKnownOrphans, 'Warnings should include known orphaned nodes');
   });
 });