jetic-cli 0.2.5 → 0.2.6

package/dist/index.js

@@ -269150,6 +269150,7 @@ var require_yaml_io = __commonJS({
     exports2.loadModelFromDir = loadModelFromDir5;
     exports2.readWorkflowDefinitionFile = readWorkflowDefinitionFile2;
     exports2.listWorkflowFiles = listWorkflowFiles2;
+    exports2.loadWorkflowByName = loadWorkflowByName3;
     exports2.hasYamlModel = hasYamlModel5;
     exports2.loadModelCompat = loadModelCompat;
     var fs10 = __importStar(require("fs"));
@@ -269245,6 +269246,29 @@ var require_yaml_io = __commonJS({
         return [];
       return fs10.readdirSync(workflowsDir).filter((f) => f.endsWith(".json") || f.endsWith(".yaml") || f.endsWith(".yml")).sort();
     }
+    function loadWorkflowByName3(workflowsDir, slugOrName) {
+      const wanted = slugOrName.trim().toLowerCase();
+      if (!wanted)
+        return null;
+      const files = listWorkflowFiles2(workflowsDir);
+      const bySlug = files.find((f) => f.replace(/.(json|ya?ml)$/, "").toLowerCase() === wanted);
+      if (bySlug) {
+        try {
+          return readWorkflowDefinitionFile2(path15.join(workflowsDir, bySlug));
+        } catch {
+          return null;
+        }
+      }
+      for (const file of files) {
+        try {
+          const def = readWorkflowDefinitionFile2(path15.join(workflowsDir, file));
+          if (def?.name && def.name.trim().toLowerCase() === wanted)
+            return def;
+        } catch {
+        }
+      }
+      return null;
+    }
     function hasYamlModel5(modelDir) {
       return fs10.existsSync(path15.join(modelDir, "api.yaml"));
     }
@@ -272353,12 +272377,15 @@ var require_dist12 = __commonJS({
     exports2.JeticMemory = void 0;
     var fs10 = __importStar(require("fs"));
     var path15 = __importStar(require("path"));
+    function memoryFilePath(projectRoot) {
+      return path15.join(projectRoot ?? process.cwd(), ".jetic", "memory.json");
+    }
     var JeticMemory4 = class {
       scope;
       filePath;
       constructor(options) {
         this.scope = options.scope;
-        this.filePath = path15.join(process.cwd(), ".jetic", "memory.json");
+        this.filePath = memoryFilePath(options.projectRoot);
       }
       ensureDirectory() {
         const dir = path15.dirname(this.filePath);
@@ -272451,8 +272478,8 @@ var require_dist12 = __commonJS({
           this.writeData(data);
         }
       }
-      static getAllMemory() {
-        const filePath = path15.join(process.cwd(), ".jetic", "memory.json");
+      static getAllMemory(projectRoot) {
+        const filePath = memoryFilePath(projectRoot);
         if (!fs10.existsSync(filePath))
           return {};
         try {
@@ -272474,8 +272501,8 @@ var require_dist12 = __commonJS({
           return {};
         }
       }
-      static clearAllMemory() {
-        const filePath = path15.join(process.cwd(), ".jetic", "memory.json");
+      static clearAllMemory(projectRoot) {
+        const filePath = memoryFilePath(projectRoot);
         if (fs10.existsSync(filePath)) {
           fs10.unlinkSync(filePath);
         }
@@ -272485,6 +272512,158 @@ var require_dist12 = __commonJS({
   }
 });
 
+// ../../packages/simulator/dist/conditions.js
+var require_conditions = __commonJS({
+  "../../packages/simulator/dist/conditions.js"(exports2) {
+    "use strict";
+    init_cjs_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.UNARY_OPERATORS = exports2.CONDITION_OPERATORS = void 0;
+    exports2.conditionKind = conditionKind3;
+    exports2.isRulesCondition = isRulesCondition3;
+    exports2.isLegacyCondition = isLegacyCondition;
+    exports2.describeInvalidCondition = describeInvalidCondition3;
+    exports2.evaluateRules = evaluateRules3;
+    exports2.evaluateLegacyCondition = evaluateLegacyCondition3;
+    exports2.CONDITION_OPERATORS = [
+      "equals",
+      "not_equals",
+      "greater_than",
+      "greater_than_or_equal",
+      "less_than",
+      "less_than_or_equal",
+      "exists",
+      "not_exists",
+      "is_empty",
+      "is_not_empty",
+      "contains",
+      "not_contains",
+      "starts_with",
+      "ends_with"
+    ];
+    exports2.UNARY_OPERATORS = ["exists", "not_exists", "is_empty", "is_not_empty"];
+    function isObject(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+    function conditionKind3(condition) {
+      if (!isObject(condition))
+        return "invalid";
+      if (isObject(condition.rules))
+        return "rules";
+      if (typeof condition.if === "string")
+        return "legacy";
+      return "invalid";
+    }
+    function isRulesCondition3(condition) {
+      return conditionKind3(condition) === "rules";
+    }
+    function isLegacyCondition(condition) {
+      return conditionKind3(condition) === "legacy";
+    }
+    function describeInvalidCondition3(condition) {
+      if (!isObject(condition))
+        return "condition must be an object";
+      const keys = Object.keys(condition);
+      return `unrecognized condition (keys: ${keys.join(", ") || "none"}). Use { "rules": { "all": [{ "left", "operator", "right" }] }, "onFail": "abort|continue|switch" }`;
+    }
+    async function evaluateRule(rule, resolve2) {
+      const left = await resolve2(String(rule.left ?? ""));
+      const right = rule.right !== void 0 ? await resolve2(String(rule.right)) : void 0;
+      switch (rule.operator) {
+        case "equals":
+          return { ok: left === right };
+        case "not_equals":
+          return { ok: left !== right };
+        case "greater_than":
+          return { ok: Number(left) > Number(right) };
+        case "greater_than_or_equal":
+          return { ok: Number(left) >= Number(right) };
+        case "less_than":
+          return { ok: Number(left) < Number(right) };
+        case "less_than_or_equal":
+          return { ok: Number(left) <= Number(right) };
+        case "exists":
+          return { ok: left !== "" && left !== void 0 };
+        case "not_exists":
+          return { ok: left === "" || left === void 0 };
+        case "is_empty":
+          return { ok: left === "" };
+        case "is_not_empty":
+          return { ok: left !== "" };
+        case "contains":
+          return { ok: right !== void 0 && left.includes(right) };
+        case "not_contains":
+          return { ok: right !== void 0 && !left.includes(right) };
+        case "starts_with":
+          return { ok: right !== void 0 && left.startsWith(right) };
+        case "ends_with":
+          return { ok: right !== void 0 && left.endsWith(right) };
+        default:
+          return { ok: false, unknownOperator: true };
+      }
+    }
+    function describeRule(rule) {
+      return `${rule.left} ${rule.operator}${rule.right !== void 0 ? ` ${rule.right}` : ""}`;
+    }
+    async function evaluateRules3(group, resolve2) {
+      const all = Array.isArray(group.all) ? group.all : void 0;
+      const any = Array.isArray(group.any) ? group.any : void 0;
+      if ((!all || all.length === 0) && (!any || any.length === 0)) {
+        return { passed: true, reason: "No rules defined" };
+      }
+      const failing = [];
+      let passed = true;
+      if (all && all.length > 0) {
+        const results = [];
+        for (const rule of all)
+          results.push({ rule, ...await evaluateRule(rule, resolve2) });
+        const bad = results.filter((r) => !r.ok);
+        if (bad.length > 0) {
+          passed = false;
+          failing.push(...bad.map((r) => r.unknownOperator ? `${describeRule(r.rule)} (unknown operator)` : describeRule(r.rule)));
+        }
+      }
+      if (any && any.length > 0) {
+        const results = [];
+        for (const rule of any)
+          results.push({ rule, ...await evaluateRule(rule, resolve2) });
+        if (!results.some((r) => r.ok)) {
+          passed = false;
+          failing.push(`none of: ${results.map((r) => describeRule(r.rule)).join(" | ")}`);
+        }
+      }
+      const mode = all && any ? "AND+OR" : all ? "AND" : "OR";
+      return {
+        passed,
+        reason: passed ? `All conditions met (${mode})` : `Failed: ${failing.join(", ")}`
+      };
+    }
+    async function evaluateLegacyCondition3(condition, resolve2) {
+      const evaluated = await resolve2(condition.if);
+      let matched;
+      if (condition.exists !== void 0) {
+        const hasValue = evaluated !== "" && evaluated !== "null" && evaluated !== "undefined";
+        matched = condition.exists ? hasValue : !hasValue;
+      } else if (condition.equals !== void 0) {
+        matched = evaluated === condition.equals;
+      } else if (condition.notEquals !== void 0) {
+        matched = evaluated !== condition.notEquals;
+      } else if (condition.contains !== void 0) {
+        matched = evaluated.includes(condition.contains);
+      } else if (condition.greaterThan !== void 0) {
+        matched = Number(evaluated) > condition.greaterThan;
+      } else if (condition.lessThan !== void 0) {
+        matched = Number(evaluated) < condition.lessThan;
+      } else if (condition.in !== void 0) {
+        matched = condition.in.includes(evaluated);
+      } else {
+        matched = evaluated !== "" && evaluated !== "false" && evaluated !== "0" && evaluated !== "null" && evaluated !== "undefined";
+      }
+      return { matched, evaluated };
+    }
+  }
+});
+
 // ../../packages/simulator/dist/workflow-simulator.js
 var require_workflow_simulator = __commonJS({
   "../../packages/simulator/dist/workflow-simulator.js"(exports2) {
@@ -272494,6 +272673,7 @@ var require_workflow_simulator = __commonJS({
     exports2.WorkflowSimulator = void 0;
     var memory_1 = require_dist12();
     var faker_1 = require("@faker-js/faker");
+    var conditions_1 = require_conditions();
     function deepGet2(obj, dotPath) {
       if (obj === null || obj === void 0)
         return void 0;
@@ -272509,27 +272689,88 @@ var require_workflow_simulator = __commonJS({
     var WorkflowSimulator2 = class {
       model;
       environment;
-      constructor(model, environment) {
+      runtime;
+      constructor(model, environment, runtime = {}) {
         this.model = model;
         this.environment = environment;
+        this.runtime = runtime;
+      }
+      memory(scope) {
+        return new memory_1.JeticMemory({ scope, projectRoot: this.runtime.projectRoot });
       }
       async simulateWorkflow(workflow, options) {
         if (options?.clearMemory) {
-          memory_1.JeticMemory.clearAllMemory();
+          memory_1.JeticMemory.clearAllMemory(this.runtime.projectRoot);
         }
-        const baseUrl = this.environment.baseUrl;
         const startTime = Date.now();
-        const stepResults = [];
-        let allPassed = true;
+        const state = { results: [], allPassed: true, halted: false };
+        await this.runSteps(workflow, options, state, [workflow.name]);
+        const stepResults = state.results;
+        const totalTimeMs = Date.now() - startTime;
+        return {
+          success: state.allPassed,
+          workflow: {
+            name: workflow.name,
+            description: workflow.description,
+            stepsCount: workflow.steps.length
+          },
+          environment: {
+            name: this.environment.name,
+            baseUrl: this.environment.baseUrl
+          },
+          stats: {
+            totalSteps: workflow.steps.length,
+            executedSteps: stepResults.length,
+            passedSteps: stepResults.filter((r) => r.passed).length,
+            failedSteps: stepResults.filter((r) => !r.passed).length,
+            totalTimeMs
+          },
+          results: stepResults
+        };
+      }
+      /**
+       * Runs one workflow's steps, appending to `state`. Returns `'stop'` when the remaining steps
+       * of THIS workflow must not run (failure, `onFail: continue|switch`), else `'done'`.
+       * `state.halted` is set only for failures, so a caller resuming after a switch knows whether to go on.
+       */
+      async runSteps(workflow, options, state, lineage) {
+        const baseUrl = this.environment.baseUrl;
+        const resolve2 = (value) => this.resolveTemplateString(value);
         for (let i = 0; i < workflow.steps.length; i++) {
           const step = workflow.steps[i];
           const stepStartTime = Date.now();
-          if (step.condition) {
-            const condResult = await this.evaluateCondition(step.condition);
+          const stepName = step.name || `${step.method} ${step.path}`;
+          const kind = step.condition === void 0 ? void 0 : (0, conditions_1.conditionKind)(step.condition);
+          if (kind === "invalid") {
+            const reason = (0, conditions_1.describeInvalidCondition)(step.condition);
+            state.results.push({
+              stepIndex: i + 1,
+              name: stepName,
+              method: step.method,
+              path: step.path,
+              targetUrl: "",
+              expectedStatus: step.expectStatus ?? 200,
+              actualStatus: 0,
+              durationMs: Date.now() - stepStartTime,
+              passed: false,
+              skipped: false,
+              retryCount: 0,
+              requestHeaders: {},
+              requestBody: {},
+              responseBody: null,
+              capturedMemory: [],
+              error: `Step ${i + 1} "${stepName}": ${reason}`
+            });
+            state.allPassed = false;
+            state.halted = true;
+            return "stop";
+          }
+          if (kind === "legacy") {
+            const condResult = await (0, conditions_1.evaluateLegacyCondition)(step.condition, resolve2);
             if (!condResult.matched) {
-              stepResults.push({
+              state.results.push({
                 stepIndex: i + 1,
-                name: step.name || `${step.method} ${step.path}`,
+                name: stepName,
                 method: step.method,
                 path: step.path,
                 targetUrl: "",
@@ -272609,97 +272850,72 @@ var require_workflow_simulator = __commonJS({
             }
           }
           const responseCaptured = stepPassed ? await this.captureToMemory(step.capture, responseBody) : [];
-          if (!stepPassed) {
-            allPassed = false;
-            const onFailure = step.onFailure ?? "abort";
-            stepResults.push({
-              stepIndex: i + 1,
-              name: step.name || `${step.method} ${step.path}`,
-              method: step.method,
-              path: step.path,
-              targetUrl: fullUrl,
-              expectedStatus,
-              actualStatus: responseStatus,
-              durationMs: Date.now() - stepStartTime,
-              passed: false,
-              skipped: false,
-              retryCount: attempts - 1,
-              failureHandling: onFailure === "continue" ? "continued" : "aborted",
-              requestHeaders: injectedHeaders,
-              requestBody: finalBody,
-              responseBody,
-              capturedMemory: [...inputCaptured],
-              error: errorMsg
-            });
-            if (onFailure === "abort")
-              break;
-            continue;
-          }
-          stepResults.push({
+          const onFailure = step.onFailure ?? "abort";
+          const result = {
             stepIndex: i + 1,
-            name: step.name || `${step.method} ${step.path}`,
+            name: stepName,
             method: step.method,
             path: step.path,
             targetUrl: fullUrl,
             expectedStatus,
             actualStatus: responseStatus,
             durationMs: Date.now() - stepStartTime,
-            passed: true,
+            passed: stepPassed,
             skipped: false,
             retryCount: attempts - 1,
             requestHeaders: injectedHeaders,
             requestBody: finalBody,
             responseBody,
-            capturedMemory: [...inputCaptured, ...responseCaptured]
-          });
-        }
-        const totalTimeMs = Date.now() - startTime;
-        return {
-          success: allPassed,
-          workflow: {
-            name: workflow.name,
-            description: workflow.description,
-            stepsCount: workflow.steps.length
-          },
-          environment: {
-            name: this.environment.name,
-            baseUrl
-          },
-          stats: {
-            totalSteps: workflow.steps.length,
-            executedSteps: stepResults.length,
-            passedSteps: stepResults.filter((r) => r.passed).length,
-            failedSteps: stepResults.filter((r) => !r.passed).length,
-            totalTimeMs
-          },
-          results: stepResults
-        };
-      }
-      // ── Condition evaluator ────────────────────────────────────────────────────
-      // Resolves the `if` template and applies the declared operator. Returns
-      // `matched: true` when the condition passes (step should execute).
-      async evaluateCondition(condition) {
-        const evaluated = await this.resolveTemplateString(condition.if);
-        let matched;
-        if (condition.exists !== void 0) {
-          const hasValue = evaluated !== "" && evaluated !== "null" && evaluated !== "undefined";
-          matched = condition.exists ? hasValue : !hasValue;
-        } else if (condition.equals !== void 0) {
-          matched = evaluated === condition.equals;
-        } else if (condition.notEquals !== void 0) {
-          matched = evaluated !== condition.notEquals;
-        } else if (condition.contains !== void 0) {
-          matched = evaluated.includes(condition.contains);
-        } else if (condition.greaterThan !== void 0) {
-          matched = Number(evaluated) > condition.greaterThan;
-        } else if (condition.lessThan !== void 0) {
-          matched = Number(evaluated) < condition.lessThan;
-        } else if (condition.in !== void 0) {
-          matched = condition.in.includes(evaluated);
-        } else {
-          matched = evaluated !== "" && evaluated !== "false" && evaluated !== "0" && evaluated !== "null" && evaluated !== "undefined";
+            capturedMemory: stepPassed ? [...inputCaptured, ...responseCaptured] : [...inputCaptured],
+            ...stepPassed ? {} : {
+              failureHandling: onFailure === "continue" ? "continued" : "aborted",
+              error: errorMsg
+            }
+          };
+          state.results.push(result);
+          if (!stepPassed) {
+            state.allPassed = false;
+            if (onFailure === "abort") {
+              state.halted = true;
+              return "stop";
+            }
+          }
+          if (kind === "rules") {
+            const condition = step.condition;
+            const outcome = await (0, conditions_1.evaluateRules)(condition.rules, resolve2);
+            result.conditionResult = { evaluated: outcome.reason, matched: outcome.passed };
+            if (outcome.passed)
+              continue;
+            result.conditionOutcome = condition.onFail;
+            const fail = (message) => {
+              result.passed = false;
+              result.error = result.error ? `${result.error}; ${message}` : message;
+              state.allPassed = false;
+              state.halted = true;
+              return "stop";
+            };
+            if (condition.onFail === "continue")
+              return "stop";
+            if (condition.onFail !== "switch")
+              return fail(`Condition failed at step ${i + 1}: ${outcome.reason}`);
+            const target = condition.switchToWorkflow;
+            if (!target)
+              return fail(`Condition failed at step ${i + 1} (${outcome.reason}) and onFail "switch" has no switchToWorkflow`);
+            if (!options?.loadWorkflow) {
+              return fail(`Condition failed at step ${i + 1} (${outcome.reason}); cannot switch to "${target}": this runner was not given a workflow loader`);
+            }
+            const switched = await options.loadWorkflow(target);
+            if (!switched)
+              return fail(`Condition failed at step ${i + 1} (${outcome.reason}); switch target workflow "${target}" was not found`);
+            if (lineage.includes(switched.name)) {
+              return fail(`Condition failed at step ${i + 1}; switching to "${switched.name}" would loop (${[...lineage, switched.name].join(" \u2192 ")})`);
+            }
+            await this.runSteps(switched, options, state, [...lineage, switched.name]);
+            if (state.halted || !condition.returnOnComplete)
+              return "stop";
+          }
         }
-        return { matched, evaluated };
+        return "done";
       }
       async resolveTemplateString(value) {
         const templateRe = /\{\{([^}]+)\}\}/g;
@@ -272718,7 +272934,7 @@ var require_workflow_simulator = __commonJS({
                 continue;
               }
             }
-            const mem = new memory_1.JeticMemory({ scope });
+            const mem = this.memory(scope);
             const memVal = await mem.get(key);
             replacements.push({ placeholder: match[0], resolved: memVal != null ? String(memVal) : "" });
             continue;
@@ -272762,7 +272978,7 @@ var require_workflow_simulator = __commonJS({
             strValue = await this.resolveTemplateString(memKeyOrTemplate);
           } else {
             const [scope, key] = memKeyOrTemplate.includes(":") ? memKeyOrTemplate.split(":", 2) : ["workflow", memKeyOrTemplate];
-            const scopedMemory = new memory_1.JeticMemory({ scope });
+            const scopedMemory = this.memory(scope);
             const value = await scopedMemory.get(key);
             if (value === null)
               continue;
@@ -272787,7 +273003,7 @@ var require_workflow_simulator = __commonJS({
           if (value === void 0 || value === null)
             continue;
           const [scope, key] = memKey.includes(":") ? memKey.split(":", 2) : ["workflow", memKey];
-          const memory = new memory_1.JeticMemory({ scope });
+          const memory = this.memory(scope);
           await memory.set(key, value);
           captured.push(`${scope}:${key} = ${JSON.stringify(value)}`);
         }
@@ -272802,7 +273018,7 @@ var require_workflow_simulator = __commonJS({
           if (value === void 0 || value === null)
             continue;
           const [scope, key] = memKey.includes(":") ? memKey.split(":", 2) : ["workflow", memKey];
-          const memory = new memory_1.JeticMemory({ scope });
+          const memory = this.memory(scope);
           await memory.set(key, value);
           captured.push(`${scope}:${key} = ${JSON.stringify(value)}`);
         }
@@ -272818,7 +273034,7 @@ var require_workflow_simulator = __commonJS({
           if (body[paramName] !== void 0) {
             result = result.replace(p, String(body[paramName]));
           } else {
-            const memory = new memory_1.JeticMemory({ scope: "workflow" });
+            const memory = this.memory("workflow");
             const memVal = await memory.get(paramName);
             if (memVal !== null) {
               result = result.replace(p, String(memVal));
@@ -272837,6 +273053,22 @@ var require_dist13 = __commonJS({
   "../../packages/simulator/dist/index.js"(exports2) {
     "use strict";
     init_cjs_shims();
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.WorkflowSimulator = exports2.ResponseValidator = exports2.DataGenerator = exports2.EndpointSimulator = void 0;
     var simulator_1 = require_simulator();
@@ -272855,6 +273087,7 @@ var require_dist13 = __commonJS({
     Object.defineProperty(exports2, "WorkflowSimulator", { enumerable: true, get: function() {
       return workflow_simulator_1.WorkflowSimulator;
     } });
+    __exportStar(require_conditions(), exports2);
   }
 });
 
@@ -273238,8 +273471,13 @@ var require_workflow_tools = __commonJS({
         ...targetEnv,
         baseUrl: args.baseUrl || targetEnv.baseUrl
       };
-      const simulator = new simulator_1.WorkflowSimulator(model, effectiveEnv);
-      const result = await simulator.simulateWorkflow(workflowDef, { clearMemory: args.clearMemory ?? false });
+      const projectRoot = (0, types_1.projectRootOfModel)(filePath);
+      const workflowsDir = path15.join(path15.dirname(filePath), "workflows");
+      const simulator = new simulator_1.WorkflowSimulator(model, effectiveEnv, { projectRoot });
+      const result = await simulator.simulateWorkflow(workflowDef, {
+        clearMemory: args.clearMemory ?? false,
+        loadWorkflow: (slugOrName) => (0, model_1.loadWorkflowByName)(workflowsDir, slugOrName)
+      });
       return {
         ...result,
         filePath,
@@ -273304,7 +273542,23 @@ var require_workflow_authoring_tools = __commonJS({
     var path15 = __importStar(require("path"));
     var types_1 = require_types();
     var workflow_tools_1 = require_workflow_tools();
-    var stepConditionSchema = zod_1.z.object({
+    var simulator_1 = require_dist13();
+    var model_1 = require_dist2();
+    var conditionRuleSchema = zod_1.z.object({
+      left: zod_1.z.string().min(1).describe('Value to test, usually a template: "{{workflow:role}}"'),
+      operator: zod_1.z.enum(simulator_1.CONDITION_OPERATORS).describe("equals, not_equals, greater_than(_or_equal), less_than(_or_equal), exists, not_exists, is_empty, is_not_empty, contains, not_contains, starts_with, ends_with"),
+      right: zod_1.z.string().optional().describe("Value to compare against (omit for exists/not_exists/is_empty/is_not_empty)")
+    });
+    var rulesConditionSchema = zod_1.z.object({
+      rules: zod_1.z.object({
+        all: zod_1.z.array(conditionRuleSchema).optional().describe("AND \u2014 every rule must hold"),
+        any: zod_1.z.array(conditionRuleSchema).optional().describe("OR \u2014 at least one rule must hold")
+      }).describe("Rule group evaluated after the step runs"),
+      onFail: zod_1.z.enum(["abort", "continue", "switch"]).describe("When the rules do not hold: abort = fail the workflow; continue = stop remaining steps without failing; switch = run switchToWorkflow"),
+      switchToWorkflow: zod_1.z.string().optional().describe('Workflow slug or name to run when onFail is "switch"'),
+      returnOnComplete: zod_1.z.boolean().optional().describe('With onFail "switch": resume this workflow after the target finishes')
+    }).describe("Canonical condition: evaluated after the step; onFail steers the run");
+    var legacyConditionSchema = zod_1.z.object({
       if: zod_1.z.string().min(1).describe('Template expression to resolve, e.g. "{{workflow:role}}"'),
       equals: zod_1.z.string().optional().describe("Resolved value must equal this string"),
       notEquals: zod_1.z.string().optional().describe("Resolved value must NOT equal this string"),
@@ -273313,7 +273567,8 @@ var require_workflow_authoring_tools = __commonJS({
       greaterThan: zod_1.z.number().optional().describe("Numeric greater-than comparison"),
       lessThan: zod_1.z.number().optional().describe("Numeric less-than comparison"),
       in: zod_1.z.array(zod_1.z.string()).optional().describe("Resolved value must be one of these strings")
-    }).describe("Skip this step when the condition is not met");
+    }).describe("Legacy guard: evaluated before the step; if not met the step is skipped");
+    var stepConditionSchema = zod_1.z.union([rulesConditionSchema, legacyConditionSchema]);
     var stepRetrySchema = zod_1.z.object({
       times: zod_1.z.number().int().positive().max(10).describe("Max retry attempts (1\u201310)"),
       delayMs: zod_1.z.number().int().nonnegative().optional().describe("Delay between retries in ms (default 0)")
@@ -273328,7 +273583,7 @@ var require_workflow_authoring_tools = __commonJS({
       capture: zod_1.z.record(zod_1.z.string()).optional().describe('Save RESPONSE fields to memory: "scope:key" \u2192 "dot.path.in.response"'),
       captureInput: zod_1.z.record(zod_1.z.string()).optional().describe('Save REQUEST body fields to memory BEFORE sending: "scope:key" \u2192 "bodyField"'),
       expectStatus: zod_1.z.number().int().positive().optional().describe("Expected HTTP status (default 200; any 2xx passes when expecting 2xx)"),
-      condition: stepConditionSchema.optional().describe('Skip this step when condition is not met. Use {{workflow:key}} in the "if" field.'),
+      condition: stepConditionSchema.optional().describe("Preferred: { rules: { all|any: [{ left, operator, right }] }, onFail: abort|continue|switch } \u2014 evaluated after the step. Legacy: { if, equals\u2026 } skips the step when not met."),
       onFailure: zod_1.z.enum(["abort", "continue"]).optional().describe('"abort" (default): stop the workflow on failure. "continue": log failure and proceed (captures skipped).'),
       continueOnStatus: zod_1.z.array(zod_1.z.number().int()).optional().describe("Additional HTTP status codes treated as pass for this step (e.g. [404])."),
       retry: stepRetrySchema.optional().describe("Retry on failure \u2014 overrides the workflow-level global retry.")
@@ -273411,6 +273666,58 @@ var require_workflow_authoring_tools = __commonJS({
       const prefix = wfPath.split("/").slice(0, 3).join("/");
       return model.filter((e) => e.path.startsWith(prefix)).map((e) => `${e.method} ${e.path}`).slice(0, 3);
     }
+    function checkRulesCondition(cond, stepNo, sName, errors, warnings, ownName, workflowsDir2) {
+      const refs = [];
+      const rules = cond.rules;
+      let ruleCount = 0;
+      for (const group of ["all", "any"]) {
+        const list = rules[group];
+        if (list === void 0)
+          continue;
+        if (!Array.isArray(list)) {
+          err(errors, stepNo, sName, "BAD_CONDITION", `Step ${stepNo} "condition.rules.${group}" must be an array of rules.`, `Use "${group}": [{ "left": "{{workflow:role}}", "operator": "equals", "right": "admin" }].`);
+          continue;
+        }
+        list.forEach((rule, ri) => {
+          ruleCount++;
+          const where = `Step ${stepNo} condition.rules.${group}[${ri}]`;
+          if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+            err(errors, stepNo, sName, "BAD_CONDITION", `${where} must be an object { left, operator, right? }.`, 'Use { "left": "{{workflow:role}}", "operator": "equals", "right": "admin" }.');
+            return;
+          }
+          if (typeof rule.left !== "string" || !rule.left.trim()) {
+            err(errors, stepNo, sName, "BAD_CONDITION", `${where} needs a non-empty "left".`, 'Set "left" to a value or template like "{{workflow:role}}".');
+          } else if (!/\{\{[^}]+\}\}/.test(rule.left)) {
+            warn(warnings, stepNo, sName, "CONDITION_BARE_IF", `${where} "left" ("${rule.left}") contains no {{template}} and is compared literally.`, "Use {{workflow:key}} or {{scope:key}} to reference captured memory values.");
+          }
+          if (!simulator_1.CONDITION_OPERATORS.includes(rule.operator)) {
+            err(errors, stepNo, sName, "BAD_CONDITION_OPERATOR", `${where} has unknown operator ${JSON.stringify(rule.operator)}.`, `Use one of: ${simulator_1.CONDITION_OPERATORS.join(", ")}.`);
+          } else if (!simulator_1.UNARY_OPERATORS.includes(rule.operator) && rule.right === void 0) {
+            err(errors, stepNo, sName, "CONDITION_MISSING_RIGHT", `${where} uses "${rule.operator}" but has no "right" operand.`, 'Add "right", or use exists / not_exists / is_empty / is_not_empty.');
+          }
+          collectTemplateRefs(rule.left, refs);
+          collectTemplateRefs(rule.right, refs);
+        });
+      }
+      if (ruleCount === 0 && !errors.some((e) => e.stepIndex === stepNo && e.code === "BAD_CONDITION")) {
+        warn(warnings, stepNo, sName, "CONDITION_NO_RULES", `Step ${stepNo} condition has no rules, so it always passes.`, 'Add rules under "rules.all" or "rules.any".');
+      }
+      if (!["abort", "continue", "switch"].includes(cond.onFail)) {
+        err(errors, stepNo, sName, "BAD_CONDITION_ONFAIL", `Step ${stepNo} condition needs "onFail" of "abort", "continue" or "switch" (got ${JSON.stringify(cond.onFail)}).`, '"abort" fails the workflow, "continue" stops the remaining steps quietly, "switch" runs switchToWorkflow.');
+      } else if (cond.onFail === "switch") {
+        const target = typeof cond.switchToWorkflow === "string" ? cond.switchToWorkflow.trim() : "";
+        if (!target) {
+          err(errors, stepNo, sName, "CONDITION_SWITCH_NO_TARGET", `Step ${stepNo} uses onFail "switch" but has no "switchToWorkflow".`, 'Set "switchToWorkflow" to the slug or name of the workflow to run.');
+        } else if (ownName && target.toLowerCase() === ownName.trim().toLowerCase()) {
+          err(errors, stepNo, sName, "CONDITION_SWITCH_SELF", `Step ${stepNo} switches to this same workflow ("${target}"), which would loop.`, 'Point "switchToWorkflow" at a different workflow.');
+        } else if (!(0, model_1.loadWorkflowByName)(workflowsDir2, target)) {
+          warn(warnings, stepNo, sName, "CONDITION_SWITCH_TARGET_MISSING", `Step ${stepNo} switches to "${target}", which does not exist in .jetic/workflows yet.`, "Create that workflow before running this one, or the run fails when the condition triggers.");
+        }
+      } else if (cond.returnOnComplete !== void 0 || cond.switchToWorkflow !== void 0) {
+        warn(warnings, stepNo, sName, "CONDITION_UNUSED_SWITCH_FIELDS", `Step ${stepNo} sets switchToWorkflow/returnOnComplete but onFail is "${cond.onFail}", so they are ignored.`, 'Use onFail "switch" or remove those fields.');
+      }
+      return refs;
+    }
     function validateWorkflowDefinition2(wf, opts) {
       const errors = [];
       const warnings = [];
@@ -273447,6 +273754,7 @@ var require_workflow_authoring_tools = __commonJS({
           return;
         }
         const step = rawStep;
+        let rulesRefs = [];
         for (const key of Object.keys(step)) {
           if (MODEL_DIALECT_KEYS.has(key)) {
             err(errors, stepNo, sName, "MODEL_DIALECT_KEY", `Step ${stepNo} uses "${key}" from the model-embedded workflow dialect, which file workflows ignore.`, 'File-workflow equivalent: split "call" into method+path; replace auth/bind with inject/capture.');
@@ -273457,9 +273765,11 @@ var require_workflow_authoring_tools = __commonJS({
         if ("condition" in step && step.condition !== void 0) {
           const cond = step.condition;
           if (!cond || typeof cond !== "object" || Array.isArray(cond)) {
-            err(errors, stepNo, sName, "BAD_CONDITION", `Step ${stepNo} "condition" must be an object.`, 'Use { "condition": { "if": "{{workflow:role}}", "equals": "admin" } }.');
+            err(errors, stepNo, sName, "BAD_CONDITION", `Step ${stepNo} "condition" must be an object.`, 'Use { "condition": { "rules": { "all": [{ "left": "{{workflow:role}}", "operator": "equals", "right": "admin" }] }, "onFail": "abort" } }.');
+          } else if ((0, simulator_1.conditionKind)(cond) === "rules") {
+            rulesRefs = checkRulesCondition(cond, stepNo, sName, errors, warnings, wf.name, path15.join(projectRoot, ".jetic", "workflows"));
           } else if (!cond.if || typeof cond.if !== "string" || !cond.if.trim()) {
-            err(errors, stepNo, sName, "BAD_CONDITION", `Step ${stepNo} "condition" must have a non-empty "if" field.`, 'Set "if" to a template expression like "{{workflow:role}}".');
+            err(errors, stepNo, sName, "BAD_CONDITION", `Step ${stepNo} "condition" is neither a rules condition (needs "rules" + "onFail") nor a legacy guard (needs a non-empty "if"). The runners fail steps with an unrecognized condition.`, 'Use { "rules": { "all": [{ "left": "{{workflow:role}}", "operator": "equals", "right": "admin" }] }, "onFail": "abort" }.');
           } else {
             const operators = ["equals", "notEquals", "contains", "exists", "greaterThan", "lessThan", "in"];
             const usedOps = operators.filter((op) => op in cond && cond[op] !== void 0);
@@ -273658,6 +273968,25 @@ var require_workflow_authoring_tools = __commonJS({
             }
           }
         }
+        for (const ref of rulesRefs) {
+          if (ref.startsWith("faker."))
+            continue;
+          if (!ref.includes(":")) {
+            err(errors, stepNo, sName, "BAD_TEMPLATE", `"{{${ref}}}" in the condition of step ${stepNo} needs a scope ("{{workflow:key}}").`, "Bare {{key}} is left literal \u2014 add the scope prefix.");
+            continue;
+          }
+          const { scope, key } = splitMemKey(ref);
+          if (!key)
+            continue;
+          if (scope === "human") {
+            humanKeys.add(key);
+            continue;
+          }
+          const full = `${scope}:${key}`;
+          if (!defined.has(full) && !persistedMemory.has(full)) {
+            err(errors, stepNo, sName, "UNDEFINED_MEMORY_REF", `"{{${ref}}}" in the condition of step ${stepNo} is not captured by this or an earlier step and is not in memory.json.`, `Capture "${full}" in this step or an earlier one before referencing it in a condition.`);
+          }
+        }
       });
       return toReport(errors, warnings, humanKeys);
     }
@@ -288859,11 +289188,20 @@ var require_server3 = __commonJS({
       "  The scaffold tool already handles faker mapping \u2014 only override to {{human:key}} when a",
       "  field appears in missingFields AND genuinely requires interactive user input.",
       "",
-      "STEP 4c \u2014 CONDITIONS (branching / skipping steps)",
-      "  Add `condition` to skip a step when a memory value does not match:",
-      '    { "condition": { "if": "{{workflow:userRole}}", "equals": "admin" } }',
-      "  Operators: equals, notEquals, contains, exists (bool), greaterThan, lessThan, in (string[]).",
-      "  Skipped steps count as passed \u2014 the workflow continues.",
+      "STEP 4c \u2014 CONDITIONS (branching / assertions on memory)",
+      "  Preferred form \u2014 checked AFTER the step runs, so it can use values that step just captured:",
+      '    { "condition": { "rules": { "all": [ { "left": "{{workflow:userRole}}", "operator": "equals", "right": "admin" } ] },',
+      '                     "onFail": "abort" } }',
+      "  rules.all = AND, rules.any = OR. Operators: equals, not_equals, greater_than(_or_equal), less_than(_or_equal),",
+      "    exists, not_exists, is_empty, is_not_empty, contains, not_contains, starts_with, ends_with.",
+      "  onFail when the rules do NOT hold:",
+      '    \u2022 "abort"    \u2014 fail the workflow',
+      '    \u2022 "continue" \u2014 stop the remaining steps, workflow still passes (branch not applicable)',
+      '    \u2022 "switch"   \u2014 run another saved workflow: add "switchToWorkflow": "<slug or name>";',
+      '                   add "returnOnComplete": true to resume this workflow afterwards',
+      "  Legacy form (still supported) \u2014 a guard checked BEFORE the step; a miss skips just that step (counts as passed):",
+      '    { "condition": { "if": "{{workflow:userRole}}", "equals": "admin" } }   // equals, notEquals, contains, exists, greaterThan, lessThan, in',
+      "  A condition that is neither shape FAILS the run \u2014 it is never ignored.",
       '  Pair with onFailure:"continue" for negative/branching flows.',
       "",
       "STEP 4d \u2014 FAILURE MODES & RETRY",
@@ -288952,8 +289290,8 @@ var require_server3 = __commonJS({
       register("jetic_simulate_workflow", "Simulate workflow", "Executes a full end-to-end multi-step workflow simulation with dynamic memory capture, header injection, and schema validation against the live server.", workflow_tools_1.simulateWorkflowSchema.shape, READ_LIVE, workflow_tools_1.handleSimulateWorkflow);
       register("jetic_simulate", "Simulate workflow (alias)", "Alias of jetic_simulate_workflow: runs a multi-step user-journey workflow against the live server. Prefer jetic_simulate_workflow in new prompts.", workflow_tools_1.simulateWorkflowSchema.shape, READ_LIVE, workflow_tools_1.handleSimulateWorkflow);
       register("jetic_scaffold_workflow", "Scaffold workflow steps from model", "PHASE 4a \u2014 FIRST STEP when building a workflow. Given an ordered endpoint list, reads model.json and returns ready-made `draftSteps`: body fields faker-mapped by type/format/name, inject derived from securitySchemes.obtainedFrom token-producer chains, capture from endpoint.produces, captureInput for reusable credentials. Returns missingFields (fields needing human input or manual fix) and securityChain analysis. Does NOT save. Review draftSteps, then call jetic_validate_workflow \u2192 jetic_create_workflow.", workflow_designer_tools_1.scaffoldWorkflowSchema.shape, READ_ONLY, workflow_designer_tools_1.handleScaffoldWorkflow);
-      register("jetic_validate_workflow", "Validate workflow (dry run)", "Deep-validates a workflow WITHOUT saving: step structure, endpoint cross-checks against model.json, full memory data-flow analysis. Now also validates condition (including condition.if template refs), onFailure, continueOnStatus, and retry fields. Accepts a saved workflow slug/name or an inline definition.", workflow_authoring_tools_1.validateWorkflowSchema.shape, READ_ONLY, workflow_authoring_tools_1.handleValidateWorkflow);
-      register("jetic_create_workflow", "Create workflow", "Creates a .jetic/workflows/<slug>.json workflow. Supports: condition (skip steps based on memory), onFailure (abort|continue), continueOnStatus (extra pass codes), retry (per-step or global default). Refuses to save on validation errors.", workflow_authoring_tools_1.createWorkflowSchema.shape, WRITES_MODEL, workflow_authoring_tools_1.handleCreateWorkflow);
+      register("jetic_validate_workflow", "Validate workflow (dry run)", "Deep-validates a workflow WITHOUT saving: step structure, endpoint cross-checks against model.json, full memory data-flow analysis. Also validates conditions (rules + onFail/switch targets, or legacy if guards; template refs), onFailure, continueOnStatus, and retry fields. Accepts a saved workflow slug/name or an inline definition.", workflow_authoring_tools_1.validateWorkflowSchema.shape, READ_ONLY, workflow_authoring_tools_1.handleValidateWorkflow);
+      register("jetic_create_workflow", "Create workflow", "Creates a .jetic/workflows/<slug>.json workflow. Supports: condition (rules with onFail abort|continue|switch, or legacy if-guards), onFailure (abort|continue), continueOnStatus (extra pass codes), retry (per-step or global default). Refuses to save on validation errors.", workflow_authoring_tools_1.createWorkflowSchema.shape, WRITES_MODEL, workflow_authoring_tools_1.handleCreateWorkflow);
       register("jetic_update_workflow", "Update workflow", "Updates a saved file workflow: rename, description/environment, full steps replacement, or appendSteps. Validates before writing and refuses to save on errors.", workflow_authoring_tools_1.updateWorkflowSchema.shape, WRITES_MODEL, workflow_authoring_tools_1.handleUpdateWorkflow);
       register("jetic_delete_workflow", "Delete workflow", "Deletes a saved .jetic/workflows/*.json workflow file by slug, name, or path. Destructive: confirm with the user before calling. Cannot delete model.json-embedded workflows.", workflow_authoring_tools_1.deleteWorkflowSchema.shape, DESTRUCTIVE, workflow_authoring_tools_1.handleDeleteWorkflow);
       register("jetic_list_agents", "List agents", "Lists registered deterministic agents (model-watcher, workflow-impact) available to jetic_run_agent.", agent_tools_1.listAgentsSchema.shape, READ_ONLY, agent_tools_1.handleListAgents);
@@ -289697,9 +290035,12 @@ Running ${files.length} workflow(s)...
   for (const file of files) {
     const workflow = (0, import_model2.readWorkflowDefinitionFile)(path9.join(config.workflowsDir, file));
     import_core11.jeticEvents.emit("workflow.started", { workflowId: workflow.name });
-    const simulator = new import_simulator.WorkflowSimulator(model, targetEnv);
-    const result = await simulator.simulateWorkflow(workflow);
-    results.push({ name: workflow.name, passed: result.success, durationMs: result.stats.totalTimeMs });
+    const simulator = new import_simulator.WorkflowSimulator(model, targetEnv, { projectRoot: config.projectRoot });
+    const result = await simulator.simulateWorkflow(workflow, {
+      loadWorkflow: (slugOrName) => (0, import_model2.loadWorkflowByName)(config.workflowsDir, slugOrName)
+    });
+    const failures = result.results.filter((r) => !r.passed).map((r) => ({ step: r.name, status: r.actualStatus, error: r.error }));
+    results.push({ name: workflow.name, passed: result.success, durationMs: result.stats.totalTimeMs, failures });
     if (result.success) {
       import_core11.jeticEvents.emit("workflow.completed", { workflowId: workflow.name, passed: true });
     } else {
@@ -289707,6 +290048,10 @@ Running ${files.length} workflow(s)...
     }
     if (!options.ci) {
       console.log(`  ${result.success ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m"} ${workflow.name}`);
+      for (const failure of failures) {
+        const detail = failure.error ?? (failure.status ? `HTTP ${failure.status}` : "failed");
+        console.log(`      \x1B[2m\u21B3 ${failure.step}: ${detail}\x1B[0m`);
+      }
     }
   }
   const passed = results.filter((r) => r.passed).length;
@@ -289830,7 +290175,7 @@ memoryCommand.command("clear").description("Clear memory").action(() => {
 init_cjs_shims();
 var import_commander15 = require("commander");
 var import_core14 = __toESM(require_dist());
-var import_simulator2 = __toESM(require_dist13());
+var import_simulator3 = __toESM(require_dist13());
 var path12 = __toESM(require("path"));
 
 // src/commands/simulate-workflow.ts
@@ -289839,7 +290184,9 @@ var path11 = __toESM(require("path"));
 var fs7 = __toESM(require("fs"));
 var import_commander14 = require("commander");
 var import_core13 = __toESM(require_dist());
+var import_model5 = __toESM(require_dist2());
 var import_memory2 = __toESM(require_dist12());
+var import_simulator2 = __toESM(require_dist13());
 var import_faker = require("@faker-js/faker");
 var c = {
   reset: "\x1B[0m",
@@ -289896,58 +290243,32 @@ function deepGet(obj, dotPath) {
 async function resolveConditionRef(ref, context = "condition") {
   return ref.replace(/\{\{([^}]+)\}\}/g, () => "").trim() === ref.trim() ? ref : await resolveTemplateString(ref, context);
 }
-async function evalConditionRule(rule, context = "condition") {
-  const left = await resolveConditionRef(rule.left, context);
-  const right = rule.right !== void 0 ? await resolveConditionRef(rule.right, context) : void 0;
-  const op = rule.operator;
-  switch (op) {
-    case "equals":
-      return left === right;
-    case "not_equals":
-      return left !== right;
-    case "greater_than":
-      return Number(left) > Number(right);
-    case "greater_than_or_equal":
-      return Number(left) >= Number(right);
-    case "less_than":
-      return Number(left) < Number(right);
-    case "less_than_or_equal":
-      return Number(left) <= Number(right);
-    case "exists":
-      return left !== "" && left !== void 0;
-    case "not_exists":
-      return left === "" || left === void 0;
-    case "is_empty":
-      return left === "";
-    case "is_not_empty":
-      return left !== "";
-    case "contains":
-      return right !== void 0 && left.includes(right);
-    case "not_contains":
-      return right !== void 0 && !left.includes(right);
-    case "starts_with":
-      return right !== void 0 && left.startsWith(right);
-    case "ends_with":
-      return right !== void 0 && left.endsWith(right);
-    default:
-      return false;
-  }
-}
 async function evaluateStepCondition(condition, context = "condition") {
-  const { rules } = condition;
-  const ruleList = rules.all ?? rules.any ?? [];
-  const isAnd = !!rules.all;
-  if (ruleList.length === 0) return { passed: true, reason: "No rules defined" };
-  const results = [];
-  for (const rule of ruleList) {
-    results.push({ rule, ok: await evalConditionRule(rule, context) });
+  return (0, import_simulator2.evaluateRules)(condition.rules, (value) => resolveConditionRef(value, context));
+}
+async function preStepCondition(step) {
+  if (!step.condition) return null;
+  const label = step.name || `${step.method} ${step.path}`;
+  const base = { step, status: 0, responseBody: null, durationMs: 0, captured: [], injected: {} };
+  const kind = (0, import_simulator2.conditionKind)(step.condition);
+  if (kind === "invalid") {
+    return { ...base, passed: false, error: `Step "${label}": ${(0, import_simulator2.describeInvalidCondition)(step.condition)}` };
+  }
+  if (kind === "legacy") {
+    const outcome = await (0, import_simulator2.evaluateLegacyCondition)(
+      step.condition,
+      (value) => resolveConditionRef(value, `condition of step "${label}"`)
+    );
+    if (!outcome.matched) {
+      return {
+        ...base,
+        passed: true,
+        skipped: true,
+        conditionResult: { passed: false, reason: `legacy guard not met (resolved "${outcome.evaluated}")` }
+      };
+    }
   }
-  const passed = isAnd ? results.every((r) => r.ok) : results.some((r) => r.ok);
-  const failing = results.filter((r) => !r.ok);
-  const reason = passed ? `All conditions met (${isAnd ? "AND" : "OR"})` : `Failed: ${failing.map(
-    (r) => `${r.rule.left} ${r.rule.operator}${r.rule.right !== void 0 ? " " + r.rule.right : ""}`
-  ).join(", ")}`;
-  return { passed, reason };
+  return null;
 }
 function envKeyForHuman(key) {
   return `JETIC_HUMAN_${key.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
@@ -290236,12 +290557,14 @@ function renderStepResult(result, index, total) {
       console.log(`  ${CHAIN}   ${c.green}\u{1F4BE} captured ${cap}${c.reset}`);
     }
   }
-  if (result.conditionResult) {
+  if (result.skipped) {
+    console.log(`  ${CHAIN}   ${c.yellow}\u2298 skipped${c.reset}  ${c.dim}${result.conditionResult?.reason ?? ""}${c.reset}`);
+  } else if (result.conditionResult) {
     const { passed: condPassed, reason } = result.conditionResult;
     const condIcon = condPassed ? `${c.magenta}\u25C7${c.reset}` : `${c.yellow}\u25C8${c.reset}`;
     const condColor = condPassed ? c.magenta : c.yellow;
     console.log(`  ${CHAIN}   ${condIcon} ${condColor}condition ${condPassed ? "passed" : "failed"}${c.reset}  ${c.dim}${reason}${c.reset}`);
-    if (!condPassed && result.step.condition) {
+    if (!condPassed && (0, import_simulator2.isRulesCondition)(result.step.condition)) {
       const { onFail, switchToWorkflow } = result.step.condition;
       const actionStr = onFail === "switch" ? `switching to workflow: ${switchToWorkflow ?? "unknown"}` : onFail === "continue" ? "continuing without remaining steps" : "aborting workflow";
       console.log(`  ${CHAIN}   ${c.yellow}  \u2192 ${actionStr}${c.reset}`);
@@ -290458,12 +290781,17 @@ var simulateWorkflowCommand = new import_commander14.Command("workflow").descrip
     spinner.start(`${stepLabel}  ${c.dim}${step.name}${c.reset}...`);
     let result;
     try {
-      result = await executeStep(step, baseUrl, {});
-      if (step.condition) {
+      const preempted = await preStepCondition(step);
+      result = preempted ?? await executeStep(step, baseUrl, {});
+      if (!preempted && (0, import_simulator2.isRulesCondition)(step.condition)) {
         const condResult = await evaluateStepCondition(step.condition, `condition of step "${step.name || step.path}"`);
         result.conditionResult = condResult;
         if (!condResult.passed) {
           const { onFail, switchToWorkflow } = step.condition;
+          if (onFail === "abort") {
+            result.passed = false;
+            result.error = `Condition failed: ${condResult.reason}`;
+          }
           results.push(result);
           const icon2 = result.passed ? TICK : CROSS;
           spinner.stop(`  ${icon2} ${stepLabel}  ${formatStatus(result.status)}  ${c.dim}${result.durationMs}ms${c.reset}`);
@@ -290481,10 +290809,9 @@ var simulateWorkflowCommand = new import_commander14.Command("workflow").descrip
           } else if (onFail === "switch" && switchToWorkflow) {
             console.log(`  ${ARROW} Condition failed \u2014 switching to workflow: ${c.bold}${switchToWorkflow}${c.reset}
 `);
-            const switchPath = path11.join(workflowsDir, `${switchToWorkflow}.json`);
-            if (fs7.existsSync(switchPath)) {
+            const switchedWorkflow = (0, import_model5.loadWorkflowByName)(workflowsDir, switchToWorkflow);
+            if (switchedWorkflow) {
               try {
-                const switchedWorkflow = JSON.parse(fs7.readFileSync(switchPath, "utf-8"));
                 console.log(`  ${TICK} Loaded switch workflow: ${c.bold}${switchedWorkflow.name}${c.reset}
 `);
                 renderWorkflowHeader(switchedWorkflow);
@@ -290495,8 +290822,9 @@ var simulateWorkflowCommand = new import_commander14.Command("workflow").descrip
                   const switchLabel = `${c.dim}${si + 1}/${switchedWorkflow.steps.length}${c.reset}  ${getMethodColor(switchStep.method)}${switchStep.method}${c.reset} ${switchStep.path}`;
                   const switchSpinner = new Spinner();
                   switchSpinner.start(`${switchLabel}  ${c.dim}${switchStep.name}${c.reset}...`);
-                  const switchResult = await executeStep(switchStep, baseUrl, {});
-                  if (switchStep.condition) {
+                  const switchPre = await preStepCondition(switchStep);
+                  const switchResult = switchPre ?? await executeStep(switchStep, baseUrl, {});
+                  if (!switchPre && (0, import_simulator2.isRulesCondition)(switchStep.condition)) {
                     switchResult.conditionResult = await evaluateStepCondition(
                       switchStep.condition,
                       `condition of step "${switchStep.name || switchStep.path}"`
@@ -290508,12 +290836,16 @@ var simulateWorkflowCommand = new import_commander14.Command("workflow").descrip
                   renderStepResult(switchResult, si, switchedWorkflow.steps.length);
                 }
               } catch (e) {
-                console.log(`  ${c.red}\u2717 Failed to load switch workflow: ${e.message}${c.reset}
+                console.log(`  ${c.red}\u2717 Failed to run switch workflow: ${e.message}${c.reset}
 `);
+                result.passed = false;
+                result.error = `Switch workflow "${switchToWorkflow}" failed: ${e.message}`;
               }
             } else {
-              console.log(`  ${c.yellow}\u26A0 Switch workflow not found: ${switchPath}${c.reset}
+              console.log(`  ${c.red}\u2717 Switch workflow not found: ${switchToWorkflow}${c.reset}
 `);
+              result.passed = false;
+              result.error = `Switch workflow "${switchToWorkflow}" was not found in ${workflowsDir}`;
             }
             if (step.condition.returnOnComplete) {
               console.log(`  ${c.green}\u21A9 Sub-workflow complete. Returning to main workflow...${c.reset}
@@ -290524,6 +290856,14 @@ var simulateWorkflowCommand = new import_commander14.Command("workflow").descrip
               break;
             }
           }
+          if (onFail === "switch" && !switchToWorkflow) {
+            console.log(`  ${c.red}\u2717 Condition failed and onFail "switch" has no switchToWorkflow.${c.reset}
+`);
+            result.passed = false;
+            result.error = 'onFail "switch" has no switchToWorkflow';
+            stopOnFailure = true;
+            break;
+          }
           continue;
         }
       }
@@ -290538,9 +290878,15 @@ var simulateWorkflowCommand = new import_commander14.Command("workflow").descrip
       throw err;
     }
     results.push(result);
-    const icon = result.passed ? TICK : CROSS;
+    const icon = result.skipped ? SKIP : result.passed ? TICK : CROSS;
     spinner.stop(`  ${icon} ${stepLabel}  ${formatStatus(result.status)}  ${c.dim}${result.durationMs}ms${c.reset}`);
     renderStepResult(result, i, workflow.steps.length);
+    if (!result.passed && result.error && !result.status && (0, import_simulator2.conditionKind)(step.condition) === "invalid") {
+      console.log(`  ${c.red}${c.bold}\u26A0 Unrecognized condition \u2014 stopping workflow.${c.reset}
+`);
+      stopOnFailure = true;
+      break;
+    }
     if (!result.passed && (step.path.includes("/login") || step.path.includes("/register") || step.path.includes("/auth"))) {
       console.log(`  ${c.red}${c.bold}\u26A0 Auth step failed \u2014 stopping workflow to prevent cascading failures.${c.reset}
 `);
@@ -290663,15 +291009,19 @@ var Spinner2 = class {
     }
   }
 };
-async function selectEnvironment(environments) {
+function defaultEnvironment(model, environments) {
+  const defaultName = model.defaultEnvironment ?? environments.find((e) => e.default)?.name;
+  return environments.find((e) => e.name === defaultName) ?? environments[0];
+}
+async function selectEnvironment(model, environments) {
   if (environments.length === 0) {
     console.log(`  ${c2.yellow}\u26A0${c2.reset}  No environments defined in model.json`);
     console.log(`  ${c2.dim}Using default: http://localhost:3000${c2.reset}
 `);
     return { name: "default", baseUrl: "http://localhost:3000" };
   }
-  if (environments.length === 1) {
-    const env = environments[0];
+  if (environments.length === 1 || !process.stdin.isTTY) {
+    const env = defaultEnvironment(model, environments);
     console.log(`  ${c2.cyan}\u{1F30D}${c2.reset} Environment: ${c2.bold}${env.name}${c2.reset} ${c2.dim}\u2192 ${env.baseUrl}${c2.reset}
 `);
     return env;
@@ -290914,7 +291264,7 @@ function loadModel3() {
 }
 var simulateCommand = new import_commander15.Command("simulate").description("Simulate API endpoints against a live server");
 simulateCommand.addCommand(simulateWorkflowCommand);
-simulateCommand.command("endpoint [method] [endpointPath]").description("Simulate a specific endpoint or all endpoints").option("--all", "Simulate all endpoints").option("--verbose", "Show detailed request/response info", false).action(async (method, endpointPath, options) => {
+simulateCommand.command("endpoint [method] [endpointPath]").description("Simulate a specific endpoint or all endpoints").option("--all", "Simulate all endpoints").option("--verbose", "Show detailed request/response info", false).option("--env <name>", "Environment name to use from model.json (skips the interactive picker)").action(async (method, endpointPath, options) => {
   console.log("");
   console.log(`  ${c2.bgCyan}${c2.black}${c2.bold} JETIC ${c2.reset}  ${c2.cyan}${c2.bold}Endpoint Simulator${c2.reset}`);
   console.log("");
@@ -290928,7 +291278,20 @@ simulateCommand.command("endpoint [method] [endpointPath]").description("Simulat
   console.log(`  ${c2.dim}Model v${model.version} \u2022 ${model.endpoints.length} endpoints${c2.reset}
 `);
   const environments = model.environments || [];
-  const selectedEnv = await selectEnvironment(environments);
+  let selectedEnv;
+  if (options.env) {
+    const named = environments.find((e) => e.name === options.env);
+    if (!named) {
+      console.log(`  ${c2.red}\u2717${c2.reset} Environment ${c2.bold}${options.env}${c2.reset} not found. Available: ${environments.map((e) => e.name).join(", ") || "(none)"}
+`);
+      process.exit(2);
+    }
+    selectedEnv = named;
+    console.log(`  ${c2.cyan}\u{1F30D}${c2.reset} Environment: ${c2.bold}${named.name}${c2.reset} ${c2.dim}\u2192 ${named.baseUrl}${c2.reset}
+`);
+  } else {
+    selectedEnv = await selectEnvironment(model, environments);
+  }
   const checkSpinner = new Spinner2();
   checkSpinner.start(`Checking if backend is active at ${selectedEnv.baseUrl}...`);
   try {
@@ -290942,7 +291305,7 @@ simulateCommand.command("endpoint [method] [endpointPath]").description("Simulat
 `);
     process.exit(1);
   }
-  const simulator = new import_simulator2.EndpointSimulator(model, selectedEnv);
+  const simulator = new import_simulator3.EndpointSimulator(model, selectedEnv);
   const spinner = new Spinner2();
   if (options.all) {
     console.log(`  ${c2.magenta}\u{1F680}${c2.reset} Simulating ${c2.bold}${model.endpoints.length}${c2.reset} endpoints...
@@ -291005,8 +291368,9 @@ var import_commander16 = require("commander");
 var import_express = __toESM(require("express"));
 var import_path = __toESM(require("path"));
 var import_fs = __toESM(require("fs"));
-var import_model5 = __toESM(require_dist2());
+var import_model6 = __toESM(require_dist2());
 var import_memory3 = __toESM(require_dist12());
+var import_simulator4 = __toESM(require_dist13());
 var IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".cache", "__pycache__", ".next", ".nuxt", ".venv"]);
 var IGNORED_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".mp4", ".webm", ".woff", ".woff2", ".ttf", ".eot", ".map"]);
 var SOURCE_EXTS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".java", ".kt", ".cs", ".rb", ".php", ".json", ".yaml", ".yml", ".toml", ".env", ".graphql", ".gql", ".sql", ".prisma", ".proto"]);
@@ -291155,7 +291519,7 @@ var ChangeScanner = class {
     this.saveChanges(data);
   }
 };
-var devCommand = new import_commander16.Command("dev").description("Start the Jetic local dashboard").option("-p, --port <number>", "Port to run the dashboard on", "8787").action(async (options) => {
+var devCommand = new import_commander16.Command("dev").description("Start the Jetic local dashboard").option("-p, --port <number>", "Port to run the dashboard on", "8787").option("--no-open", "Do not open the dashboard in a browser (also: JETIC_NO_OPEN=1)").action(async (options) => {
   const port = parseInt(options.port, 10);
   const app = (0, import_express.default)();
   const projectRoot = process.cwd();
@@ -291183,7 +291547,7 @@ var devCommand = new import_commander16.Command("dev").description("Start the Je
     const jeticDir2 = import_path.default.join(process.cwd(), ".jetic");
     const modelDir = import_path.default.join(jeticDir2, "model");
     try {
-      if ((0, import_model5.hasYamlModel)(modelDir)) return res.json((0, import_model5.loadModelFromDir)(modelDir));
+      if ((0, import_model6.hasYamlModel)(modelDir)) return res.json((0, import_model6.loadModelFromDir)(modelDir));
       const modelPath = import_path.default.join(jeticDir2, "model.json");
       if (!import_fs.default.existsSync(modelPath)) return res.json(null);
       res.json(JSON.parse(import_fs.default.readFileSync(modelPath, "utf8")));
@@ -291793,57 +292157,43 @@ var devCommand = new import_commander16.Command("dev").description("Start the Je
       }
       return result;
     }
-    async function evalCondRule(rule, stepIndex, stepName) {
-      const left = await resolveCondRef(rule.left, stepIndex, stepName);
-      const right = rule.right !== void 0 ? await resolveCondRef(rule.right, stepIndex, stepName) : void 0;
-      switch (rule.operator) {
-        case "equals":
-          return left === right;
-        case "not_equals":
-          return left !== right;
-        case "greater_than":
-          return Number(left) > Number(right);
-        case "greater_than_or_equal":
-          return Number(left) >= Number(right);
-        case "less_than":
-          return Number(left) < Number(right);
-        case "less_than_or_equal":
-          return Number(left) <= Number(right);
-        case "exists":
-          return left !== "" && left !== void 0;
-        case "not_exists":
-          return left === "" || left === void 0;
-        case "is_empty":
-          return left === "";
-        case "is_not_empty":
-          return left !== "";
-        case "contains":
-          return right !== void 0 && left.includes(right);
-        case "not_contains":
-          return right !== void 0 && !left.includes(right);
-        case "starts_with":
-          return right !== void 0 && left.startsWith(right);
-        case "ends_with":
-          return right !== void 0 && left.endsWith(right);
-        default:
-          return false;
-      }
-    }
     async function evalCondition(condition, stepIndex, stepName) {
-      const rules = condition.rules?.all ?? condition.rules?.any ?? [];
-      const isAnd = !!condition.rules?.all;
-      if (rules.length === 0) return { passed: true, reason: "No rules" };
-      const results = [];
-      for (const rule of rules) results.push({ rule, ok: await evalCondRule(rule, stepIndex, stepName) });
-      const passed2 = isAnd ? results.every((r) => r.ok) : results.some((r) => r.ok);
-      const failing = results.filter((r) => !r.ok);
-      const reason = passed2 ? `All conditions met (${isAnd ? "AND" : "OR"})` : `Failed: ${failing.map((r) => `${r.rule.left} ${r.rule.operator}${r.rule.right !== void 0 ? " " + r.rule.right : ""}`).join(", ")}`;
-      return { passed: passed2, reason };
+      return (0, import_simulator4.evaluateRules)(condition.rules ?? {}, (value) => resolveCondRef(value, stepIndex, stepName));
     }
     for (let i = 0; i < workflow.steps.length; i++) {
       if (aborted) break;
       const step = workflow.steps[i];
       send("step_start", { index: i, step: { name: step.name, method: step.method, path: step.path } });
+      const condKind = step.condition ? (0, import_simulator4.conditionKind)(step.condition) : void 0;
+      const stepSummary = { name: step.name, method: step.method, path: step.path, description: step.description };
+      if (condKind === "invalid") {
+        const reason = `Step ${i + 1} "${step.name || `${step.method} ${step.path}`}": ${(0, import_simulator4.describeInvalidCondition)(step.condition)}`;
+        failed++;
+        send("step_result", { index: i, step: stepSummary, status: 0, passed: false, durationMs: 0, captured: [], injected: {}, responseBody: null, error: reason });
+        send("aborted", { index: i, reason });
+        res.end();
+        return;
+      }
+      if (condKind === "legacy") {
+        const guard = await (0, import_simulator4.evaluateLegacyCondition)(step.condition, (value) => resolveCondRef(value, i, step.name || ""));
+        if (!guard.matched) {
+          passed++;
+          send("step_result", {
+            index: i,
+            step: stepSummary,
+            status: 0,
+            passed: true,
+            skipped: true,
+            durationMs: 0,
+            captured: [],
+            injected: {},
+            responseBody: null,
+            error: null,
+            skipReason: `legacy guard not met (resolved "${guard.evaluated}")`
+          });
+          continue;
+        }
+      }
       let result;
       try {
         result = await executeStep2(step, i);
@@ -291868,7 +292218,7 @@ var devCommand = new import_commander16.Command("dev").description("Start the Je
         responseBody: result.responseBody,
         error: result.error
       });
-      if (step.condition && !aborted) {
+      if ((0, import_simulator4.isRulesCondition)(step.condition) && !aborted) {
         const condResult = await evalCondition(step.condition, i, step.name || `${step.method} ${step.path}`);
         send("condition_result", {
           index: i,
@@ -292050,6 +292400,8 @@ var devCommand = new import_commander16.Command("dev").description("Start the Je
     console.log(`
 \u{1F680} Jetic Studio is running at ${url}
 `);
+    const noOpenEnv = process.env.JETIC_NO_OPEN;
+    if (!options.open || noOpenEnv && noOpenEnv !== "0" && noOpenEnv.toLowerCase() !== "false") return;
     const { exec } = require("child_process");
     const start = process.platform == "darwin" ? "open" : process.platform == "win32" ? "start" : "xdg-open";
     exec(`${start} ${url}`);