jetic-cli 0.2.6 → 0.2.7

package/dist/index.js

@@ -272674,6 +272674,21 @@ var require_workflow_simulator = __commonJS({
     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;
@@ -272690,6 +272705,8 @@ var require_workflow_simulator = __commonJS({
       model;
       environment;
       runtime;
+      strictTemplates = true;
+      requestTimeoutMs = 3e4;
       constructor(model, environment, runtime = {}) {
         this.model = model;
         this.environment = environment;
@@ -272702,7 +272719,36 @@ var require_workflow_simulator = __commonJS({
         if (options?.clearMemory) {
           memory_1.JeticMemory.clearAllMemory(this.runtime.projectRoot);
         }
+        this.strictTemplates = options?.strictTemplates ?? true;
+        this.requestTimeoutMs = options?.requestTimeoutMs ?? 3e4;
         const startTime = Date.now();
+        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;
@@ -272725,7 +272771,8 @@ var require_workflow_simulator = __commonJS({
             failedSteps: stepResults.filter((r) => !r.passed).length,
             totalTimeMs
           },
-          results: stepResults
+          results: stepResults,
+          ...preflight ? { preflight } : {}
         };
       }
       /**
@@ -272735,7 +272782,7 @@ var require_workflow_simulator = __commonJS({
        */
       async runSteps(workflow, options, state, lineage) {
         const baseUrl = this.environment.baseUrl;
-        const resolve2 = (value) => this.resolveTemplateString(value);
+        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();
@@ -272789,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;
@@ -272803,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) {
@@ -272811,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;
@@ -272846,7 +272946,14 @@ 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) : [];
@@ -272865,6 +272972,7 @@ var require_workflow_simulator = __commonJS({
             retryCount: attempts - 1,
             requestHeaders: injectedHeaders,
             requestBody: finalBody,
+            ...Object.keys(resolvedQuery).length > 0 ? { requestQuery: resolvedQuery } : {},
             responseBody,
             capturedMemory: stepPassed ? [...inputCaptured, ...responseCaptured] : [...inputCaptured],
             ...stepPassed ? {} : {
@@ -272875,6 +272983,13 @@ var require_workflow_simulator = __commonJS({
           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";
@@ -272917,55 +273032,120 @@ var require_workflow_simulator = __commonJS({
         }
         return "done";
       }
-      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;
-              }
-            }
-            const mem = this.memory(scope);
-            const memVal = await mem.get(key);
-            replacements.push({ placeholder: match[0], resolved: memVal != null ? String(memVal) : "" });
+      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 = {};
@@ -272980,10 +273160,18 @@ var require_workflow_simulator = __commonJS({
             const [scope, key] = memKeyOrTemplate.includes(":") ? memKeyOrTemplate.split(":", 2) : ["workflow", memKeyOrTemplate];
             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:")) {
@@ -273025,24 +273213,57 @@ var require_workflow_simulator = __commonJS({
         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 = this.memory("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;
   }
@@ -273242,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) {
@@ -273294,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")
     });
@@ -273385,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);
@@ -273472,14 +273936,62 @@ var require_workflow_tools = __commonJS({
         baseUrl: args.baseUrl || targetEnv.baseUrl
       };
       const projectRoot = (0, types_1.projectRootOfModel)(filePath);
-      const workflowsDir = path15.join(path15.dirname(filePath), "workflows");
+      const jeticDir = path15.dirname(filePath);
+      const workflowsDir = path15.join(jeticDir, "workflows");
       const simulator = new simulator_1.WorkflowSimulator(model, effectiveEnv, { projectRoot });
-      const result = await simulator.simulateWorkflow(workflowDef, {
-        clearMemory: args.clearMemory ?? false,
-        loadWorkflow: (slugOrName) => (0, model_1.loadWorkflowByName)(workflowsDir, slugOrName)
-      });
+      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
       };
@@ -273576,9 +274088,11 @@ 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"'),
@@ -273598,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",
@@ -273610,6 +274123,8 @@ var require_workflow_authoring_tools = __commonJS({
       "captureInput",
       "expectStatus",
       "body",
+      "query",
+      "timeoutMs",
       "condition",
       "onFailure",
       "continueOnStatus",
@@ -273647,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);
@@ -273746,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;
@@ -273759,7 +274318,7 @@ var require_workflow_authoring_tools = __commonJS({
           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) {
@@ -273839,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);
@@ -273871,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;
           }
@@ -273929,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) {
@@ -288652,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";
@@ -288659,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: [{
@@ -288668,6 +289274,7 @@ var require_response_envelope = __commonJS({
       };
     }
     function toErrorResult(error) {
+      const { message, hint } = describeError(error);
       return {
         isError: true,
         content: [{
@@ -288676,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)
         }]
@@ -289020,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) {
@@ -289070,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) {
@@ -289134,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 {
@@ -289222,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`.",
@@ -289289,6 +290044,8 @@ 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. 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);
@@ -292564,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);