@o-lang/olang 1.1.8 → 1.2.1

package/{cli.js → cli/olang.js}

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
+
 const { Command } = require('commander');
-const { parse } = require('./src/parser');
-const { execute } = require('./src/runtime');
+const { parse } = require('../src/parser');
+const { execute } = require('../src/runtime');
 const fs = require('fs');
 const path = require('path');
+const { createRequire } = require('module');
 
-// === ADDED: Load package.json for version (1 line added) ===
-const pkg = require('./package.json');
+// === Load kernel package.json for version ===
+const pkg = require('../package.json');
 
 /**
  * Enforce .ol extension ONLY (CLI only)
@@ -21,21 +23,21 @@ function ensureOlExtension(filename) {
 }
 
 /**
- * Default mock resolver (for demo use)
+ * Default mock resolver (for demo / fallback)
  */
-async function defaultMockResolver(action, context) {
-  if (!action || typeof action !== 'string') return `[Unhandled: ${String(action)}]`;
+async function defaultMockResolver(action) {
+  if (!action || typeof action !== 'string') return undefined;
 
   if (action.startsWith('Search for ')) {
     return {
-      title: "HR Policy 2025",
-      text: "Employees are entitled to 20 days of paid leave per year.",
-      url: "mock://hr-policy"
+      title: 'HR Policy 2025',
+      text: 'Employees are entitled to 20 days of paid leave per year.',
+      url: 'mock://hr-policy'
     };
   }
 
   if (action.startsWith('Ask ')) {
-    return "✅ [Mock] Summarized for demonstration.";
+    return '✅ [Mock] Summarized for demonstration.';
   }
 
   if (action.startsWith('Notify ')) {
@@ -48,7 +50,7 @@ async function defaultMockResolver(action, context) {
     return 'Acknowledged';
   }
 
-  return `[Unhandled: ${action}]`;
+  return undefined;
 }
 defaultMockResolver.resolverName = 'defaultMockResolver';
 
@@ -67,15 +69,16 @@ async function builtInMathResolver(action, context) {
   if ((m = a.match(/^subtract\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] - +m[2];
   if ((m = a.match(/^multiply\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] * +m[2];
   if ((m = a.match(/^divide\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] / +m[2];
-  if ((m = a.match(/^sum\(\s*\[([^\]]+)\]\s*\)$/i)))
+  if ((m = a.match(/^sum\(\s*\[([^\]]+)\]\s*\)$/i))) {
     return m[1].split(',').map(Number).reduce((a, b) => a + b, 0);
+  }
 
   return undefined;
 }
 builtInMathResolver.resolverName = 'builtInMathResolver';
 
 /**
- * Resolver chaining
+ * Create resolver chain
  */
 function createResolverChain(resolvers, verbose = false) {
   const wrapped = async (action, context) => {
@@ -95,44 +98,59 @@ function createResolverChain(resolvers, verbose = false) {
     if (verbose) console.log(`⏭️ No resolver handled "${action}"`);
     return undefined;
   };
+
   wrapped._chain = resolvers;
   return wrapped;
 }
 
 /**
- * Load a single resolver
+ * Load a single resolver (CRITICAL FIX)
+ *
+ * Resolution order:
+ * 1. User project node_modules (npm install / npm link)
+ * 2. Relative/local path
+ * 3. Error with actionable message
  */
 function loadSingleResolver(specifier) {
   if (!specifier) throw new Error('Empty resolver specifier');
 
-  if (specifier.endsWith('.json')) {
-    const manifest = JSON.parse(fs.readFileSync(specifier, 'utf8'));
-    if (manifest.protocol?.startsWith('http')) {
-      const externalResolver = async () => undefined;
-      externalResolver.resolverName = manifest.name;
-      externalResolver.manifest = manifest;
-      console.log(`🌐 Loaded external resolver: ${manifest.name}`);
-      return externalResolver;
-    }
-  }
+  // Anchor resolution to the CALLING PROJECT, not the kernel
+  const projectRequire = createRequire(
+    path.join(process.cwd(), 'package.json')
+  );
 
   let resolver;
-  const pkgName = specifier.startsWith('.') || specifier.startsWith('/')
-    ? path.basename(specifier, path.extname(specifier))
-    : specifier.replace(/^@[^/]+\//, '');
+  let resolvedFrom = 'unknown';
 
   try {
-    resolver = require(specifier);
+    resolver = projectRequire(specifier);
+    resolvedFrom = 'project';
   } catch {
-    resolver = require(path.resolve(process.cwd(), specifier));
+    try {
+      resolver = require(path.resolve(process.cwd(), specifier));
+      resolvedFrom = 'local';
+    } catch {
+      throw new Error(
+        `Resolver "${specifier}" not found.\n` +
+        `Install it in your project with:\n` +
+        `  npm install ${specifier}\n` +
+        `or link it with:\n` +
+        `  npm link ${specifier}`
+      );
+    }
   }
 
   if (typeof resolver !== 'function') {
-    throw new Error(`Resolver must export a function`);
+    throw new Error(`Resolver "${specifier}" must export a function`);
   }
 
-  resolver.resolverName ||= pkgName;
-  console.log(`📦 Loaded resolver: ${resolver.resolverName}`);
+  const name =
+    resolver.resolverName ||
+    specifier.replace(/^@[^/]+\//, '');
+
+  resolver.resolverName = name;
+
+  console.log(`📦 Loaded resolver: ${name} (${resolvedFrom})`);
   return resolver;
 }
 
@@ -142,14 +160,21 @@ function loadSingleResolver(specifier) {
 function loadResolverChain(specifiers, verbose, allowed) {
   const resolvers = [];
 
-  if (allowed.has('builtInMathResolver')) resolvers.push(builtInMathResolver);
+  if (allowed.has('builtInMathResolver')) {
+    resolvers.push(builtInMathResolver);
+  }
 
   for (const r of specifiers.map(loadSingleResolver)) {
-    if (allowed.has(r.resolverName)) resolvers.push(r);
-    else if (verbose) console.warn(`⚠️ Skipped disallowed resolver: ${r.resolverName}`);
+    if (allowed.has(r.resolverName)) {
+      resolvers.push(r);
+    } else if (verbose) {
+      console.warn(`⚠️ Skipped disallowed resolver: ${r.resolverName}`);
+    }
   }
 
-  if (allowed.has('defaultMockResolver')) resolvers.push(defaultMockResolver);
+  if (allowed.has('defaultMockResolver')) {
+    resolvers.push(defaultMockResolver);
+  }
 
   return createResolverChain(resolvers, verbose);
 }
@@ -159,10 +184,8 @@ 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')
   .command('run <file>')
@@ -175,17 +198,30 @@ program
   .option('-v, --verbose')
   .action(async (file, options) => {
     ensureOlExtension(file);
+
     const workflowSource = fs.readFileSync(file, 'utf8');
     const workflow = parse(workflowSource, file);
 
     const allowed = new Set(workflow.allowedResolvers);
-    const resolver = loadResolverChain(options.resolver, options.verbose, allowed);
+    const resolver = loadResolverChain(
+      options.resolver,
+      options.verbose,
+      allowed
+    );
+
+    const result = await execute(
+      workflow,
+      options.input,
+      resolver,
+      options.verbose
+    );
 
-    const result = await execute(workflow, options.input, resolver, options.verbose);
     console.log(JSON.stringify(result, null, 2));
   });
 
-// === SERVER COMMAND (✅ PROPER INTEGRATION) ===
+/**
+ * SERVER MODE
+ */
 program
   .command('server')
   .description('Start O-lang kernel in HTTP server mode')
@@ -204,10 +240,6 @@ program
       try {
         const { workflowSource, inputs = {}, resolvers = [], verbose = false } = req.body;
 
-        if (typeof workflowSource !== 'string') {
-          return reply.status(400).send({ error: 'workflowSource must be a string' });
-        }
-
         const workflow = parse(workflowSource, 'remote.ol');
         const allowed = new Set(workflow.allowedResolvers);
         const resolver = loadResolverChain(resolvers, verbose, allowed);
@@ -219,17 +251,12 @@ program
       }
     });
 
-    const PORT = parseInt(options.port, 10);
-    const HOST = options.host;
+    await fastify.listen({
+      port: Number(options.port),
+      host: options.host
+    });
 
-    try {
-      await fastify.listen({ port: PORT, host: HOST });
-      console.log(`✅ O-Lang Kernel running on http://${HOST}:${PORT}`);
-    } catch (err) {
-      console.error('❌ Failed to start server:', err);
-      process.exit(1);
-    }
+    console.log(`✅ O-Lang Kernel running on http://${options.host}:${options.port}`);
   });
 
-// === PARSE CLI ===
 program.parse(process.argv);

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@o-lang/olang",
-  "version": "1.1.8",
+  "version": "1.2.1",
   "author": "Olalekan Ogundipe <info@workfily.com>",
   "description": "O-Lang: A governance language for user-directed, rule-enforced agent workflows",
   "main": "./src/index.js",
-  "bin": {
-    "olang": "./cli.js"
-  },
+"bin": {
+  "olang": "./cli/olang.js"
+},
   "files": [
     "cli.js",
     "src/"
@@ -15,8 +15,10 @@
     "start": "node cli.js"
   },
   "dependencies": {
-    "commander": "^12.0.0",
-    "dotenv": "^17.2.3"
+   "commander": "^12.0.0",
+  "dotenv": "^17.2.3",
+  "lodash": "^4.17.21",
+  "fastify": "^4.26.0"
   },
   "keywords": [
     "agent",

package/src/{parser.js → parser/index.js}

@@ -1,6 +1,6 @@
 const fs = require('fs');
 
-// ✅ Symbol normalization helper (backward compatible)
+// ✅ Symbol normalization helper (backward compatible - SAFE to keep)
 function normalizeSymbol(raw) {
   if (!raw) return raw;
   // Take only the first word (stop at first whitespace)
@@ -8,17 +8,7 @@ function normalizeSymbol(raw) {
   return raw.split(/\s+/)[0].replace(/[^\w$]/g, '');
 }
 
-// ✅ ACTION NORMALIZATION HELPER (NEW)
-// Strip decorative prefixes for consistent resolver matching
-function normalizeAction(actionRaw) {
-  if (typeof actionRaw !== 'string') return actionRaw;
-  
-  // Strip optional decorative prefixes (case-insensitive)
-  // Preserves semantic prefixes: "Ask", "Use" (handled as separate step types)
-  return actionRaw
-    .replace(/^(Action|Do|Perform|Execute|Run|Call|Invoke)\s+/i, '')
-    .trim();
-}
+// ❌ REMOVED: normalizeAction() function (was stripping "Action" prefix → broke resolver matching)
 
 function parse(content, filename = '<unknown>') {
   if (typeof content === 'string') {
@@ -269,27 +259,24 @@ function parseWorkflowLines(lines, filename) {
       }
     }
 
-    // Step declaration - ✅ NORMALIZE ACTION HERE
+    // Step declaration - ✅ PRESERVE ACTION EXACTLY (NO NORMALIZATION)
     const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
     if (stepMatch) {
       flushCurrentStep(); // ✅ Flush previous step
       const stepNumber = parseInt(stepMatch[1], 10);
-      let stepContent = stepMatch[2].trim();
-      
-      // ✅ CRITICAL: Normalize action syntax BEFORE storing in AST
-      stepContent = normalizeAction(stepContent);
+      const stepContent = stepMatch[2].trim();  // ← PRESERVED EXACTLY (no normalizeAction)
       
       currentStep = {
         type: 'action',
         stepNumber: stepNumber,
-        actionRaw: stepContent,  // ← CLEAN, normalized action string
+        actionRaw: stepContent,  // ← CRITICAL: No normalization here
         saveAs: null,
         constraints: {}
       };
       continue;
     }
 
-    // Save as - ✅ Apply normalization
+    // Save as - ✅ Apply normalization (safe for symbol names)
     const saveMatch = line.match(/^Save as\s+(.+)$/i);
     if (saveMatch && currentStep) {
       currentStep.saveAs = normalizeSymbol(saveMatch[1].trim());
@@ -383,13 +370,13 @@ function parseWorkflowLines(lines, filename) {
       continue;
     }
 
-    // Use (for Notify-like actions) - ✅ NORMALIZE TOOL HERE
+    // Use (for Notify-like actions) - ✅ PRESERVE TOOL EXACTLY (NO NORMALIZATION)
     const useMatch = line.match(/^Use\s+(.+)$/i);
     if (useMatch) {
       flushCurrentStep();
       workflow.steps.push({
         type: 'use',
-        tool: normalizeAction(useMatch[1].trim()),  // ✅ Normalize tool name
+        tool: useMatch[1].trim(),  // ← PRESERVED EXACTLY (no normalizeAction)
         stepNumber: workflow.steps.length + 1,
         saveAs: null,
         constraints: {}
@@ -397,13 +384,13 @@ function parseWorkflowLines(lines, filename) {
       continue;
     }
 
-    // Ask (for Notify/resolver calls) - ✅ NORMALIZE TARGET HERE
+    // Ask (for Notify/resolver calls) - ✅ PRESERVE TARGET EXACTLY (NO NORMALIZATION)
     const askMatch = line.match(/^Ask\s+(.+)$/i);
     if (askMatch) {
       flushCurrentStep();
       workflow.steps.push({
         type: 'ask',
-        target: normalizeAction(askMatch[1].trim()),  // ✅ Normalize target
+        target: askMatch[1].trim(),  // ← PRESERVED EXACTLY (no normalizeAction)
         stepNumber: workflow.steps.length + 1,
         saveAs: null,
         constraints: {}
@@ -425,12 +412,12 @@ function parseWorkflowLines(lines, filename) {
         currentStep = {
           type: 'action',
           stepNumber: workflow.steps.length + 1,
-          actionRaw: normalizeAction(line),  // ✅ Normalize fallback actions too
+          actionRaw: line,  // ← PRESERVED EXACTLY (no normalizeAction)
           saveAs: null,
           constraints: {}
         };
       } else {
-        currentStep.actionRaw += ' ' + normalizeAction(line);
+        currentStep.actionRaw += ' ' + line;  // ← PRESERVED EXACTLY (no normalizeAction)
       }
     }
   }
@@ -466,7 +453,7 @@ function parseWorkflowLines(lines, filename) {
   return workflow;
 }
 
-// Parses blocks (for parallel, if, escalation levels) - ✅ UPDATED FOR NORMALIZATION
+// Parses blocks (for parallel, if, escalation levels) - ✅ PRESERVE ALL FUNCTIONALITY
 function parseBlock(lines) {
   const steps = [];
   let current = null;
@@ -482,20 +469,17 @@ function parseBlock(lines) {
     line = line.trim();
     if (!line || line.startsWith('#')) continue;
 
-    // Step declaration in block - ✅ NORMALIZE ACTION HERE
+    // Step declaration in block - ✅ PRESERVE ACTION EXACTLY (NO NORMALIZATION)
     const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
     if (stepMatch) {
       flush();
       const stepNumber = parseInt(stepMatch[1], 10);
-      let stepContent = stepMatch[2].trim();
-      
-      // ✅ CRITICAL: Normalize action syntax in blocks too
-      stepContent = normalizeAction(stepContent);
+      const stepContent = stepMatch[2].trim();  // ← PRESERVED EXACTLY
       
       current = {
         type: 'action',
         stepNumber: stepNumber,
-        actionRaw: stepContent,
+        actionRaw: stepContent,  // ← CRITICAL: No normalization
         saveAs: null,
         constraints: {}
       };
@@ -545,26 +529,26 @@ function parseBlock(lines) {
       continue;
     }
 
-    // Use in block - ✅ NORMALIZE TOOL HERE
+    // Use in block - ✅ PRESERVE TOOL EXACTLY (NO NORMALIZATION)
     const useMatch = line.match(/^Use\s+(.+)$/i);
     if (useMatch) {
       flush();
       steps.push({ 
         type: 'use', 
-        tool: normalizeAction(useMatch[1].trim()),  // ✅ Normalize
+        tool: useMatch[1].trim(),  // ← PRESERVED EXACTLY
         saveAs: null, 
         constraints: {} 
       });
       continue;
     }
 
-    // Ask in block - ✅ NORMALIZE TARGET HERE
+    // Ask in block - ✅ PRESERVE TARGET EXACTLY (NO NORMALIZATION)
     const askMatch = line.match(/^Ask\s+(.+)$/i);
     if (askMatch) {
       flush();
       steps.push({ 
         type: 'ask', 
-        target: normalizeAction(askMatch[1].trim()),  // ✅ Normalize
+        target: askMatch[1].trim(),  // ← PRESERVED EXACTLY
         saveAs: null, 
         constraints: {} 
       });
@@ -593,7 +577,7 @@ function parseBlock(lines) {
 
     // Fallback
     if (current) {
-      current.actionRaw += ' ' + normalizeAction(line);
+      current.actionRaw += ' ' + line;  // ← PRESERVED EXACTLY (no normalizeAction)
     }
   }
 
@@ -625,4 +609,4 @@ function validate(workflow) {
   return errors;
 }
 
-module.exports = { parse, parseFromFile, parseLines, validate, normalizeAction };
+module.exports = { parse, parseFromFile, parseLines, validate };

package/src/{runtime.js → runtime/RuntimeAPI.js}

@@ -1,8 +1,10 @@
+// src/runtime/RuntimeAPI.js
 const fs = require('fs');
 const path = require('path');
 
 class RuntimeAPI {
   constructor({ verbose = false } = {}) {
+   console.log('✅ KERNEL FIX VERIFIED - Unwrapping active');
     this.context = {};
     this.resources = {};
     this.agentMap = {};
@@ -331,7 +333,19 @@ class RuntimeAPI {
   }
 
   // -----------------------------
-  // Step execution
+  // ✅ CRITICAL FIX: Resolver output unwrapping helper
+  // -----------------------------
+  _unwrapResolverResult(result) {
+    // Standard O-Lang resolver contract: { output: {...} } or { error: "..." }
+    if (result && typeof result === 'object' && 'output' in result && result.output !== undefined) {
+      return result.output;
+    }
+    // Legacy resolvers might return raw values
+    return result;
+  }
+
+  // -----------------------------
+  // Step execution (WHERE RESOLVERS ARE INVOKED)
   // -----------------------------
   async executeStep(step, agentResolver) {
     const stepType = step.type;
@@ -420,8 +434,11 @@ class RuntimeAPI {
 
           // ✅ ACCEPT valid result immediately (non-null/non-undefined)
           if (result !== undefined && result !== null) {
+            // ✅ CRITICAL FIX: Save raw result for debugging (like __resolver_0)
             this.context[`__resolver_${idx}`] = result;
-            return result;
+            
+            // ✅ UNWRAP before returning to workflow logic
+            return this._unwrapResolverResult(result);
           }
 
           // ⚪ Resolver skipped this action (normal behavior)
@@ -521,7 +538,7 @@ class RuntimeAPI {
         }
       });
       if (!hasDocs) {
-        errorMessage += `    → Visit https://www.npmjs.com/search?q=%40o-lang for resolver packages\n`;  // ✅ FIXED
+        errorMessage += `    → Visit https://www.npmjs.com/search?q=%40o-lang   for resolver packages\n`;  // ✅ FIXED
       }
 
       errorMessage += `\n🛑 Workflow halted to prevent unsafe data propagation to LLMs.`;
@@ -554,24 +571,38 @@ class RuntimeAPI {
           }
         }
 
-        const res = await runResolvers(action);
-        if (step.saveAs) this.context[step.saveAs] = res;
+        // ✅ CRITICAL FIX: UNWRAP resolver result BEFORE saving to context
+        const rawResult = await runResolvers(action);
+        const unwrapped = this._unwrapResolverResult(rawResult);
+        
+        if (step.saveAs) {
+          this.context[step.saveAs] = unwrapped;
+        }
         break;
       }
 
       case 'use': {
         // ✅ SAFE INTERPOLATION for tool name
         const tool = this._safeInterpolate(step.tool, this.context, 'tool name');
-        const res = await runResolvers(`Use ${tool}`);
-        if (step.saveAs) this.context[step.saveAs] = res;
+        const rawResult = await runResolvers(`Use ${tool}`);
+        const unwrapped = this._unwrapResolverResult(rawResult);
+        
+        if (step.saveAs) this.context[step.saveAs] = unwrapped;
         break;
       }
 
       case 'ask': {
-        // ✅ SAFE INTERPOLATION: CRITICAL for LLM prompts (hallucination prevention)
         const target = this._safeInterpolate(step.target, this.context, 'LLM prompt');
-        const res = await runResolvers(`Ask ${target}`);
-        if (step.saveAs) this.context[step.saveAs] = res;
+        
+        // ✅ ADD THIS CHECK
+        if (/{[^}]+}/.test(target)) {
+          throw new Error(`[O-Lang] Unresolved variables in prompt: "${target}"`);
+        }
+        
+        const rawResult = await runResolvers(`Ask ${target}`);
+        const unwrapped = this._unwrapResolverResult(rawResult);
+        
+        if (step.saveAs) this.context[step.saveAs] = unwrapped;
         break;
       }
 
@@ -842,7 +873,7 @@ class RuntimeAPI {
               const db = this.dbClient.client.db(process.env.DB_NAME || 'olang');
               await db.collection(step.collection).insertOne({
                 workflow_name: this.context.workflow_name || 'unknown',
-                data: sourceValue,
+                data: sourceValue,  // ✅ FIXED: Added property name "data" (was broken syntax)
                 created_at: new Date()
               });
               break;
@@ -915,7 +946,7 @@ class RuntimeAPI {
       });
     }
 
-    // ✅ SEMANTIC VALIDATION: For return values..
+    // ✅ SEMANTIC VALIDATION: For return values
     const result = {};
     for (const key of workflow.returnValues) {
       if (this._requireSemantic(key, 'return')) {

package/src/runtime/index.js

@@ -0,0 +1,4 @@
+// src/runtime/index.js
+const { RuntimeAPI, execute } = require('./RuntimeAPI');
+
+module.exports = { execute, RuntimeAPI };

package/src/runtime/math.js

@@ -0,0 +1,61 @@
+function getNested(obj, path) {
+  if (!path) return undefined;
+  return path.split('.').reduce((o, k) =>
+    o && o[k] !== undefined ? o[k] : undefined, obj);
+}
+
+const mathFunctions = {
+  add: (a, b) => a + b,
+  subtract: (a, b) => a - b,
+  multiply: (a, b) => a * b,
+  divide: (a, b) => a / b,
+  equals: (a, b) => a === b,
+  greater: (a, b) => a > b,
+  less: (a, b) => a < b,
+  sum: arr => arr.reduce((a, v) => a + v, 0),
+  avg: arr => arr.reduce((a, v) => a + v, 0) / arr.length,
+  min: arr => Math.min(...arr),
+  max: arr => Math.max(...arr),
+  increment: a => a + 1,
+  decrement: a => a - 1,
+  round: Math.round,
+  floor: Math.floor,
+  ceil: Math.ceil,
+  abs: Math.abs
+};
+
+function evaluateMath(expr, context, addWarning) {
+  expr = expr.replace(/\{([^\}]+)\}/g, (_, p) => {
+    const v = getNested(context, p.trim());
+    return v !== undefined ? v : 0;
+  });
+
+  try {
+    const fn = new Function(
+      ...Object.keys(mathFunctions),
+      `return ${expr};`
+    );
+    return fn(...Object.values(mathFunctions));
+  } catch (e) {
+    addWarning?.(`Failed to evaluate math "${expr}": ${e.message}`);
+    return 0;
+  }
+}
+
+function evaluateCondition(cond, ctx) {
+  cond = cond.trim();
+  const eq = cond.match(/^\{(.+)\}\s+equals\s+"(.*)"$/);
+  if (eq) return getNested(ctx, eq[1]) == eq[2];
+  const gt = cond.match(/^\{(.+)\}\s+greater than\s+(\d+\.?\d*)$/);
+  if (gt) return +getNested(ctx, gt[1]) > +gt[2];
+  const lt = cond.match(/^\{(.+)\}\s+less than\s+(\d+\.?\d*)$/);
+  if (lt) return +getNested(ctx, lt[1]) < +lt[2];
+  return Boolean(getNested(ctx, cond.replace(/[{}]/g, '')));
+}
+
+module.exports = {
+  getNested,
+  mathFunctions,
+  evaluateMath,
+  evaluateCondition
+};

package/src/runtime/resolverRunner.js

@@ -0,0 +1,267 @@
+// src/runtime/resolverRunner.js
+const path = require('path');
+
+class ResolverRunner {
+  constructor({ verbose = false, resolvers = [] }) {
+    this.verbose = verbose;
+    this.resolvers = resolvers;
+  }
+
+  /**
+   * Parse action string into structured parameters.
+   * Handles BOTH quoted and unquoted values:
+   *   "bank-account-lookup customer_id=12345 db_path=bank.db"
+   *   "bank-account-lookup customer_id=\"12345\" db_path=\"bank.db\""
+   * 
+   * @param {string} actionStr - Raw action string from workflow step
+   * @returns {Object|null} Parsed action with resolverName, params[], namedParams{}, and raw string
+   */
+  _parseAction(actionStr) {
+    if (typeof actionStr !== 'string' || !actionStr.trim()) return null;
+
+    // Normalize: Remove leading "Action"/"Ask" keywords for parsing
+    let normalized = actionStr.trim();
+    const actionMatch = normalized.match(/^(Action|Ask)\s+(.+)/i);
+    if (actionMatch) {
+      normalized = actionMatch[2].trim();
+    }
+
+    // Extract resolver name (first word)
+    const firstSpace = normalized.indexOf(' ');
+    const resolverName = firstSpace > 0 
+      ? normalized.substring(0, firstSpace).toLowerCase()
+      : normalized.toLowerCase();
+
+    // Extract key=value pairs (handles quoted/unquoted values)
+    const namedParams = {};
+    const paramRegex = /(\w+)=(?:"([^"]*)"|(\S+))/g;
+    let match;
+    while ((match = paramRegex.exec(normalized)) !== null) {
+      const [, key, quotedVal, unquotedVal] = match;
+      namedParams[key] = quotedVal || unquotedVal;
+    }
+
+    // For "Ask llm-groq \"prompt\"" style - extract the quoted prompt as first param
+    const askMatch = normalized.match(/^(\S+)\s+"([^"]+)"$/);
+    if (askMatch && !Object.keys(namedParams).length) {
+      namedParams.prompt = askMatch[2];
+    }
+
+    // Build positional params array (order matters for legacy resolvers)
+    const params = Object.values(namedParams);
+
+    return {
+      resolverName,
+      params,
+      namedParams,
+      raw: actionStr,
+      normalized
+    };
+  }
+
+  /**
+   * Used ONLY for logging / routing insight
+   */
+  normalizeAction(action) {
+    const trimmed = action.trim();
+    if (/^Action\s+/i.test(trimmed)) {
+      return trimmed.replace(/^Action\s+/i, '');
+    }
+    if (/^Ask\s+/i.test(trimmed)) {
+      return trimmed.replace(/^Ask\s+/i, '');
+    }
+    return trimmed;
+  }
+
+  /**
+   * Resolve placeholders {var} in text using context values
+   */
+  resolvePlaceholders(text, context) {
+    return text.replace(/{([^}]+)}/g, (_, expr) => {
+      const value = expr
+        .trim()
+        .split('.')
+        .reduce((acc, key) => acc?.[key], context);
+      
+      if (value === undefined) {
+        throw new Error(
+          `[O-Lang SAFETY] Unresolved placeholder at runtime: {${expr}}`
+        );
+      }
+      
+      // 🔒 SAFETY: Block object/array interpolation into strings
+      if (value !== null && typeof value === 'object') {
+        const type = Array.isArray(value) ? 'array' : 'object';
+        throw new Error(
+          `[O-Lang SAFETY] Cannot interpolate ${type} "{${expr}}" into action string.\n` +
+          `  → Use dot notation: "{${expr}.field}" (e.g., {account_info.balance})`
+        );
+      }
+      
+      return String(value);
+    });
+  }
+
+  /**
+   * Execute workflow plan with context mediation
+   */
+  async execute({ plan, context }) {
+    if (this.verbose) {
+      console.log('[ResolverRunner] execute called with steps:', plan.steps.length);
+    }
+
+    for (let i = 0; i < plan.steps.length; i++) {
+      const step = plan.steps[i];
+      
+      if (!step.actionRaw) {
+        throw new Error('[O-Lang SAFETY] Step missing actionRaw');
+      }
+
+      // ✅ Resolve placeholders JUST IN TIME (after semantic validation)
+      const resolvedAction = this.resolvePlaceholders(step.actionRaw, context);
+      const normalized = this.normalizeAction(resolvedAction);
+
+      if (this.verbose) {
+        console.log(`\n[Step ${i + 1}] Raw action: "${step.actionRaw}"`);
+        console.log(`[Step ${i + 1}] Resolved:   "${resolvedAction}"`);
+      }
+
+      // ✅ PARSE ACTION BEFORE RESOLVER INVOCATION (critical fix)
+      const parsed = this._parseAction(resolvedAction);
+      
+      if (this.verbose && parsed) {
+        console.log(`[Step ${i + 1}] Parsed resolver: "${parsed.resolverName}"`);
+        console.log(`[Step ${i + 1}] Parsed params:`, parsed.namedParams);
+      }
+
+      let handled = false;
+      let resolverAttempts = [];
+
+      for (const resolver of this.resolvers) {
+        const resolverName = resolver?.resolverName?.toLowerCase() || 'unknown';
+        let result;
+        let invocationMethod = 'unknown';
+
+        try {
+          // ✅ STRATEGY 1: If resolver name matches parsed action → try POSITIONAL PARAMS (backward compatible)
+          if (parsed && resolverName === parsed.resolverName) {
+            try {
+              // Call with native params: resolver(customer_id, db_path, context)
+              result = await resolver(...parsed.params, context);
+              invocationMethod = 'positional_params';
+              
+              if (this.verbose) {
+                console.log(`[ResolverRunner] ✓ Invoked "${resolverName}" via positional params`);
+              }
+            } catch (e) {
+              // If positional params fail, fall through to raw string invocation below
+              if (this.verbose) {
+                console.log(`[ResolverRunner] ✗ Positional params failed for "${resolverName}", trying raw string...`);
+              }
+            }
+          }
+
+          // ✅ STRATEGY 2: If not handled yet → try RAW STRING INVOCATION (for generic/new-style resolvers)
+          if (result === undefined) {
+            result = await resolver(resolvedAction, context);
+            invocationMethod = 'raw_string';
+            
+            if (this.verbose && result !== undefined) {
+              console.log(`[ResolverRunner] ✓ Invoked "${resolverName}" via raw string`);
+            }
+          }
+
+          // ✅ ACCEPT valid result (non-undefined)
+          if (result !== undefined) {
+            handled = true;
+            
+            // Handle resolver error contract
+            if (result?.error) {
+              // Parse structured error if JSON string
+              let errorMsg = result.error;
+              try {
+                const errObj = JSON.parse(result.error);
+                errorMsg = `[${errObj.code}] ${errObj.message || errObj.error}`;
+              } catch (e) {
+                // Not JSON - use as-is
+              }
+              
+              throw new Error(`[Resolver Error] ${resolverName}: ${errorMsg}`);
+            }
+
+            // ✅ CRITICAL FIX: UNWRAP output BEFORE saving to context
+            const valueToSave = result?.output !== undefined ? result.output : result;
+            
+            // Save to context if requested
+            if (valueToSave !== undefined && step.saveAs) {
+              context[step.saveAs] = valueToSave;
+              
+              if (this.verbose) {
+                console.log(`[Step ${i + 1}] Output saved to context.${step.saveAs}:`, valueToSave);
+              }
+            }
+
+            resolverAttempts.push({
+              name: resolverName,
+              status: 'success',
+              method: invocationMethod
+            });
+            break;
+          } else {
+            resolverAttempts.push({
+              name: resolverName,
+              status: 'skipped',
+              reason: 'returned undefined'
+            });
+          }
+
+        } catch (e) {
+          resolverAttempts.push({
+            name: resolverName,
+            status: 'failed',
+            error: e.message || String(e)
+          });
+          
+          if (this.verbose) {
+            console.warn(`[ResolverRunner] Resolver "${resolverName}" failed:`, e.message || e);
+          }
+          // Continue to next resolver in chain
+        }
+      }
+
+      // ✅ SAFETY: No resolver handled this action → halt workflow
+      if (!handled) {
+        let errorMessage = `[O-Lang SAFETY] No resolver handled action: "${resolvedAction}"\n\n`;
+        errorMessage += `Attempted resolvers:\n`;
+
+        resolverAttempts.forEach((attempt, idx) => {
+          const namePad = attempt.name.padEnd(30);
+          if (attempt.status === 'skipped') {
+            errorMessage += `  ${idx + 1}. ${namePad} → SKIPPED (returned undefined)\n`;
+          } else if (attempt.status === 'failed') {
+            errorMessage += `  ${idx + 1}. ${namePad} → FAILED\n`;
+            errorMessage += `     Error: ${attempt.error.substring(0, 80)}\n`;
+          } else {
+            errorMessage += `  ${idx + 1}. ${namePad} → ${attempt.status.toUpperCase()} (${attempt.method})\n`;
+          }
+        });
+
+        errorMessage += `\n💡 How to fix:\n`;
+        errorMessage += `  • Verify resolver is loaded with correct name ("${parsed?.resolverName || 'unknown'}")\n`;
+        errorMessage += `  • Ensure resolver package is installed and registered with kernel\n`;
+        errorMessage += `  • Check resolver signature matches kernel expectations:\n`;
+        errorMessage += `      → Legacy: resolver(param1, param2, context)\n`;
+        errorMessage += `      → Modern: resolver(actionString, context)\n`;
+        errorMessage += `\n🛑 Workflow halted to prevent unsafe data propagation.`;
+
+        throw new Error(errorMessage);
+      }
+    }
+
+    if (this.verbose) {
+      console.log('\n[ResolverRunner] All steps executed successfully');
+    }
+  }
+}
+
+module.exports = ResolverRunner;

package/src/runtime/semantic.js

@@ -0,0 +1,36 @@
+// src/runtime/semantic.js
+const { parse } = require('../parser');
+
+class SemanticEngine {
+  constructor(options = {}) {
+    this.verbose = options.verbose || false;
+  }
+
+  analyze(workflowSource) {
+    let workflowPlan;
+
+    if (typeof workflowSource === 'string') {
+      if (this.verbose) console.log('[semantic] Parsing workflow string...');
+      workflowPlan = parse(workflowSource); // always parse string to workflow object
+    } else if (typeof workflowSource === 'object' && workflowSource !== null) {
+      workflowPlan = workflowSource;
+      // Ensure steps array exists
+      if (!Array.isArray(workflowPlan.steps)) workflowPlan.steps = [];
+    } else {
+      throw new Error('[semantic] Invalid workflow input');
+    }
+
+    // Ensure safe defaults
+    if (!workflowPlan.steps) workflowPlan.steps = [];
+    if (!workflowPlan.allowedResolvers) workflowPlan.allowedResolvers = [];
+    if (!workflowPlan.returnValues) workflowPlan.returnValues = [];
+
+    if (this.verbose) {
+      console.log(`[semantic] Workflow "${workflowPlan.name || '<unknown>'}" analyzed: ${workflowPlan.steps.length} steps`);
+    }
+
+    return workflowPlan;
+  }
+}
+
+module.exports = SemanticEngine;

package/src/runtime/transport/http.js

@@ -0,0 +1,62 @@
+// src/runtime/transport/http.js
+
+/**
+ * Existing function — KEPT AS-IS
+ * Backward compatible
+ */
+async function callExternalResolver(resolver, action, context) {
+  const { endpoint, timeout_ms = 30000 } = resolver.manifest;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout_ms);
+
+  try {
+    const res = await fetch(`${endpoint}/resolve`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        action,
+        context,
+        resolver: resolver.resolverName,
+        workflow: context.workflow_name,
+        timestamp: new Date().toISOString()
+      }),
+      signal: controller.signal
+    });
+
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+
+    const json = await res.json();
+    if (json?.error) throw new Error(json.error.message);
+
+    return json.result;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * ✅ NEW: Class wrapper expected by RuntimeAPI
+ */
+class HttpTransport {
+  constructor({ verbose = false } = {}) {
+    this.verbose = verbose;
+  }
+
+  async call(resolver, action, context) {
+    if (this.verbose) {
+      console.log(
+        `[transport:http] calling external resolver "${resolver.resolverName}"`
+      );
+    }
+    return callExternalResolver(resolver, action, context);
+  }
+}
+
+/**
+ * ✅ EXPORTS
+ * - default export: class (for RuntimeAPI)
+ * - named export: function (for existing code)
+ */
+module.exports = HttpTransport;
+module.exports.callExternalResolver = callExternalResolver;