elsabro 7.3.2 → 7.5.0

package/commands/elsabro/execute.md

@@ -34,6 +34,78 @@ vive en el engine y en `flows/development-flow.json`. Este archivo solo define e
 Leer `.elsabro/state.json` siguiendo el protocolo de @references/state-sync.md.
 Verificar flujo en progreso. Actualizar phase a "stepping".
 
+### Skill Discovery Gate (OBLIGATORIO)
+
+Antes de cualquier otra accion, verificar que skill discovery fue ejecutado:
+
+```javascript
+// GATE: Verificar skill discovery antes de ejecutar
+const skillGateResult = Bash('bash hooks/skill-gate.sh status');
+const skillGate = JSON.parse(skillGateResult);
+
+if (skillGate.elsabro_active && !skillGate.done) {
+  // Skill discovery no ejecutado — ejecutar ahora
+  output("Ejecutando skill discovery antes de continuar...");
+  state.context = state.context || {};
+  try {
+    const discoveryResult = Bash(`bash ./hooks/skill-discovery.sh "${inputs.task || args}" "medium"`, { timeout: 30000 });
+    try {
+      state.context.available_skills = JSON.parse(discoveryResult).recommended || [];
+    } catch (e) {
+      output("Warning: skill-discovery devolvio JSON invalido, continuando sin skills");
+      state.context.available_skills = [];
+    }
+  } catch (e) {
+    output("Warning: skill-discovery fallo, continuando sin skills");
+    state.context.available_skills = [];
+  }
+  Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+  Bash('bash hooks/skill-gate.sh set "execute"');
+}
+```
+
+### Plan Verification (OBLIGATORIO)
+
+Antes de ejecutar CUALQUIER codigo, verificar que existe un plan aprobado:
+
+```javascript
+// GATE: No ejecutar sin plan previo
+state.context = state.context || {};
+const planFile = state.context.plan_file;
+const hasPlan = planFile && fs.existsSync(planFile);
+const hasPlanInPlanning = fs.readdirSync('.planning/').some(f => f.endsWith('-PLAN.md'));
+
+if (!hasPlan && !hasPlanInPlanning) {
+  // No hay plan — forzar planificacion primero
+  output("⚠ No se encontro plan de implementacion.");
+  output("→ Ejecuta /elsabro:plan primero, o usa EnterPlanMode para crear un plan.");
+  output("→ ELSABRO requiere un plan aprobado antes de ejecutar codigo.");
+
+  // Ofrecer opciones al usuario
+  const answer = AskUserQuestion({
+    questions: [{
+      question: "No hay plan de implementacion. ¿Que deseas hacer?",
+      header: "Plan Check",
+      options: [
+        { label: "Crear plan ahora (Recomendado)", description: "Entra a plan mode para disenar la implementacion" },
+        { label: "Continuar sin plan", description: "Solo para tareas triviales - se registra como excepcion" }
+      ],
+      multiSelect: false
+    }]
+  });
+
+  if (answer.includes("Crear plan")) {
+    EnterPlanMode();
+    return; // Exit execute — se reanuda despues de aprobar plan
+  }
+
+  // Usuario eligio continuar sin plan — registrar excepcion
+  state.context.plan_skipped = true;
+  state.context.plan_skip_reason = "user_override";
+  Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+}
+```
+
 ```bash
 FLOW="flows/development-flow.json"
 TASK="[descripcion de la tarea del usuario]"
@@ -311,10 +383,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 +553,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:
@@ -484,15 +620,166 @@ Cuando el loop retorna `{ finished: true }`:
    - Establecer `suggested_next: "verify-work"`
 2. Actualizar `.elsabro/context.md` con resumen legible
 
+<code_review_gate>
+## 5.1. Code Review Gate (OBLIGATORIO - NO NEGOCIABLE)
+
+**ANTES de mostrar resultado o ofrecer commit, VERIFICAR:**
+
+```
+¿Se escribió/modificó código durante la ejecución?
+│
+├─ SÍ → ¿Se ejecutó code review (parallel_review node)?
+│    │
+│    ├─ NO → EJECUTAR AHORA con Agent Teams FULL (5 agentes):
+│    │   1. bash hooks/review-gate.sh set (si no esta activo)
+│    │   2. TeamCreate("elsabro-review") + 5 teammates especializados
+│    │   3. Consolidar hallazgos de los 5 reviewers
+│    │   4. Si issues criticos > 0: fix y re-review (max 3 iteraciones)
+│    │   5. Solo cuando issues criticos == 0: bash hooks/review-gate.sh clear
+│    │   6. SendMessage(shutdown_request) x5 + TeamDelete()
+│    │   7. Continuar
+│    │
+│    └─ SÍ, issues == 0, gate cleared → Continuar
+│
+└─ NO → Continuar (no aplica)
+```
+
+```javascript
+// Verificacion programatica del review gate
+const gateStatus = Bash("bash hooks/review-gate.sh status");
+const gate = JSON.parse(gateStatus);
+
+state.current_flow = state.current_flow || {};
+
+if (gate.pending) {
+  // Hay codigo modificado sin review — EJECUTAR REVIEW con Agent Teams FULL
+  state.current_flow.code_written = true;
+  output("⚠ Review gate activo: " + gate.count + " archivo(s) sin revisar");
+  output("→ Lanzando Agent Teams FULL review (5 agentes especializados)...");
+
+  // 1. Crear team de review
+  TeamCreate({ team_name: "elsabro-review", description: "Code review team - 5 agentes especializados" })
+
+  // 2. Lanzar 5 teammates en paralelo (UN SOLO MENSAJE con multiples Task calls)
+  Task({
+    subagent_type: "pr-review-toolkit:code-reviewer",
+    team_name: "elsabro-review",
+    name: "quality-reviewer",
+    model: "sonnet",
+    prompt: "Review code quality: naming conventions, design patterns, DRY, SOLID principles. Focus on recently modified files. DO NOT ask questions. Report only high-confidence issues."
+  })
+  Task({
+    subagent_type: "feature-dev:code-reviewer",
+    team_name: "elsabro-review",
+    name: "security-reviewer",
+    model: "sonnet",
+    prompt: "Review security: OWASP top 10, injection vulnerabilities, XSS, secrets exposure, token handling, input validation. Focus on recently modified files. DO NOT ask questions. Report only high-confidence issues."
+  })
+  Task({
+    subagent_type: "pr-review-toolkit:pr-test-analyzer",
+    team_name: "elsabro-review",
+    name: "test-analyzer",
+    model: "sonnet",
+    prompt: "Analyze test coverage: missing tests, edge cases, happy/error paths, test quality. Focus on recently modified files. DO NOT ask questions. Report only critical gaps."
+  })
+  Task({
+    subagent_type: "pr-review-toolkit:silent-failure-hunter",
+    team_name: "elsabro-review",
+    name: "performance-reviewer",
+    model: "sonnet",
+    prompt: "Review for silent failures, N+1 queries, memory leaks, inadequate error handling, dangerous fallback behavior. Focus on recently modified files. DO NOT ask questions. Report only high-confidence issues."
+  })
+  Task({
+    subagent_type: "pr-review-toolkit:type-design-analyzer",
+    team_name: "elsabro-review",
+    name: "type-analyzer",
+    model: "sonnet",
+    prompt: "Analyze type design: encapsulation, invariant expression, null safety, interface correctness. Focus on recently modified files. DO NOT ask questions. Report only high-confidence issues."
+  })
+
+  // 3. Consolidar resultados — esperar que todos terminen
+  // Agregar hallazgos de cada reviewer al reporte consolidado
+  // Si ANY reviewer reporta issues criticos: fix y re-review (max 3 iteraciones)
+
+  // 4. Shutdown team
+  for (const name of ["quality-reviewer", "security-reviewer", "test-analyzer", "performance-reviewer", "type-analyzer"]) {
+    SendMessage({ type: "shutdown_request", recipient: name, content: "Review complete" })
+  }
+  TeamDelete()
+
+  // 5. Si review pasa sin issues criticos, limpiar gate y setear flag
+  Bash("bash hooks/review-gate.sh clear");
+  state.current_flow.code_review_passed = true;
+  Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+}
+```
+
+**Donde se setean los flags:**
+- `state.current_flow.code_written = true` — se setea aqui (5.1) cuando review-gate.sh detecta archivos pendientes, y tambien por el PostToolUse hook al hacer Write/Edit
+- `state.current_flow.code_review_passed = true` — se setea aqui (5.1) despues de que los 5 reviewers pasan sin issues criticos y el gate se limpia
+
+**Agent Teams FULL — 5 Reviewers:**
+| Teammate | Plugin | Foco |
+|----------|--------|------|
+| quality-reviewer | pr-review-toolkit:code-reviewer | naming, patterns, DRY, SOLID |
+| security-reviewer | feature-dev:code-reviewer | OWASP, injection, secrets |
+| test-analyzer | pr-review-toolkit:pr-test-analyzer | coverage, edge cases |
+| performance-reviewer | pr-review-toolkit:silent-failure-hunter | silent failures, N+1, memory |
+| type-analyzer | pr-review-toolkit:type-design-analyzer | types, encapsulation, null safety |
+
+**VIOLACIÓN CRÍTICA**: Reportar resultado o ofrecer commit sin code review = ABORTAR OPERACIÓN
+</code_review_gate>
+
+<siguiente_paso>
 ## 6. Siguiente Paso
 
-**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)
+Al completar la ejecucion, verificar gates programaticamente antes de sugerir siguiente paso:
+
+```javascript
+// GATE CHECK: Enforcement estricto antes de cerrar
+state.current_flow = state.current_flow || {};
+
+// Cross-check: review-gate.sh es la fuente de verdad para codigo pendiente
+const gateStatus = Bash("bash hooks/review-gate.sh status");
+const gate = JSON.parse(gateStatus);
+
+// Si review-gate tiene archivos pendientes, code_written DEBE estar seteado
+if (gate.pending && !state.current_flow.code_written) {
+  state.current_flow.code_written = true; // Auto-fix inconsistencia
+}
+
+// Flags verificados
+const codeWritten = state.current_flow.code_written === true;
+const codeReviewPassed = state.current_flow.code_review_passed === true;
+
+// Rule 7: Si se escribio codigo, code review DEBE haber pasado
+if (codeWritten && !codeReviewPassed) {
+  // VIOLACIÓN CRÍTICA — NO proceder. Volver a code_review_gate.
+  output("⛔ CRITICAL: Code written without review. Execute section 5.1 first.");
+  output("→ Volver a Code Review Gate (seccion 5.1) antes de continuar.");
+  return; // Bloquea — no se puede llegar a suggested_next sin review
+}
+
+// Rule 7b: Double-check con review-gate.sh (fuente de verdad del sistema)
+if (gate.pending) {
+  output("⛔ REVIEW GATE PENDING: " + gate.count + " file(s) sin revisar.");
+  output("→ Ejecutar code review y bash hooks/review-gate.sh clear primero.");
+  return; // Bloquea — gate aun activo
+}
+
+// Rule 8: Si se usaron 2+ agentes, Agent Teams debe haberse usado
+// (callbacks.js lo garantiza, pero verificamos por seguridad)
+
+// Todo limpio — establecer siguiente paso
+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
+→ /elsabro:verify-work — verificar el trabajo completado
+→ /elsabro:progress — ver el progreso general del proyecto
 ```
+</siguiente_paso>

package/commands/elsabro/quick.md

@@ -1,6 +1,18 @@
 ---
 name: quick
 description: Modo de ejecución rápida para tareas simples - mínima ceremonia, máxima velocidad
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - TeamCreate
+  - TeamDelete
+  - SendMessage
+  - AskUserQuestion
 sync:
   reads: [".elsabro/state.json"]
   writes: [".elsabro/state.json", ".elsabro/context.md"]
@@ -126,9 +138,11 @@ ELSABRO: [Ejecuta en <30 segundos]
 4. Verify (10 seg)
    └─ Correr tests afectados
 
-5. Code Review (OBLIGATORIO)
-   └─ Task(pr-review-toolkit:code-reviewer) sobre archivos modificados
-   └─ Si hay issues: fix antes de reportar
+5. Code Review (OBLIGATORIO - Agent Teams LITE)
+   └─ TeamCreate("elsabro-review-lite") + 3 teammates especializados
+   └─ quality-reviewer + failure-hunter + test-analyzer (en paralelo)
+   └─ Consolidar hallazgos. Si issues criticos: fix y re-review
+   └─ SendMessage(shutdown_request) x3 + TeamDelete()
    └─ Si issues == 0: state.current_flow.code_review_passed = true ← MARCAR
 
 6. Report
@@ -141,7 +155,7 @@ ELSABRO: [Ejecuta en <30 segundos]
 1. **Max 2 preguntas** - Si necesitas más info, usa `/elsabro:plan`
 2. **Max 3 archivos** - Si afecta más, usa flujo normal
 3. **Auto-test** - Siempre corre tests relacionados
-4. **Auto-review** - SIEMPRE ejecutar code review con `Task(pr-review-toolkit:code-reviewer)` después de escribir código
+4. **Auto-review** - SIEMPRE ejecutar code review con Agent Teams LITE (3 agentes) después de escribir código
 5. **No docs** - Skip documentación para velocidad
 6. **Offer commit** - Siempre pregunta si commitear
 
@@ -177,18 +191,27 @@ Task({
 ```
 ¿Se escribió/modificó código?
 │
