@o-lang/olang 1.1.9 → 1.2.2

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,22 +1,25 @@
 {
   "name": "@o-lang/olang",
-  "version": "1.1.9",
+  "version": "1.2.2",
   "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"
+    "olang": "./cli/olang.js"
   },
   "files": [
     "cli.js",
     "src/"
   ],
   "scripts": {
-    "start": "node cli.js"
+    "start": "node cli.js",
+    "test": "jest"
   },
   "dependencies": {
     "commander": "^12.0.0",
-    "dotenv": "^17.2.3"
+    "dotenv": "^17.2.3",
+    "fastify": "^4.26.0",
+    "lodash": "^4.17.21"
   },
   "keywords": [
     "agent",
@@ -35,5 +38,8 @@
   "homepage": "https://github.com/O-Lang-Central/olang-kernel",
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "jest": "^30.2.0"
   }
 }

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.`;
@@ -535,43 +552,83 @@ class RuntimeAPI {
         break;
       }
 
-      case 'action': {
-        // ✅ SAFE INTERPOLATION: Block object→string coercion BEFORE resolver invocation
-        const action = this._safeInterpolate(step.actionRaw, this.context, 'action step');
+     case 'action': {
+  // 🔒 Interpolate workflow variables first
+  let action = this._safeInterpolate(
+    step.actionRaw,
+    this.context,
+    'action step'
+  );
 
-        const mathCall = action.match(/^(add|subtract|multiply|divide|sum|avg|min|max|round|floor|ceil|abs)\((.*)\)$/i);
-        if (mathCall) {
-          const fn = mathCall[1].toLowerCase();
-          const args = mathCall[2].split(',').map(s => {
-            s = s.trim();
-            if (!isNaN(s)) return parseFloat(s);
-            return this.getNested(this.context, s.replace(/^\{|\}$/g, ''));
-          });
-          if (this.mathFunctions[fn]) {
-            const value = this.mathFunctions[fn](...args);
-            if (step.saveAs) this.context[step.saveAs] = value;
-            break;
-          }
-        }
+  // ✅ CANONICALIZATION: Normalize DSL verbs → runtime Action
+  if (action.startsWith('Ask ')) {
+    action = 'Action ' + action.slice(4);
+  } else if (action.startsWith('Use ')) {
+    action = 'Action ' + action.slice(4);
+  }
+
+  // ❌ Reject non-canonical runtime actions early
+  if (!action.startsWith('Action ')) {
+    throw new Error(
+      `[O-Lang SAFETY] Non-canonical action received: "${action}"\n` +
+      `  → Expected format: Action <resolver> <args>\n` +
+      `  → This indicates a kernel or workflow authoring error.`
+    );
+  }
+
+  // ✅ Inline math support (language feature)
+  const mathCall = action.match(
+    /^(add|subtract|multiply|divide|sum|avg|min|max|round|floor|ceil|abs)\((.*)\)$/i
+  );
+
+  if (mathCall) {
+    const fn = mathCall[1].toLowerCase();
+    const args = mathCall[2].split(',').map(s => {
+      s = s.trim();
+      if (!isNaN(s)) return parseFloat(s);
+      return this.getNested(this.context, s.replace(/^\{|\}$/g, ''));
+    });
+
+    if (this.mathFunctions[fn]) {
+      const value = this.mathFunctions[fn](...args);
+      if (step.saveAs) this.context[step.saveAs] = value;
+      break;
+    }
+  }
+
+  // ✅ Resolver dispatch receives ONLY canonical actions
+  const rawResult = await runResolvers(action);
+  const unwrapped = this._unwrapResolverResult(rawResult);
+
+  if (step.saveAs) {
+    this.context[step.saveAs] = unwrapped;
+  }
+  break;
+}
 
-        const res = await runResolvers(action);
-        if (step.saveAs) this.context[step.saveAs] = res;
-        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;
       }
 

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;