@o-lang/olang 1.0.27 → 1.1.2

package/cli.js

@@ -1,10 +1,13 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 const { Command } = require('commander');
 const { parse } = require('./src/parser');
 const { execute } = require('./src/runtime');
 const fs = require('fs');
 const path = require('path');
 
+// === ADDED: Load package.json for version (1 line added) ===
+const pkg = require('./package.json');
+
 /**
  * Enforce .ol extension ONLY (CLI only)
  */
@@ -156,6 +159,9 @@ function loadResolverChain(specifiers, verbose, allowed) {
  */
 const program = new Command();
 
+// === ADDED: Version support (1 line added) ===
+program.version(pkg.version, '-V, --version', 'Show O-lang kernel version');
+
 // === RUN COMMAND ===
 program
   .name('olang')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/olang",
-  "version": "1.0.27",
+  "version": "1.1.2",
   "author": "Olalekan Ogundipe <info@workfily.com>",
   "description": "O-Lang: A governance language for user-directed, rule-enforced agent workflows",
   "main": "./src/index.js",

package/src/parser.js

@@ -1,11 +1,23 @@
 const fs = require('fs');
 
+// ✅ Symbol normalization helper (backward compatible)
+function normalizeSymbol(raw) {
+  if (!raw) return raw;
+  // Take only the first word (stop at first whitespace)
+  // Keep letters, numbers, underscores, and $ (for JS compatibility)
+  return raw.split(/\s+/)[0].replace(/[^\w$]/g, '');
+}
+
 function parse(content, filename = '<unknown>') {
   if (typeof content === 'string') {
+    // ✅ Strip UTF-8 BOM if present (0xFEFF = Unicode BOM)
+    if (content.charCodeAt(0) === 0xFEFF) {
+      content = content.slice(1);
+    }
+    
     const lines = content.split('\n').map(line => line.replace(/\r$/, ''));
     return parseLines(lines, filename);
   } else if (typeof content === 'object' && content !== null) {
-    // Already parsed
     return content;
   } else {
     throw new Error('parse() expects string content or pre-parsed object');
@@ -13,12 +25,15 @@ function parse(content, filename = '<unknown>') {
 }
 
 function parseFromFile(filepath) {
+  // Enforce .ol extension
+  if (!filepath.endsWith(".ol")) {
+    throw new Error(`Expected .ol workflow, got: ${filepath}`);
+  }
   const content = fs.readFileSync(filepath, 'utf8');
   return parse(content, filepath);
 }
 
 function parseLines(lines, filename) {
-  // Remove evolution file parsing - evolution is now in-workflow
   return parseWorkflowLines(lines, filename);
 }
 
@@ -30,27 +45,40 @@ function parseWorkflowLines(lines, filename) {
     steps: [],
     returnValues: [],
     allowedResolvers: [],
-    maxGenerations: null, // ✅ Updated field name for Constraint: max_generations = X
+    maxGenerations: null,
     __warnings: [],
     filename: filename
   };
-  
+
   let i = 0;
   let currentStep = null;
   let inAllowResolvers = false;
   let inIfBlock = false;
   let ifCondition = null;
   let ifBody = [];
-  
+  let inParallelBlock = false;
+  let parallelSteps = [];
+  let parallelTimeout = null;
+  let inEscalationBlock = false;
+  let escalationLevels = [];
+  let currentLevel = null;
+
+  // ✅ Helper to flush currentStep
+  const flushCurrentStep = () => {
+    if (currentStep) {
+      workflow.steps.push(currentStep);
+      currentStep = null;
+    }
+  };
+
   while (i < lines.length) {
     let line = lines[i++].trim();
-    
-    // Skip empty lines and comments
+
     if (line === '' || line.startsWith('#')) {
       continue;
     }
-    
-    // Parse Workflow declaration
+
+    // Workflow declaration
     if (line.startsWith('Workflow ')) {
       const match = line.match(/^Workflow\s+"([^"]+)"(?:\s+with\s+(.+))?$/i);
       if (match) {
@@ -63,8 +91,8 @@ function parseWorkflowLines(lines, filename) {
       }
       continue;
     }
-    
-    // Parse Constraint: max_generations = X (✅ Updated syntax)
+
+    // Global Constraint: max_generations
     if (line.startsWith('Constraint: max_generations = ')) {
       const match = line.match(/^Constraint:\s+max_generations\s*=\s*(\d+)$/i);
       if (match) {
@@ -74,13 +102,13 @@ function parseWorkflowLines(lines, filename) {
       }
       continue;
     }
-    
-    // Parse Allow resolvers section
+
+    // Allow resolvers section
     if (line === 'Allow resolvers:') {
       inAllowResolvers = true;
       continue;
     }
-    
+
     if (inAllowResolvers) {
       if (line.startsWith('- ')) {
         const resolverName = line.substring(2).trim();
@@ -88,28 +116,153 @@ function parseWorkflowLines(lines, filename) {
           workflow.allowedResolvers.push(resolverName);
         }
       } else if (line === '' || line.startsWith('#')) {
-        // Continue
+        continue;
       } else {
-        // End of Allow resolvers section
         inAllowResolvers = false;
-        i--; // Re-process this line
+        i--;
         continue;
       }
       continue;
     }
-    
-    // Parse Step declarations
-    const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
-    if (stepMatch) {
-      // Save previous step if it exists
-      if (currentStep) {
-        workflow.steps.push(currentStep);
-        currentStep = null;
+
+    // ✅ Parse Escalation block
+    if (line.match(/^Run in parallel with escalation:$/i)) {
+      flushCurrentStep();
+      inEscalationBlock = true;
+      escalationLevels = [];
+      currentLevel = null;
+      continue;
+    }
+
+    if (inEscalationBlock) {
+      if (line.match(/^End$/i)) {
+        if (currentLevel) {
+          escalationLevels.push(currentLevel);
+        }
+        workflow.steps.push({
+          type: 'escalation',
+          levels: escalationLevels,
+          stepNumber: workflow.steps.length + 1
+        });
+        inEscalationBlock = false;
+        continue;
+      } else if (line.match(/^Level \d+:/i)) {
+        // Parse level declaration
+        const levelMatch = line.match(/^Level (\d+):\s+(.+)$/i);
+        if (levelMatch) {
+          if (currentLevel) {
+            escalationLevels.push(currentLevel);
+          }
+          
+          // Parse timeout from level description
+          let timeoutMs = null;
+          const desc = levelMatch[2].trim().toLowerCase();
+          if (desc.includes('immediately')) {
+            timeoutMs = 0;
+          } else {
+            const timeMatch = desc.match(/within\s+(\d+)\s*([smhd])/i);
+            if (timeMatch) {
+              const value = parseInt(timeMatch[1]);
+              const unit = timeMatch[2].toLowerCase();
+              const multipliers = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+              timeoutMs = value * (multipliers[unit] || 1000);
+            }
+          }
+          
+          currentLevel = {
+            levelNumber: parseInt(levelMatch[1]),
+            timeout: timeoutMs,
+            steps: []
+          };
+          continue;
+        }
+      } else if (currentLevel) {
+        // Parse steps within level
+        currentLevel.steps.push(line);
+        continue;
       }
+    }
+
+    // ✅ Parse Timed Parallel block (EXACT FORMAT - NO DUPLICATION)
+    const timedParMatch = line.match(/^Run in parallel for (\d+)\s*([smhd])$/i);
+    if (timedParMatch) {
+      flushCurrentStep();
+      
+      const value = parseInt(timedParMatch[1]);
+      const unit = timedParMatch[2].toLowerCase();
+      const multipliers = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+      const timeoutMs = value * (multipliers[unit] || 1000);
       
+      inParallelBlock = true;
+      parallelSteps = [];
+      parallelTimeout = timeoutMs;
+      continue;
+    }
+
+    // ✅ Parse Normal Parallel block (backward compatible)
+    if (line.match(/^Run in parallel$/i)) {
+      flushCurrentStep();
+      inParallelBlock = true;
+      parallelSteps = [];
+      parallelTimeout = null;
+      continue;
+    }
+
+    if (inParallelBlock) {
+      if (line.match(/^End$/i)) {
+        flushCurrentStep(); // ✅ Flush last parallel step
+        const parsedParallel = parseBlock(parallelSteps);
+        workflow.steps.push({
+          type: 'parallel',
+          steps: parsedParallel,
+          timeout: parallelTimeout,
+          stepNumber: workflow.steps.length + 1
+        });
+        inParallelBlock = false;
+        parallelTimeout = null;
+        continue;
+      } else {
+        parallelSteps.push(line);
+        continue;
+      }
+    }
+
+    // ✅ FLUSH before If/When block
+    if (line.match(/^(?:If|When)\s+(.+)$/i)) {
+      flushCurrentStep();
+      const ifMatch = line.match(/^(?:If|When)\s+(.+)$/i);
+      ifCondition = ifMatch[1].trim();
+      inIfBlock = true;
+      ifBody = [];
+      continue;
+    }
+
+    if (inIfBlock) {
+      if (line.match(/^End(?:If)?$/i)) {
+        flushCurrentStep(); // ✅ Flush last if step
+        const parsedIfBody = parseBlock(ifBody);
+        workflow.steps.push({
+          type: 'if',
+          condition: ifCondition,
+          body: parsedIfBody,
+          stepNumber: workflow.steps.length + 1
+        });
+        inIfBlock = false;
+        ifCondition = null;
+        ifBody = [];
+        continue;
+      } else {
+        ifBody.push(line);
+        continue;
+      }
+    }
+
+    // Step declaration
+    const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
+    if (stepMatch) {
+      flushCurrentStep(); // ✅ Flush previous step
       const stepNumber = parseInt(stepMatch[1], 10);
       const stepContent = stepMatch[2];
-      
       currentStep = {
         type: 'action',
         stepNumber: stepNumber,
@@ -119,81 +272,138 @@ function parseWorkflowLines(lines, filename) {
       };
       continue;
     }
-    
-    // Parse Evolve steps (✅ NEW IN-WORKFLOW EVOLUTION)
+
+    // Save as - ✅ Apply normalization
+    const saveMatch = line.match(/^Save as\s+(.+)$/i);
+    if (saveMatch && currentStep) {
+      currentStep.saveAs = normalizeSymbol(saveMatch[1].trim());
+      continue;
+    }
+
+    // Constraint (per-step)
+    const constraintMatch = line.match(/^Constraint:\s*(.+)$/i);
+    if (constraintMatch && currentStep) {
+      const constraintLine = constraintMatch[1].trim();
+      const eq = constraintLine.match(/^([^=]+)=\s*(.+)$/);
+      if (eq) {
+        let key = eq[1].trim();
+        let value = eq[2].trim();
+
+        if (value.startsWith('[') && value.endsWith(']')) {
+          value = value.slice(1, -1).split(',').map(v => v.trim().replace(/^"/, '').replace(/"$/, ''));
+        } else if (!isNaN(value)) {
+          value = Number(value);
+        } else if (value.startsWith('"') && value.endsWith('"')) {
+          value = value.slice(1, -1);
+        }
+
+        currentStep.constraints[key] = value;
+      }
+      continue;
+    }
+
+    // Debrief
+    const debriefMatch = line.match(/^Debrief\s+([^\s]+)\s+with\s+"([^"]*)"$/i);
+    if (debriefMatch) {
+      flushCurrentStep();
+      workflow.steps.push({
+        type: 'debrief',
+        agent: debriefMatch[1].trim(),
+        message: debriefMatch[2],
+        stepNumber: workflow.steps.length + 1
+      });
+      continue;
+    }
+
+    // Evolve
     const evolveMatch = line.match(/^Evolve\s+([^\s]+)\s+using\s+feedback:\s*"([^"]*)"$/i);
     if (evolveMatch) {
-      if (currentStep) {
-        workflow.steps.push(currentStep);
-        currentStep = null;
-      }
-      
-      currentStep = {
+      flushCurrentStep();
+      workflow.steps.push({
         type: 'evolve',
-        stepNumber: workflow.steps.length + 1,
         targetResolver: evolveMatch[1].trim(),
         feedback: evolveMatch[2],
-        saveAs: null,
-        constraints: {}
-      };
+        stepNumber: workflow.steps.length + 1
+      });
       continue;
     }
-    
-    // Parse Save as
-    const saveMatch = line.match(/^Save as\s+(.+)$/i);
-    if (saveMatch && currentStep) {
-      currentStep.saveAs = saveMatch[1].trim();
+
+    // Prompt
+    const promptMatch = line.match(/^Prompt user to\s+"([^"]*)"$/i);
+    if (promptMatch) {
+      flushCurrentStep();
+      workflow.steps.push({
+        type: 'prompt',
+        question: promptMatch[1],
+        stepNumber: workflow.steps.length + 1,
+        saveAs: null
+      });
       continue;
     }
-    
-    // Parse If/When conditions
-    const ifMatch = line.match(/^(?:If|When)\s+(.+)$/i);
-    if (ifMatch) {
-      ifCondition = ifMatch[1].trim();
-      inIfBlock = true;
-      ifBody = [];
+
+    // Persist
+    const persistMatch = line.match(/^Persist\s+([^\s]+)\s+to\s+"([^"]*)"$/i);
+    if (persistMatch) {
+      flushCurrentStep();
+      workflow.steps.push({
+        type: 'persist',
+        variable: persistMatch[1].trim(),
+        target: persistMatch[2],
+        stepNumber: workflow.steps.length + 1
+      });
       continue;
     }
-    
-    const endIfMatch = line.match(/^End(?:If)?$/i);
-    if (endIfMatch && inIfBlock) {
-      if (currentStep) {
-        workflow.steps.push(currentStep);
-        currentStep = null;
-      }
-      
+
+    // Emit
+    const emitMatch = line.match(/^Emit\s+"([^"]+)"\s+with\s+(.+)$/i);
+    if (emitMatch) {
+      flushCurrentStep();
       workflow.steps.push({
-        type: 'if',
-        condition: ifCondition,
-        body: ifBody,
+        type: 'emit',
+        event: emitMatch[1],
+        payload: emitMatch[2].trim(),
         stepNumber: workflow.steps.length + 1
       });
-      
-      inIfBlock = false;
-      ifCondition = null;
-      ifBody = [];
       continue;
     }
-    
-    // Handle lines inside If block
-    if (inIfBlock) {
-      ifBody.push(line);
+
+    // Use (for Notify-like actions)
+    const useMatch = line.match(/^Use\s+(.+)$/i);
+    if (useMatch) {
+      flushCurrentStep();
+      workflow.steps.push({
+        type: 'use',
+        tool: useMatch[1].trim(),
+        stepNumber: workflow.steps.length + 1,
+        saveAs: null,
+        constraints: {}
+      });
       continue;
     }
-    
-    // Parse Return statement
+
+    // Ask (for Notify/resolver calls)
+    const askMatch = line.match(/^Ask\s+(.+)$/i);
+    if (askMatch) {
+      flushCurrentStep();
+      workflow.steps.push({
+        type: 'ask',
+        target: askMatch[1].trim(),
+        stepNumber: workflow.steps.length + 1,
+        saveAs: null,
+        constraints: {}
+      });
+      continue;
+    }
+
+    // Return
     const returnMatch = line.match(/^Return\s+(.+)$/i);
     if (returnMatch) {
-      if (currentStep) {
-        workflow.steps.push(currentStep);
-        currentStep = null;
-      }
+      flushCurrentStep();
       workflow.returnValues = returnMatch[1].split(',').map(r => r.trim()).filter(r => r !== '');
       continue;
     }
-    
-    // If we reach here and have unprocessed content, it's likely a workflow line without "Step X:"
-    // Try to handle it as a step
+
+    // Fallback: treat as action
     if (line.trim() !== '') {
       if (!currentStep) {
         currentStep = {
@@ -204,51 +414,179 @@ function parseWorkflowLines(lines, filename) {
           constraints: {}
         };
       } else {
-        // Append to current step action (multi-line)
         currentStep.actionRaw += ' ' + line;
       }
     }
   }
-  
-  // Don't forget the last step
-  if (currentStep) {
-    workflow.steps.push(currentStep);
-  }
-  
-  // Post-process steps to extract Save as from actionRaw
+
+  flushCurrentStep(); // ✅ Final flush
+
+  // Post-process Save as in actionRaw - ✅ Apply normalization
   workflow.steps.forEach(step => {
     if (step.actionRaw && step.saveAs === null) {
       const saveInAction = step.actionRaw.match(/(.+?)\s+Save as\s+(.+)$/i);
       if (saveInAction) {
         step.actionRaw = saveInAction[1].trim();
-        step.saveAs = saveInAction[2].trim();
+        step.saveAs = normalizeSymbol(saveInAction[2].trim());
       }
     }
+    // ✅ Also normalize any existing saveAs values
+    if (step.saveAs) {
+      step.saveAs = normalizeSymbol(step.saveAs);
+    }
   });
-  
-  // Check for common issues
+
+  // Validation warnings
   if (!workflow.name) {
     workflow.__warnings.push('Workflow name not found');
   }
-  
   if (workflow.steps.length === 0) {
     workflow.__warnings.push('No steps found in workflow');
   }
-  
   if (workflow.returnValues.length === 0 && workflow.steps.length > 0) {
     workflow.__warnings.push('No Return statement found');
   }
-  
+
   return workflow;
 }
 
+// Parses blocks (for parallel, if, escalation levels)
+function parseBlock(lines) {
+  const steps = [];
+  let current = null;
+
+  const flush = () => {
+    if (current) {
+      steps.push(current);
+      current = null;
+    }
+  };
+
+  for (let line of lines) {
+    line = line.trim();
+    if (!line || line.startsWith('#')) continue;
+
+    const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
+    if (stepMatch) {
+      flush();
+      current = {
+        type: 'action',
+        stepNumber: parseInt(stepMatch[1], 10),
+        actionRaw: stepMatch[2].trim(),
+        saveAs: null,
+        constraints: {}
+      };
+      continue;
+    }
+
+    // Save as - ✅ Apply normalization
+    const saveMatch = line.match(/^Save as\s+(.+)$/i);
+    if (saveMatch && current) {
+      current.saveAs = normalizeSymbol(saveMatch[1].trim());
+      continue;
+    }
+
+    // Handle all special steps inside blocks
+    const debriefMatch = line.match(/^Debrief\s+([^\s]+)\s+with\s+"([^"]*)"$/i);
+    if (debriefMatch) {
+      flush();
+      steps.push({ type: 'debrief', agent: debriefMatch[1].trim(), message: debriefMatch[2] });
+      continue;
+    }
+
+    const evolveMatch = line.match(/^Evolve\s+([^\s]+)\s+using\s+feedback:\s*"([^"]*)"$/i);
+    if (evolveMatch) {
+      flush();
+      steps.push({ type: 'evolve', targetResolver: evolveMatch[1].trim(), feedback: evolveMatch[2] });
+      continue;
+    }
+
+    const promptMatch = line.match(/^Prompt user to\s+"([^"]*)"$/i);
+    if (promptMatch) {
+      flush();
+      steps.push({ type: 'prompt', question: promptMatch[1], saveAs: null });
+      continue;
+    }
+
+    const persistMatch = line.match(/^Persist\s+([^\s]+)\s+to\s+"([^"]*)"$/i);
+    if (persistMatch) {
+      flush();
+      steps.push({ type: 'persist', variable: persistMatch[1].trim(), target: persistMatch[2] });
+      continue;
+    }
+
+    const emitMatch = line.match(/^Emit\s+"([^"]+)"\s+with\s+(.+)$/i);
+    if (emitMatch) {
+      flush();
+      steps.push({ type: 'emit', event: emitMatch[1], payload: emitMatch[2].trim() });
+      continue;
+    }
+
+    const useMatch = line.match(/^Use\s+(.+)$/i);
+    if (useMatch) {
+      flush();
+      steps.push({ type: 'use', tool: useMatch[1].trim(), saveAs: null, constraints: {} });
+      continue;
+    }
+
+    const askMatch = line.match(/^Ask\s+(.+)$/i);
+    if (askMatch) {
+      flush();
+      steps.push({ type: 'ask', target: askMatch[1].trim(), saveAs: null, constraints: {} });
+      continue;
+    }
+
+    // Constraint inside block
+    const constraintMatch = line.match(/^Constraint:\s*(.+)$/i);
+    if (constraintMatch && current) {
+      const constraintLine = constraintMatch[1].trim();
+      const eq = constraintLine.match(/^([^=]+)=\s*(.+)$/);
+      if (eq) {
+        let key = eq[1].trim();
+        let value = eq[2].trim();
+        if (value.startsWith('[') && value.endsWith(']')) {
+          value = value.slice(1, -1).split(',').map(v => v.trim().replace(/^"/, '').replace(/"$/, ''));
+        } else if (!isNaN(value)) {
+          value = Number(value);
+        } else if (value.startsWith('"') && value.endsWith('"')) {
+          value = value.slice(1, -1);
+        }
+        current.constraints[key] = value;
+      }
+      continue;
+    }
+
+    // Fallback
+    if (current) {
+      current.actionRaw += ' ' + line;
+    }
+  }
+
+  flush(); // ✅ Final flush in block
+
+  // ✅ Post-process Save as for steps inside blocks - Apply normalization
+  steps.forEach(step => {
+    if (step.actionRaw && step.saveAs === null) {
+      const saveInAction = step.actionRaw.match(/(.+?)\s+Save as\s+(.+)$/i);
+      if (saveInAction) {
+        step.actionRaw = saveInAction[1].trim();
+        step.saveAs = normalizeSymbol(saveInAction[2].trim());
+      }
+    }
+    // ✅ Also normalize any existing saveAs values
+    if (step.saveAs) {
+      step.saveAs = normalizeSymbol(step.saveAs);
+    }
+  });
+
+  return steps;
+}
+
 function validate(workflow) {
   const errors = [];
-  
   if (workflow.maxGenerations !== null && workflow.maxGenerations <= 0) {
     errors.push('max_generations must be positive');
   }
-  
   return errors;
 }
 

package/src/runtime.js

@@ -92,6 +92,33 @@ class RuntimeAPI {
     }
   }
 
