@o-lang/olang 1.0.6 → 1.0.8

package/cli.js

@@ -49,61 +49,47 @@ async function defaultMockResolver(action, context) {
 }
 
 /**
- * Built-in Math Resolver (so action style math strings are handled too)
- * Supports action strings like: add(1,2), subtract(5,2), multiply(2,3), divide(6,3), sum([1,2,3])
- * Note: runtime handles calculate steps; this resolver helps when parser emits actions with math strings.
+ * Built-in Math Resolver
  */
 async function builtInMathResolver(action, context) {
   if (!action || typeof action !== 'string') return null;
 
-  // Replace contextual placeholders {var}
   const a = action.replace(/\{([^\}]+)\}/g, (_, k) => {
     const v = context[k.trim()];
     return v !== undefined ? v : `{${k}}`;
   });
 
-  // simple function matches
   let m;
-  m = a.match(/^add\(([^,]+),\s*([^)]+)\)$/i);
-  if (m) return parseFloat(m[1]) + parseFloat(m[2]);
+  m = a.match(/^add\(([^,]+),\s*([^)]+)\)$/i); if (m) return parseFloat(m[1]) + parseFloat(m[2]);
+  m = a.match(/^subtract\(([^,]+),\s*([^)]+)\)$/i); if (m) return parseFloat(m[1]) - parseFloat(m[2]);
+  m = a.match(/^multiply\(([^,]+),\s*([^)]+)\)$/i); if (m) return parseFloat(m[1]) * parseFloat(m[2]);
+  m = a.match(/^divide\(([^,]+),\s*([^)]+)\)$/i); if (m) return parseFloat(m[1]) / parseFloat(m[2]);
+  m = a.match(/^sum\(\s*\[([^\]]+)\]\s*\)$/i); if (m) return m[1].split(',').map(s => parseFloat(s.trim())).reduce((s, v) => s + v, 0);
 
-  m = a.match(/^subtract\(([^,]+),\s*([^)]+)\)$/i);
-  if (m) return parseFloat(m[1]) - parseFloat(m[2]);
-
-  m = a.match(/^multiply\(([^,]+),\s*([^)]+)\)$/i);
-  if (m) return parseFloat(m[1]) * parseFloat(m[2]);
-
-  m = a.match(/^divide\(([^,]+),\s*([^)]+)\)$/i);
-  if (m) return parseFloat(m[1]) / parseFloat(m[2]);
-
-  m = a.match(/^sum\(\s*\[([^\]]+)\]\s*\)$/i);
-  if (m) {
-    const arr = m[1].split(',').map(s => parseFloat(s.trim()));
-    return arr.reduce((s, v) => s + v, 0);
-  }
-
-  // not a math action
   return null;
 }
 
 /**
- * Resolver chaining mechanism
+ * Resolver chaining with verbose + context logging
  */
