jetic-cli 0.2.5 → 0.2.7

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,22 @@ 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();
+    var CONNECTION_ERROR_CODES = /* @__PURE__ */ new Set([
+      "ECONNREFUSED",
+      "ECONNRESET",
+      "ENOTFOUND",
+      "EAI_AGAIN",
+      "ETIMEDOUT",
+      "EHOSTUNREACH",
+      "ENETUNREACH",
+      "UND_ERR_CONNECT_TIMEOUT",
+      "UND_ERR_SOCKET"
+    ]);
+    function networkErrorCode(error) {
+      const raw = error?.cause?.code ?? error?.cause?.errno ?? error?.code ?? error?.errno;
+      return typeof raw === "string" ? raw : void 0;
+    }
     function deepGet2(obj, dotPath) {
       if (obj === null || obj === void 0)
         return void 0;
@@ -272509,27 +272704,120 @@ var require_workflow_simulator = __commonJS({
     var WorkflowSimulator2 = class {
       model;
       environment;
-      constructor(model, environment) {
+      runtime;
+      strictTemplates = true;
+      requestTimeoutMs = 3e4;
+      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;
+        this.strictTemplates = options?.strictTemplates ?? true;
+        this.requestTimeoutMs = options?.requestTimeoutMs ?? 3e4;
         const startTime = Date.now();
-        const stepResults = [];
-        let allPassed = true;
+        const preflightMode = options?.preflight ?? "off";
+        const preflight = preflightMode !== "off" && workflow.steps.length > 0 ? await this.runPreflight(this.environment.baseUrl, options?.preflightTimeoutMs ?? 3e3) : void 0;
+        if (preflight && preflightMode === "abort" && preflight.verdict === "unreachable") {
+          preflight.aborted = true;
+          return {
+            success: false,
+            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: 0,
+              passedSteps: 0,
+              failedSteps: 0,
+              totalTimeMs: Date.now() - startTime
+            },
+            results: [],
+            preflight,
+            abortReason: preflight.message
+          };
+        }
+        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,
+          ...preflight ? { preflight } : {}
+        };
+      }
+      /**
+       * 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, false);
         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: "",
@@ -272548,12 +272836,44 @@ var require_workflow_simulator = __commonJS({
               continue;
             }
           }
-          const { headers: injectedHeaders, body: injectedBody } = await this.resolveInjections(step.inject);
-          const resolvedBody = await this.resolveBodyTemplates(step.body || {});
-          const finalBody = { ...injectedBody, ...resolvedBody };
-          const inputCaptured = await this.captureInputToMemory(step.captureInput, finalBody);
-          const resolvedPath = await this.resolvePathParams(step.path, finalBody);
-          const fullUrl = `${baseUrl.replace(/\/$/, "")}${resolvedPath}`;
+          let injectedHeaders = {};
+          let finalBody = {};
+          let resolvedQuery = {};
+          let resolvedPath = step.path;
+          let fullUrl = "";
+          let inputCaptured = [];
+          try {
+            const injections = await this.resolveInjections(step.inject);
+            injectedHeaders = injections.headers;
+            const resolvedBody = await this.resolveBodyTemplates(step.body || {});
+            finalBody = { ...injections.body, ...resolvedBody };
+            resolvedQuery = await this.resolveBodyTemplates(step.query || {});
+            inputCaptured = await this.captureInputToMemory(step.captureInput, finalBody);
+            resolvedPath = await this.resolvePathParams(step.path, finalBody);
+            fullUrl = `${baseUrl.replace(/\/$/, "")}${resolvedPath}`;
+          } catch (err) {
+            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}": ${err?.message || err}`
+            });
+            state.allPassed = false;
+            state.halted = true;
+            return "stop";
+          }
           const expectedStatus = step.expectStatus ?? 200;
           const maxAttempts = Math.max(1, step.retry?.times ?? workflow.retry?.times ?? 1);
           const retryDelayMs = step.retry?.delayMs ?? workflow.retry?.delayMs ?? 0;
@@ -272562,6 +272882,7 @@ var require_workflow_simulator = __commonJS({
           let responseBody = null;
           let stepPassed = false;
           let errorMsg;
+          let connectionCode;
           while (attempts < maxAttempts) {
             attempts++;
             if (attempts > 1 && retryDelayMs > 0) {
@@ -272570,22 +272891,42 @@ var require_workflow_simulator = __commonJS({
             responseStatus = 0;
             responseBody = null;
             errorMsg = void 0;
+            connectionCode = void 0;
+            const timeoutMs = step.timeoutMs ?? this.requestTimeoutMs;
             try {
+              const upperMethod = step.method.toUpperCase();
               const fetchOptions = {
-                method: step.method.toUpperCase(),
+                method: upperMethod,
                 headers: { "Content-Type": "application/json", ...injectedHeaders }
               };
-              if (!["GET", "HEAD"].includes(step.method.toUpperCase()) && Object.keys(finalBody).length > 0) {
+              if (!["GET", "HEAD"].includes(upperMethod) && Object.keys(finalBody).length > 0) {
                 fetchOptions.body = JSON.stringify(finalBody);
               }
+              if (timeoutMs > 0) {
+                fetchOptions.signal = AbortSignal.timeout(timeoutMs);
+              }
               let finalUrl = fullUrl;
-              if (["GET", "HEAD"].includes(step.method.toUpperCase()) && Object.keys(finalBody).length > 0) {
+              const bodyAsQuery = ["GET", "HEAD"].includes(upperMethod) && Object.keys(finalBody).length > 0;
+              if (Object.keys(resolvedQuery).length > 0 || bodyAsQuery) {
                 const params = new URLSearchParams();
-                for (const [k, v] of Object.entries(finalBody)) {
-                  if (v !== void 0 && v !== null)
-                    params.set(k, String(v));
-                }
-                finalUrl = `${fullUrl}?${params.toString()}`;
+                const append = (source) => {
+                  for (const [k, v] of Object.entries(source)) {
+                    if (v === void 0 || v === null)
+                      continue;
+                    if (Array.isArray(v)) {
+                      for (const item of v)
+                        params.append(k, typeof item === "object" ? JSON.stringify(item) : String(item));
+                    } else {
+                      params.append(k, typeof v === "object" ? JSON.stringify(v) : String(v));
+                    }
+                  }
+                };
+                append(resolvedQuery);
+                if (bodyAsQuery)
+                  append(finalBody);
+                const qs = params.toString();
+                if (qs)
+                  finalUrl = `${fullUrl}${fullUrl.includes("?") ? "&" : "?"}${qs}`;
               }
               const resp = await fetch(finalUrl, fetchOptions);
               responseStatus = resp.status;
@@ -272605,151 +272946,206 @@ var require_workflow_simulator = __commonJS({
                 break;
             } catch (err) {
               stepPassed = false;
-              errorMsg = err.message || String(err);
+              connectionCode = networkErrorCode(err);
+              if (err?.name === "TimeoutError" || connectionCode === "ETIMEDOUT") {
+                errorMsg = `Request timed out after ${timeoutMs}ms (${step.method} ${resolvedPath}).`;
+              } else if (connectionCode === "ECONNREFUSED") {
+                errorMsg = `Connection refused (ECONNREFUSED) at ${baseUrl} \u2014 the server is not accepting connections.`;
+              } else {
+                errorMsg = err?.message || String(err);
+              }
             }
           }
           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,
+            ...Object.keys(resolvedQuery).length > 0 ? { requestQuery: resolvedQuery } : {},
             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";
-        }
-        return { matched, evaluated };
-      }
-      async resolveTemplateString(value) {
-        const templateRe = /\{\{([^}]+)\}\}/g;
-        let match;
-        const replacements = [];
-        while ((match = templateRe.exec(value)) !== null) {
-          const expr = match[1].trim();
-          if (expr.includes(":") && !expr.startsWith("faker.")) {
-            const colonIdx = expr.indexOf(":");
-            const scope = expr.slice(0, colonIdx);
-            const key = expr.slice(colonIdx + 1);
-            if (scope === "human") {
-              const envVal = process.env[`JETIC_HUMAN_${key.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`];
-              if (envVal !== void 0 && envVal !== "") {
-                replacements.push({ placeholder: match[0], resolved: envVal });
-                continue;
-              }
+            capturedMemory: stepPassed ? [...inputCaptured, ...responseCaptured] : [...inputCaptured],
+            ...stepPassed ? {} : {
+              failureHandling: onFailure === "continue" ? "continued" : "aborted",
+              error: errorMsg
             }
-            const mem = new memory_1.JeticMemory({ scope });
-            const memVal = await mem.get(key);
-            replacements.push({ placeholder: match[0], resolved: memVal != null ? String(memVal) : "" });
+          };
+          state.results.push(result);
+          if (!stepPassed) {
+            state.allPassed = false;
+            if (connectionCode && CONNECTION_ERROR_CODES.has(connectionCode)) {
+              const remaining = workflow.steps.length - (i + 1);
+              result.failureHandling = "aborted";
+              result.error = `${result.error || "Connection failed"}; aborting early because the target is unreachable${remaining > 0 ? ` (${remaining} step(s) not executed)` : ""}.`;
+              state.halted = true;
+              return "stop";
+            }
+            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 "done";
+      }
+      findPlaceholders(value) {
+        const placeholders = [];
+        let i = 0;
+        while (i < value.length - 1) {
+          if (value[i] !== "{" || value[i + 1] !== "{") {
+            i++;
             continue;
           }
-          if (expr.startsWith("faker.")) {
-            const parts = expr.split(".");
-            try {
-              let fn = faker_1.faker;
-              for (const part of parts.slice(1))
-                fn = fn[part];
-              const generated = typeof fn === "function" ? fn() : fn;
-              replacements.push({ placeholder: match[0], resolved: String(generated) });
-            } catch {
-              replacements.push({ placeholder: match[0], resolved: expr });
+          let depth = 0;
+          let closed = -1;
+          let j = i + 2;
+          while (j < value.length) {
+            const ch = value[j];
+            if (ch === "{")
+              depth++;
+            else if (ch === "}") {
+              if (depth > 0)
+                depth--;
+              else if (value[j + 1] === "}") {
+                closed = j;
+                break;
+              }
             }
-            continue;
+            j++;
           }
-          replacements.push({ placeholder: match[0], resolved: match[0] });
+          if (closed === -1)
+            break;
+          placeholders.push({ raw: value.slice(i, closed + 2), expr: value.slice(i + 2, closed).trim(), index: i });
+          i = closed + 2;
+        }
+        return placeholders;
+      }
+      async resolveTemplateString(value, strict = this.strictTemplates) {
+        const placeholders = this.findPlaceholders(value);
+        if (placeholders.length === 0)
+          return value;
+        let result = "";
+        let cursor = 0;
+        for (const placeholder of placeholders) {
+          result += value.slice(cursor, placeholder.index);
+          result += await this.resolveExpression(placeholder.expr, strict, placeholder.raw);
+          cursor = placeholder.index + placeholder.raw.length;
         }
-        let result = value;
-        for (const { placeholder, resolved } of replacements) {
-          result = result.replace(placeholder, resolved);
+        return result + value.slice(cursor);
+      }
+      async resolveExpression(expr, strict, raw) {
+        if (expr.startsWith("faker.")) {
+          return this.resolveFakerExpression(expr, strict, raw);
+        }
+        if (expr.includes(":")) {
+          const colonIdx = expr.indexOf(":");
+          const scope = expr.slice(0, colonIdx);
+          const key = expr.slice(colonIdx + 1);
+          const envKey = `JETIC_HUMAN_${key.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
+          if (scope === "human") {
+            const envVal = process.env[envKey];
+            if (envVal !== void 0 && envVal !== "")
+              return envVal;
+          }
+          const memVal = await this.memory(scope).get(key);
+          if (memVal !== null && memVal !== void 0) {
+            return typeof memVal === "string" ? memVal : JSON.stringify(memVal);
+          }
+          if (!strict)
+            return "";
+          if (scope === "human") {
+            throw new Error(`missing human input ${raw} \u2014 set ${envKey} or seed "human:${key}" memory (non-interactive runners cannot prompt)`);
+          }
+          throw new Error(`unresolved template ${raw} \u2014 no value for "${scope}:${key}"; capture it in an earlier step or seed it first`);
+        }
+        return raw;
+      }
+      resolveFakerExpression(expr, strict, raw) {
+        if (/[({]/.test(expr)) {
+          if (!strict)
+            return raw;
+          throw new Error(`unsupported faker expression ${raw} \u2014 parameterized calls are not supported; use a parameterless path like {{faker.internet.email}} or a literal value`);
+        }
+        let fn = faker_1.faker;
+        for (const part of expr.split(".").slice(1))
+          fn = fn?.[part];
+        if (typeof fn !== "function") {
+          if (!strict)
+            return raw;
+          throw new Error(`unknown faker path ${raw} \u2014 use a complete parameterless path like {{faker.internet.email}} or {{faker.string.uuid}}`);
+        }
+        try {
+          return String(fn());
+        } catch (err) {
+          if (!strict)
+            return raw;
+          throw new Error(`faker expression ${raw} failed: ${err?.message || err} \u2014 this faker path needs arguments; parameterized faker calls are not supported`);
         }
-        return result;
       }
       async resolveBodyTemplates(body) {
-        const resolved = {};
-        for (const [key, value] of Object.entries(body)) {
-          resolved[key] = typeof value === "string" ? await this.resolveTemplateString(value) : value;
+        const resolved = await this.resolveDeep(body);
+        return resolved && typeof resolved === "object" && !Array.isArray(resolved) ? resolved : {};
+      }
+      async resolveDeep(value) {
+        if (typeof value === "string")
+          return this.resolveTemplateString(value);
+        if (Array.isArray(value)) {
+          const out = [];
+          for (const item of value)
+            out.push(await this.resolveDeep(item));
+          return out;
+        }
+        if (value && typeof value === "object") {
+          const out = {};
+          for (const [key, item] of Object.entries(value))
+            out[key] = await this.resolveDeep(item);
+          return out;
         }
-        return resolved;
+        return value;
       }
       async resolveInjections(inject) {
         const headers = {};
@@ -272762,12 +273158,20 @@ 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)
+            if (value === null || value === void 0) {
+              if (this.strictTemplates) {
+                throw new Error(`inject target "${target}" references "${scope}:${key}", which is not in memory \u2014 capture it earlier or seed it first`);
+              }
               continue;
+            }
             strValue = typeof value === "string" ? value : JSON.stringify(value);
           }
+          const headerName = target.startsWith("header:") ? target.slice("header:".length) : target.startsWith("body:") ? null : target;
+          if (headerName && headerName.toLowerCase() === "authorization" && strValue && !/^[A-Za-z][A-Za-z0-9-]*\s/.test(strValue)) {
+            strValue = `Bearer ${strValue}`;
+          }
           if (target.startsWith("body:")) {
             body[target.slice(5)] = strValue;
           } else if (target.startsWith("header:")) {
@@ -272787,7 +273191,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,31 +273206,64 @@ 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)}`);
         }
         return captured;
       }
       async resolvePathParams(urlPath, body) {
-        let result = urlPath;
-        const paramMatches = urlPath.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g);
+        let result = await this.resolveTemplateString(urlPath);
+        const paramMatches = result.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g);
         if (!paramMatches)
           return result;
-        for (const p of paramMatches) {
+        for (const p of [...new Set(paramMatches)].sort((a, b) => b.length - a.length)) {
           const paramName = p.substring(1);
-          if (body[paramName] !== void 0) {
-            result = result.replace(p, String(body[paramName]));
-          } else {
-            const memory = new memory_1.JeticMemory({ scope: "workflow" });
-            const memVal = await memory.get(paramName);
-            if (memVal !== null) {
-              result = result.replace(p, String(memVal));
-            }
+          let value = body[paramName];
+          if (value === void 0 || value === null) {
+            value = await this.memory("workflow").get(paramName);
+          }
+          if (value !== void 0 && value !== null) {
+            result = result.split(p).join(typeof value === "string" ? value : String(value));
+            continue;
+          }
+          if (this.strictTemplates) {
+            throw new Error(`unresolved path parameter "${p}" in "${urlPath}" \u2014 provide it through a body field, a {{template}}, or a memory key named "${paramName}"`);
           }
         }
         return result;
       }
+      async runPreflight(baseUrl, timeoutMs) {
+        const probe = { url: baseUrl, verdict: "unreachable", message: "", aborted: false };
+        try {
+          const resp = await fetch(baseUrl, {
+            method: "GET",
+            redirect: "manual",
+            signal: AbortSignal.timeout(timeoutMs)
+          });
+          probe.status = resp.status;
+          if (resp.status >= 500) {
+            probe.verdict = "server-error";
+            probe.message = `Server is reachable at ${baseUrl} but responded HTTP ${resp.status} \u2014 the app is likely failing (database/init error). Check the server logs before simulating.`;
+          } else {
+            probe.verdict = "healthy";
+            probe.message = `Server reachable at ${baseUrl} (HTTP ${resp.status}).`;
+          }
+        } catch (err) {
+          const code = networkErrorCode(err);
+          probe.status = void 0;
+          if (err?.name === "TimeoutError" || code === "ETIMEDOUT") {
+            probe.message = `No response from ${baseUrl} within ${timeoutMs}ms \u2014 the server may be down or hanging.`;
+          } else if (code === "ECONNREFUSED") {
+            probe.message = `Connection refused at ${baseUrl} \u2014 nothing is listening there. Start the app (check its PORT/.env) and retry.`;
+          } else if (code === "ENOTFOUND" || code === "EAI_AGAIN") {
+            probe.message = `DNS lookup failed for ${baseUrl}${code ? ` (${code})` : ""} \u2014 check the host name.`;
+          } else {
+            probe.message = `Cannot reach ${baseUrl}${code ? ` (${code})` : ""}: ${err?.message || err}`;
+          }
+        }
+        return probe;
+      }
     };
     exports2.WorkflowSimulator = WorkflowSimulator2;
   }
@@ -272837,6 +273274,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 +273308,7 @@ var require_dist13 = __commonJS({
     Object.defineProperty(exports2, "WorkflowSimulator", { enumerable: true, get: function() {
       return workflow_simulator_1.WorkflowSimulator;
     } });
+    __exportStar(require_conditions(), exports2);
   }
 });
 
@@ -273009,6 +273463,243 @@ var require_environment_tools = __commonJS({
   }
 });
 
+// ../../packages/mcp-server/dist/run-store.js
+var require_run_store = __commonJS({
+  "../../packages/mcp-server/dist/run-store.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 __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.newRunId = newRunId;
+    exports2.runsDir = runsDir;
+    exports2.runDir = runDir;
+    exports2.deriveRunStatus = deriveRunStatus;
+    exports2.writeSimulationRun = writeSimulationRun;
+    exports2.readSimulationRun = readSimulationRun;
+    exports2.readRunStatus = readRunStatus;
+    exports2.writeRunningStatus = writeRunningStatus;
+    exports2.writeRunError = writeRunError;
+    exports2.listRuns = listRuns;
+    exports2.compactSimulationResult = compactSimulationResult;
+    var fs10 = __importStar(require("fs"));
+    var path15 = __importStar(require("path"));
+    var core_1 = require_dist();
+    function newRunId() {
+      return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    }
+    function runsDir(jeticDir) {
+      return path15.join(jeticDir, "runs");
+    }
+    function runDir(jeticDir, runId) {
+      return path15.join(runsDir(jeticDir), runId);
+    }
+    function reportPath(jeticDir, runId) {
+      return path15.join(runDir(jeticDir, runId), "simulation-report.json");
+    }
+    function statusPath(jeticDir, runId) {
+      return path15.join(runDir(jeticDir, runId), "simulation-status.json");
+    }
+    function deriveRunStatus(result) {
+      if (result.success)
+        return "passed";
+      if (result.abortReason)
+        return "aborted";
+      return "failed";
+    }
+    function writeSimulationRun(jeticDir, runId, result, meta) {
+      const status = deriveRunStatus(result);
+      const durationMs = result.stats?.totalTimeMs ?? 0;
+      const report = {
+        type: "simulation",
+        runId,
+        workflowName: result.workflow?.name || "workflow",
+        workflowFile: meta.workflowFile,
+        environment: result.environment?.name || "unknown",
+        baseUrl: result.environment?.baseUrl || "",
+        status,
+        startedAt: meta.startedAt,
+        finishedAt: meta.finishedAt,
+        durationMs,
+        result
+      };
+      const rPath = reportPath(jeticDir, runId);
+      (0, core_1.writeJsonSync)(rPath, report);
+      const sPath = statusPath(jeticDir, runId);
+      const statusDoc = {
+        type: "simulation",
+        runId,
+        workflowName: report.workflowName,
+        environment: report.environment,
+        baseUrl: report.baseUrl,
+        status,
+        startedAt: meta.startedAt,
+        finishedAt: meta.finishedAt,
+        durationMs,
+        stats: {
+          totalSteps: result.stats?.totalSteps ?? result.results.length,
+          executedSteps: result.stats?.executedSteps ?? 0,
+          passedSteps: result.stats?.passedSteps ?? 0,
+          failedSteps: result.stats?.failedSteps ?? 0,
+          skippedSteps: result.results.filter((r) => r.skipped).length
+        },
+        reportPath: rPath
+      };
+      (0, core_1.writeJsonSync)(sPath, statusDoc);
+      return { runDir: runDir(jeticDir, runId), reportPath: rPath };
+    }
+    function readSimulationRun(jeticDir, runId) {
+      return (0, core_1.readJsonSync)(reportPath(jeticDir, runId));
+    }
+    function readRunStatus(jeticDir, runId) {
+      return (0, core_1.readJsonSync)(statusPath(jeticDir, runId));
+    }
+    function writeRunningStatus(jeticDir, runId, meta) {
+      const doc = {
+        type: "simulation",
+        runId,
+        workflowName: meta.workflowName,
+        environment: meta.environment,
+        baseUrl: meta.baseUrl,
+        status: "running",
+        startedAt: meta.startedAt,
+        stats: { totalSteps: 0, executedSteps: 0, passedSteps: 0, failedSteps: 0, skippedSteps: 0 },
+        reportPath: reportPath(jeticDir, runId)
+      };
+      (0, core_1.writeJsonSync)(statusPath(jeticDir, runId), doc);
+    }
+    function writeRunError(jeticDir, runId, error, meta) {
+      const doc = {
+        type: "simulation",
+        runId,
+        workflowName: meta.workflowName,
+        environment: meta.environment,
+        baseUrl: meta.baseUrl,
+        status: "error",
+        startedAt: meta.startedAt,
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        error: error instanceof Error ? error.message : String(error),
+        stats: { totalSteps: 0, executedSteps: 0, passedSteps: 0, failedSteps: 0, skippedSteps: 0 },
+        reportPath: reportPath(jeticDir, runId)
+      };
+      (0, core_1.writeJsonSync)(statusPath(jeticDir, runId), doc);
+    }
+    function listRuns(jeticDir, limit = 20) {
+      const dir = runsDir(jeticDir);
+      if (!fs10.existsSync(dir))
+        return [];
+      const items = [];
+      for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+          continue;
+        const runId = entry.name;
+        const simStatus = (0, core_1.readJsonSync)(statusPath(jeticDir, runId));
+        if (simStatus) {
+          items.push({
+            runId,
+            type: "simulation",
+            name: simStatus.workflowName,
+            status: simStatus.status,
+            startedAt: simStatus.startedAt,
+            durationMs: simStatus.durationMs,
+            reportPath: simStatus.reportPath
+          });
+          continue;
+        }
+        const agentReport = (0, core_1.readJsonSync)(path15.join(runDir(jeticDir, runId), "agent-report.json"));
+        if (agentReport) {
+          items.push({
+            runId,
+            type: "agent",
+            name: agentReport.agentId || "agent",
+            status: agentReport.status || "completed",
+            reportPath: path15.join(runDir(jeticDir, runId), "agent-report.json")
+          });
+        }
+      }
+      items.sort((a, b) => b.runId.localeCompare(a.runId));
+      return items.slice(0, limit);
+    }
+    function compactSimulationResult(result, runId, reportFilePath) {
+      const steps = result.results.map((r) => {
+        const summary = {
+          // stepIndex is already 1-based (set as i + 1 by the simulator).
+          step: r.stepIndex,
+          name: r.name,
+          method: r.method,
+          path: r.path,
+          targetUrl: r.targetUrl,
+          status: r.skipped ? "skipped" : r.passed ? "passed" : "failed",
+          expectedStatus: r.expectedStatus,
+          durationMs: r.durationMs
+        };
+        if (!r.skipped)
+          summary.actualStatus = r.actualStatus;
+        if (r.retryCount > 0)
+          summary.retryCount = r.retryCount;
+        if (r.conditionResult) {
+          summary.condition = `${r.conditionResult.evaluated} \u2192 ${r.conditionResult.matched ? "matched" : "not matched"}`;
+        }
+        if (r.error)
+          summary.error = r.error;
+        return summary;
+      });
+      return {
+        ok: result.success,
+        success: result.success,
+        runId,
+        status: deriveRunStatus(result),
+        workflow: result.workflow?.name || "workflow",
+        environment: {
+          name: result.environment?.name || "unknown",
+          baseUrl: result.environment?.baseUrl || ""
+        },
+        stats: result.stats,
+        ...result.preflight ? { preflight: result.preflight } : {},
+        ...result.abortReason ? { abortReason: result.abortReason } : {},
+        steps,
+        reportPath: reportFilePath,
+        next: result.success ? `Full request/response detail: jetic_get_run { "runId": "${runId}" }` : `Inspect the failing step in full detail: jetic_get_run { "runId": "${runId}" }`
+      };
+    }
+  }
+});
+
 // ../../packages/mcp-server/dist/tools/workflow-tools.js
 var require_workflow_tools = __commonJS({
   "../../packages/mcp-server/dist/tools/workflow-tools.js"(exports2) {
@@ -273061,6 +273752,7 @@ var require_workflow_tools = __commonJS({
     var types_1 = require_types();
     var model_1 = require_dist2();
     var simulator_1 = require_dist13();
+    var run_store_1 = require_run_store();
     exports2.listWorkflowsSchema = zod_1.z.object({
       projectPath: zod_1.z.string().optional().describe("Path to project root or .jetic folder")
     });
@@ -273152,7 +273844,12 @@ var require_workflow_tools = __commonJS({
       workflow: zod_1.z.string().optional().describe("Workflow slug, name, or JSON file path to execute. If omitted, defaults to available workflow"),
       envName: zod_1.z.string().optional().describe("Target environment name (e.g., local, staging)"),
       baseUrl: zod_1.z.string().optional().describe("Override target base URL (e.g. http://localhost:3000)"),
-      clearMemory: zod_1.z.boolean().optional().default(false).describe("If true, clears Jetic memory before execution")
+      clearMemory: zod_1.z.boolean().optional().default(false).describe("If true, clears Jetic memory before execution"),
+      includeStepResults: zod_1.z.boolean().optional().default(false).describe("Return every step's full request/response detail (large payload). Default false returns a compact per-step summary plus a runId \u2014 use jetic_get_run for full detail."),
+      async: zod_1.z.boolean().optional().default(false).describe("Start the run in the background and return immediately with a runId. Poll it with jetic_get_run or jetic_list_runs."),
+      preflight: zod_1.z.enum(["abort", "warn", "off"]).optional().default("abort").describe('Probe the target baseUrl before step 1. "abort" (default) fails fast when the server is unreachable; "warn" records the probe and continues; "off" skips it.'),
+      strictTemplates: zod_1.z.boolean().optional().default(true).describe("Fail a step before sending when a {{template}} or :path param has no value (default true). Set false to restore legacy empty-string behaviour."),
+      requestTimeoutMs: zod_1.z.number().int().positive().max(12e4).optional().default(3e4).describe("Per-request timeout in ms (default 30000, max 120000).")
     });
     async function handleSimulateWorkflow(args) {
       const { model, filePath } = (0, types_1.loadModel)(args.projectPath);
@@ -273238,10 +273935,63 @@ 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 jeticDir = path15.dirname(filePath);
+      const workflowsDir = path15.join(jeticDir, "workflows");
+      const simulator = new simulator_1.WorkflowSimulator(model, effectiveEnv, { projectRoot });
+      const runId = (0, run_store_1.newRunId)();
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const runMeta = {
+        workflowName: workflowDef.name || selectedItem.name,
+        environment: effectiveEnv.name,
+        baseUrl: effectiveEnv.baseUrl,
+        startedAt
+      };
+      const execute = async () => {
+        const result2 = await simulator.simulateWorkflow(workflowDef, {
+          clearMemory: args.clearMemory ?? false,
+          loadWorkflow: (slugOrName) => (0, model_1.loadWorkflowByName)(workflowsDir, slugOrName),
+          strictTemplates: args.strictTemplates ?? true,
+          preflight: args.preflight ?? "abort",
+          requestTimeoutMs: args.requestTimeoutMs ?? 3e4
+        });
+        const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const { reportPath: reportPath2 } = (0, run_store_1.writeSimulationRun)(jeticDir, runId, result2, {
+          startedAt,
+          finishedAt,
+          workflowFile: selectedItem.filePath
+        });
+        return { result: result2, reportPath: reportPath2 };
+      };
+      if (args.async) {
+        (0, run_store_1.writeRunningStatus)(jeticDir, runId, runMeta);
+        execute().then(() => void 0).catch((err) => {
+          try {
+            (0, run_store_1.writeRunError)(jeticDir, runId, err, runMeta);
+          } catch {
+          }
+        });
+        return {
+          status: "running",
+          runId,
+          workflowName: runMeta.workflowName,
+          environment: { name: effectiveEnv.name, baseUrl: effectiveEnv.baseUrl },
+          message: `Run started in the background against ${effectiveEnv.baseUrl}. Poll with jetic_get_run { "runId": "${runId}" } or jetic_list_runs.`
+        };
+      }
+      const { result, reportPath } = await execute();
+      if (args.includeStepResults) {
+        return {
+          runId,
+          status: (0, run_store_1.deriveRunStatus)(result),
+          reportPath,
+          filePath,
+          workflowFile: selectedItem.filePath,
+          ...result
+        };
+      }
       return {
-        ...result,
+        ...(0, run_store_1.compactSimulationResult)(result, runId, reportPath),
         filePath,
         workflowFile: selectedItem.filePath
       };
@@ -273304,7 +274054,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 +274079,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)")
@@ -273321,14 +274088,16 @@ var require_workflow_authoring_tools = __commonJS({
     exports2.workflowStepSchema = zod_1.z.object({
       name: zod_1.z.string().min(1).describe("Step name (must be unique within the workflow)"),
       method: zod_1.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]).describe("HTTP method"),
-      path: zod_1.z.string().min(1).describe("Route path; :params resolve from body/memory (NOT from {{templates}} \u2014 those only work in body/inject)"),
+      path: zod_1.z.string().min(1).describe("Route path. :params resolve from a body field, or a memory key of the same name; {{templates}} are also resolved in the path."),
       description: zod_1.z.string().optional().describe("What this step does"),
-      body: zod_1.z.record(zod_1.z.any()).optional().describe("Request payload. Values support {{faker.*}}, {{scope:key}}, {{workflow:key}} and {{human:key}} templates"),
+      body: zod_1.z.record(zod_1.z.any()).optional().describe("Request payload (nested objects/arrays are templated too). Values support {{faker.*}}, {{scope:key}}, {{workflow:key}} and {{human:key}} templates"),
+      query: zod_1.z.record(zod_1.z.any()).optional().describe("URL query parameters (deep-resolved templates). Use this instead of a body on GET/HEAD steps."),
+      timeoutMs: zod_1.z.number().int().positive().optional().describe("Per-step request timeout in ms (overrides the run default, which is 30000; max 120000)."),
       inject: zod_1.z.record(zod_1.z.string()).optional().describe('Header/body injection: "header:Name" or "body:field" \u2192 "scope:key" or "{{template}}"'),
       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.")
@@ -273343,7 +274112,6 @@ var require_workflow_authoring_tools = __commonJS({
       retry: stepRetrySchema.optional().describe("Global retry default applied to all steps (overridden per step)"),
       steps: zod_1.z.array(exports2.workflowStepSchema).min(1).describe("Ordered steps; later steps can use memory captured by earlier ones")
     }).passthrough();
-    var TEMPLATE_RE = /\{\{\s*([^}]+?)\s*\}\}/g;
     var KNOWN_WORKFLOW_KEYS = /* @__PURE__ */ new Set(["name", "description", "environment", "steps", "generatedAt", "retry"]);
     var KNOWN_STEP_KEYS = /* @__PURE__ */ new Set([
       "name",
@@ -273355,6 +274123,8 @@ var require_workflow_authoring_tools = __commonJS({
       "captureInput",
       "expectStatus",
       "body",
+      "query",
+      "timeoutMs",
       "condition",
       "onFailure",
       "continueOnStatus",
@@ -273392,10 +274162,35 @@ var require_workflow_authoring_tools = __commonJS({
     }
     function collectTemplateRefs(value, out) {
       if (typeof value === "string") {
-        TEMPLATE_RE.lastIndex = 0;
-        let m;
-        while ((m = TEMPLATE_RE.exec(value)) !== null)
-          out.push(m[1].trim());
+        let i = 0;
+        while (i < value.length) {
+          const open = value.indexOf("{{", i);
+          if (open === -1)
+            break;
+          let depth = 0;
+          let end = -1;
+          for (let j = open + 2; j < value.length; j++) {
+            const ch = value[j];
+            if (ch === "{") {
+              depth++;
+            } else if (ch === "}") {
+              if (depth > 0) {
+                depth--;
+              } else if (value[j + 1] === "}") {
+                end = j;
+                break;
+              } else {
+                break;
+              }
+            }
+          }
+          if (end === -1) {
+            i = open + 2;
+            continue;
+          }
+          out.push(value.slice(open + 2, end).trim());
+          i = end + 2;
+        }
       } else if (Array.isArray(value)) {
         for (const v of value)
           collectTemplateRefs(v, out);
@@ -273411,6 +274206,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 = [];
@@ -273439,6 +274286,25 @@ var require_workflow_authoring_tools = __commonJS({
       const seenNames = /* @__PURE__ */ new Set();
       const defined = /* @__PURE__ */ new Set();
       const humanKeys = /* @__PURE__ */ new Set();
+      const refsUsedAnywhere = /* @__PURE__ */ new Set();
+      for (const rawStep of wf.steps) {
+        const stepRefs = [];
+        collectTemplateRefs(rawStep?.body, stepRefs);
+        collectTemplateRefs(rawStep?.query, stepRefs);
+        collectTemplateRefs(rawStep?.path, stepRefs);
+        const inject = rawStep?.inject;
+        if (inject && typeof inject === "object" && !Array.isArray(inject)) {
+          for (const v of Object.values(inject))
+            collectTemplateRefs(v, stepRefs);
+        }
+        for (const ref of stepRefs) {
+          if (ref.startsWith("faker.") || !ref.includes(":"))
+            continue;
+          const { scope, key } = splitMemKey(ref);
+          if (key)
+            refsUsedAnywhere.add(`${scope}:${key}`);
+        }
+      }
       wf.steps.forEach((rawStep, i) => {
         const stepNo = i + 1;
         const sName = typeof rawStep?.name === "string" ? rawStep.name : void 0;
@@ -273447,19 +274313,22 @@ 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.');
           } else if (!KNOWN_STEP_KEYS.has(key)) {
-            warn(warnings, stepNo, sName, "UNKNOWN_STEP_KEY", `Step ${stepNo} has unknown key "${key}" which the simulator ignores.`, "Remove it or check the field name (valid: name, method, path, description, body, inject, capture, captureInput, expectStatus).");
+            warn(warnings, stepNo, sName, "UNKNOWN_STEP_KEY", `Step ${stepNo} has unknown key "${key}" which the simulator ignores.`, "Remove it or check the field name (valid: name, method, path, description, body, query, timeoutMs, inject, capture, captureInput, expectStatus, condition, onFailure, continueOnStatus, retry).");
           }
         }
         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);
@@ -273529,30 +274398,46 @@ var require_workflow_authoring_tools = __commonJS({
         if (step.body !== void 0 && (typeof step.body !== "object" || step.body === null || Array.isArray(step.body))) {
           err(errors, stepNo, sName, "BAD_BODY", `Step ${stepNo} "body" must be an object of field -> value.`, 'Use { "email": "{{faker.internet.email}}" }.');
         }
-        if ((method === "GET" || method === "HEAD") && step.body && Object.keys(step.body).length > 0) {
-          warn(warnings, stepNo, sName, "GET_WITH_BODY", `Step ${stepNo} is ${method} with a body \u2014 it will be sent as URL query params, not a JSON body.`, "This is usually what you want for filters; otherwise switch to POST.");
+        if (step.query !== void 0 && (typeof step.query !== "object" || step.query === null || Array.isArray(step.query))) {
+          err(errors, stepNo, sName, "BAD_QUERY", `Step ${stepNo} "query" must be an object of param -> value.`, 'Use { "query": { "page": 1, "search": "{{workflow:term}}" } }.');
+        }
+        if ((method === "GET" || method === "HEAD") && step.body && typeof step.body === "object" && !Array.isArray(step.body)) {
+          const nested = Object.values(step.body).some((v) => v !== null && typeof v === "object");
+          if (nested) {
+            warn(warnings, stepNo, sName, "GET_WITH_BODY", `Step ${stepNo} is ${method} with nested body values \u2014 they are stringified into the URL query string.`, 'Move flat filters to the "query" field instead.');
+          }
         }
-        if (endpoint?.requestBody?.fields && step.body && typeof step.body === "object") {
+        if (endpoint?.requestBody?.fields && step.body && typeof step.body === "object" && method !== "GET" && method !== "HEAD") {
           for (const field of Object.keys(step.body)) {
             if (!(field in endpoint.requestBody.fields)) {
               warn(warnings, stepNo, sName, "UNKNOWN_BODY_FIELD", `Step ${stepNo} sends body field "${field}" not declared on ${method} ${wfPath}.`, "Check the spelling, or extend the endpoint with jetic_update_endpoint.");
             }
           }
         }
+        if (step.query && typeof step.query === "object" && !Array.isArray(step.query) && endpoint) {
+          const declaredQuery = (endpoint.parameters || []).filter((p) => p.in === "query");
+          if (declaredQuery.length > 0) {
+            for (const param of Object.keys(step.query)) {
+              if (!declaredQuery.some((p) => p.name === param)) {
+                warn(warnings, stepNo, sName, "UNKNOWN_QUERY_PARAM", `Step ${stepNo} sends query param "${param}" not declared on ${method} ${wfPath}.`, "Check the spelling, or extend the endpoint with jetic_update_endpoint.");
+              }
+            }
+          }
+        }
         const pathParams = wfPath.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g) || [];
         for (const p of pathParams) {
           const pname = p.substring(1);
           const inBody = step.body && typeof step.body === "object" && pname in step.body;
+          const inInjectBody = step.inject && typeof step.inject === "object" && !Array.isArray(step.inject) && Object.keys(step.inject).includes(`body:${pname}`);
           const inMemory = [...defined].some((d) => d.split(":")[1] === pname) || [...persistedMemory].some((d) => d.split(":")[1] === pname);
-          if (!inBody && !inMemory) {
-            err(errors, stepNo, sName, "UNRESOLVED_PATH_PARAM", `Path param ":${pname}" in step ${stepNo} has no body field or memory source \u2014 the URL will literally contain ":${pname}" and fail.`, `Add "${pname}" to this step's body, or capture it as memory in an earlier step (capture: { "workflow:${pname}": "data.${pname}" }).`);
+          if (!inBody && !inInjectBody && !inMemory) {
+            err(errors, stepNo, sName, "UNRESOLVED_PATH_PARAM", `Path param ":${pname}" in step ${stepNo} has no body field or memory source \u2014 the URL will literally contain ":${pname}" and fail.`, `Add "${pname}" to this step's body (or inject { "body:${pname}": "<scope:key>" }), capture it as memory in an earlier step (capture: { "workflow:${pname}": "data.${pname}" }), or inline it as "/users/{{workflow:${pname}}}".`);
           }
         }
-        if (/\{\{[^}]+\}\}/.test(wfPath)) {
-          warn(warnings, stepNo, sName, "PATH_TEMPLATE", `Step ${stepNo} path contains a {{template}} \u2014 paths only resolve :params, templates work in body/inject.`, 'Use "/api/users/:id" with an "id" body field or captured memory key.');
-        }
         const refs = [];
         collectTemplateRefs(step.body, refs);
+        collectTemplateRefs(step.query, refs);
+        collectTemplateRefs(step.path, refs);
         if (step.inject && typeof step.inject === "object") {
           for (const v of Object.values(step.inject))
             collectTemplateRefs(v, refs);
@@ -273561,6 +274446,8 @@ var require_workflow_authoring_tools = __commonJS({
           if (ref.startsWith("faker.")) {
             if (ref.split(".").length < 3) {
               warn(warnings, stepNo, sName, "SUSPICIOUS_FAKER", `"{{${ref}}}" looks like an incomplete faker path.`, "Use full paths like {{faker.internet.email}} or {{faker.string.uuid}}.");
+            } else if (ref.includes("(") || ref.includes("{") || ref.includes("[")) {
+              err(errors, stepNo, sName, "UNSUPPORTED_FAKER_CALL", `"{{${ref}}}" in step ${stepNo} passes arguments \u2014 the simulator only supports parameterless faker paths.`, "Use a plain path like {{faker.internet.email}} or {{faker.number.int}}, or hard-code the value.");
             }
             continue;
           }
@@ -273619,7 +274506,13 @@ var require_workflow_authoring_tools = __commonJS({
             err(errors, stepNo, sName, "BAD_ON_FAILURE", `Step ${stepNo} "onFailure" must be "abort" or "continue" (got "${step.onFailure}").`, 'Use "abort" (default, stops the workflow) or "continue" (logs failure, proceeds).');
           }
           if (step.onFailure === "continue" && step.capture && Object.keys(step.capture).length > 0) {
-            warn(warnings, stepNo, sName, "CONTINUE_WITH_CAPTURE", `Step ${stepNo} uses onFailure:"continue" but has captures \u2014 captures are only saved when the step passes.`, "This is usually fine for optional captures; ensure later steps handle missing memory gracefully.");
+            const consumedDownstream = Object.keys(step.capture).some((k) => {
+              const { scope, key } = splitMemKey(k);
+              return key && refsUsedAnywhere.has(`${scope}:${key}`);
+            });
+            if (consumedDownstream) {
+              warn(warnings, stepNo, sName, "CONTINUE_WITH_CAPTURE", `Step ${stepNo} uses onFailure:"continue" but later steps depend on its captures \u2014 if the request fails, those captures are skipped and downstream steps will fail or be skipped.`, "Make the run conditional on the capture, or move the capture to a step that must pass.");
+            }
           }
         }
         if (step.continueOnStatus !== void 0) {
@@ -273658,6 +274551,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);
     }
@@ -288323,6 +289235,7 @@ var require_response_envelope = __commonJS({
       "WRITE_DISABLED",
       "INTERNAL"
     ];
+    var MAX_MESSAGE_LENGTH = 500;
     function errorCodeFrom(error) {
       if (typeof error !== "object" || error === null || !("code" in error)) {
         return "INTERNAL";
@@ -288330,6 +289243,28 @@ var require_response_envelope = __commonJS({
       const code = error.code;
       return typeof code === "string" && ERROR_CODES.includes(code) ? code : "INTERNAL";
     }
+    function describeError(error) {
+      const record = typeof error === "object" && error !== null ? error : {};
+      const issues = Array.isArray(record.issues) ? record.issues : void 0;
+      if (issues && issues.length > 0) {
+        const parts = issues.slice(0, 5).map((issue) => {
+          const path15 = Array.isArray(issue?.path) ? issue.path.join(".") : "";
+          return `${path15 ? `${path15}: ` : ""}${issue?.message ?? "invalid"}`;
+        });
+        const more = issues.length > 5 ? ` (+${issues.length - 5} more)` : "";
+        return {
+          message: `Invalid input \u2014 ${parts.join("; ")}${more}`,
+          hint: "Fix the flagged argument(s) and retry. Use the tool schema for exact field types."
+        };
+      }
+      const rawMessage = typeof record.message === "string" ? record.message.trim() : "";
+      const message = rawMessage ? rawMessage.length > MAX_MESSAGE_LENGTH ? `${rawMessage.slice(0, MAX_MESSAGE_LENGTH)}\u2026` : rawMessage : "Tool execution failed.";
+      const customHint = typeof record.hint === "string" && record.hint.trim() ? record.hint.trim() : "";
+      return {
+        message,
+        hint: customHint || "Check the project configuration and arguments, then retry."
+      };
+    }
     function toTextResult(data) {
       return {
         content: [{
@@ -288339,6 +289274,7 @@ var require_response_envelope = __commonJS({
       };
     }
     function toErrorResult(error) {
+      const { message, hint } = describeError(error);
       return {
         isError: true,
         content: [{
@@ -288347,8 +289283,8 @@ var require_response_envelope = __commonJS({
             ok: false,
             error: {
               code: errorCodeFrom(error),
-              message: "Tool execution failed.",
-              hint: "Check the project configuration and arguments, then retry."
+              message,
+              hint
             }
           }, null, 2)
         }]
@@ -288691,6 +289627,47 @@ var require_workflow_designer_tools = __commonJS({
           if (Object.keys(inject).length > 0)
             step.inject = inject;
         }
+        const pathParams = [...new Set(endpoint.path.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g) || [])].map((p) => p.slice(1));
+        for (const pname of pathParams) {
+          const inBody = step.body && typeof step.body === "object" && pname in step.body;
+          if (inBody)
+            continue;
+          const memKey = [...producedKeys].find((k) => (k.split(":").pop() || "").toLowerCase() === pname.toLowerCase());
+          if (memKey) {
+            step.path = step.path.split(`:${pname}`).join(`{{${memKey}}}`);
+          } else {
+            missing.push(`Path param ":${pname}" has no source \u2014 add a body field "${pname}", capture a memory key named "${pname}" in an earlier step, or inline {{workflow:${pname}}} in the path.`);
+          }
+        }
+        const queryParams = (endpoint.parameters || []).filter((p) => p.in === "query");
+        if (queryParams.length > 0) {
+          const query = {};
+          for (const p of queryParams) {
+            const memKey = [...producedKeys].find((k) => (k.split(":").pop() || "").toLowerCase() === p.name.toLowerCase());
+            if (memKey) {
+              query[p.name] = `{{${memKey}}}`;
+              continue;
+            }
+            if (p.required !== true)
+              continue;
+            const val = fieldToFakerValue(p.name, {
+              type: p.type || "string",
+              format: p.format,
+              min: p.min,
+              max: p.max,
+              enum: p.enum
+            });
+            if (val !== null) {
+              query[p.name] = val;
+            } else {
+              query[p.name] = `{{human:${p.name}}}`;
+              allHumanKeys.add(p.name);
+              missing.push(`Query param "${p.name}" (required, type: ${p.type || "string"}) \u2014 no auto-mapping. Using {{human:${p.name}}} (will pause for interactive input at runtime).`);
+            }
+          }
+          if (Object.keys(query).length > 0)
+            step.query = query;
+        }
         const capture = {};
         if (endpoint.produces) {
           for (const p of endpoint.produces) {
@@ -288741,6 +289718,109 @@ var require_workflow_designer_tools = __commonJS({
   }
 });
 
+// ../../packages/mcp-server/dist/tools/run-tools.js
+var require_run_tools = __commonJS({
+  "../../packages/mcp-server/dist/tools/run-tools.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 __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.listRunsSchema = exports2.getRunSchema = void 0;
+    exports2.handleGetRun = handleGetRun;
+    exports2.handleListRuns = handleListRuns;
+    var zod_1 = require("zod");
+    var path15 = __importStar(require("path"));
+    var core_1 = require_dist();
+    var types_1 = require_types();
+    var run_store_1 = require_run_store();
+    exports2.getRunSchema = zod_1.z.object({
+      projectPath: zod_1.z.string().optional().describe("Path to project root or .jetic folder"),
+      runId: zod_1.z.string().describe('Run id returned by jetic_simulate_workflow (e.g. "2026-10-19T12-34-56-789Z") or jetic_run_agent')
+    });
+    exports2.listRunsSchema = zod_1.z.object({
+      projectPath: zod_1.z.string().optional().describe("Path to project root or .jetic folder"),
+      limit: zod_1.z.number().int().positive().max(100).optional().default(20).describe("Max runs to return, newest first (default 20)")
+    });
+    function handleGetRun(args) {
+      const projectRoot = path15.resolve((0, types_1.resolveProjectInput)(args.projectPath));
+      const config = (0, core_1.loadConfig)(projectRoot);
+      const report = (0, run_store_1.readSimulationRun)(config.jeticDir, args.runId);
+      if (report)
+        return { found: true, ...report };
+      const status = (0, run_store_1.readRunStatus)(config.jeticDir, args.runId);
+      if (status) {
+        return {
+          found: true,
+          type: "simulation",
+          runId: args.runId,
+          status: status.status,
+          workflowName: status.workflowName,
+          environment: status.environment,
+          baseUrl: status.baseUrl,
+          startedAt: status.startedAt,
+          finishedAt: status.finishedAt,
+          stats: status.stats,
+          reportPath: status.reportPath,
+          ...status.error ? { error: status.error } : {},
+          ...status.status === "running" ? { message: "Run still in progress \u2014 poll again shortly." } : {}
+        };
+      }
+      const agentReport = (0, core_1.readJsonSync)(path15.join(config.jeticDir, "runs", args.runId, "agent-report.json"));
+      if (agentReport)
+        return { found: true, type: "agent", runId: args.runId, ...agentReport };
+      const available = (0, run_store_1.listRuns)(config.jeticDir, 10).map((r) => `${r.runId} (${r.type}: ${r.status})`);
+      const detail = available.length > 0 ? ` Recent runs: ${available.join(", ")}.` : " No runs found yet.";
+      throw new Error(`Run "${args.runId}" not found under .jetic/runs/.${detail}`);
+    }
+    function handleListRuns(args) {
+      const projectRoot = path15.resolve((0, types_1.resolveProjectInput)(args.projectPath));
+      const config = (0, core_1.loadConfig)(projectRoot);
+      const runs = (0, run_store_1.listRuns)(config.jeticDir, args.limit ?? 20);
+      return {
+        runsDir: path15.join(config.jeticDir, "runs"),
+        totalCount: runs.length,
+        runs
+      };
+    }
+  }
+});
+
 // ../../packages/mcp-server/dist/server.js
 var require_server3 = __commonJS({
   "../../packages/mcp-server/dist/server.js"(exports2) {
@@ -288805,6 +289885,7 @@ var require_server3 = __commonJS({
     var session_tools_1 = require_session_tools();
     var workflow_designer_tools_1 = require_workflow_designer_tools();
     var agent_tools_1 = require_agent_tools();
+    var run_tools_1 = require_run_tools();
     exports2.JETIC_MCP_SERVER_NAME = "jetic-mcp-server";
     function getJeticMcpVersion() {
       try {
@@ -288859,11 +289940,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",
@@ -288884,6 +289974,9 @@ var require_server3 = __commonJS({
       "",
       "STEP 4g \u2014 RUN",
       '  jetic_simulate_workflow { "workflow": "<slug>" }',
+      "  It preflights the target first and fails fast with a clear reason when the app is unreachable.",
+      '  The response is a compact summary + runId. Full step detail: jetic_get_run { "runId": "..." };',
+      "  recent runs: jetic_list_runs. For long journeys pass async:true, then poll jetic_get_run.",
       "",
       "\u2501\u2501 GENERAL RULES \u2501\u2501",
       "No AI-provider setup is needed: never ask for OpenRouter/OpenAI keys and never use `jetic config ai`.",
@@ -288951,9 +290044,11 @@ var require_server3 = __commonJS({
       register("jetic_list_workflows", "List workflows", "Lists multi-step integration test workflows from .jetic/workflows/*.json, .jetic/workflow.json, or embedded model.json workflows.", workflow_tools_1.listWorkflowsSchema.shape, READ_ONLY, workflow_tools_1.handleListWorkflows);
       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_get_run", "Get run report", "Returns the full stored report of a previous run \u2014 every step's request, response, captures and errors \u2014 from .jetic/runs/<runId>/. Use the runId returned by jetic_simulate_workflow or jetic_list_runs.", run_tools_1.getRunSchema.shape, READ_ONLY, run_tools_1.handleGetRun);
+      register("jetic_list_runs", "List runs", "Lists recent simulation and agent runs from .jetic/runs/, newest first, with status, step counts and duration. Use jetic_get_run for the full report of one run.", run_tools_1.listRunsSchema.shape, READ_ONLY, run_tools_1.handleListRuns);
       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 +290792,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 +290805,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 +290932,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 +290941,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 +291000,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 +291314,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 +291538,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 +291566,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 +291579,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 +291593,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 +291613,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 +291635,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 +291766,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 +292021,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 +292035,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 +292062,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 +292125,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 +292276,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 +292304,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 +292914,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 +292975,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 +293157,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}`);
@@ -292212,7 +293321,7 @@ var mcpCommand = new import_commander18.Command("mcp").description("Launch Model
 
 // src/index.ts
 var program = new import_commander19.Command();
-program.name("jetic").description("AI-Native API Behavior Testing").version("0.2.5");
+program.name("jetic").description("AI-Native API Behavior Testing").version("0.2.6");
 program.addCommand(initCommand);
 program.addCommand(scanCommand);
 program.addCommand(inspectCommand);