+  // -----------------------------
+  // ✅ SEMANTIC ENFORCEMENT HELPER
+  // -----------------------------
+  _requireSemantic(symbol, stepType) {
+    const value = this.context[symbol];
+    if (value === undefined) {
+      const error = {
+        type: 'semantic_violation',
+        symbol: symbol,
+        expected: 'defined value',
+        used_by: stepType,
+        phase: 'execution'
+      };
+      
+      // Emit semantic event (for observability)
+      this.emit('semantic_violation', error);
+      
+      // Log as error (not warning)
+      if (this.verbose) {
+        console.error(`[O-Lang SEMANTIC] Missing required symbol "${symbol}" for ${stepType}`);
+      }
+      
+      return false;
+    }
+    return true;
+  }
+
   // -----------------------------
   // Parser/runtime warnings
   // -----------------------------
@@ -148,11 +175,6 @@ class RuntimeAPI {
   // -----------------------------
   // ✅ ADDITION 1 — External Resolver Detection
   // -----------------------------
-  /**
-   * Determines whether a resolver is external (HTTP-based)
-   * External resolvers MUST be declared via a manifest (.json)
-   * and explicitly allowed by workflow policy
-   */
   _isExternalResolver(resolver) {
     return Boolean(
       resolver &&
@@ -166,13 +188,6 @@ class RuntimeAPI {
   // -----------------------------
   // ✅ ADDITION 2 — External Resolver Invocation (HTTP Enforcement)
   // -----------------------------
-  /**
-   * Calls an external HTTP resolver using its manifest definition.
-   * Enforces:
-   * - timeout
-   * - JSON contract
-   * - isolation (no direct execution)
-   */
   async _callExternalResolver(resolver, action, context) {
     const manifest = resolver.manifest;
     const endpoint = manifest.endpoint;
@@ -291,6 +306,18 @@ class RuntimeAPI {
   async executeStep(step, agentResolver) {
     const stepType = step.type;
 
+    // ✅ Enforce per-step constraints (basic validation)
+    if (step.constraints && Object.keys(step.constraints).length > 0) {
+      for (const [key, value] of Object.entries(step.constraints)) {
+        // Log unsupported constraints (future extensibility)
+        if (['max_time_sec', 'cost_limit', 'allowed_resolvers'].includes(key)) {
+          this.addWarning(`Per-step constraint "${key}=${value}" is parsed but not yet enforced`);
+        } else {
+          this.addWarning(`Unknown per-step constraint: ${key}=${value}`);
+        }
+      }
+    }
+
     // ✅ ADDITION 3 — Resolver Policy Enforcement (External + Local)
     const enforceResolverPolicy = (resolver, step) => {
       const resolverName = resolver?.resolverName || resolver?.name;
@@ -316,9 +343,8 @@ class RuntimeAPI {
       }
     };
 
+    // ✅ STRICT SAFETY: Updated runResolvers with failure halting
     const runResolvers = async (action) => {
-      const outputs = [];
-
       const mathPattern =
         /^(Add|Subtract|Multiply|Divide|Sum|Avg|Min|Max|Round|Floor|Ceil|Abs)\b/i;
 
@@ -344,13 +370,13 @@ class RuntimeAPI {
         resolversToRun = [agentResolver];
       }
 
-      // ✅ Return the FIRST resolver that returns a non-undefined result
+      // ✅ STRICT SAFETY: Fail fast on resolver errors or empty results
       for (let idx = 0; idx < resolversToRun.length; idx++) {
         const resolver = resolversToRun[idx];
-        enforceResolverPolicy(resolver, step); // ✅ Use new policy enforcement
+        enforceResolverPolicy(resolver, step);
 
         try {
-          let result; // ✅ ADDITION 4 — External Resolver Execution Path
+          let result;
 
           if (this._isExternalResolver(resolver)) {
             result = await this._callExternalResolver(
@@ -362,22 +388,32 @@ class RuntimeAPI {
             result = await resolver(action, this.context);
           }
 
-          if (result !== undefined) {
-            this.context[`__resolver_${idx}`] = result;
-            return result;
+          // ✅ SAFETY GUARD 1: Reject undefined/null results
+          if (result === undefined || result === null) {
+            throw new Error(
+              `[O-Lang SAFETY] Resolver "${resolver.resolverName || resolver.name || 'anonymous'}" returned empty result for action: "${action}". ` +
+              `Workflow halted to prevent unsafe data propagation.`
+            );
           }
 
-          outputs.push(result);
           this.context[`__resolver_${idx}`] = result;
+          return result;
+
         } catch (e) {
-          this.addWarning(`Resolver ${resolver?.resolverName || resolver?.name || idx} failed for action "${action}": ${e.message}`);
-          outputs.push(null);
-          this.context[`__resolver_${idx}`] = null;
+          // ✅ SAFETY GUARD 2: HALT workflow immediately on resolver failure
+          throw new Error(
+            `[O-Lang SAFETY] Resolver "${resolver?.resolverName || resolver?.name || idx}" failed for action "${action}": ${e.message}\n` +
+            `Workflow execution halted.`
+          );
         }
       }
 
-      // If no resolver handled the action, return undefined
-      return undefined;
+      // ✅ SAFETY GUARD 3: No resolver handled the action — HALT
+      throw new Error(
+        `[O-Lang SAFETY] No resolver handled action: "${action}". ` +
+        `Available resolvers: ${resolversToRun.map(r => r.resolverName || r.name || 'anonymous').join(', ')}. ` +
+        `Workflow execution halted.`
+      );
     };
 
     switch (stepType) {
@@ -426,14 +462,12 @@ class RuntimeAPI {
       }
 
       case 'evolve': {
-        // ✅ Handle in-workflow Evolve steps
         const { targetResolver, feedback } = step;
         
         if (this.verbose) {
           console.log(`🔄 Evolve step: ${targetResolver} with feedback: "${feedback}"`);
         }
         
-        // Basic evolution: record the request (free tier)
         const evolutionResult = {
           resolver: targetResolver,
           feedback: feedback,
@@ -442,12 +476,10 @@ class RuntimeAPI {
           workflow: this.context.workflow_name
         };
         
-        // ✅ Check for Advanced Evolution Service (paid tier)
-      // ✅ Check for Advanced Evolution Service (paid tier)
-     if (process.env.OLANG_EVOLUTION_API_KEY) {
-      evolutionResult.status = 'advanced_evolution_enabled';
-      evolutionResult.message = 'Advanced evolution service would process this request';
-    }
+        if (process.env.OLANG_EVOLUTION_API_KEY) {
+          evolutionResult.status = 'advanced_evolution_enabled';
+          evolutionResult.message = 'Advanced evolution service would process this request';
+        }
         
         if (step.saveAs) {
           this.context[step.saveAs] = evolutionResult;
@@ -463,7 +495,99 @@ class RuntimeAPI {
       }
 
       case 'parallel': {
-        await Promise.all(step.steps.map(s => this.executeStep(s, agentResolver)));
+        const { steps, timeout } = step;
+        
+        if (timeout !== undefined && timeout > 0) {
+          // Timed parallel execution
+          const timeoutPromise = new Promise(resolve => {
+            setTimeout(() => resolve({ timedOut: true }), timeout);
+          });
+          
+          const parallelPromise = Promise.all(
+            steps.map(s => this.executeStep(s, agentResolver))
+          ).then(() => ({ timedOut: false }));
+          
+          const result = await Promise.race([timeoutPromise, parallelPromise]);
+          this.context.timed_out = result.timedOut;
+          
+          if (result.timedOut) {
+            this.emit('parallel_timeout', { duration: timeout, steps: steps.length });
+            if (this.verbose) {
+              console.log(`⏰ Parallel execution timed out after ${timeout}ms`);
+            }
+          }
+        } else {
+          // Normal parallel execution (no timeout)
+          await Promise.all(steps.map(s => this.executeStep(s, agentResolver)));
+          this.context.timed_out = false;
+        }
+        break;
+      }
+
+      case 'escalation': {
+        const { levels } = step;
+        let finalResult = null;
+        let currentTimeout = 0;
+        let completedLevel = null;
+        
+        for (const level of levels) {
+          if (level.timeout === 0) {
+            // Immediate execution (no timeout)
+            const levelSteps = require('./parser').parseBlock(level.steps);
+            for (const levelStep of levelSteps) {
+              await this.executeStep(levelStep, agentResolver);
+            }
+            
+            // Check if the target variable was set in this level
+            // For now, we'll assume the last saveAs in the level is the result
+            if (levelSteps.length > 0) {
+              const lastStep = levelSteps[levelSteps.length - 1];
+              if (lastStep.saveAs && this.context[lastStep.saveAs] !== undefined) {
+                finalResult = this.context[lastStep.saveAs];
+                completedLevel = level.levelNumber;
+                break;
+              }
+            }
+          } else {
+            // Timed execution for this level
+            currentTimeout += level.timeout;
+            
+            const timeoutPromise = new Promise(resolve => {
+              setTimeout(() => resolve({ timedOut: true }), level.timeout);
+            });
+            
+            const levelPromise = (async () => {
+              const levelSteps = require('./parser').parseBlock(level.steps);
+              for (const levelStep of levelSteps) {
+                await this.executeStep(levelStep, agentResolver);
+              }
+              return { timedOut: false };
+            })();
+            
+            const result = await Promise.race([timeoutPromise, levelPromise]);
+            
+            if (!result.timedOut) {
+              // Level completed successfully
+              if (levelSteps && levelSteps.length > 0) {
+                const lastStep = levelSteps[levelSteps.length - 1];
+                if (lastStep.saveAs && this.context[lastStep.saveAs] !== undefined) {
+                  finalResult = this.context[lastStep.saveAs];
+                  completedLevel = level.levelNumber;
+                  break;
+                }
+              }
+            }
+            // If timed out, continue to next level
+          }
+        }
+        
+        // Set escalation status in context
+        this.context.escalation_completed = finalResult !== null;
+        this.context.timed_out = finalResult === null;
+        if (completedLevel !== null) {
+          this.context.escalation_level = completedLevel;
+        }
+        
         break;
       }
 
@@ -478,26 +602,87 @@ class RuntimeAPI {
       }
 
       case 'debrief': {
+        // ✅ SEMANTIC VALIDATION: Check symbols in message
+        if (step.message.includes('{')) {
+          const symbols = step.message.match(/\{([^\}]+)\}/g) || [];
+          for (const symbolMatch of symbols) {
+            const symbol = symbolMatch.replace(/[{}]/g, '');
+            this._requireSemantic(symbol, 'debrief');
+          }
+        }
         this.emit('debrief', { agent: step.agent, message: step.message });
         break;
       }
 
-      // ✅ File Persist step handler
-      case 'persist': {
-        const sourceValue = this.getNested(this.context, step.source);
-        if (sourceValue === undefined) {
-          this.addWarning(`Cannot persist undefined value from "${step.source}" to "${step.destination}"`);
+      // ✅ NEW: Prompt step handler
+      case 'prompt': {
+        if (this.verbose) {
+          console.log(`❓ Prompt: ${step.question}`);
+        }
+        // In non-interactive mode, leave as no-op
+        // (Could integrate with stdin or API in future)
+        break;
+      }
+
+      // ✅ NEW: Emit step handler with semantic validation
+      case 'emit': {
+        // ✅ SEMANTIC VALIDATION: Check all symbols in payload
+        const payloadTemplate = step.payload;
+        const symbols = [...new Set(payloadTemplate.match(/\{([^\}]+)\}/g) || [])];
+        
+        let shouldEmit = true;
+        for (const symbolMatch of symbols) {
+          const symbol = symbolMatch.replace(/[{}]/g, '');
+          if (!this._requireSemantic(symbol, 'emit')) {
+            shouldEmit = false;
+            // Continue to validate all symbols (for complete error reporting)
+          }
+        }
+        
+        if (!shouldEmit) {
+          if (this.verbose) {
+            console.log(`⏭️ Skipped emit due to missing semantic symbols`);
+          }
           break;
         }
+        
+        const payload = step.payload.replace(/\{([^\}]+)\}/g, (_, path) => {
+          const value = this.getNested(this.context, path.trim());
+          return value !== undefined ? String(value) : `{${path}}`;
+        });
+        
+        this.emit(step.event, { 
+          payload: payload,
+          workflow: this.context.workflow_name,
+          timestamp: new Date().toISOString()
+        });
+        
+        if (this.verbose) {
+          console.log(`📤 Emit event "${step.event}" with payload: ${payload}`);
+        }
+        break;
+      }
 
-        const outputPath = path.resolve(process.cwd(), step.destination);
+      // ✅ File Persist step handler with semantic validation
+      case 'persist': {
+        // ✅ SEMANTIC VALIDATION: Require symbol exists
+        if (!this._requireSemantic(step.variable, 'persist')) {
+          // Default policy: Skip persist (safe)
+          if (this.verbose) {
+            console.log(`⏭️ Skipped persist for undefined "${step.variable}"`);
+          }
+          break;
+        }
+        
+        const sourceValue = this.context[step.variable]; // Now guaranteed defined
+        const outputPath = path.resolve(process.cwd(), step.target);
         const outputDir = path.dirname(outputPath);
         if (!fs.existsSync(outputDir)) {
           fs.mkdirSync(outputDir, { recursive: true });
         }
 
         let content;
-        if (step.destination.endsWith('.json')) {
+        if (step.target.endsWith('.json')) {
           content = JSON.stringify(sourceValue, null, 2);
         } else {
           content = String(sourceValue);
@@ -506,23 +691,27 @@ class RuntimeAPI {
         fs.writeFileSync(outputPath, content, 'utf8');
 
         if (this.verbose) {
-          console.log(`💾 Persisted "${step.source}" to ${step.destination}`);
+          console.log(`💾 Persisted "${step.variable}" to ${step.target}`);
         }
         break;
       }
 
-      // ✅ NEW: Database persist handler
+      // ✅ NEW: Database persist handler with semantic validation
       case 'persist-db': {
         if (!this.dbClient) {
           this.addWarning(`DB persistence skipped (no DB configured). Set OLANG_DB_TYPE env var.`);
           break;
         }
 
-        const sourceValue = this.getNested(this.context, step.source);
-        if (sourceValue === undefined) {
-          this.addWarning(`Cannot persist undefined value from "${step.source}" to DB collection "${step.collection}"`);
+        // ✅ SEMANTIC VALIDATION: Require symbol exists
+        if (!this._requireSemantic(step.variable, 'persist-db')) {
+          if (this.verbose) {
+            console.log(`⏭️ Skipped DB persist for undefined "${step.variable}"`);
+          }
           break;
         }
+        
+        const sourceValue = this.context[step.variable]; // Now guaranteed defined
 
         try {
           switch (this.dbClient.type) {
@@ -563,39 +752,31 @@ class RuntimeAPI {
           }
           
           if (this.verbose) {
-            console.log(`🗄️  Persisted "${step.source}" to DB collection ${step.collection}`);
+            console.log(`🗄️  Persisted "${step.variable}" to DB collection ${step.collection}`);
           }
         } catch (e) {
-          this.addWarning(`DB persist failed for "${step.source}": ${e.message}`);
+          this.addWarning(`DB persist failed for "${step.variable}": ${e.message}`);
         }
         break;
       }
     }
 
-    // ✅ ADDITION 5 — Security Warning for External Resolvers
     if (this.verbose) {
-      for (const r of this.allowedResolvers) {
-        // Note: We can't easily check if resolvers are external here since we only have names
-        // This would need to be moved to where we have the actual resolver objects
-      }
       console.log(`\n[Step: ${step.type} | saveAs: ${step.saveAs || 'N/A'}]`);
       console.log(JSON.stringify(this.context, null, 2));
     }
   }
 
   async executeWorkflow(workflow, inputs, agentResolver) {
-    // Handle regular workflows only (Evolve is a step type now)
     if (workflow.type !== 'workflow') {
       throw new Error(`Unknown workflow type: ${workflow.type}`);
     }
 
-    // ✅ Inject workflow name into context
     this.context = { 
       ...inputs, 
       workflow_name: workflow.name 
     };
     
-    // ✅ Check generation constraint from Constraint: max_generations = X
     const currentGeneration = inputs.__generation || 1;
     if (workflow.maxGenerations !== null && currentGeneration > workflow.maxGenerations) {
       throw new Error(`Workflow generation ${currentGeneration} exceeds Constraint: max_generations = ${workflow.maxGenerations}`);
@@ -626,9 +807,13 @@ class RuntimeAPI {
       });
     }
 
+    // ✅ SEMANTIC VALIDATION: For return values
     const result = {};
     for (const key of workflow.returnValues) {
-      result[key] = this.getNested(this.context, key);
+      if (this._requireSemantic(key, 'return')) {
+        result[key] = this.context[key];
+      }
+      // Skip undefined return values (safe default)
     }
     return result;
   }