-function createResolverChain(resolvers) {
-  return async (action, context) => {
-    for (const resolver of resolvers) {
+function createResolverChain(resolvers, verbose = false) {
+  const chain = resolvers.slice();
+  const wrapped = async (action, context) => {
+    let lastResult;
+    for (let i = 0; i < chain.length; i++) {
       try {
-        const result = await resolver(action, context);
-        if (result !== null && result !== undefined) {
-          return result;
-        }
-      } catch (err) {
-        console.error(`❌ Resolver error for action "${action}":`, err.message);
-        throw err;
+        const res = await chain[i](action, context);
+        context[`__resolver_${i}`] = res;
+        lastResult = res;
+      } catch (e) {
+        console.error(`❌ Resolver ${i} failed for action "${action}":`, e.message);
       }
     }
-    return `[Unhandled: ${action}]`;
+    if (verbose) console.log(`[Resolver Chain] action="${action}" lastResult=`, lastResult);
+    return lastResult;
   };
+  wrapped._chain = chain;
+  return wrapped;
 }
 
 function loadSingleResolver(specifier) {
@@ -111,9 +97,7 @@ function loadSingleResolver(specifier) {
 
   try {
     const resolver = require(specifier);
-    if (typeof resolver !== 'function') {
-      throw new Error(`Resolver must export a function`);
-    }
+    if (typeof resolver !== 'function') throw new Error(`Resolver must export a function`);
     console.log(`📦 Loaded resolver: ${specifier}`);
     return resolver;
   } catch (e1) {
@@ -133,7 +117,7 @@ function loadSingleResolver(specifier) {
 /**
  * loadResolverChain: include built-in math resolver first, then user resolvers, then default mock resolver
  */
-function loadResolverChain(specifiers) {
+function loadResolverChain(specifiers, verbose = false) {
   const userResolvers = specifiers?.map(loadSingleResolver) || [];
   const resolvers = [builtInMathResolver, ...userResolvers, defaultMockResolver];
 
@@ -143,7 +127,7 @@ function loadResolverChain(specifiers) {
     console.log(`📦 Loaded user resolvers: ${specifiers.join(', ')}`);
   }
 
-  return createResolverChain(resolvers);
+  return createResolverChain(resolvers, verbose);
 }
 
 /**
@@ -157,7 +141,7 @@ program
   .command('run <file>')
   .option(
     '-r, --resolver <specifier>',
-    'Resolver (npm package or local path). Can be used multiple times.\nExample:\n  -r @o-lang/llm-groq\n  -r @o-lang/notify-telegram',
+    'Resolver (npm package or local path). Can be used multiple times.',
     (val, acc) => { acc.push(val); return acc; },
     []
   )
@@ -166,13 +150,13 @@ program
     'Input parameters',
     (val, acc = {}) => {
       const [k, v] = val.split('=');
-      // try to parse numbers, preserve strings otherwise
       const parsed = v === undefined ? '' : (v === 'true' ? true : (v === 'false' ? false : (isNaN(v) ? v : parseFloat(v))));
       acc[k] = parsed;
       return acc;
     },
     {}
   )
+  .option('-v, --verbose', 'Verbose mode: logs resolver outputs and context after each step')
   .action(async (file, options) => {
     try {
       ensureOlExtension(file);
@@ -180,8 +164,8 @@ program
       const content = fs.readFileSync(file, 'utf8');
       const workflow = parse(content);
 
-      const resolver = loadResolverChain(options.resolver);
-      const result = await execute(workflow, options.input, resolver);
+      const resolver = loadResolverChain(options.resolver, options.verbose);
+      const result = await execute(workflow, options.input, resolver, options.verbose);
 
       console.log('\n=== Workflow Result ===');
       console.log(JSON.stringify(result, null, 2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/olang",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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,7 +1,7 @@
 // src/parser.js
 
 function parse(code, fileName = null) {
-  // --- New: Enforce .ol extension if filename provided ---
+  // --- Enforce .ol extension if filename provided ---
   if (fileName && !fileName.endsWith(".ol")) {
     throw new Error(`Expected .ol workflow, got: ${fileName}`);
   }
@@ -15,18 +15,30 @@ function parse(code, fileName = null) {
     name: 'Unnamed Workflow',
     parameters: [],
     steps: [],
-    returnValues: []
+    returnValues: [],
+    allowedResolvers: [] // NEW: store allowed resolvers
   };
 
   let i = 0;
   while (i < lines.length) {
     let line = lines[i];
 
+    // ---------------------------
+    // NEW: Detect Allow resolvers
+    // ---------------------------
+    const allowMatch = line.match(/^Allow resolvers\s*:\s*$/i);
+    if (allowMatch) {
+      i++;
+      while (i < lines.length && lines[i].startsWith('  ')) {
+        workflow.allowedResolvers.push(lines[i].trim());
+        i++;
+      }
+      continue;
+    }
+
     // ============================
-    // NEW: Detect math operations..
+    // Math operations
     // ============================
-
-    // Add X and Y
     let mathAdd = line.match(/^Add\s+\{(.+?)\}\s+and\s+\{(.+?)\}\s+Save as\s+(.+)$/i);
     if (mathAdd) {
       workflow.steps.push({
@@ -38,7 +50,6 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // Subtract A from B => B - A
     let mathSub = line.match(/^Subtract\s+\{(.+?)\}\s+from\s+\{(.+?)\}\s+Save as\s+(.+)$/i);
     if (mathSub) {
       workflow.steps.push({
@@ -50,7 +61,6 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // Multiply X and Y
     let mathMul = line.match(/^Multiply\s+\{(.+?)\}\s+and\s+\{(.+?)\}\s+Save as\s+(.+)$/i);
     if (mathMul) {
       workflow.steps.push({
@@ -62,7 +72,6 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // Divide A by B
     let mathDiv = line.match(/^Divide\s+\{(.+?)\}\s+by\s+\{(.+?)\}\s+Save as\s+(.+)$/i);
     if (mathDiv) {
       workflow.steps.push({
@@ -74,11 +83,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // ====================== END NEW MATH RULES ======================
-
-
-
-    // Workflow
+    // ---------------------------
+    // Workflow definition
+    // ---------------------------
     const wfMatch = line.match(/^Workflow\s+"([^"]+)"(?:\s+with\s+(.+))?/i);
     if (wfMatch) {
       workflow.name = wfMatch[1];
@@ -87,7 +94,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // Step
+    // ---------------------------
+    // Steps
+    // ---------------------------
     const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
     if (stepMatch) {
       workflow.steps.push({
@@ -101,7 +110,6 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // Save as
     const saveMatch = line.match(/^Save as\s+(.+)$/i);
     if (saveMatch && workflow.steps.length > 0) {
       workflow.steps[workflow.steps.length - 1].saveAs = saveMatch[1].trim();
@@ -109,7 +117,6 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // Constraint
     const constraintMatch = line.match(/^Constraint:\s*(.+)$/i);
     if (constraintMatch && workflow.steps.length > 0) {
       const lastStep = workflow.steps[workflow.steps.length - 1];
@@ -135,7 +142,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // If
+    // ---------------------------
+    // If blocks
+    // ---------------------------
     const ifMatch = line.match(/^If\s+(.+)\s+then$/i);
     if (ifMatch) {
       const condition = ifMatch[1].trim();
@@ -150,7 +159,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // Parallel
+    // ---------------------------
+    // Parallel blocks
+    // ---------------------------
     const parMatch = line.match(/^Run in parallel$/i);
     if (parMatch) {
       const steps = [];
@@ -164,7 +175,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
+    // ---------------------------
     // Connect
+    // ---------------------------
     const connMatch = line.match(/^Connect\s+"([^"]+)"\s+using\s+"([^"]+)"$/i);
     if (connMatch) {
       workflow.steps.push({
@@ -176,7 +189,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
+    // ---------------------------
     // Agent uses
+    // ---------------------------
     const agentUseMatch = line.match(/^Agent\s+"([^"]+)"\s+uses\s+"([^"]+)"$/i);
     if (agentUseMatch) {
       workflow.steps.push({
@@ -188,7 +203,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
+    // ---------------------------
     // Debrief
+    // ---------------------------
     const debriefMatch = line.match(/^Debrief\s+(\w+)\s+with\s+"(.+)"$/i);
     if (debriefMatch) {
       workflow.steps.push({
@@ -200,7 +217,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
+    // ---------------------------
     // Evolve
+    // ---------------------------
     const evolveMatch = line.match(/^Evolve\s+(\w+)\s+using\s+feedback:\s+"(.+)"$/i);
     if (evolveMatch) {
       workflow.steps.push({
@@ -212,7 +231,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // Prompt
+    // ---------------------------
+    // Prompt user
+    // ---------------------------
     const promptMatch = line.match(/^Prompt user to\s+"(.+)"$/i);
     if (promptMatch) {
       workflow.steps.push({
@@ -224,7 +245,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
+    // ---------------------------
     // Persist
+    // ---------------------------
     const persistMatch = line.match(/^Persist\s+(.+)\s+to\s+"(.+)"$/i);
     if (persistMatch) {
       workflow.steps.push({
@@ -236,7 +259,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
+    // ---------------------------
     // Emit
+    // ---------------------------
     const emitMatch = line.match(/^Emit\s+"(.+)"\s+with\s+(.+)$/i);
     if (emitMatch) {
       workflow.steps.push({
@@ -248,7 +273,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
+    // ---------------------------
     // Return
+    // ---------------------------
     const returnMatch = line.match(/^Return\s+(.+)$/i);
     if (returnMatch) {
       workflow.returnValues = returnMatch[1].split(',').map(v => v.trim());
@@ -256,7 +283,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // Use <Tool>
+    // ---------------------------
+    // Use tool
+    // ---------------------------
     const useMatch = line.match(/^Use\s+(.+)$/i);
     if (useMatch) {
       workflow.steps.push({
@@ -269,7 +298,9 @@ function parse(code, fileName = null) {
       continue;
     }
 
-    // Ask <Target>
+    // ---------------------------
+    // Ask target
+    // ---------------------------
     const askMatch = line.match(/^Ask\s+(.+)$/i);
     if (askMatch) {
       workflow.steps.push({
@@ -288,6 +319,9 @@ function parse(code, fileName = null) {
   return workflow;
 }
 
+// ---------------------------
+// Parse nested blocks (If / Parallel)
+// ---------------------------
 function parseBlock(lines) {
   const steps = [];
   let current = null;

package/src/runtime.js

@@ -1,15 +1,28 @@
-// src/runtime.js
 const fs = require('fs');
+const path = require('path');
 
 class RuntimeAPI {
-  constructor() {
+  constructor({ verbose = false } = {}) {
     this.context = {};
     this.resources = {};
     this.agentMap = {};
     this.events = {};
-    this.workflowSteps = []; // store for evolve lookup
+    this.workflowSteps = [];
+    this.allowedResolvers = null;
+    this.verbose = verbose;
+
+    // Ensure logs folder exists
+    const logsDir = path.resolve('./logs');
+    if (!fs.existsSync(logsDir)) fs.mkdirSync(logsDir, { recursive: true });
+    this.disallowedLogFile = path.join(logsDir, 'disallowed_resolvers.json');
+
+    // In-memory store for summary
+    this.disallowedAttempts = [];
   }
 
+  // -----------------------------
+  // Event handling
+  // -----------------------------
   on(eventName, cb) {
     if (!this.events[eventName]) this.events[eventName] = [];
     this.events[eventName].push(cb);
@@ -21,6 +34,40 @@ class RuntimeAPI {
     }
   }
 
+  // -----------------------------
+  // Disallowed resolver handling
+  // -----------------------------
+  logDisallowedResolver(resolverName, stepAction) {
+    const entry = {
+      resolver: resolverName,
+      step: stepAction,
+      timestamp: new Date().toISOString()
+    };
+    fs.appendFileSync(this.disallowedLogFile, JSON.stringify(entry) + '\n', 'utf8');
+    this.disallowedAttempts.push(entry);
+
+    if (this.verbose) {
+      console.warn(`[O-Lang] Disallowed resolver blocked: ${resolverName} | step: ${stepAction}`);
+    }
+  }
+
+  printDisallowedSummary() {
+    if (!this.disallowedAttempts.length) return;
+    console.log('\n[O-Lang] ⚠️ Disallowed resolver summary:');
+    console.log(`Total blocked attempts: ${this.disallowedAttempts.length}`);
+    const displayCount = Math.min(5, this.disallowedAttempts.length);
+    console.log(`First ${displayCount} entries:`);
+    this.disallowedAttempts.slice(0, displayCount).forEach((e, i) => {
+      console.log(`${i + 1}. Resolver: ${e.resolver}, Step: ${e.step}, Time: ${e.timestamp}`);
+    });
+    if (this.disallowedAttempts.length > displayCount) {
+      console.log(`...and ${this.disallowedAttempts.length - displayCount} more entries logged in ${this.disallowedLogFile}`);
+    }
+  }
+
+  // -----------------------------
+  // Condition & math utilities
+  // -----------------------------
   evaluateCondition(cond, ctx) {
     cond = cond.trim();
     const eq = cond.match(/^\{(.+)\}\s+equals\s+"(.*)"$/);
@@ -37,19 +84,6 @@ class RuntimeAPI {
     return path.split('.').reduce((o, k) => (o && o[k] !== undefined) ? o[k] : undefined, obj);
   }
 
-  findLastSummaryStep() {
-    for (let i = this.workflowSteps.length - 1; i >= 0; i--) {
-      const step = this.workflowSteps[i];
-      if (step.type === 'action' && step.actionRaw?.startsWith('Ask ') && step.saveAs) {
-        return step;
-      }
-    }
-    return null;
-  }
-
-  // --------------------------
-  // Math helper functions
-  // --------------------------
   mathFunctions = {
     add: (a, b) => a + b,
     subtract: (a, b) => a - b,
@@ -71,23 +105,17 @@ class RuntimeAPI {
   };
 
   evaluateMath(expr) {
-    // Replace context variables in curly braces
     expr = expr.replace(/\{([^\}]+)\}/g, (_, path) => {
       const value = this.getNested(this.context, path.trim());
-      // if value is string, wrap in quotes for functions that accept strings
       if (typeof value === 'string') return `"${value.replace(/"/g, '\\"')}"`;
       return value !== undefined ? value : 0;
     });
 
-    // expose safe functions only
     const funcNames = Object.keys(this.mathFunctions);
     const safeFunc = {};
-    funcNames.forEach(fn => {
-      safeFunc[fn] = this.mathFunctions[fn];
-    });
+    funcNames.forEach(fn => safeFunc[fn] = this.mathFunctions[fn]);
 
     try {
-      // eslint-disable-next-line no-new-func
       const f = new Function(...funcNames, `return ${expr};`);
       return f(...funcNames.map(fn => safeFunc[fn]));
     } catch (e) {
@@ -96,140 +124,156 @@ class RuntimeAPI {
     }
   }
 
-  // --------------------------
-  // Execute workflow step
-  // --------------------------
+  findLastSummaryStep() {
+    for (let i = this.workflowSteps.length - 1; i >= 0; i--) {
+      const step = this.workflowSteps[i];
+      if (step.type === 'action' && step.actionRaw?.startsWith('Ask ') && step.saveAs) {
+        return step;
+      }
+    }
+    return null;
+  }
+
+  // -----------------------------
+  // Step execution
+  // -----------------------------
   async executeStep(step, agentResolver) {
-    switch (step.type) {
+    const stepType = step.type;
+
+    const validateResolver = (resolver) => {
+      const resolverName = resolver?.name || resolver?.resolverName;
+      if (!resolverName) throw new Error('[O-Lang] Resolver missing name metadata');
+      if (!this.allowedResolvers.has(resolverName)) {
+        this.logDisallowedResolver(resolverName, step.actionRaw || step.tool || step.target);
+        throw new Error(`[O-Lang] Resolver "${resolverName}" is not allowed by workflow policy`);
+      }
+    };
+
+    const runAllResolvers = async (action) => {
+      const outputs = [];
+      if (agentResolver && Array.isArray(agentResolver._chain)) {
+        for (let idx = 0; idx < agentResolver._chain.length; idx++) {
+          const resolver = agentResolver._chain[idx];
+          validateResolver(resolver);
+          try {
+            const out = await resolver(action, this.context);
+            outputs.push(out);
+            this.context[`__resolver_${idx}`] = out;
+          } catch (e) {
+            console.error(`❌ Resolver ${idx} error for action "${action}":`, e.message);
+            outputs.push(null);
+          }
+        }
+      } else {
+        validateResolver(agentResolver);
+        const out = await agentResolver(action, this.context);
+        outputs.push(out);
+        this.context['__resolver_0'] = out;
+      }
+      return outputs[outputs.length - 1];
+    };
+
+    switch (stepType) {
       case 'calculate': {
-        // step.expression or actionRaw can contain math expression strings
         const expr = step.expression || step.actionRaw;
         const result = this.evaluateMath(expr);
         if (step.saveAs) this.context[step.saveAs] = result;
         break;
       }
-
       case 'action': {
         const action = step.actionRaw.replace(/\{([^\}]+)\}/g, (_, path) => {
           const value = this.getNested(this.context, path.trim());
           return value !== undefined ? String(value) : `{${path}}`;
         });
-
-        // Provide fallback math recognition for action lines too (e.g., add(1,2))
-        // Try simple math function calls in action form
         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 argsRaw = mathCall[2];
-          // simple split by comma (doesn't handle nested arrays/funcs) — fine for workflow math
           const args = argsRaw.split(',').map(s => s.trim()).map(s => {
-            // if it's a quoted string
             if (/^".*"$/.test(s) || /^'.*'$/.test(s)) return s.slice(1, -1);
-            // try number
             if (!isNaN(s)) return parseFloat(s);
-            // variable lookup
             const lookup = s.replace(/^\{|\}$/g, '').trim();
             return this.getNested(this.context, lookup);
           });
-
           if (this.mathFunctions[fn]) {
             const value = this.mathFunctions[fn](...args);
             if (step.saveAs) this.context[step.saveAs] = value;
             break;
           }
         }
-
-        // fallback to agent resolver
-        const res = await agentResolver(action, this.context);
+        const res = await runAllResolvers(action);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
-
       case 'use': {
-        const res = await agentResolver(`Use ${step.tool}`, this.context);
+        const res = await runAllResolvers(`Use ${step.tool}`);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
-
       case 'ask': {
-        const res = await agentResolver(`Ask ${step.target}`, this.context);
+        const res = await runAllResolvers(`Ask ${step.target}`);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
-
       case 'if': {
         if (this.evaluateCondition(step.condition, this.context)) {
           for (const s of step.body) await this.executeStep(s, agentResolver);
         }
         break;
       }
-
       case 'parallel': {
         await Promise.all(step.steps.map(s => this.executeStep(s, agentResolver)));
         break;
       }
-
       case 'connect': {
         this.resources[step.resource] = step.endpoint;
         break;
       }
-
       case 'agent_use': {
         this.agentMap[step.logicalName] = step.resource;
         break;
       }
-
       case 'debrief': {
         this.emit('debrief', { agent: step.agent, message: step.message });
         break;
       }
-
       case 'evolve': {
         const maxGen = step.constraints?.max_generations || 1;
         if (maxGen < 1) {
           this.context['improved_summary'] = this.context['summary'] || '';
           return;
         }
-
         const summaryStep = this.findLastSummaryStep();
         if (!summaryStep) {
           console.warn('[O-Lang] Evolve: No prior "Ask ... Save as" step found to evolve');
           this.context['improved_summary'] = this.context['summary'] || '';
           return;
         }
-
         const varName = summaryStep.saveAs;
         let currentOutput = this.context[varName] || '';
-
         for (let attempt = 0; attempt < maxGen; attempt++) {
           let revisedAction = summaryStep.actionRaw.replace(/\{([^\}]+)\}/g, (_, path) => {
             const val = this.getNested(this.context, path.trim());
             return val !== undefined ? String(val) : `{${path}}`;
           });
-
           if (step.feedback) {
             revisedAction = revisedAction.replace(/(")$/, `\n\n[IMPROVEMENT FEEDBACK: ${step.feedback}]$1`);
           }
-
-          currentOutput = await agentResolver(revisedAction, this.context);
+          currentOutput = await runAllResolvers(revisedAction);
           this.context[varName] = currentOutput;
-
           this.emit('debrief', {
             agent: step.agent || 'Evolver',
             message: `Evolve attempt ${attempt + 1}/${maxGen}: ${currentOutput.substring(0, 80)}...`
           });
         }
-
         this.context['improved_summary'] = currentOutput;
         break;
       }
-
       case 'prompt': {
         const input = await this.getUserInput(step.question);
         if (step.saveAs) this.context[step.saveAs] = input;
         break;
       }
-
       case 'persist': {
         const val = this.context[step.variable];
         if (val !== undefined) {
@@ -237,13 +281,17 @@ class RuntimeAPI {
         }
         break;
       }
-
       case 'emit': {
         const payload = step.payload ? this.getNested(this.context, step.payload) : undefined;
         this.emit(step.event, payload || step.payload);
         break;
       }
     }
+
+    if (this.verbose) {
+      console.log(`\n[Step: ${step.type} | saveAs: ${step.saveAs || 'N/A'}]`);
+      console.log(JSON.stringify(this.context, null, 2));
+    }
   }
 
   async getUserInput(question) {
@@ -260,11 +308,15 @@ class RuntimeAPI {
   async executeWorkflow(workflow, inputs, agentResolver) {
     this.context = { ...inputs };
     this.workflowSteps = workflow.steps;
+    this.allowedResolvers = new Set(workflow.allowedResolvers || []);
 
     for (const step of workflow.steps) {
       await this.executeStep(step, agentResolver);
     }
 
+    // Print disallowed resolver summary at the end
+    this.printDisallowedSummary();
+
     const result = {};
     for (const key of workflow.returnValues) {
       result[key] = this.getNested(this.context, key);
@@ -273,8 +325,8 @@ class RuntimeAPI {
   }
 }
 
-async function execute(workflow, inputs, agentResolver) {
-  const rt = new RuntimeAPI();
+async function execute(workflow, inputs, agentResolver, verbose = false) {
+  const rt = new RuntimeAPI({ verbose });
   return rt.executeWorkflow(workflow, inputs, agentResolver);
 }