elsabro 7.2.0 → 7.3.1

package/flow-engine/src/executors.js

@@ -9,9 +9,15 @@
  * 9 node types total:
  *   Simple (Wave 2):  entry, exit, condition, router, sequence
  *   Complex (Wave 3): agent, parallel, interrupt, team
+ *
+ * NOTE: The elsabro-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 for sprint planning. They are independent agents serving
+ * different purposes.
  */
 
 const { resolveTemplate, resolveExpression } = require('./template');
+const { serializeContext } = require('./runner');
 
 // ---------- Error types ----------
 
@@ -59,6 +65,7 @@ function checkRuntimeStatus(node) {
  * Entry node: no-op, just transitions to next.
  */
 async function executeEntry(node, context, callbacks) {
+  checkRuntimeStatus(node);
   return { next: node.next, outputs: {} };
 }
 
@@ -66,6 +73,7 @@ async function executeEntry(node, context, callbacks) {
  * Exit node: resolve output templates, terminate flow.
  */
 async function executeExit(node, context, callbacks) {
+  checkRuntimeStatus(node);
   const resolvedOutputs = node.outputs
     ? resolveTemplate(node.outputs, context)
     : {};
@@ -81,7 +89,18 @@ async function executeExit(node, context, callbacks) {
  * Condition node: evaluate condition, route to true/false branch.
  */
 async function executeCondition(node, context, callbacks) {
+  checkRuntimeStatus(node);
   if (!node.condition) {
+    // Save checkpoint before error
+    if (callbacks.onCheckpoint) {
+      await callbacks.onCheckpoint({
+        currentNode: node.id,
+        nextNode: null,
+        context: serializeContext(context),
+        stoppedAt: node.id,
+        reason: 'Condition node has no "condition" field'
+      });
+    }
     throw new ExecutorError(node.id, 'Condition node has no "condition" field');
   }
 
@@ -94,6 +113,16 @@ async function executeCondition(node, context, callbacks) {
   const nextNode = result ? node.true : node.false;
 
   if (!nextNode) {
+    // Save checkpoint before error
+    if (callbacks.onCheckpoint) {
+      await callbacks.onCheckpoint({
+        currentNode: node.id,
+        nextNode: null,
+        context: serializeContext(context),
+        stoppedAt: node.id,
+        reason: `Condition evaluated to ${!!result} but no "${result ? 'true' : 'false'}" branch defined`
+      });
+    }
     throw new ExecutorError(
       node.id,
       `Condition evaluated to ${!!result} but no "${result ? 'true' : 'false'}" branch defined`
@@ -107,6 +136,7 @@ async function executeCondition(node, context, callbacks) {
  * Router node: evaluate condition as a string, match against routes map.
  */
 async function executeRouter(node, context, callbacks) {
+  checkRuntimeStatus(node);
   if (!node.condition) {
     throw new ExecutorError(node.id, 'Router node has no "condition" field');
   }
@@ -139,8 +169,19 @@ async function executeRouter(node, context, callbacks) {
 
 /**
  * Sequence node: execute steps sequentially, collect step outputs.
+ *
+ * Special integrations:
+ * - skill-discovery.sh: Auto-parses JSON output, extracts discovered/recommended skills
+ * - skill-install.sh: Can be called via bash action for skill installation
+ *
+ * Callbacks used:
+ * - onBash(command): Execute bash commands
+ * - onReadFiles(files): Read file contents
+ * - onAgent(params): Invoke agent execution
+ * - onLog(level, message): Optional logging callback for skill discovery results
  */
 async function executeSequence(node, context, callbacks) {
+  checkRuntimeStatus(node);
   const steps = node.steps || [];
 
   for (const step of steps) {
@@ -154,6 +195,39 @@ async function executeSequence(node, context, callbacks) {
           const command = resolveTemplate(step.command, context);
           if (callbacks.onBash) {
             stepOutput = await callbacks.onBash(command);
+
+            // Special handling for skill-discovery hook integration
+            if (command.includes('skill-discovery.sh') && stepOutput.output) {
+              try {
+                // Parse JSON output from skill-discovery
+                const discoveryData = JSON.parse(stepOutput.output);
+
+                // Enhance output with parsed discovery data
+                stepOutput.discovered = discoveryData.discovered || [];
+                stepOutput.recommended = discoveryData.recommended || {};
+                stepOutput.registry_available = discoveryData.registry_available || false;
+
+                // Log skill discovery results (if callbacks provide logging)
+                if (callbacks.onLog) {
+                  callbacks.onLog('info', `[skill-discovery] Found ${stepOutput.discovered.length} installed skills`);
+
+                  if (stepOutput.recommended.skills && stepOutput.recommended.skills.length > 0) {
+                    callbacks.onLog('info', `[skill-discovery] Recommended: ${stepOutput.recommended.skills.join(', ')}`);
+                  }
+
+                  if (stepOutput.recommended.install_commands && stepOutput.recommended.install_commands.length > 0) {
+                    callbacks.onLog('info', `[skill-discovery] ${stepOutput.recommended.install_commands.length} install commands available`);
+                  }
+                }
+              } catch (parseErr) {
+                // If JSON parse fails, log warning but don't fail the step
+                if (callbacks.onLog) {
+                  callbacks.onLog('warn', `[skill-discovery] Failed to parse output as JSON: ${parseErr.message}`);
+                }
+                // Keep raw output available
+                stepOutput.parseError = parseErr.message;
+              }
+            }
           } else {
             stepOutput = { output: '', exitCode: -1, skipped: true };
           }
@@ -234,6 +308,7 @@ async function executeSequence(node, context, callbacks) {
  * Agent node: invoke an external agent via callback.
  */
 async function executeAgent(node, context, callbacks) {
+  checkRuntimeStatus(node);
   const resolvedInputs = node.inputs
     ? resolveTemplate(node.inputs, context)
     : {};
@@ -267,6 +342,7 @@ async function executeAgent(node, context, callbacks) {
  * Parallel node: execute branches concurrently via callback.
  */
 async function executeParallel(node, context, callbacks) {
+  checkRuntimeStatus(node);
   const branches = node.branches || [];
 
   // Resolve inputs for each branch
@@ -313,9 +389,65 @@ async function executeParallel(node, context, callbacks) {
   if (node.maxIterations && context._iterations[node.id] >= node.maxIterations) {
     if (node.onMaxIterations) {
       return { next: node.onMaxIterations, outputs: { branches: branchOutputs } };
+    } else {
+      // Fall through to next when no handler defined (graceful degradation)
+      return { next: node.next, outputs: { branches: branchOutputs } };
     }
   }
 
+  // Check errorPolicy quorum for parallel failures
+  if (node.errorPolicy === 'quorum') {
+    // Count successful branches
+    let successCount = 0;
+    const totalCount = branchResults.length;
+
+    for (const branchResult of branchResults) {
+      // Consider a branch successful if it doesn't have an error and wasn't skipped
+      if (branchResult && !branchResult.error && !branchResult.skipped) {
+        successCount++;
+      }
+    }
+
+    // Determine if quorum is met
+    let quorumMet = true;
+    let quorumType = 'default';
+
+    if (node.quorumThreshold !== undefined) {
+      // Percentage-based quorum (0.0 to 1.0)
+      quorumType = 'threshold';
+      const successRate = totalCount > 0 ? successCount / totalCount : 0;
+      quorumMet = successRate >= node.quorumThreshold;
+    } else if (node.quorumMinSuccess !== undefined) {
+      // Absolute count quorum
+      quorumType = 'minSuccess';
+      quorumMet = successCount >= node.quorumMinSuccess;
+    } else {
+      // Default: all must succeed (100% quorum)
+      quorumType = 'all';
+      quorumMet = successCount === totalCount;
+    }
+
+    // Build detailed outputs
+    const quorumOutputs = {
+      branches: branchOutputs,
+      quorumMet,
+      quorumType,
+      successCount,
+      totalCount,
+      failureCount: totalCount - successCount,
+      successRate: totalCount > 0 ? successCount / totalCount : 0
+    };
+
+    if (!quorumMet) {
+      // Quorum not met, route to error handler if defined
+      const errorRoute = node.onError || node.next;
+      return { next: errorRoute, outputs: quorumOutputs };
+    }
+
+    // Quorum met, proceed to next
+    return { next: node.next, outputs: quorumOutputs };
+  }
+
   return { next: node.next, outputs: { branches: branchOutputs } };
 }
 
@@ -323,6 +455,7 @@ async function executeParallel(node, context, callbacks) {
  * Interrupt node: pause execution, display info, route on user choice.
  */
 async function executeInterrupt(node, context, callbacks) {
+  checkRuntimeStatus(node);
   const resolvedDisplay = node.display
     ? resolveTemplate(node.display, context)
     : { title: node.reason || 'Interrupt', options: [] };
@@ -359,11 +492,9 @@ async function executeInterrupt(node, context, callbacks) {
  * Team node: deprecated, throws NotImplementedError.
  */
 async function executeTeam(node, context, callbacks) {
+  checkRuntimeStatus(node);
   // Team nodes are deprecated in ELSABRO v5.3+
-  // Agent Teams are now handled inline via IMPERATIVO_AGENT_TEAMS in execute.md
-  if (node.runtime_status === 'not_implemented') {
-    throw new NotImplementedError(node.id, node.gaps);
-  }
+  // Agent Teams are now handled via parallel dispatch in execute.md#3-dispatch + callbacks.js
 
   // If somehow called on a non-deprecated team node
   if (callbacks.onTeam) {

package/flow-engine/src/graph.js

@@ -64,15 +64,16 @@ function buildGraph(flowDefinition) {
 
 /**
  * Validate that all node references (next, routes, true, false, onMaxIterations,
- * onError) point to existing nodes.
+ * onError) point to existing nodes, and detect orphaned nodes.
  *
- * @param {{ nodes: Map<string, object> }} graph
+ * @param {{ nodes: Map<string, object>, entryNode: string }} graph
  * @returns {{ valid: boolean, errors: string[] }}
  */
 function validateGraph(graph) {
   const errors = [];
   const nodeIds = new Set(graph.nodes.keys());
 
+  // 1. Check for dangling references (invalid routes)
   for (const [id, node] of graph.nodes) {
     const refs = getNextNodes(node);
     for (const ref of refs) {
@@ -82,6 +83,33 @@ function validateGraph(graph) {
     }
   }
 
+  // 2. Detect orphaned nodes (nodes that are never reachable from entry)
+  const reachable = new Set();
+  const queue = [graph.entryNode];
+
+  while (queue.length > 0) {
+    const currentId = queue.shift();
+    if (reachable.has(currentId)) continue;
+
+    reachable.add(currentId);
+    const node = graph.nodes.get(currentId);
+    if (!node) continue; // Skip if node doesn't exist (handled by dangling ref check)
+
+    const nextNodes = getNextNodes(node);
+    for (const nextId of nextNodes) {
+      if (!reachable.has(nextId) && nodeIds.has(nextId)) {
+        queue.push(nextId);
+      }
+    }
+  }
+
+  // Find orphaned nodes
+  for (const nodeId of nodeIds) {
+    if (!reachable.has(nodeId)) {
+      errors.push(`Orphaned node "${nodeId}" is unreachable from entry point`);
+    }
+  }
+
   return { valid: errors.length === 0, errors };
 }
 

package/flow-engine/src/template.js

@@ -73,7 +73,17 @@ registerFunction('collectErrors', (context) => {
 registerFunction('hasCriticalIssues', (context, obj) => {
   if (!obj) return false;
   const json = typeof obj === 'string' ? obj : JSON.stringify(obj);
-  return json.includes('"critical"') || json.includes('"blocking"');
+
+  // Enhanced pattern detection for critical issues
+  const criticalPatterns = [
+    '"critical"',
+    '"blocking"',
+    '"P0"',
+    '"MUST_FIX"',
+    '"URGENT"'
+  ];
+
+  return criticalPatterns.some(pattern => json.includes(pattern));
 });
 
 registerFunction('generateSummary', (context) => {
@@ -144,92 +154,162 @@ function parseLiteral(str) {
 }
 
 /**
- * Resolve a single expression string (the content inside {{ }}).
- *
- * @param {string} expr – raw expression without {{ }}
- * @param {object} context – { inputs, nodes, steps, state }
- * @returns {*}
+ * Handle filter syntax: "value | filterName"
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Filtered value or null if no match
  */
-function resolveExpression(expr, context) {
-  const trimmed = expr.trim();
-
-  // 1. Check for filter syntax: "value | filterName"
-  //    Only match pipes that are NOT inside || (fallback operator)
-  const filterMatch = trimmed.match(/^(.+?)\s*\|\s*(?!\|)(\w+)\s*$/);
-  if (filterMatch) {
-    const innerValue = resolveExpression(filterMatch[1], context);
-    const filterName = filterMatch[2];
-    const filter = _filters.get(filterName);
-    if (!filter) {
-      throw new TemplateError(`Unknown filter: "${filterName}"`);
-    }
-    return filter(innerValue);
+function tryResolveFilter(expr, context) {
+  // Only match pipes that are NOT inside || (fallback operator)
+  const filterMatch = expr.match(/^(.+?)\s*\|\s*(?!\|)(\w+)\s*$/);
+  if (!filterMatch) return null;
+
+  const innerValue = resolveExpression(filterMatch[1], context);
+  const filterName = filterMatch[2];
+  const filter = _filters.get(filterName);
+  if (!filter) {
+    throw new TemplateError(`Unknown filter: "${filterName}"`);
   }
+  return filter(innerValue);
+}
 
-  // 2. Check for fallback operator: "expr || default"
-  const fallbackMatch = trimmed.match(/^(.+?)\s*\|\|\s*(.+)$/);
-  if (fallbackMatch) {
-    const primary = resolveExpression(fallbackMatch[1], context);
-    if (primary != null && primary !== '') return primary;
-    // Try to resolve the default as an expression or literal
-    const fallbackLiteral = parseLiteral(fallbackMatch[2]);
-    if (fallbackLiteral.matched) return fallbackLiteral.value;
-    return resolveExpression(fallbackMatch[2], context);
-  }
+/**
+ * Handle fallback operator: "expr || default"
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Primary or fallback value, or null if no match
+ */
+function tryResolveFallback(expr, context) {
+  const fallbackMatch = expr.match(/^(.+?)\s*\|\|\s*(.+)$/);
+  if (!fallbackMatch) return null;
+
+  const primary = resolveExpression(fallbackMatch[1], context);
+  if (primary != null && primary !== '') return primary;
+
+  // Try to resolve the default as a literal or expression
+  const fallbackLiteral = parseLiteral(fallbackMatch[2]);
+  if (fallbackLiteral.matched) return fallbackLiteral.value;
+  return resolveExpression(fallbackMatch[2], context);
+}
+
+/**
+ * Handle negation: "!expr"
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Negated value or null if no match
+ */
+function tryResolveNegation(expr, context) {
+  if (!expr.startsWith('!')) return null;
+  const inner = resolveExpression(expr.slice(1), context);
+  return !inner;
+}
 
-  // 3. Check for negation: "!expr"
-  if (trimmed.startsWith('!')) {
-    const inner = resolveExpression(trimmed.slice(1), context);
-    return !inner;
+/**
+ * Handle boolean && expression
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Boolean result or null if no match
+ */
+function tryResolveAnd(expr, context) {
+  if (!expr.includes('&&')) return null;
+
+  const parts = expr.split('&&').map(p => p.trim());
+  return parts.every(part => {
+    const val = resolveExpression(part, context);
+    return !!val;
+  });
+}
+
+/**
+ * Handle comparison operators: ===, !==
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Comparison result or null if no match
+ */
+function tryResolveComparison(expr, context) {
+  const compMatch = expr.match(/^(.+?)\s*(===|!==)\s*(.+)$/);
+  if (!compMatch) return null;
+
+  const left = resolveExpression(compMatch[1], context);
+  const right = resolveExpression(compMatch[3], context);
+  if (compMatch[2] === '===') return left === right;
+  if (compMatch[2] === '!==') return left !== right;
+  return null;
+}
+
+/**
+ * Handle function call: "functionName(args)"
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Function result or null if no match
+ */
+function tryResolveFunctionCall(expr, context) {
+  const funcMatch = expr.match(/^(\w+)\(([^)]*)\)$/);
+  if (!funcMatch) return null;
+
+  const funcName = funcMatch[1];
+  const fn = _functions.get(funcName);
+  if (!fn) {
+    throw new TemplateError(`Unknown function: "${funcName}"`);
   }
 
-  // 4. Check for boolean && expression
-  if (trimmed.includes('&&')) {
-    const parts = trimmed.split('&&').map(p => p.trim());
-    return parts.every(part => {
-      const val = resolveExpression(part, context);
-      return !!val;
-    });
+  const argsStr = funcMatch[2].trim();
+  if (argsStr === '') {
+    return fn(context);
   }
 
-  // 5. Check for comparison operators: ===, !==
-  const compMatch = trimmed.match(/^(.+?)\s*(===|!==)\s*(.+)$/);
-  if (compMatch) {
-    const left = resolveExpression(compMatch[1], context);
-    const right = resolveExpression(compMatch[3], context);
-    if (compMatch[2] === '===') return left === right;
-    if (compMatch[2] === '!==') return left !== right;
+  // Parse argument: could be a path reference or a quoted string
+  const argLiteral = parseLiteral(argsStr);
+  if (argLiteral.matched) {
+    return fn(context, argLiteral.value);
   }
 
-  // 6. Check for function call: "functionName(args)"
-  const funcMatch = trimmed.match(/^(\w+)\(([^)]*)\)$/);
-  if (funcMatch) {
-    const funcName = funcMatch[1];
-    const fn = _functions.get(funcName);
-    if (!fn) {
-      throw new TemplateError(`Unknown function: "${funcName}"`);
-    }
-    const argsStr = funcMatch[2].trim();
-    if (argsStr === '') {
-      return fn(context);
-    }
-    // Parse argument: could be a path reference or a quoted string
-    const argLiteral = parseLiteral(argsStr);
-    if (argLiteral.matched) {
-      return fn(context, argLiteral.value);
-    }
-    // Resolve as expression (path)
-    const argValue = resolveExpression(argsStr, context);
-    return fn(context, argValue);
+  // Resolve as expression (path)
+  const argValue = resolveExpression(argsStr, context);
+  return fn(context, argValue);
+}
+
+/**
+ * Resolve a single expression string (the content inside {{ }}).
+ *
+ * Delegates to specialized handlers in order:
+ * 1. Filter syntax: "value | filterName"
+ * 2. Fallback operator: "expr || default"
+ * 3. Negation: "!expr"
+ * 4. Boolean AND: "a && b"
+ * 5. Comparison: "a === b", "a !== b"
+ * 6. Function call: "functionName(args)"
+ * 7. Literal value: true, false, number, string, [], {}
+ * 8. Path resolution: "inputs.task", "nodes.X.outputs.Y"
+ *
+ * @param {string} expr – raw expression without {{ }}
+ * @param {object} context – { inputs, nodes, steps, state }
+ * @returns {*}
+ */
+function resolveExpression(expr, context) {
+  const trimmed = expr.trim();
+
+  // Try each expression type in order (most specific to least specific)
+  const handlers = [
+    tryResolveFilter,
+    tryResolveFallback,
+    tryResolveNegation,
+    tryResolveAnd,
+    tryResolveComparison,
+    tryResolveFunctionCall
+  ];
+
+  for (const handler of handlers) {
+    const result = handler(trimmed, context);
+    if (result !== null) return result;
   }
 
-  // 7. Literal value
+  // Try literal value
   const literal = parseLiteral(trimmed);
   if (literal.matched) return literal.value;
 
-  // 8. Path resolution (the most common case)
-  const value = resolvePath(context, trimmed);
-  return value;
+  // Default: path resolution (most common case)
+  return resolvePath(context, trimmed);
 }
 
 /**