-├─ SÍ → ¿Se ejecutó code review (Paso 5)?
+├─ SÍ → ¿Se ejecutó code review con Agent Teams LITE (Paso 5)?
 │    │
 │    ├─ NO → EJECUTAR AHORA:
-│    │   Task(pr-review-toolkit:code-reviewer)
-│    │   Si issues > 0: fix y re-review
-│    │   Solo cuando issues == 0: continuar
+│    │   TeamCreate("elsabro-review-lite")
+│    │   + 3 teammates: quality-reviewer, failure-hunter, test-analyzer
+│    │   Consolidar hallazgos
+│    │   Si issues criticos > 0: fix y re-review
+│    │   Solo cuando issues == 0: shutdown + TeamDelete + continuar
 │    │
-│    └─ SÍ, issues == 0 → Continuar
+│    └─ SÍ, issues == 0, team deleted → Continuar
 │
 └─ NO → Continuar (no aplica)
 ```
 
+**Agent Teams LITE — 3 Reviewers:**
+| Teammate | Plugin | Foco |
+|----------|--------|------|
+| quality-reviewer | pr-review-toolkit:code-reviewer | bugs, patterns, naming |
+| failure-hunter | pr-review-toolkit:silent-failure-hunter | error handling, fallbacks |
+| test-analyzer | pr-review-toolkit:pr-test-analyzer | coverage, edge cases |
+
 **VIOLACIÓN CRÍTICA**: Reportar resultado sin code review = ABORTAR OPERACIÓN
 </code_review_gate>
 

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');
   });
 });