@duckflux/runner 0.6.8 → 0.7.1

package/dist/main.js

@@ -23,10 +23,10 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 var exports_eventhub = {};
 __export(exports_eventhub, {
   createHub: () => createHub,
-  MemoryHub: () => MemoryHub
+  MemoryHub: () => MemoryHub2
 });
 
-class MemoryHub {
+class MemoryHub2 {
   listeners = new Map;
   buffer = new Map;
   closed = false;
@@ -114,7 +114,7 @@ class MemoryHub {
 async function createHub(config) {
   switch (config.backend) {
     case "memory":
-      return new MemoryHub;
+      return new MemoryHub2;
     case "nats":
       throw new Error("NATS backend has been moved to @duckflux/hub-nats. " + "Install it and pass a NatsHub instance via ExecuteOptions.hub instead.");
     case "redis":
@@ -126,25 +126,27 @@ async function createHub(config) {
 var init_eventhub = () => {};
 
 // src/main.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync } from "fs";
 import { parseArgs } from "util";
-import { dirname as dirname7, resolve as resolve6 } from "path";
+import { dirname as dirname5, resolve as resolve5 } from "path";
 
-// src/run.ts
-import { readFile as readFile2 } from "node:fs/promises";
+// src/lint.ts
+import { dirname as dirname2 } from "node:path";
 
-// ../core/dist/engine/index.js
+// ../core/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
 import { readFile } from "node:fs/promises";
-import { readFileSync } from "node:fs";
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
 import { resolve } from "node:path";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { appendFile, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 import { spawn } from "node:child_process";
 import { dirname, resolve as resolve2 } from "node:path";
 import { resolve as resolvePath, isAbsolute } from "node:path";
-import { dirname as dirname2, resolve as resolve3 } from "node:path";
-import { env } from "node:process";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
@@ -21520,20 +21522,20 @@ var require_compile = __commonJS((exports) => {
   var validate_1 = require_validate();
 
   class SchemaEnv {
-    constructor(env2) {
+    constructor(env) {
       var _a;
       this.refs = {};
       this.dynamicAnchors = {};
       let schema;
-      if (typeof env2.schema == "object")
-        schema = env2.schema;
-      this.schema = env2.schema;
-      this.schemaId = env2.schemaId;
-      this.root = env2.root || this;
-      this.baseId = (_a = env2.baseId) !== null && _a !== undefined ? _a : (0, resolve_1.normalizeId)(schema === null || schema === undefined ? undefined : schema[env2.schemaId || "$id"]);
-      this.schemaPath = env2.schemaPath;
-      this.localRefs = env2.localRefs;
-      this.meta = env2.meta;
+      if (typeof env.schema == "object")
+        schema = env.schema;
+      this.schema = env.schema;
+      this.schemaId = env.schemaId;
+      this.root = env.root || this;
+      this.baseId = (_a = env.baseId) !== null && _a !== undefined ? _a : (0, resolve_1.normalizeId)(schema === null || schema === undefined ? undefined : schema[env.schemaId || "$id"]);
+      this.schemaPath = env.schemaPath;
+      this.localRefs = env.localRefs;
+      this.meta = env.meta;
       this.$async = schema === null || schema === undefined ? undefined : schema.$async;
       this.refs = {};
     }
@@ -21630,7 +21632,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root2.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve4.call(this, root2, ref);
+    let _sch = resolve3.call(this, root2, ref);
     if (_sch === undefined) {
       const schema = (_a = root2.localRefs) === null || _a === undefined ? undefined : _a[ref];
       const { schemaId } = this.opts;
@@ -21657,7 +21659,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve4(root2, ref) {
+  function resolve3(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -21716,15 +21718,15 @@ var require_compile = __commonJS((exports) => {
         baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
       }
     }
-    let env2;
+    let env;
     if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
       const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
-      env2 = resolveSchema.call(this, root2, $ref);
+      env = resolveSchema.call(this, root2, $ref);
     }
     const { schemaId } = this.opts;
-    env2 = env2 || new SchemaEnv({ schema, schemaId, root: root2, baseId });
-    if (env2.schema !== env2.root.schema)
-      return env2;
+    env = env || new SchemaEnv({ schema, schemaId, root: root2, baseId });
+    if (env.schema !== env.root.schema)
+      return env;
     return;
   }
 });
@@ -22179,7 +22181,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve4(baseURI, relativeURI, options) {
+  function resolve3(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -22407,7 +22409,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve4,
+    resolve: resolve3,
     resolveComponent,
     equal,
     serialize,
@@ -23038,8 +23040,8 @@ var require_ref = __commonJS((exports) => {
     schemaType: "string",
     code(cxt) {
       const { gen, schema: $ref, it } = cxt;
-      const { baseId, schemaEnv: env2, validateName, opts, self: self2 } = it;
-      const { root: root2 } = env2;
+      const { baseId, schemaEnv: env, validateName, opts, self: self2 } = it;
+      const { root: root2 } = env;
       if (($ref === "#" || $ref === "#/") && baseId === root2.baseId)
         return callRootRef();
       const schOrEnv = compile_1.resolveRef.call(self2, root2, baseId, $ref);
@@ -23049,8 +23051,8 @@ var require_ref = __commonJS((exports) => {
         return callValidate(schOrEnv);
       return inlineRefSchema(schOrEnv);
       function callRootRef() {
-        if (env2 === root2)
-          return callRef(cxt, validateName, env2, env2.$async);
+        if (env === root2)
+          return callRef(cxt, validateName, env, env.$async);
         const rootName = gen.scopeValue("root", { ref: root2 });
         return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root2, root2.$async);
       }
@@ -23080,14 +23082,14 @@ var require_ref = __commonJS((exports) => {
   exports.getValidate = getValidate;
   function callRef(cxt, v, sch, $async) {
     const { gen, it } = cxt;
-    const { allErrors, schemaEnv: env2, opts } = it;
+    const { allErrors, schemaEnv: env, opts } = it;
     const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
     if ($async)
       callAsyncRef();
     else
       callSyncRef();
     function callAsyncRef() {
-      if (!env2.$async)
+      if (!env.$async)
         throw new Error("async schema referenced by sync schema");
       const valid = gen.let("valid");
       gen.try(() => {
@@ -25796,6 +25798,549 @@ var require_dist2 = __commonJS((exports, module) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.default = formatsPlugin;
 });
+var duckflux_schema_default;
+var init_duckflux_schema = __esm2(() => {
+  duckflux_schema_default = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://raw.githubusercontent.com/duckflux/spec/main/duckflux.schema.json",
+    title: "duckflux Workflow",
+    description: "Schema for duckflux — a minimal, deterministic, runtime-agnostic workflow DSL.",
+    type: "object",
+    required: ["flow"],
+    additionalProperties: false,
+    properties: {
+      id: {
+        type: "string",
+        description: "Unique identifier for the workflow."
+      },
+      name: {
+        type: "string",
+        description: "Human-readable workflow name."
+      },
+      version: {
+        description: "Version identifier for the workflow definition.",
+        oneOf: [
+          { type: "string" },
+          { type: "integer" }
+        ]
+      },
+      defaults: {
+        $ref: "#/$defs/defaults"
+      },
+      inputs: {
+        $ref: "#/$defs/inputs"
+      },
+      participants: {
+        type: "object",
+        description: "Named steps that can be referenced in the flow.",
+        additionalProperties: {
+          $ref: "#/$defs/participant"
+        },
+        not: {
+          anyOf: [
+            { required: ["workflow"] },
+            { required: ["execution"] },
+            { required: ["input"] },
+            { required: ["output"] },
+            { required: ["env"] },
+            { required: ["loop"] },
+            { required: ["event"] }
+          ]
+        }
+      },
+      flow: {
+        $ref: "#/$defs/flowSequence"
+      },
+      output: {
+        $ref: "#/$defs/workflowOutput"
+      }
+    },
+    $defs: {
+      duration: {
+        type: "string",
+        pattern: "^[0-9]+(ms|s|m|h|d)$",
+        description: "Duration string, e.g. '30s', '5m', '2h', '1d'."
+      },
+      celExpression: {
+        type: "string",
+        description: "A Google CEL expression."
+      },
+      defaults: {
+        type: "object",
+        description: "Global defaults applied to all participants.",
+        additionalProperties: false,
+        properties: {
+          timeout: {
+            $ref: "#/$defs/duration"
+          },
+          cwd: {
+            type: "string",
+            description: "Default working directory for exec participants. Supports CEL expressions."
+          }
+        }
+      },
+      inputs: {
+        type: "object",
+        description: "Workflow input parameters. Accessed in CEL as workflow.inputs.<field>. Each key is a parameter name. Value can be null (string, no schema), or a JSON Schema object for validation.",
+        additionalProperties: {
+          oneOf: [
+            { type: "null" },
+            { $ref: "#/$defs/inputField" }
+          ]
+        }
+      },
+      inputField: {
+        type: "object",
+        description: "JSON Schema field definition with optional 'required: true' shortcut.",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["string", "integer", "number", "boolean", "array", "object"]
+          },
+          description: { type: "string" },
+          default: {},
+          required: { type: "boolean" },
+          format: { type: "string" },
+          enum: { type: "array" },
+          minimum: { type: "number" },
+          maximum: { type: "number" },
+          minLength: { type: "integer" },
+          maxLength: { type: "integer" },
+          pattern: { type: "string" },
+          items: {
+            $ref: "#/$defs/inputField"
+          }
+        },
+        additionalProperties: false
+      },
+      retryConfig: {
+        type: "object",
+        description: "Retry configuration. Only applies when onError is 'retry'.",
+        additionalProperties: false,
+        required: ["max"],
+        properties: {
+          max: {
+            type: "integer",
+            minimum: 1,
+            description: "Maximum number of retry attempts."
+          },
+          backoff: {
+            $ref: "#/$defs/duration",
+            description: "Interval between attempts. Default: 0s."
+          },
+          factor: {
+            type: "number",
+            minimum: 1,
+            description: "Backoff multiplier. Default: 1 (no escalation)."
+          }
+        }
+      },
+      onError: {
+        type: "string",
+        description: "Error handling strategy: 'fail' (default), 'skip', 'retry', or a participant name for redirect.",
+        minLength: 1
+      },
+      onTimeout: {
+        type: "string",
+        description: "Timeout handling strategy: 'fail' (default), 'skip', or a participant name for redirect.",
+        minLength: 1
+      },
+      participantInput: {
+        description: "Explicit input mapping. String for direct passthrough, object for structured mapping. Values are CEL expressions. Merged with implicit I/O chain input at runtime.",
+        oneOf: [
+          { type: "string" },
+          {
+            type: "object",
+            additionalProperties: {
+              type: "string"
+            }
+          }
+        ]
+      },
+      participantOutputSchema: {
+        type: "object",
+        description: "Output schema (JSON Schema fields). Opt-in validation.",
+        additionalProperties: {
+          $ref: "#/$defs/inputField"
+        }
+      },
+      payload: {
+        description: "Event payload. String (CEL expression) or object with CEL expressions as values.",
+        oneOf: [
+          { type: "string" },
+          {
+            type: "object",
+            additionalProperties: {}
+          }
+        ]
+      },
+      participant: {
+        type: "object",
+        required: ["type"],
+        description: "A named, reusable building block of the workflow.",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["exec", "http", "mcp", "workflow", "emit"],
+            description: "Participant type."
+          },
+          as: {
+            type: "string",
+            description: "Human-readable display name."
+          },
+          timeout: {
+            $ref: "#/$defs/duration"
+          },
+          onError: {
+            $ref: "#/$defs/onError"
+          },
+          retry: {
+            $ref: "#/$defs/retryConfig"
+          },
+          input: {
+            $ref: "#/$defs/participantInput"
+          },
+          output: {
+            $ref: "#/$defs/participantOutputSchema"
+          },
+          run: {
+            type: "string",
+            description: "[exec] Shell command to execute."
+          },
+          cwd: {
+            type: "string",
+            description: "[exec] Working directory. Supports CEL expressions."
+          },
+          url: {
+            type: "string",
+            description: "[http] Target URL. Supports CEL expressions."
+          },
+          method: {
+            type: "string",
+            enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+            description: "[http] HTTP method."
+          },
+          headers: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: "[http] HTTP headers. Values support CEL expressions."
+          },
+          body: {
+            description: "[http] Request body. String or object. Supports CEL expressions.",
+            oneOf: [
+              { type: "string" },
+              { type: "object" }
+            ]
+          },
+          path: {
+            type: "string",
+            description: "[workflow] Path to the sub-workflow YAML file."
+          },
+          server: {
+            type: "string",
+            description: "[mcp] MCP server identifier."
+          },
+          tool: {
+            type: "string",
+            description: "[mcp] MCP tool name to invoke."
+          },
+          event: {
+            type: "string",
+            description: "[emit] Event name to emit."
+          },
+          payload: {
+            $ref: "#/$defs/payload",
+            description: "[emit] Event payload. CEL expression or object with CEL expressions."
+          },
+          ack: {
+            type: "boolean",
+            description: "[emit] If true, wait for delivery acknowledgment. Default: false.",
+            default: false
+          }
+        },
+        additionalProperties: false
+      },
+      inlineParticipant: {
+        type: "object",
+        required: ["type"],
+        description: "An inline participant definition in the flow. 'as' is optional — if omitted, the participant is anonymous and its output is only accessible via the implicit I/O chain.",
+        properties: {
+          as: {
+            type: "string",
+            description: "Optional name for inline participants. If provided, must be unique across all participant names. Enables output reference by name."
+          },
+          type: {
+            type: "string",
+            enum: ["exec", "http", "mcp", "workflow", "emit"],
+            description: "Participant type."
+          },
+          when: {
+            $ref: "#/$defs/celExpression",
+            description: "Guard condition. If false, step is skipped."
+          },
+          timeout: {
+            $ref: "#/$defs/duration"
+          },
+          onError: {
+            $ref: "#/$defs/onError"
+          },
+          retry: {
+            $ref: "#/$defs/retryConfig"
+          },
+          input: {
+            $ref: "#/$defs/participantInput"
+          },
+          output: {
+            $ref: "#/$defs/participantOutputSchema"
+          },
+          run: { type: "string" },
+          cwd: { type: "string" },
+          url: { type: "string" },
+          method: { type: "string", enum: ["GET", "POST", "PUT", "PATCH", "DELETE"] },
+          headers: { type: "object", additionalProperties: { type: "string" } },
+          body: { oneOf: [{ type: "string" }, { type: "object" }] },
+          path: { type: "string" },
+          server: { type: "string" },
+          tool: { type: "string" },
+          event: { type: "string" },
+          payload: { $ref: "#/$defs/payload" },
+          ack: { type: "boolean" }
+        },
+        additionalProperties: false
+      },
+      flowSequence: {
+        type: "array",
+        description: "Ordered list of flow steps. Each step's output is implicitly chained as input to the next step.",
+        minItems: 1,
+        items: {
+          $ref: "#/$defs/flowStep"
+        }
+      },
+      flowStep: {
+        description: "A single step in the flow: participant reference (string), control construct, inline participant (named or anonymous), or participant override.",
+        oneOf: [
+          {
+            type: "string",
+            description: "Simple participant reference by name."
+          },
+          { $ref: "#/$defs/loopStep" },
+          { $ref: "#/$defs/parallelStep" },
+          { $ref: "#/$defs/ifStep" },
+          { $ref: "#/$defs/setStep" },
+          { $ref: "#/$defs/waitStep" },
+          { $ref: "#/$defs/inlineParticipant" },
+          { $ref: "#/$defs/participantOverrideStep" }
+        ]
+      },
+      loopStep: {
+        type: "object",
+        required: ["loop"],
+        additionalProperties: false,
+        properties: {
+          loop: {
+            type: "object",
+            additionalProperties: false,
+            required: ["steps"],
+            properties: {
+              as: {
+                type: "string",
+                description: "Renames the loop context variable. Access as <as>.index, <as>.iteration, etc. instead of loop.*"
+              },
+              until: {
+                $ref: "#/$defs/celExpression",
+                description: "CEL condition to break out of the loop."
+              },
+              max: {
+                description: "Maximum iterations. Integer or CEL expression.",
+                oneOf: [
+                  { type: "integer", minimum: 1 },
+                  { type: "string" }
+                ]
+              },
+              steps: {
+                $ref: "#/$defs/flowSequence"
+              }
+            },
+            anyOf: [
+              { required: ["until"] },
+              { required: ["max"] }
+            ]
+          }
+        }
+      },
+      parallelStep: {
+        type: "object",
+        required: ["parallel"],
+        additionalProperties: false,
+        properties: {
+          parallel: {
+            $ref: "#/$defs/flowSequence",
+            description: "Steps to run concurrently. The chained output after a parallel block is an array of all branch outputs in declaration order."
+          }
+        }
+      },
+      ifStep: {
+        type: "object",
+        required: ["if"],
+        additionalProperties: false,
+        properties: {
+          if: {
+            type: "object",
+            required: ["condition", "then"],
+            additionalProperties: false,
+            properties: {
+              condition: {
+                $ref: "#/$defs/celExpression",
+                description: "CEL expression that determines which branch to take."
+              },
+              then: {
+                $ref: "#/$defs/flowSequence"
+              },
+              else: {
+                $ref: "#/$defs/flowSequence"
+              }
+            }
+          }
+        }
+      },
+      setStep: {
+        type: "object",
+        required: ["set"],
+        additionalProperties: false,
+        properties: {
+          set: {
+            type: "object",
+            description: "Writes values into execution.context. Each key becomes execution.context.<key>. Values are CEL expressions.",
+            minProperties: 1,
+            additionalProperties: {
+              $ref: "#/$defs/celExpression"
+            },
+            not: {
+              anyOf: [
+                { required: ["workflow"] },
+                { required: ["execution"] },
+                { required: ["input"] },
+                { required: ["output"] },
+                { required: ["env"] },
+                { required: ["loop"] },
+                { required: ["event"] }
+              ]
+            }
+          }
+        }
+      },
+      waitStep: {
+        type: "object",
+        required: ["wait"],
+        additionalProperties: false,
+        properties: {
+          wait: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              event: {
+                type: "string",
+                description: "Event name to wait for (event mode)."
+              },
+              match: {
+                $ref: "#/$defs/celExpression",
+                description: "CEL condition to match against event payload. 'event' variable contains the payload."
+              },
+              until: {
+                $ref: "#/$defs/celExpression",
+                description: "CEL condition to wait for (polling mode)."
+              },
+              poll: {
+                $ref: "#/$defs/duration",
+                description: "Polling interval for 'until' condition. Default: runtime decides."
+              },
+              timeout: {
+                $ref: "#/$defs/duration",
+                description: "Maximum wait time."
+              },
+              onTimeout: {
+                $ref: "#/$defs/onTimeout",
+                description: "Strategy when timeout is reached: 'fail' (default), 'skip', or participant name."
+              }
+            }
+          }
+        }
+      },
+      participantOverrideStep: {
+        type: "object",
+        description: "A participant reference with flow-level overrides (timeout, onError, when, input, workflow, etc.).",
+        minProperties: 1,
+        maxProperties: 1,
+        not: {
+          anyOf: [
+            { required: ["loop"] },
+            { required: ["parallel"] },
+            { required: ["if"] },
+            { required: ["wait"] },
+            { required: ["set"] },
+            { required: ["type"] }
+          ]
+        },
+        additionalProperties: {
+          type: "object",
+          properties: {
+            when: {
+              $ref: "#/$defs/celExpression",
+              description: "Guard condition. If false, step is skipped."
+            },
+            timeout: {
+              $ref: "#/$defs/duration"
+            },
+            onError: {
+              $ref: "#/$defs/onError"
+            },
+            retry: {
+              $ref: "#/$defs/retryConfig"
+            },
+            input: {
+              $ref: "#/$defs/participantInput"
+            },
+            workflow: {
+              type: "string",
+              description: "Inline sub-workflow path (alternative to defining as participant)."
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      workflowOutput: {
+        description: "Workflow output. Accessed in CEL as workflow.output. String (single CEL expression), object (structured mapping), or object with schema+map.",
+        oneOf: [
+          {
+            type: "string",
+            description: "Single CEL expression mapping."
+          },
+          {
+            type: "object",
+            description: "Structured output mapping (key → CEL expression) or schema+map.",
+            properties: {
+              schema: {
+                type: "object",
+                additionalProperties: {
+                  $ref: "#/$defs/inputField"
+                }
+              },
+              map: {
+                type: "object",
+                additionalProperties: {
+                  type: "string"
+                }
+              }
+            },
+            additionalProperties: {
+              type: "string"
+            }
+          }
+        ]
+      }
+    }
+  };
+});
 function validateSchema(workflow) {
   const valid = validate(workflow);
   if (valid) {
@@ -25809,15 +26354,14 @@ function validateSchema(workflow) {
 }
 var import__2020;
 var import_ajv_formats;
-var rawSchema;
 var schema;
 var ajv;
 var validate;
 var init_schema = __esm2(() => {
+  init_duckflux_schema();
   import__2020 = __toESM(require_2020(), 1);
   import_ajv_formats = __toESM(require_dist2(), 1);
-  rawSchema = readFileSync(new URL("./schema/duckflux.schema.json", import.meta.url), "utf-8");
-  schema = JSON.parse(rawSchema);
+  schema = { ...duckflux_schema_default };
   delete schema.$schema;
   ajv = new import__2020.default({ allErrors: true, strict: false });
   import_ajv_formats.default(ajv);
@@ -26219,6 +26763,234 @@ var init_validate = __esm2(() => {
   RESERVED_NAMES = new Set(["workflow", "execution", "input", "output", "env", "loop", "event"]);
   BUILTIN_ONERROR = new Set(["fail", "skip", "retry"]);
 });
+var exports_json = {};
+__export2(exports_json, {
+  JsonTraceWriter: () => JsonTraceWriter
+});
+
+class JsonTraceWriter {
+  dir;
+  filePath = "";
+  trace = {
+    execution: {
+      id: "",
+      startedAt: "",
+      finishedAt: "",
+      duration: 0,
+      status: "running",
+      inputs: null,
+      output: null
+    },
+    steps: []
+  };
+  constructor(dir) {
+    this.dir = dir;
+  }
+  async open(meta) {
+    this.filePath = join(this.dir, `${meta.id}.json`);
+    this.trace = {
+      execution: {
+        id: meta.id,
+        workflowId: meta.workflowId,
+        workflowName: meta.workflowName,
+        workflowVersion: meta.workflowVersion,
+        startedAt: meta.startedAt,
+        finishedAt: "",
+        duration: 0,
+        status: "running",
+        inputs: meta.inputs,
+        output: null
+      },
+      steps: []
+    };
+    await this.flush();
+  }
+  writeStep(step) {
+    this.trace.steps.push(step);
+    this.flushSync();
+  }
+  async finalize(meta) {
+    this.trace.execution.status = meta.status;
+    this.trace.execution.output = meta.output;
+    this.trace.execution.finishedAt = meta.finishedAt;
+    this.trace.execution.duration = meta.duration;
+    await this.flush();
+  }
+  flushSync() {
+    this.flush().catch(() => {});
+  }
+  async flush() {
+    if (!this.filePath)
+      return;
+    await writeFile(this.filePath, JSON.stringify(this.trace, null, 2), "utf-8");
+  }
+}
+var exports_txt = {};
+__export2(exports_txt, {
+  TxtTraceWriter: () => TxtTraceWriter
+});
+function serializeValue(value) {
+  if (value === undefined || value === null)
+    return "none";
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value, null, 2);
+}
+function formatStep(step) {
+  const lines = [
+    `## [${step.seq}] ${step.name} (${step.type})`,
+    `startedAt: ${step.startedAt}`
+  ];
+  if (step.finishedAt)
+    lines.push(`finishedAt: ${step.finishedAt}`);
+  if (step.duration !== undefined)
+    lines.push(`duration: ${step.duration}ms`);
+  lines.push(`status: ${step.status}`);
+  if (step.loopIndex !== undefined)
+    lines.push(`loopIndex: ${step.loopIndex}`);
+  if (step.retries !== undefined && step.retries > 0)
+    lines.push(`retries: ${step.retries}`);
+  lines.push(`input: ${serializeValue(step.input)}`);
+  lines.push(`output: ${serializeValue(step.output)}`);
+  if (step.error)
+    lines.push(`error: ${step.error}`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+class TxtTraceWriter {
+  dir;
+  filePath = "";
+  constructor(dir) {
+    this.dir = dir;
+  }
+  async open(meta) {
+    this.filePath = join2(this.dir, `${meta.id}.txt`);
+    const versionStr = meta.workflowVersion !== undefined ? ` (v${meta.workflowVersion})` : "";
+    const workflowLabel = meta.workflowName ?? meta.workflowId ?? "unnamed";
+    const header = [
+      "# execution",
+      `id: ${meta.id}`,
+      `workflow: ${workflowLabel}${versionStr}`,
+      `startedAt: ${meta.startedAt}`,
+      "status: running",
+      "",
+      "# inputs",
+      serializeValue(meta.inputs),
+      "",
+      "# steps",
+      ""
+    ].join(`
+`);
+    await writeFile2(this.filePath, header, "utf-8");
+  }
+  async writeStep(step) {
+    if (!this.filePath)
+      return;
+    await appendFile(this.filePath, formatStep(step), "utf-8");
+  }
+  async finalize(meta) {
+    if (!this.filePath)
+      return;
+    const outputSection = [
+      "# output",
+      serializeValue(meta.output),
+      ""
+    ].join(`
+`);
+    await appendFile(this.filePath, outputSection, "utf-8");
+    const content = await readFile2(this.filePath, "utf-8");
+    const updated = content.replace(/^status: running$/m, `status: ${meta.status}
+finishedAt: ${meta.finishedAt}
+duration: ${meta.duration}ms`);
+    await writeFile2(this.filePath, updated, "utf-8");
+  }
+}
+var exports_sqlite = {};
+__export2(exports_sqlite, {
+  SqliteTraceWriter: () => SqliteTraceWriter
+});
+function toJson(value) {
+  if (value === undefined || value === null)
+    return null;
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value);
+}
+
+class SqliteTraceWriter {
+  dir;
+  db = null;
+  executionId = "";
+  constructor(dir) {
+    this.dir = dir;
+  }
+  async open(meta) {
+    this.executionId = meta.id;
+    const filePath = join3(this.dir, `${meta.id}.sqlite`);
+    const { Database } = await import("bun:sqlite");
+    this.db = new Database(filePath);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS executions (
+        id TEXT PRIMARY KEY,
+        workflow_id TEXT,
+        workflow_name TEXT,
+        workflow_version TEXT,
+        started_at TEXT NOT NULL,
+        finished_at TEXT,
+        duration_ms INTEGER,
+        status TEXT NOT NULL,
+        inputs TEXT,
+        output TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS steps (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        execution_id TEXT NOT NULL REFERENCES executions(id),
+        seq INTEGER NOT NULL,
+        name TEXT NOT NULL,
+        type TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        duration_ms INTEGER,
+        status TEXT NOT NULL,
+        input TEXT,
+        output TEXT,
+        error TEXT,
+        retries INTEGER,
+        loop_index INTEGER
+      );
+    `);
+    const insert = this.db.prepare(`
+      INSERT INTO executions (id, workflow_id, workflow_name, workflow_version, started_at, status, inputs)
+      VALUES (?, ?, ?, ?, ?, 'running', ?)
+    `);
+    insert.run(meta.id, meta.workflowId ?? null, meta.workflowName ?? null, meta.workflowVersion !== undefined ? String(meta.workflowVersion) : null, meta.startedAt, toJson(meta.inputs));
+  }
+  writeStep(step) {
+    if (!this.db)
+      return;
+    const insert = this.db.prepare(`
+      INSERT INTO steps
+        (execution_id, seq, name, type, started_at, finished_at, duration_ms, status, input, output, error, retries, loop_index)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    insert.run(this.executionId, step.seq, step.name, step.type, step.startedAt ?? null, step.finishedAt ?? null, step.duration ?? null, step.status, toJson(step.input), toJson(step.output), step.error ?? null, step.retries ?? null, step.loopIndex ?? null);
+  }
+  async finalize(meta) {
+    if (!this.db)
+      return;
+    const update = this.db.prepare(`
+      UPDATE executions
+      SET status = ?, output = ?, finished_at = ?, duration_ms = ?
+      WHERE id = ?
+    `);
+    update.run(meta.status, toJson(meta.output), meta.finishedAt, Math.round(meta.duration), this.executionId);
+    this.db.close();
+    this.db = null;
+  }
+}
 function sleep(ms) {
   return new Promise((resolve22) => setTimeout(resolve22, ms));
 }
@@ -26345,13 +27117,13 @@ function isMap3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function mapToEnvVars(input) {
-  const env2 = {};
+  const env = {};
   for (const [key, value] of Object.entries(input)) {
-    env2[key] = typeof value === "string" ? value : String(value);
+    env[key] = typeof value === "string" ? value : String(value);
   }
-  return env2;
+  return env;
 }
-async function executeExec(participant, input, env2 = {}, signal) {
+async function executeExec(participant, input, env = {}, signal) {
   const command = participant.run ?? "";
   const participantEnv = participant.env ?? {};
   const cwd = participant.cwd ?? process.cwd();
@@ -26362,7 +27134,7 @@ async function executeExec(participant, input, env2 = {}, signal) {
   return new Promise((resolve22) => {
     try {
       const proc = spawn("sh", ["-c", command], {
-        env: { ...process.env, ...env2, ...participantEnv, ...inputEnvVars },
+        env: { ...process.env, ...env, ...participantEnv, ...inputEnvVars },
         cwd,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -26510,7 +27282,7 @@ async function executeHttp(participant, input) {
   };
 }
 async function executeMcp(participant, _input) {
-  throw new Error(`mcp participant is not yet implemented (server: ${participant.server ?? "unspecified"}, tool: ${participant.tool ?? "unspecified"}). ` + "Use onError to handle this gracefully.");
+  throw new Error(`mcp participant is not yet implemented (server: ${participant.server ?? "unspecified"}, tool: ${participant.tool ?? "unspecified"}). Use onError to handle this gracefully.`);
 }
 function toWorkflowInputs(input) {
   if (input && typeof input === "object" && !Array.isArray(input)) {
@@ -26555,12 +27327,12 @@ var init_workflow = __esm2(() => {
   init_schema();
   init_validate();
 });
-async function executeParticipant(participant, input, env2 = {}, basePath, engineExecutor, hub, celContext, ancestorPaths) {
+async function executeParticipant(participant, input, env = {}, basePath, engineExecutor, hub, celContext, ancestorPaths) {
   const executor = executors[participant.type];
   if (!executor) {
     throw new Error(`participant type '${participant.type}' is not yet implemented`);
   }
-  return executor(participant, input, env2, basePath, engineExecutor, hub, celContext, ancestorPaths);
+  return executor(participant, input, env, basePath, engineExecutor, hub, celContext, ancestorPaths);
 }
 var executors;
 var init_participant = __esm2(() => {
@@ -26568,7 +27340,7 @@ var init_participant = __esm2(() => {
   init_exec();
   init_workflow();
   executors = {
-    exec: async (participant, input, env2) => executeExec(participant, input, env2),
+    exec: async (participant, input, env) => executeExec(participant, input, env),
     http: async (participant, input) => executeHttp(participant, input),
     workflow: async (participant, input, _env, basePath, engineExecutor, _hub, _celContext, ancestorPaths) => {
       if (!basePath) {
@@ -26796,6 +27568,10 @@ async function executeStep(workflow, state, step, basePath = process.cwd(), engi
           output: "",
           duration: 0
         });
+        const loopIndex2 = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+        const skippedSeq = state.tracer?.startStep(stepName, participant.type, undefined, loopIndex2);
+        if (skippedSeq !== undefined)
+          state.tracer?.endStep(skippedSeq, "skipped");
       }
       return chain;
     }
@@ -26804,6 +27580,8 @@ async function executeStep(workflow, state, step, basePath = process.cwd(), engi
   const overrideInput = override?.input !== undefined ? resolveParticipantInput(override.input, state) : undefined;
   const mergedWithBase = mergeChainedInput(chain, baseInput);
   const mergedInput = mergeChainedInput(mergedWithBase, overrideInput);
+  const loopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+  const traceSeq = state.tracer?.startStep(stepName ?? "<anonymous>", participant.type, mergedInput, loopIndex);
   state.currentInput = mergedInput;
   const strategy = resolveErrorStrategy(override ?? null, participant, workflow.defaults ?? null);
   const timeoutMs = resolveTimeout(override ?? null, participant, workflow.defaults ?? null);
@@ -26881,6 +27659,8 @@ async function executeStep(workflow, state, step, basePath = process.cwd(), engi
     }
     const outputValue = result.parsedOutput ?? result.output;
     state.currentOutput = outputValue;
+    if (traceSeq !== undefined)
+      state.tracer?.endStep(traceSeq, result.status, outputValue, undefined, retries);
     return outputValue;
   } catch (error) {
     const message = String(error?.message ?? error);
@@ -26906,6 +27686,8 @@ async function executeStep(workflow, state, step, basePath = process.cwd(), engi
       if (stepName) {
         state.setResult(stepName, skipResult);
       }
+      if (traceSeq !== undefined)
+        state.tracer?.endStep(traceSeq, "skipped", undefined, message);
       return chain;
     }
     if (strategy !== "fail" && strategy !== "retry") {
@@ -26924,6 +27706,8 @@ async function executeStep(workflow, state, step, basePath = process.cwd(), engi
           ...httpMeta
         });
       }
+      if (traceSeq !== undefined)
+        state.tracer?.endStep(traceSeq, "failure", undefined, message);
       const fallbackResult = await executeStep(workflow, state, fallbackName, basePath, engineExecutor, [...fallbackStack, stepName ?? "<anonymous>"], chain, hub);
       return fallbackResult;
     }
@@ -26938,6 +27722,8 @@ async function executeStep(workflow, state, step, basePath = process.cwd(), engi
         ...httpMeta
       });
     }
+    if (traceSeq !== undefined)
+      state.tracer?.endStep(traceSeq, "failure", undefined, message);
     throw error;
   }
 }
@@ -26960,7 +27746,7 @@ __export2(exports_wait, {
   executeWait: () => executeWait
 });
 function sleep2(ms) {
-  return new Promise((resolve32) => setTimeout(resolve32, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function executeWait(state, waitDef, chain, hub, signal) {
   const timeoutMs = waitDef.timeout ? parseDuration(waitDef.timeout) : undefined;
@@ -27046,21 +27832,38 @@ async function executeControlStep(workflow, state, step, basePath = process.cwd(
   }
   const obj = step;
   if ("wait" in obj && Object.keys(obj).length === 1) {
-    const { executeWait: executeWait2 } = await Promise.resolve().then(() => (init_wait(), exports_wait));
-    return executeWait2(state, obj.wait, chain, hub, signal);
+    const loopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+    const traceSeq = state.tracer?.startStep("wait", "wait", undefined, loopIndex);
+    try {
+      const { executeWait: executeWait2 } = await Promise.resolve().then(() => (init_wait(), exports_wait));
+      const result = await executeWait2(state, obj.wait, chain, hub, signal);
+      if (traceSeq !== undefined)
+        state.tracer?.endStep(traceSeq, "success", result);
+      return result;
+    } catch (err) {
+      if (traceSeq !== undefined)
+        state.tracer?.endStep(traceSeq, "failure", undefined, String(err?.message ?? err));
+      throw err;
+    }
   }
   if ("set" in obj && Object.keys(obj).length === 1) {
     const setDef = obj.set;
     const ctx = state.toCelContext();
+    const loopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+    const traceSeq = state.tracer?.startStep("set", "set", setDef, loopIndex);
     if (!state.executionMeta.context) {
       state.executionMeta.context = {};
     }
     for (const [key, expr] of Object.entries(setDef)) {
       if (RESERVED_SET_KEYS.has(key)) {
+        if (traceSeq !== undefined)
+          state.tracer?.endStep(traceSeq, "failure", undefined, `set key '${key}' uses a reserved name`);
         throw new Error(`set key '${key}' uses a reserved name`);
       }
       state.executionMeta.context[key] = evaluateCel(expr, ctx);
     }
+    if (traceSeq !== undefined)
+      state.tracer?.endStep(traceSeq, "success", state.executionMeta.context);
     return chain;
   }
   if ("loop" in obj && Object.keys(obj).length === 1) {
@@ -27077,6 +27880,8 @@ async function executeControlStep(workflow, state, step, basePath = process.cwd(
       maxIterations = loopDef.max ?? Number.POSITIVE_INFINITY;
     }
     const hasMax = loopDef.max !== undefined;
+    const outerLoopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+    const loopTraceSeq = state.tracer?.startStep(loopAs ?? "loop", "loop", undefined, outerLoopIndex);
     state.pushLoop(loopAs);
     let loopChain = chain;
     try {
@@ -27100,6 +27905,12 @@ async function executeControlStep(workflow, state, step, basePath = process.cwd(
         iterations += 1;
         state.incrementLoop();
       }
+      if (loopTraceSeq !== undefined)
+        state.tracer?.endStep(loopTraceSeq, "success", loopChain);
+    } catch (err) {
+      if (loopTraceSeq !== undefined)
+        state.tracer?.endStep(loopTraceSeq, "failure", undefined, String(err?.message ?? err));
+      throw err;
     } finally {
       state.popLoop();
     }
@@ -27108,29 +27919,54 @@ async function executeControlStep(workflow, state, step, basePath = process.cwd(
   if ("parallel" in obj && Object.keys(obj).length === 1) {
     const parallelSteps = obj.parallel;
     const controller = new AbortController;
+    const loopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+    const parallelTraceSeq = state.tracer?.startStep("parallel", "parallel", undefined, loopIndex);
     const branchSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
-    const results = await Promise.all(parallelSteps.map(async (parallelStep) => {
-      try {
-        return await executeControlStep(workflow, state, parallelStep, basePath, engineExecutor, chain, hub, branchSignal);
-      } catch (error) {
-        controller.abort();
-        throw error;
-      }
-    }));
-    return results;
+    try {
+      const results = await Promise.all(parallelSteps.map(async (parallelStep) => {
+        try {
+          return await executeControlStep(workflow, state, parallelStep, basePath, engineExecutor, chain, hub, branchSignal);
+        } catch (error) {
+          controller.abort();
+          throw error;
+        }
+      }));
+      if (parallelTraceSeq !== undefined)
+        state.tracer?.endStep(parallelTraceSeq, "success", results);
+      return results;
+    } catch (err) {
+      if (parallelTraceSeq !== undefined)
+        state.tracer?.endStep(parallelTraceSeq, "failure", undefined, String(err?.message ?? err));
+      throw err;
+    }
   }
   if ("if" in obj && Object.keys(obj).length === 1) {
     const ifDef = obj.if;
     const condition = evaluateCel(ifDef.condition, state.toCelContext());
+    const loopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+    const ifTraceSeq = state.tracer?.startStep("if", "if", { condition: ifDef.condition }, loopIndex);
     if (typeof condition !== "boolean") {
+      if (ifTraceSeq !== undefined)
+        state.tracer?.endStep(ifTraceSeq, "failure", undefined, `if.condition must evaluate to boolean, got ${typeof condition}`);
       throw new Error(`if.condition must evaluate to boolean, got ${typeof condition}`);
     }
-    if (condition) {
-      return executeSequential(workflow, state, ifDef.then, basePath, engineExecutor, chain, hub, signal);
-    } else if (ifDef.else) {
-      return executeSequential(workflow, state, ifDef.else, basePath, engineExecutor, chain, hub, signal);
+    try {
+      let result;
+      if (condition) {
+        result = await executeSequential(workflow, state, ifDef.then, basePath, engineExecutor, chain, hub, signal);
+      } else if (ifDef.else) {
+        result = await executeSequential(workflow, state, ifDef.else, basePath, engineExecutor, chain, hub, signal);
+      } else {
+        result = chain;
+      }
+      if (ifTraceSeq !== undefined)
+        state.tracer?.endStep(ifTraceSeq, "success", result);
+      return result;
+    } catch (err) {
+      if (ifTraceSeq !== undefined)
+        state.tracer?.endStep(ifTraceSeq, "failure", undefined, String(err?.message ?? err));
+      throw err;
     }
-    return chain;
   }
   return executeStep(workflow, state, step, basePath, engineExecutor, [], chain, hub, signal);
 }
@@ -27140,7 +27976,92 @@ var init_control = __esm2(() => {
   init_sequential();
   RESERVED_SET_KEYS = new Set(["workflow", "execution", "input", "output", "env", "loop", "event"]);
 });
-init_cel();
+
+class MemoryHub {
+  listeners = new Map;
+  buffer = new Map;
+  closed = false;
+  async publish(event, payload) {
+    if (this.closed)
+      throw new Error("hub is closed");
+    const envelope = { name: event, payload };
+    let buf = this.buffer.get(event);
+    if (!buf) {
+      buf = [];
+      this.buffer.set(event, buf);
+    }
+    buf.push(envelope);
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(envelope);
+      }
+    }
+  }
+  async publishAndWaitAck(event, payload, _timeoutMs) {
+    await this.publish(event, payload);
+  }
+  async* subscribe(event, signal) {
+    if (this.closed)
+      return;
+    const buffered = this.buffer.get(event);
+    if (buffered) {
+      for (const envelope of buffered) {
+        if (signal?.aborted)
+          return;
+        yield envelope;
+      }
+    }
+    const queue = [];
+    let resolve3 = null;
+    const listener = (envelope) => {
+      queue.push(envelope);
+      if (resolve3) {
+        resolve3();
+        resolve3 = null;
+      }
+    };
+    let listeners = this.listeners.get(event);
+    if (!listeners) {
+      listeners = new Set;
+      this.listeners.set(event, listeners);
+    }
+    listeners.add(listener);
+    const onAbort = () => {
+      listeners.delete(listener);
+      if (resolve3) {
+        resolve3();
+        resolve3 = null;
+      }
+    };
+    if (signal) {
+      signal.addEventListener("abort", onAbort);
+    }
+    try {
+      while (!this.closed && !signal?.aborted) {
+        if (queue.length > 0) {
+          yield queue.shift();
+        } else {
+          await new Promise((r) => {
+            resolve3 = r;
+          });
+        }
+      }
+    } finally {
+      listeners.delete(listener);
+      if (signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+    }
+  }
+  async close() {
+    this.closed = true;
+    for (const listeners of this.listeners.values()) {
+      listeners.clear();
+    }
+    this.listeners.clear();
+  }
+}
 init_parser3();
 init_schema();
 init_validate();
@@ -27304,357 +28225,219 @@ function validateInputs(inputDefs, provided) {
     resolved
   };
 }
-init_control();
+init_cel();
+init_cel();
+init_parser3();
+init_schema();
+init_validate();
 
-class WorkflowState {
-  inputs;
-  results;
-  loopStack;
-  workflowInputs;
-  workflowMeta;
-  executionMeta;
-  currentInput;
-  currentOutput;
-  chainValue;
-  eventPayload;
-  ancestorPaths;
-  constructor(inputs = {}) {
-    this.inputs = { ...inputs };
-    this.workflowInputs = { ...inputs };
-    this.workflowMeta = {};
-    this.executionMeta = {
-      id: crypto.randomUUID(),
+class TraceCollector {
+  openSteps = new Map;
+  seq = 0;
+  truncateAt;
+  writer;
+  constructor(truncateAt = 1e6) {
+    this.truncateAt = truncateAt;
+  }
+  startStep(name, type3, input, loopIndex) {
+    this.seq += 1;
+    this.openSteps.set(this.seq, {
+      name,
+      type: type3,
       startedAt: new Date().toISOString(),
-      status: "running",
-      cwd: process.cwd()
-    };
-    this.currentInput = undefined;
-    this.currentOutput = undefined;
-    this.chainValue = undefined;
-    this.eventPayload = undefined;
-    this.ancestorPaths = new Set;
-    this.results = new Map;
-    this.loopStack = [];
-  }
-  setResult(stepName, result) {
-    this.results.set(stepName, result);
-  }
-  getResult(stepName) {
-    return this.results.get(stepName);
-  }
-  getAllResults() {
-    const out = {};
-    for (const [k, v] of this.results.entries())
-      out[k] = v;
-    return out;
-  }
-  pushLoop(as) {
-    this.loopStack.push({ index: 0, as });
-  }
-  incrementLoop() {
-    const top = this.loopStack[this.loopStack.length - 1];
-    if (top)
-      top.index += 1;
-  }
-  popLoop() {
-    this.loopStack.pop();
-  }
-  currentLoopIndex() {
-    const top = this.loopStack[this.loopStack.length - 1];
-    return top ? top.index : 0;
-  }
-  setLoopLast(last2) {
-    const top = this.loopStack[this.loopStack.length - 1];
-    if (top)
-      top.last = last2;
-  }
-  currentLoopContext() {
-    const top = this.loopStack[this.loopStack.length - 1];
-    if (!top)
-      return { index: 0, iteration: 1, first: true, last: false };
-    return {
-      index: top.index,
-      iteration: top.index + 1,
-      first: top.index === 0,
-      last: top.last ?? false,
-      as: top.as
-    };
-  }
-  toCelContext() {
-    const ctx = {};
-    for (const [name, res] of this.results.entries()) {
-      ctx[name] = {
-        output: res.parsedOutput ?? res.output,
-        status: res.status,
-        startedAt: res.startedAt,
-        finishedAt: res.finishedAt,
-        duration: res.duration,
-        retries: res.retries ?? 0,
-        error: res.error,
-        cwd: res.cwd
-      };
-    }
-    ctx["workflow"] = {
-      id: this.workflowMeta.id,
-      name: this.workflowMeta.name,
-      version: this.workflowMeta.version,
-      inputs: this.workflowInputs,
-      output: null
-    };
-    ctx["execution"] = { ...this.executionMeta };
-    ctx["input"] = this.currentInput ?? {};
-    ctx["output"] = this.currentOutput ?? {};
-    ctx["env"] = { ...env };
-    const loopCtx = this.currentLoopContext();
-    const loopObj = {
-      index: loopCtx.index,
-      iteration: loopCtx.iteration,
-      first: loopCtx.first,
-      last: loopCtx.last
-    };
-    if (loopCtx.as) {
-      ctx[`_${loopCtx.as}`] = loopObj;
-    }
-    ctx["_loop"] = loopObj;
-    ctx["loop"] = loopObj;
-    ctx["event"] = this.eventPayload ?? {};
-    ctx["now"] = Math.floor(Date.now() / 1000);
-    return ctx;
-  }
-  resolveOutput(outputDef, celEvaluator) {
-    const ctx = this.toCelContext();
-    if (typeof outputDef === "object" && "map" in outputDef && "schema" in outputDef) {
-      const result2 = {};
-      for (const [k, expr] of Object.entries(outputDef.map)) {
-        result2[k] = celEvaluator(expr, ctx);
-      }
-      return result2;
-    }
-    if (typeof outputDef === "string") {
-      return celEvaluator(outputDef, ctx);
-    }
-    const result = {};
-    for (const k of Object.keys(outputDef)) {
-      const expr = outputDef[k];
-      result[k] = celEvaluator(expr, ctx);
-    }
-    return result;
-  }
-}
-async function executeWorkflow(workflow, inputs = {}, basePath = process.cwd(), options = {}) {
-  const { result: inputResult, resolved } = validateInputs(workflow.inputs, inputs);
-  if (!inputResult.valid) {
-    throw new Error(`input validation failed: ${JSON.stringify(inputResult.errors)}`);
-  }
-  const state = new WorkflowState(resolved);
-  state.workflowMeta = {
-    id: workflow.id,
-    name: workflow.name,
-    version: workflow.version
-  };
-  state.executionMeta.number = options.executionNumber ?? 1;
-  if (options.cwd) {
-    state.executionMeta.cwd = options.cwd;
-  }
-  const startedAt = performance.now();
-  if (options._ancestorPaths) {
-    state.ancestorPaths = options._ancestorPaths;
-  }
-  const engineExecutor = async (subWorkflow, subInputs, subBasePath) => {
-    return executeWorkflow(subWorkflow, subInputs, subBasePath, {
-      ...options,
-      _ancestorPaths: state.ancestorPaths
+      startMs: performance.now(),
+      input: input !== undefined ? this.truncate(input) : undefined,
+      loopIndex
     });
-  };
-  let chain;
-  for (const step of workflow.flow) {
-    chain = await executeControlStep(workflow, state, step, basePath, engineExecutor, chain, options.hub);
-  }
-  let output;
-  if (workflow.output !== undefined) {
-    output = state.resolveOutput(workflow.output, evaluateCel);
-    if (typeof workflow.output === "object" && "schema" in workflow.output && "map" in workflow.output && typeof output === "object" && output !== null) {
-      validateOutputSchema(workflow.output.schema, output);
-    }
-  } else {
-    output = chain;
+    return this.seq;
   }
-  const steps = state.getAllResults();
-  const success = !Object.values(steps).some((step) => step.status === "failure");
-  state.executionMeta.status = success ? "success" : "failure";
-  return {
-    success,
-    output,
-    steps,
-    duration: Math.max(0, performance.now() - startedAt)
-  };
-}
-async function runWorkflowFromFile(filePath, inputs = {}, options = {}) {
-  const workflow = await parseWorkflowFile(filePath);
-  const schemaValidation = validateSchema(workflow);
-  if (!schemaValidation.valid) {
-    throw new Error(`schema validation failed: ${JSON.stringify(schemaValidation.errors)}`);
+  endStep(seq, status, output, error, retries) {
+    const open = this.openSteps.get(seq);
+    if (!open)
+      return;
+    this.openSteps.delete(seq);
+    const finishedAt = new Date().toISOString();
+    const duration = Math.max(0, performance.now() - open.startMs);
+    const step = {
+      seq,
+      name: open.name,
+      type: open.type,
+      startedAt: open.startedAt,
+      finishedAt,
+      duration: Math.round(duration),
+      status,
+      ...open.input !== undefined ? { input: open.input } : {},
+      ...output !== undefined ? { output: this.truncate(output) } : {},
+      ...error !== undefined ? { error } : {},
+      ...retries !== undefined && retries > 0 ? { retries } : {},
+      ...open.loopIndex !== undefined ? { loopIndex: open.loopIndex } : {}
+    };
+    this.writer?.writeStep(step);
   }
-  const workflowBasePath = dirname2(resolve3(filePath));
-  const semanticValidation = await validateSemantic(workflow, workflowBasePath);
-  if (!semanticValidation.valid) {
-    throw new Error(`semantic validation failed: ${JSON.stringify(semanticValidation.errors)}`);
+  truncate(value) {
+    if (value == null)
+      return value;
+    const str = typeof value === "string" ? value : JSON.stringify(value);
+    const bytes = new TextEncoder().encode(str);
+    if (bytes.length <= this.truncateAt)
+      return value;
+    const cut = new TextDecoder().decode(bytes.slice(0, this.truncateAt));
+    return cut + "...[truncated]";
   }
-  return executeWorkflow(workflow, inputs, workflowBasePath, options);
 }
 init_control();
 init_sequential();
-init_errors();
-init_timeout();
 init_wait();
+init_emit();
 
-// src/run.ts
-async function createHubFromFlags(values2) {
-  const backend = values2?.["event-backend"] ?? "memory";
-  if (backend === "memory") {
-    const { MemoryHub: MemoryHub2 } = await Promise.resolve().then(() => (init_eventhub(), exports_eventhub));
-    return new MemoryHub2;
-  }
-  if (backend === "nats") {
-    const url = values2?.["nats-url"];
-    if (!url) {
-      console.error("Error: --nats-url is required when using the NATS backend");
-      throw new Error("missing --nats-url");
+// src/lint.ts
+function collectLintWarnings(workflow) {
+  const warnings = [];
+  const participants = workflow.participants ?? {};
+  collectFlowWarnings(workflow.flow ?? [], participants, warnings);
+  return warnings;
+}
+function collectFlowWarnings(flow, participants, warnings, basePath = "flow") {
+  for (const [index, step] of flow.entries()) {
+    const stepPath = `${basePath}[${index}]`;
+    if (!step || typeof step !== "object")
+      continue;
+    const obj = step;
+    if (obj.loop && Object.keys(obj).length === 1) {
+      const loopDef = obj.loop;
+      if (loopDef.until == null && loopDef.max == null) {
+        warnings.push({
+          path: `${stepPath}.loop`,
+          message: "loop has no 'until' and no 'max' — this will be rejected at runtime"
+        });
+      }
+      collectFlowWarnings(loopDef.steps ?? [], participants, warnings, `${stepPath}.loop.steps`);
+      continue;
     }
-    const stream = values2?.["nats-stream"] ?? "duckflux-events";
-    try {
-      const { NatsHub } = await import("@duckflux/hub-nats");
-      return await NatsHub.create({ url, stream });
-    } catch (err) {
-      if (err instanceof Error && (err.message.includes("Cannot find module") || err.message.includes("Cannot find package"))) {
-        console.error("Error: install @duckflux/hub-nats to use the NATS backend");
-        throw new Error("@duckflux/hub-nats not installed");
+    if (obj.parallel && Object.keys(obj).length === 1) {
+      const parallelSteps = obj.parallel;
+      const branchSetKeys = new Map;
+      for (const [branchIdx, branch] of parallelSteps.entries()) {
+        const setKeys = collectSetKeys(branch);
+        for (const key of setKeys) {
+          const branches = branchSetKeys.get(key) ?? [];
+          branches.push(branchIdx);
+          branchSetKeys.set(key, branches);
+        }
       }
-      throw err;
+      for (const [key, branches] of branchSetKeys) {
+        if (branches.length > 1) {
+          warnings.push({
+            path: `${stepPath}.parallel`,
+            message: `branches [${branches.join(", ")}] both write to '${key}' via set — race condition risk`
+          });
+        }
+      }
+      collectFlowWarnings(parallelSteps, participants, warnings, `${stepPath}.parallel`);
+      continue;
     }
-  }
-  if (backend === "redis") {
-    const addr = values2?.["redis-addr"] ?? "localhost:6379";
-    const db = Number(values2?.["redis-db"] ?? "0");
-    try {
-      const { RedisHub } = await import("@duckflux/hub-redis");
-      return await RedisHub.create({ addr, db });
-    } catch (err) {
-      if (err instanceof Error && (err.message.includes("Cannot find module") || err.message.includes("Cannot find package"))) {
-        console.error("Error: install @duckflux/hub-redis to use the Redis backend");
-        throw new Error("@duckflux/hub-redis not installed");
+    if ("type" in obj && !obj.as) {
+      warnings.push({
+        path: stepPath,
+        message: "inline participant without 'as' — its output cannot be referenced by name"
+      });
+      continue;
+    }
+    if (obj.if && Object.keys(obj).length === 1) {
+      const ifDef = obj.if;
+      collectFlowWarnings(ifDef.then ?? [], participants, warnings, `${stepPath}.if.then`);
+      if (ifDef.else) {
+        collectFlowWarnings(ifDef.else, participants, warnings, `${stepPath}.if.else`);
       }
-      throw err;
     }
   }
-  console.error(`Error: unknown event backend "${backend}". Supported: memory, nats, redis`);
-  throw new Error(`unknown event backend: ${backend}`);
 }
-function parseInputFlags(arr) {
-  const out = {};
-  if (!arr)
-    return out;
-  for (const item of arr) {
-    const idx = item.indexOf("=");
-    if (idx === -1) {
-      out[item] = true;
-    } else {
-      const k = item.slice(0, idx);
-      const v = item.slice(idx + 1);
-      try {
-        out[k] = JSON.parse(v);
-      } catch {
-        out[k] = v;
+function collectSetKeys(step) {
+  if (!step || typeof step !== "object")
+    return [];
+  const obj = step;
+  if ("set" in obj && Object.keys(obj).length === 1) {
+    return Object.keys(obj.set);
+  }
+  const keys3 = [];
+  if (obj.loop) {
+    const loopDef = obj.loop;
+    for (const s of loopDef.steps ?? []) {
+      keys3.push(...collectSetKeys(s));
+    }
+  }
+  if (obj.if) {
+    const ifDef = obj.if;
+    for (const s of ifDef.then ?? []) {
+      keys3.push(...collectSetKeys(s));
+    }
+    if (ifDef.else) {
+      for (const s of ifDef.else) {
+        keys3.push(...collectSetKeys(s));
       }
     }
   }
-  return out;
+  return keys3;
 }
-async function runCommand(filePath, cliValues) {
+async function lintCommand(filePath) {
   if (!filePath) {
-    console.error("Usage: duckflux run <workflow.yaml> [--input k=v] [--input-file file.json] [--cwd dir]");
+    console.error("Usage: quack lint <workflow.yaml>");
     return 1;
   }
-  let inputs = {};
   try {
-    if (process.stdin && !process.stdin.isTTY) {
-      let stdin = "";
-      for await (const chunk of process.stdin) {
-        stdin += chunk;
-      }
-      stdin = stdin.trim();
-      if (stdin.length > 0) {
-        try {
-          const parsed = JSON.parse(stdin);
-          if (typeof parsed === "object" && parsed !== null)
-            inputs = { ...inputs, ...parsed };
-        } catch {}
+    const workflow = await parseWorkflowFile(filePath);
+    const schemaRes = validateSchema(workflow);
+    if (!schemaRes.valid) {
+      console.error("Schema validation failed:");
+      for (const e of schemaRes.errors) {
+        console.error(`  - ${e.path}: ${e.message}`);
       }
+      return 1;
     }
-  } catch {}
-  if (cliValues) {
-    if (cliValues["input-file"]) {
-      try {
-        const content = await readFile2(String(cliValues["input-file"]), "utf-8");
-        const parsed = JSON.parse(content);
-        if (typeof parsed === "object" && parsed !== null)
-          inputs = { ...inputs, ...parsed };
-      } catch (err) {
-        console.error("Failed to read input file:", err);
-        return 1;
+    const basePath = dirname2(filePath);
+    const semanticRes = await validateSemantic(workflow, basePath);
+    if (!semanticRes.valid) {
+      console.error("Semantic validation failed:");
+      for (const e of semanticRes.errors) {
+        console.error(`  - ${e.path}: ${e.message}`);
       }
+      return 1;
     }
-    if (cliValues.input) {
-      const parsed = Array.isArray(cliValues.input) ? cliValues.input : [cliValues.input];
-      inputs = { ...inputs, ...parseInputFlags(parsed) };
-    }
-  }
-  let hub;
-  try {
-    hub = await createHubFromFlags(cliValues);
-  } catch {
-    return 1;
-  }
-  const options = {
-    hub,
-    cwd: cliValues?.cwd,
-    verbose: cliValues?.verbose,
-    quiet: cliValues?.quiet
-  };
-  try {
-    const res = await runWorkflowFromFile(filePath, inputs, options);
-    const output = res.output;
-    if (output === undefined || output === null) {} else if (typeof output === "string") {
-      process.stdout.write(output);
-    } else {
-      console.log(JSON.stringify(output, null, 2));
+    const warnings = collectLintWarnings(workflow);
+    if (warnings.length > 0) {
+      console.warn("Warnings:");
+      for (const w of warnings) {
+        console.warn(`  - ${w.path}: ${w.message}`);
+      }
     }
-    return res.success ? 0 : 2;
+    console.log("valid");
+    return 0;
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error("Error:", msg);
-    if (cliValues?.verbose && err instanceof Error && err.stack) {
-      console.error(err.stack);
-    }
+    console.error("Error during lint:", err && err.message ? err.message : err);
     return 1;
-  } finally {
-    await hub?.close();
   }
 }
 
-// src/lint.ts
-import { dirname as dirname5 } from "node:path";
+// src/run.ts
+import { readFile as readFile5 } from "node:fs/promises";
 
-// ../core/dist/index.js
+// ../core/dist/engine/index.js
 import { createRequire as createRequire3 } from "node:module";
 import { readFile as readFile3 } from "node:fs/promises";
-import { readFileSync as readFileSync2 } from "node:fs";
 import { constants as constants2 } from "node:fs";
 import { access as access2 } from "node:fs/promises";
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve3 } from "node:path";
+import { writeFile as writeFile3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { appendFile as appendFile2, readFile as readFile22, writeFile as writeFile22 } from "node:fs/promises";
+import { join as join22 } from "node:path";
+import { join as join32 } from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 import { dirname as dirname3, resolve as resolve22 } from "node:path";
 import { resolve as resolvePath2, isAbsolute as isAbsolute2 } from "node:path";
+import { dirname as dirname22, resolve as resolve32 } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { env } from "node:process";
 var __create2 = Object.create;
 var __getProtoOf2 = Object.getPrototypeOf;
 var __defProp3 = Object.defineProperty;
@@ -49140,7 +49923,7 @@ var require_compile2 = __commonJS2((exports) => {
     const schOrFunc = root22.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve5.call(this, root22, ref);
+    let _sch = resolve4.call(this, root22, ref);
     if (_sch === undefined) {
       const schema2 = (_a = root22.localRefs) === null || _a === undefined ? undefined : _a[ref];
       const { schemaId } = this.opts;
@@ -49167,7 +49950,7 @@ var require_compile2 = __commonJS2((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve5(root22, ref) {
+  function resolve4(root22, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -49689,7 +50472,7 @@ var require_fast_uri2 = __commonJS2((exports, module) => {
     }
     return uri;
   }
-  function resolve5(baseURI, relativeURI, options) {
+  function resolve4(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse22(baseURI, schemelessOptions), parse22(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -49917,7 +50700,7 @@ var require_fast_uri2 = __commonJS2((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve5,
+    resolve: resolve4,
     resolveComponent,
     equal,
     serialize,
@@ -53306,6 +54089,549 @@ var require_dist22 = __commonJS2((exports, module) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.default = formatsPlugin;
 });
+var duckflux_schema_default2;
+var init_duckflux_schema2 = __esm3(() => {
+  duckflux_schema_default2 = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://raw.githubusercontent.com/duckflux/spec/main/duckflux.schema.json",
+    title: "duckflux Workflow",
+    description: "Schema for duckflux — a minimal, deterministic, runtime-agnostic workflow DSL.",
+    type: "object",
+    required: ["flow"],
+    additionalProperties: false,
+    properties: {
+      id: {
+        type: "string",
+        description: "Unique identifier for the workflow."
+      },
+      name: {
+        type: "string",
+        description: "Human-readable workflow name."
+      },
+      version: {
+        description: "Version identifier for the workflow definition.",
+        oneOf: [
+          { type: "string" },
+          { type: "integer" }
+        ]
+      },
+      defaults: {
+        $ref: "#/$defs/defaults"
+      },
+      inputs: {
+        $ref: "#/$defs/inputs"
+      },
+      participants: {
+        type: "object",
+        description: "Named steps that can be referenced in the flow.",
+        additionalProperties: {
+          $ref: "#/$defs/participant"
+        },
+        not: {
+          anyOf: [
+            { required: ["workflow"] },
+            { required: ["execution"] },
+            { required: ["input"] },
+            { required: ["output"] },
+            { required: ["env"] },
+            { required: ["loop"] },
+            { required: ["event"] }
+          ]
+        }
+      },
+      flow: {
+        $ref: "#/$defs/flowSequence"
+      },
+      output: {
+        $ref: "#/$defs/workflowOutput"
+      }
+    },
+    $defs: {
+      duration: {
+        type: "string",
+        pattern: "^[0-9]+(ms|s|m|h|d)$",
+        description: "Duration string, e.g. '30s', '5m', '2h', '1d'."
+      },
+      celExpression: {
+        type: "string",
+        description: "A Google CEL expression."
+      },
+      defaults: {
+        type: "object",
+        description: "Global defaults applied to all participants.",
+        additionalProperties: false,
+        properties: {
+          timeout: {
+            $ref: "#/$defs/duration"
+          },
+          cwd: {
+            type: "string",
+            description: "Default working directory for exec participants. Supports CEL expressions."
+          }
+        }
+      },
+      inputs: {
+        type: "object",
+        description: "Workflow input parameters. Accessed in CEL as workflow.inputs.<field>. Each key is a parameter name. Value can be null (string, no schema), or a JSON Schema object for validation.",
+        additionalProperties: {
+          oneOf: [
+            { type: "null" },
+            { $ref: "#/$defs/inputField" }
+          ]
+        }
+      },
+      inputField: {
+        type: "object",
+        description: "JSON Schema field definition with optional 'required: true' shortcut.",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["string", "integer", "number", "boolean", "array", "object"]
+          },
+          description: { type: "string" },
+          default: {},
+          required: { type: "boolean" },
+          format: { type: "string" },
+          enum: { type: "array" },
+          minimum: { type: "number" },
+          maximum: { type: "number" },
+          minLength: { type: "integer" },
+          maxLength: { type: "integer" },
+          pattern: { type: "string" },
+          items: {
+            $ref: "#/$defs/inputField"
+          }
+        },
+        additionalProperties: false
+      },
+      retryConfig: {
+        type: "object",
+        description: "Retry configuration. Only applies when onError is 'retry'.",
+        additionalProperties: false,
+        required: ["max"],
+        properties: {
+          max: {
+            type: "integer",
+            minimum: 1,
+            description: "Maximum number of retry attempts."
+          },
+          backoff: {
+            $ref: "#/$defs/duration",
+            description: "Interval between attempts. Default: 0s."
+          },
+          factor: {
+            type: "number",
+            minimum: 1,
+            description: "Backoff multiplier. Default: 1 (no escalation)."
+          }
+        }
+      },
+      onError: {
+        type: "string",
+        description: "Error handling strategy: 'fail' (default), 'skip', 'retry', or a participant name for redirect.",
+        minLength: 1
+      },
+      onTimeout: {
+        type: "string",
+        description: "Timeout handling strategy: 'fail' (default), 'skip', or a participant name for redirect.",
+        minLength: 1
+      },
+      participantInput: {
+        description: "Explicit input mapping. String for direct passthrough, object for structured mapping. Values are CEL expressions. Merged with implicit I/O chain input at runtime.",
+        oneOf: [
+          { type: "string" },
+          {
+            type: "object",
+            additionalProperties: {
+              type: "string"
+            }
+          }
+        ]
+      },
+      participantOutputSchema: {
+        type: "object",
+        description: "Output schema (JSON Schema fields). Opt-in validation.",
+        additionalProperties: {
+          $ref: "#/$defs/inputField"
+        }
+      },
+      payload: {
+        description: "Event payload. String (CEL expression) or object with CEL expressions as values.",
+        oneOf: [
+          { type: "string" },
+          {
+            type: "object",
+            additionalProperties: {}
+          }
+        ]
+      },
+      participant: {
+        type: "object",
+        required: ["type"],
+        description: "A named, reusable building block of the workflow.",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["exec", "http", "mcp", "workflow", "emit"],
+            description: "Participant type."
+          },
+          as: {
+            type: "string",
+            description: "Human-readable display name."
+          },
+          timeout: {
+            $ref: "#/$defs/duration"
+          },
+          onError: {
+            $ref: "#/$defs/onError"
+          },
+          retry: {
+            $ref: "#/$defs/retryConfig"
+          },
+          input: {
+            $ref: "#/$defs/participantInput"
+          },
+          output: {
+            $ref: "#/$defs/participantOutputSchema"
+          },
+          run: {
+            type: "string",
+            description: "[exec] Shell command to execute."
+          },
+          cwd: {
+            type: "string",
+            description: "[exec] Working directory. Supports CEL expressions."
+          },
+          url: {
+            type: "string",
+            description: "[http] Target URL. Supports CEL expressions."
+          },
+          method: {
+            type: "string",
+            enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+            description: "[http] HTTP method."
+          },
+          headers: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: "[http] HTTP headers. Values support CEL expressions."
+          },
+          body: {
+            description: "[http] Request body. String or object. Supports CEL expressions.",
+            oneOf: [
+              { type: "string" },
+              { type: "object" }
+            ]
+          },
+          path: {
+            type: "string",
+            description: "[workflow] Path to the sub-workflow YAML file."
+          },
+          server: {
+            type: "string",
+            description: "[mcp] MCP server identifier."
+          },
+          tool: {
+            type: "string",
+            description: "[mcp] MCP tool name to invoke."
+          },
+          event: {
+            type: "string",
+            description: "[emit] Event name to emit."
+          },
+          payload: {
+            $ref: "#/$defs/payload",
+            description: "[emit] Event payload. CEL expression or object with CEL expressions."
+          },
+          ack: {
+            type: "boolean",
+            description: "[emit] If true, wait for delivery acknowledgment. Default: false.",
+            default: false
+          }
+        },
+        additionalProperties: false
+      },
+      inlineParticipant: {
+        type: "object",
+        required: ["type"],
+        description: "An inline participant definition in the flow. 'as' is optional — if omitted, the participant is anonymous and its output is only accessible via the implicit I/O chain.",
+        properties: {
+          as: {
+            type: "string",
+            description: "Optional name for inline participants. If provided, must be unique across all participant names. Enables output reference by name."
+          },
+          type: {
+            type: "string",
+            enum: ["exec", "http", "mcp", "workflow", "emit"],
+            description: "Participant type."
+          },
+          when: {
+            $ref: "#/$defs/celExpression",
+            description: "Guard condition. If false, step is skipped."
+          },
+          timeout: {
+            $ref: "#/$defs/duration"
+          },
+          onError: {
+            $ref: "#/$defs/onError"
+          },
+          retry: {
+            $ref: "#/$defs/retryConfig"
+          },
+          input: {
+            $ref: "#/$defs/participantInput"
+          },
+          output: {
+            $ref: "#/$defs/participantOutputSchema"
+          },
+          run: { type: "string" },
+          cwd: { type: "string" },
+          url: { type: "string" },
+          method: { type: "string", enum: ["GET", "POST", "PUT", "PATCH", "DELETE"] },
+          headers: { type: "object", additionalProperties: { type: "string" } },
+          body: { oneOf: [{ type: "string" }, { type: "object" }] },
+          path: { type: "string" },
+          server: { type: "string" },
+          tool: { type: "string" },
+          event: { type: "string" },
+          payload: { $ref: "#/$defs/payload" },
+          ack: { type: "boolean" }
+        },
+        additionalProperties: false
+      },
+      flowSequence: {
+        type: "array",
+        description: "Ordered list of flow steps. Each step's output is implicitly chained as input to the next step.",
+        minItems: 1,
+        items: {
+          $ref: "#/$defs/flowStep"
+        }
+      },
+      flowStep: {
+        description: "A single step in the flow: participant reference (string), control construct, inline participant (named or anonymous), or participant override.",
+        oneOf: [
+          {
+            type: "string",
+            description: "Simple participant reference by name."
+          },
+          { $ref: "#/$defs/loopStep" },
+          { $ref: "#/$defs/parallelStep" },
+          { $ref: "#/$defs/ifStep" },
+          { $ref: "#/$defs/setStep" },
+          { $ref: "#/$defs/waitStep" },
+          { $ref: "#/$defs/inlineParticipant" },
+          { $ref: "#/$defs/participantOverrideStep" }
+        ]
+      },
+      loopStep: {
+        type: "object",
+        required: ["loop"],
+        additionalProperties: false,
+        properties: {
+          loop: {
+            type: "object",
+            additionalProperties: false,
+            required: ["steps"],
+            properties: {
+              as: {
+                type: "string",
+                description: "Renames the loop context variable. Access as <as>.index, <as>.iteration, etc. instead of loop.*"
+              },
+              until: {
+                $ref: "#/$defs/celExpression",
+                description: "CEL condition to break out of the loop."
+              },
+              max: {
+                description: "Maximum iterations. Integer or CEL expression.",
+                oneOf: [
+                  { type: "integer", minimum: 1 },
+                  { type: "string" }
+                ]
+              },
+              steps: {
+                $ref: "#/$defs/flowSequence"
+              }
+            },
+            anyOf: [
+              { required: ["until"] },
+              { required: ["max"] }
+            ]
+          }
+        }
+      },
+      parallelStep: {
+        type: "object",
+        required: ["parallel"],
+        additionalProperties: false,
+        properties: {
+          parallel: {
+            $ref: "#/$defs/flowSequence",
+            description: "Steps to run concurrently. The chained output after a parallel block is an array of all branch outputs in declaration order."
+          }
+        }
+      },
+      ifStep: {
+        type: "object",
+        required: ["if"],
+        additionalProperties: false,
+        properties: {
+          if: {
+            type: "object",
+            required: ["condition", "then"],
+            additionalProperties: false,
+            properties: {
+              condition: {
+                $ref: "#/$defs/celExpression",
+                description: "CEL expression that determines which branch to take."
+              },
+              then: {
+                $ref: "#/$defs/flowSequence"
+              },
+              else: {
+                $ref: "#/$defs/flowSequence"
+              }
+            }
+          }
+        }
+      },
+      setStep: {
+        type: "object",
+        required: ["set"],
+        additionalProperties: false,
+        properties: {
+          set: {
+            type: "object",
+            description: "Writes values into execution.context. Each key becomes execution.context.<key>. Values are CEL expressions.",
+            minProperties: 1,
+            additionalProperties: {
+              $ref: "#/$defs/celExpression"
+            },
+            not: {
+              anyOf: [
+                { required: ["workflow"] },
+                { required: ["execution"] },
+                { required: ["input"] },
+                { required: ["output"] },
+                { required: ["env"] },
+                { required: ["loop"] },
+                { required: ["event"] }
+              ]
+            }
+          }
+        }
+      },
+      waitStep: {
+        type: "object",
+        required: ["wait"],
+        additionalProperties: false,
+        properties: {
+          wait: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              event: {
+                type: "string",
+                description: "Event name to wait for (event mode)."
+              },
+              match: {
+                $ref: "#/$defs/celExpression",
+                description: "CEL condition to match against event payload. 'event' variable contains the payload."
+              },
+              until: {
+                $ref: "#/$defs/celExpression",
+                description: "CEL condition to wait for (polling mode)."
+              },
+              poll: {
+                $ref: "#/$defs/duration",
+                description: "Polling interval for 'until' condition. Default: runtime decides."
+              },
+              timeout: {
+                $ref: "#/$defs/duration",
+                description: "Maximum wait time."
+              },
+              onTimeout: {
+                $ref: "#/$defs/onTimeout",
+                description: "Strategy when timeout is reached: 'fail' (default), 'skip', or participant name."
+              }
+            }
+          }
+        }
+      },
+      participantOverrideStep: {
+        type: "object",
+        description: "A participant reference with flow-level overrides (timeout, onError, when, input, workflow, etc.).",
+        minProperties: 1,
+        maxProperties: 1,
+        not: {
+          anyOf: [
+            { required: ["loop"] },
+            { required: ["parallel"] },
+            { required: ["if"] },
+            { required: ["wait"] },
+            { required: ["set"] },
+            { required: ["type"] }
+          ]
+        },
+        additionalProperties: {
+          type: "object",
+          properties: {
+            when: {
+              $ref: "#/$defs/celExpression",
+              description: "Guard condition. If false, step is skipped."
+            },
+            timeout: {
+              $ref: "#/$defs/duration"
+            },
+            onError: {
+              $ref: "#/$defs/onError"
+            },
+            retry: {
+              $ref: "#/$defs/retryConfig"
+            },
+            input: {
+              $ref: "#/$defs/participantInput"
+            },
+            workflow: {
+              type: "string",
+              description: "Inline sub-workflow path (alternative to defining as participant)."
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      workflowOutput: {
+        description: "Workflow output. Accessed in CEL as workflow.output. String (single CEL expression), object (structured mapping), or object with schema+map.",
+        oneOf: [
+          {
+            type: "string",
+            description: "Single CEL expression mapping."
+          },
+          {
+            type: "object",
+            description: "Structured output mapping (key → CEL expression) or schema+map.",
+            properties: {
+              schema: {
+                type: "object",
+                additionalProperties: {
+                  $ref: "#/$defs/inputField"
+                }
+              },
+              map: {
+                type: "object",
+                additionalProperties: {
+                  type: "string"
+                }
+              }
+            },
+            additionalProperties: {
+              type: "string"
+            }
+          }
+        ]
+      }
+    }
+  };
+});
 function validateSchema2(workflow) {
   const valid = validate2(workflow);
   if (valid) {
@@ -53319,15 +54645,14 @@ function validateSchema2(workflow) {
 }
 var import__20202;
 var import_ajv_formats2;
-var rawSchema2;
 var schema2;
 var ajv2;
 var validate2;
 var init_schema2 = __esm3(() => {
+  init_duckflux_schema2();
   import__20202 = __toESM2(require_20202(), 1);
   import_ajv_formats2 = __toESM2(require_dist22(), 1);
-  rawSchema2 = readFileSync2(new URL("./schema/duckflux.schema.json", import.meta.url), "utf-8");
-  schema2 = JSON.parse(rawSchema2);
+  schema2 = { ...duckflux_schema_default2 };
   delete schema2.$schema;
   ajv2 = new import__20202.default({ allErrors: true, strict: false });
   import_ajv_formats2.default(ajv2);
@@ -53711,7 +55036,7 @@ async function validateSemantic2(workflow, basePath) {
   for (const [name, participant] of Object.entries(participants)) {
     if (participant.type !== "workflow")
       continue;
-    const resolvedPath = resolve4(basePath, participant.path);
+    const resolvedPath = resolve3(basePath, participant.path);
     const exists = await access2(resolvedPath, constants2.F_OK).then(() => true, () => false);
     if (!exists) {
       errors.push({
@@ -53729,6 +55054,237 @@ var init_validate2 = __esm3(() => {
   RESERVED_NAMES2 = new Set(["workflow", "execution", "input", "output", "env", "loop", "event"]);
   BUILTIN_ONERROR2 = new Set(["fail", "skip", "retry"]);
 });
+var exports_json2 = {};
+__export3(exports_json2, {
+  JsonTraceWriter: () => JsonTraceWriter2
+});
+
+class JsonTraceWriter2 {
+  dir;
+  filePath = "";
+  trace = {
+    execution: {
+      id: "",
+      startedAt: "",
+      finishedAt: "",
+      duration: 0,
+      status: "running",
+      inputs: null,
+      output: null
+    },
+    steps: []
+  };
+  constructor(dir) {
+    this.dir = dir;
+  }
+  async open(meta) {
+    this.filePath = join4(this.dir, `${meta.id}.json`);
+    this.trace = {
+      execution: {
+        id: meta.id,
+        workflowId: meta.workflowId,
+        workflowName: meta.workflowName,
+        workflowVersion: meta.workflowVersion,
+        startedAt: meta.startedAt,
+        finishedAt: "",
+        duration: 0,
+        status: "running",
+        inputs: meta.inputs,
+        output: null
+      },
+      steps: []
+    };
+    await this.flush();
+  }
+  writeStep(step) {
+    this.trace.steps.push(step);
+    this.flushSync();
+  }
+  async finalize(meta) {
+    this.trace.execution.status = meta.status;
+    this.trace.execution.output = meta.output;
+    this.trace.execution.finishedAt = meta.finishedAt;
+    this.trace.execution.duration = meta.duration;
+    await this.flush();
+  }
+  flushSync() {
+    this.flush().catch(() => {});
+  }
+  async flush() {
+    if (!this.filePath)
+      return;
+    await writeFile3(this.filePath, JSON.stringify(this.trace, null, 2), "utf-8");
+  }
+}
+var init_json = () => {};
+var exports_txt2 = {};
+__export3(exports_txt2, {
+  TxtTraceWriter: () => TxtTraceWriter2
+});
+function serializeValue2(value) {
+  if (value === undefined || value === null)
+    return "none";
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value, null, 2);
+}
+function formatStep2(step) {
+  const lines = [
+    `## [${step.seq}] ${step.name} (${step.type})`,
+    `startedAt: ${step.startedAt}`
+  ];
+  if (step.finishedAt)
+    lines.push(`finishedAt: ${step.finishedAt}`);
+  if (step.duration !== undefined)
+    lines.push(`duration: ${step.duration}ms`);
+  lines.push(`status: ${step.status}`);
+  if (step.loopIndex !== undefined)
+    lines.push(`loopIndex: ${step.loopIndex}`);
+  if (step.retries !== undefined && step.retries > 0)
+    lines.push(`retries: ${step.retries}`);
+  lines.push(`input: ${serializeValue2(step.input)}`);
+  lines.push(`output: ${serializeValue2(step.output)}`);
+  if (step.error)
+    lines.push(`error: ${step.error}`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+class TxtTraceWriter2 {
+  dir;
+  filePath = "";
+  constructor(dir) {
+    this.dir = dir;
+  }
+  async open(meta) {
+    this.filePath = join22(this.dir, `${meta.id}.txt`);
+    const versionStr = meta.workflowVersion !== undefined ? ` (v${meta.workflowVersion})` : "";
+    const workflowLabel = meta.workflowName ?? meta.workflowId ?? "unnamed";
+    const header = [
+      "# execution",
+      `id: ${meta.id}`,
+      `workflow: ${workflowLabel}${versionStr}`,
+      `startedAt: ${meta.startedAt}`,
+      "status: running",
+      "",
+      "# inputs",
+      serializeValue2(meta.inputs),
+      "",
+      "# steps",
+      ""
+    ].join(`
+`);
+    await writeFile22(this.filePath, header, "utf-8");
+  }
+  async writeStep(step) {
+    if (!this.filePath)
+      return;
+    await appendFile2(this.filePath, formatStep2(step), "utf-8");
+  }
+  async finalize(meta) {
+    if (!this.filePath)
+      return;
+    const outputSection = [
+      "# output",
+      serializeValue2(meta.output),
+      ""
+    ].join(`
+`);
+    await appendFile2(this.filePath, outputSection, "utf-8");
+    const content = await readFile22(this.filePath, "utf-8");
+    const updated = content.replace(/^status: running$/m, `status: ${meta.status}
+finishedAt: ${meta.finishedAt}
+duration: ${meta.duration}ms`);
+    await writeFile22(this.filePath, updated, "utf-8");
+  }
+}
+var init_txt = () => {};
+var exports_sqlite2 = {};
+__export3(exports_sqlite2, {
+  SqliteTraceWriter: () => SqliteTraceWriter2
+});
+function toJson2(value) {
+  if (value === undefined || value === null)
+    return null;
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value);
+}
+
+class SqliteTraceWriter2 {
+  dir;
+  db = null;
+  executionId = "";
+  constructor(dir) {
+    this.dir = dir;
+  }
+  async open(meta) {
+    this.executionId = meta.id;
+    const filePath = join32(this.dir, `${meta.id}.sqlite`);
+    const { Database } = await import("bun:sqlite");
+    this.db = new Database(filePath);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS executions (
+        id TEXT PRIMARY KEY,
+        workflow_id TEXT,
+        workflow_name TEXT,
+        workflow_version TEXT,
+        started_at TEXT NOT NULL,
+        finished_at TEXT,
+        duration_ms INTEGER,
+        status TEXT NOT NULL,
+        inputs TEXT,
+        output TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS steps (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        execution_id TEXT NOT NULL REFERENCES executions(id),
+        seq INTEGER NOT NULL,
+        name TEXT NOT NULL,
+        type TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        duration_ms INTEGER,
+        status TEXT NOT NULL,
+        input TEXT,
+        output TEXT,
+        error TEXT,
+        retries INTEGER,
+        loop_index INTEGER
+      );
+    `);
+    const insert = this.db.prepare(`
+      INSERT INTO executions (id, workflow_id, workflow_name, workflow_version, started_at, status, inputs)
+      VALUES (?, ?, ?, ?, ?, 'running', ?)
+    `);
+    insert.run(meta.id, meta.workflowId ?? null, meta.workflowName ?? null, meta.workflowVersion !== undefined ? String(meta.workflowVersion) : null, meta.startedAt, toJson2(meta.inputs));
+  }
+  writeStep(step) {
+    if (!this.db)
+      return;
+    const insert = this.db.prepare(`
+      INSERT INTO steps
+        (execution_id, seq, name, type, started_at, finished_at, duration_ms, status, input, output, error, retries, loop_index)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    insert.run(this.executionId, step.seq, step.name, step.type, step.startedAt ?? null, step.finishedAt ?? null, step.duration ?? null, step.status, toJson2(step.input), toJson2(step.output), step.error ?? null, step.retries ?? null, step.loopIndex ?? null);
+  }
+  async finalize(meta) {
+    if (!this.db)
+      return;
+    const update = this.db.prepare(`
+      UPDATE executions
+      SET status = ?, output = ?, finished_at = ?, duration_ms = ?
+      WHERE id = ?
+    `);
+    update.run(meta.status, toJson2(meta.output), meta.finishedAt, Math.round(meta.duration), this.executionId);
+    this.db.close();
+    this.db = null;
+  }
+}
+var init_sqlite = () => {};
 function sleep3(ms) {
   return new Promise((resolve23) => setTimeout(resolve23, ms));
 }
@@ -54020,7 +55576,7 @@ async function executeHttp2(participant, input) {
   };
 }
 async function executeMcp2(participant, _input) {
-  throw new Error(`mcp participant is not yet implemented (server: ${participant.server ?? "unspecified"}, tool: ${participant.tool ?? "unspecified"}). ` + "Use onError to handle this gracefully.");
+  throw new Error(`mcp participant is not yet implemented (server: ${participant.server ?? "unspecified"}, tool: ${participant.tool ?? "unspecified"}). Use onError to handle this gracefully.`);
 }
 function toWorkflowInputs2(input) {
   if (input && typeof input === "object" && !Array.isArray(input)) {
@@ -54306,6 +55862,10 @@ async function executeStep2(workflow, state, step, basePath = process.cwd(), eng
           output: "",
           duration: 0
         });
+        const loopIndex2 = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+        const skippedSeq = state.tracer?.startStep(stepName, participant.type, undefined, loopIndex2);
+        if (skippedSeq !== undefined)
+          state.tracer?.endStep(skippedSeq, "skipped");
       }
       return chain;
     }
@@ -54314,6 +55874,8 @@ async function executeStep2(workflow, state, step, basePath = process.cwd(), eng
   const overrideInput = override?.input !== undefined ? resolveParticipantInput2(override.input, state) : undefined;
   const mergedWithBase = mergeChainedInput2(chain, baseInput);
   const mergedInput = mergeChainedInput2(mergedWithBase, overrideInput);
+  const loopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+  const traceSeq = state.tracer?.startStep(stepName ?? "<anonymous>", participant.type, mergedInput, loopIndex);
   state.currentInput = mergedInput;
   const strategy = resolveErrorStrategy2(override ?? null, participant, workflow.defaults ?? null);
   const timeoutMs = resolveTimeout2(override ?? null, participant, workflow.defaults ?? null);
@@ -54391,6 +55953,8 @@ async function executeStep2(workflow, state, step, basePath = process.cwd(), eng
     }
     const outputValue = result.parsedOutput ?? result.output;
     state.currentOutput = outputValue;
+    if (traceSeq !== undefined)
+      state.tracer?.endStep(traceSeq, result.status, outputValue, undefined, retries);
     return outputValue;
   } catch (error) {
     const message = String(error?.message ?? error);
@@ -54416,6 +55980,8 @@ async function executeStep2(workflow, state, step, basePath = process.cwd(), eng
       if (stepName) {
         state.setResult(stepName, skipResult);
       }
+      if (traceSeq !== undefined)
+        state.tracer?.endStep(traceSeq, "skipped", undefined, message);
       return chain;
     }
     if (strategy !== "fail" && strategy !== "retry") {
@@ -54434,6 +56000,8 @@ async function executeStep2(workflow, state, step, basePath = process.cwd(), eng
           ...httpMeta
         });
       }
+      if (traceSeq !== undefined)
+        state.tracer?.endStep(traceSeq, "failure", undefined, message);
       const fallbackResult = await executeStep2(workflow, state, fallbackName, basePath, engineExecutor, [...fallbackStack, stepName ?? "<anonymous>"], chain, hub);
       return fallbackResult;
     }
@@ -54448,6 +56016,8 @@ async function executeStep2(workflow, state, step, basePath = process.cwd(), eng
         ...httpMeta
       });
     }
+    if (traceSeq !== undefined)
+      state.tracer?.endStep(traceSeq, "failure", undefined, message);
     throw error;
   }
 }
@@ -54470,7 +56040,7 @@ __export3(exports_wait2, {
   executeWait: () => executeWait2
 });
 function sleep22(ms) {
-  return new Promise((resolve32) => setTimeout(resolve32, ms));
+  return new Promise((resolve33) => setTimeout(resolve33, ms));
 }
 async function executeWait2(state, waitDef, chain, hub, signal) {
   const timeoutMs = waitDef.timeout ? parseDuration2(waitDef.timeout) : undefined;
@@ -54556,21 +56126,38 @@ async function executeControlStep2(workflow, state, step, basePath = process.cwd
   }
   const obj = step;
   if ("wait" in obj && Object.keys(obj).length === 1) {
-    const { executeWait: executeWait22 } = await Promise.resolve().then(() => (init_wait2(), exports_wait2));
-    return executeWait22(state, obj.wait, chain, hub, signal);
+    const loopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+    const traceSeq = state.tracer?.startStep("wait", "wait", undefined, loopIndex);
+    try {
+      const { executeWait: executeWait22 } = await Promise.resolve().then(() => (init_wait2(), exports_wait2));
+      const result = await executeWait22(state, obj.wait, chain, hub, signal);
+      if (traceSeq !== undefined)
+        state.tracer?.endStep(traceSeq, "success", result);
+      return result;
+    } catch (err) {
+      if (traceSeq !== undefined)
+        state.tracer?.endStep(traceSeq, "failure", undefined, String(err?.message ?? err));
+      throw err;
+    }
   }
   if ("set" in obj && Object.keys(obj).length === 1) {
     const setDef = obj.set;
     const ctx = state.toCelContext();
+    const loopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+    const traceSeq = state.tracer?.startStep("set", "set", setDef, loopIndex);
     if (!state.executionMeta.context) {
       state.executionMeta.context = {};
     }
     for (const [key, expr] of Object.entries(setDef)) {
       if (RESERVED_SET_KEYS2.has(key)) {
+        if (traceSeq !== undefined)
+          state.tracer?.endStep(traceSeq, "failure", undefined, `set key '${key}' uses a reserved name`);
         throw new Error(`set key '${key}' uses a reserved name`);
       }
       state.executionMeta.context[key] = evaluateCel2(expr, ctx);
     }
+    if (traceSeq !== undefined)
+      state.tracer?.endStep(traceSeq, "success", state.executionMeta.context);
     return chain;
   }
   if ("loop" in obj && Object.keys(obj).length === 1) {
@@ -54587,6 +56174,8 @@ async function executeControlStep2(workflow, state, step, basePath = process.cwd
       maxIterations = loopDef.max ?? Number.POSITIVE_INFINITY;
     }
     const hasMax = loopDef.max !== undefined;
+    const outerLoopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+    const loopTraceSeq = state.tracer?.startStep(loopAs ?? "loop", "loop", undefined, outerLoopIndex);
     state.pushLoop(loopAs);
     let loopChain = chain;
     try {
@@ -54610,6 +56199,12 @@ async function executeControlStep2(workflow, state, step, basePath = process.cwd
         iterations += 1;
         state.incrementLoop();
       }
+      if (loopTraceSeq !== undefined)
+        state.tracer?.endStep(loopTraceSeq, "success", loopChain);
+    } catch (err) {
+      if (loopTraceSeq !== undefined)
+        state.tracer?.endStep(loopTraceSeq, "failure", undefined, String(err?.message ?? err));
+      throw err;
     } finally {
       state.popLoop();
     }
@@ -54618,29 +56213,54 @@ async function executeControlStep2(workflow, state, step, basePath = process.cwd
   if ("parallel" in obj && Object.keys(obj).length === 1) {
     const parallelSteps = obj.parallel;
     const controller = new AbortController;
+    const loopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+    const parallelTraceSeq = state.tracer?.startStep("parallel", "parallel", undefined, loopIndex);
     const branchSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
-    const results = await Promise.all(parallelSteps.map(async (parallelStep) => {
-      try {
-        return await executeControlStep2(workflow, state, parallelStep, basePath, engineExecutor, chain, hub, branchSignal);
-      } catch (error) {
-        controller.abort();
-        throw error;
-      }
-    }));
-    return results;
+    try {
+      const results = await Promise.all(parallelSteps.map(async (parallelStep) => {
+        try {
+          return await executeControlStep2(workflow, state, parallelStep, basePath, engineExecutor, chain, hub, branchSignal);
+        } catch (error) {
+          controller.abort();
+          throw error;
+        }
+      }));
+      if (parallelTraceSeq !== undefined)
+        state.tracer?.endStep(parallelTraceSeq, "success", results);
+      return results;
+    } catch (err) {
+      if (parallelTraceSeq !== undefined)
+        state.tracer?.endStep(parallelTraceSeq, "failure", undefined, String(err?.message ?? err));
+      throw err;
+    }
   }
   if ("if" in obj && Object.keys(obj).length === 1) {
     const ifDef = obj.if;
     const condition = evaluateCel2(ifDef.condition, state.toCelContext());
+    const loopIndex = state.isInsideLoop() ? state.currentLoopIndex() : undefined;
+    const ifTraceSeq = state.tracer?.startStep("if", "if", { condition: ifDef.condition }, loopIndex);
     if (typeof condition !== "boolean") {
+      if (ifTraceSeq !== undefined)
+        state.tracer?.endStep(ifTraceSeq, "failure", undefined, `if.condition must evaluate to boolean, got ${typeof condition}`);
       throw new Error(`if.condition must evaluate to boolean, got ${typeof condition}`);
     }
-    if (condition) {
-      return executeSequential2(workflow, state, ifDef.then, basePath, engineExecutor, chain, hub, signal);
-    } else if (ifDef.else) {
-      return executeSequential2(workflow, state, ifDef.else, basePath, engineExecutor, chain, hub, signal);
+    try {
+      let result;
+      if (condition) {
+        result = await executeSequential2(workflow, state, ifDef.then, basePath, engineExecutor, chain, hub, signal);
+      } else if (ifDef.else) {
+        result = await executeSequential2(workflow, state, ifDef.else, basePath, engineExecutor, chain, hub, signal);
+      } else {
+        result = chain;
+      }
+      if (ifTraceSeq !== undefined)
+        state.tracer?.endStep(ifTraceSeq, "success", result);
+      return result;
+    } catch (err) {
+      if (ifTraceSeq !== undefined)
+        state.tracer?.endStep(ifTraceSeq, "failure", undefined, String(err?.message ?? err));
+      throw err;
     }
-    return chain;
   }
   return executeStep2(workflow, state, step, basePath, engineExecutor, [], chain, hub, signal);
 }
@@ -54650,92 +56270,7 @@ var init_control2 = __esm3(() => {
   init_sequential2();
   RESERVED_SET_KEYS2 = new Set(["workflow", "execution", "input", "output", "env", "loop", "event"]);
 });
-
-class MemoryHub2 {
-  listeners = new Map;
-  buffer = new Map;
-  closed = false;
-  async publish(event, payload) {
-    if (this.closed)
-      throw new Error("hub is closed");
-    const envelope = { name: event, payload };
-    let buf = this.buffer.get(event);
-    if (!buf) {
-      buf = [];
-      this.buffer.set(event, buf);
-    }
-    buf.push(envelope);
-    const listeners = this.listeners.get(event);
-    if (listeners) {
-      for (const listener of listeners) {
-        listener(envelope);
-      }
-    }
-  }
-  async publishAndWaitAck(event, payload, _timeoutMs) {
-    await this.publish(event, payload);
-  }
-  async* subscribe(event, signal) {
-    if (this.closed)
-      return;
-    const buffered = this.buffer.get(event);
-    if (buffered) {
-      for (const envelope of buffered) {
-        if (signal?.aborted)
-          return;
-        yield envelope;
-      }
-    }
-    const queue = [];
-    let resolve5 = null;
-    const listener = (envelope) => {
-      queue.push(envelope);
-      if (resolve5) {
-        resolve5();
-        resolve5 = null;
-      }
-    };
-    let listeners = this.listeners.get(event);
-    if (!listeners) {
-      listeners = new Set;
-      this.listeners.set(event, listeners);
-    }
-    listeners.add(listener);
-    const onAbort = () => {
-      listeners.delete(listener);
-      if (resolve5) {
-        resolve5();
-        resolve5 = null;
-      }
-    };
-    if (signal) {
-      signal.addEventListener("abort", onAbort);
-    }
-    try {
-      while (!this.closed && !signal?.aborted) {
-        if (queue.length > 0) {
-          yield queue.shift();
-        } else {
-          await new Promise((r) => {
-            resolve5 = r;
-          });
-        }
-      }
-    } finally {
-      listeners.delete(listener);
-      if (signal) {
-        signal.removeEventListener("abort", onAbort);
-      }
-    }
-  }
-  async close() {
-    this.closed = true;
-    for (const listeners of this.listeners.values()) {
-      listeners.clear();
-    }
-    this.listeners.clear();
-  }
-}
+init_cel2();
 init_parser32();
 init_schema2();
 init_validate2();
@@ -54899,147 +56434,514 @@ function validateInputs2(inputDefs, provided) {
     resolved
   };
 }
-init_cel2();
-init_cel2();
-init_parser32();
-init_schema2();
-init_validate2();
-init_control2();
-init_sequential2();
-init_wait2();
-init_emit2();
 
-// src/lint.ts
-function collectLintWarnings(workflow) {
-  const warnings = [];
-  const participants = workflow.participants ?? {};
-  collectFlowWarnings(workflow.flow ?? [], participants, warnings);
-  return warnings;
+class TraceCollector2 {
+  openSteps = new Map;
+  seq = 0;
+  truncateAt;
+  writer;
+  constructor(truncateAt = 1e6) {
+    this.truncateAt = truncateAt;
+  }
+  startStep(name, type3, input, loopIndex) {
+    this.seq += 1;
+    this.openSteps.set(this.seq, {
+      name,
+      type: type3,
+      startedAt: new Date().toISOString(),
+      startMs: performance.now(),
+      input: input !== undefined ? this.truncate(input) : undefined,
+      loopIndex
+    });
+    return this.seq;
+  }
+  endStep(seq, status, output, error, retries) {
+    const open = this.openSteps.get(seq);
+    if (!open)
+      return;
+    this.openSteps.delete(seq);
+    const finishedAt = new Date().toISOString();
+    const duration = Math.max(0, performance.now() - open.startMs);
+    const step = {
+      seq,
+      name: open.name,
+      type: open.type,
+      startedAt: open.startedAt,
+      finishedAt,
+      duration: Math.round(duration),
+      status,
+      ...open.input !== undefined ? { input: open.input } : {},
+      ...output !== undefined ? { output: this.truncate(output) } : {},
+      ...error !== undefined ? { error } : {},
+      ...retries !== undefined && retries > 0 ? { retries } : {},
+      ...open.loopIndex !== undefined ? { loopIndex: open.loopIndex } : {}
+    };
+    this.writer?.writeStep(step);
+  }
+  truncate(value) {
+    if (value == null)
+      return value;
+    const str = typeof value === "string" ? value : JSON.stringify(value);
+    const bytes = new TextEncoder().encode(str);
+    if (bytes.length <= this.truncateAt)
+      return value;
+    const cut = new TextDecoder().decode(bytes.slice(0, this.truncateAt));
+    return cut + "...[truncated]";
+  }
 }
-function collectFlowWarnings(flow, participants, warnings, basePath = "flow") {
-  for (const [index, step] of flow.entries()) {
-    const stepPath = `${basePath}[${index}]`;
-    if (!step || typeof step !== "object")
-      continue;
-    const obj = step;
-    if (obj.loop && Object.keys(obj).length === 1) {
-      const loopDef = obj.loop;
-      if (loopDef.until == null && loopDef.max == null) {
-        warnings.push({
-          path: `${stepPath}.loop`,
-          message: "loop has no 'until' and no 'max' — this will be rejected at runtime"
-        });
-      }
-      collectFlowWarnings(loopDef.steps ?? [], participants, warnings, `${stepPath}.loop.steps`);
-      continue;
+async function createTraceWriter(dir, format) {
+  await mkdir(dir, { recursive: true });
+  if (format === "json") {
+    const { JsonTraceWriter: JsonTraceWriter22 } = await Promise.resolve().then(() => (init_json(), exports_json2));
+    return new JsonTraceWriter22(dir);
+  }
+  if (format === "txt") {
+    const { TxtTraceWriter: TxtTraceWriter22 } = await Promise.resolve().then(() => (init_txt(), exports_txt2));
+    return new TxtTraceWriter22(dir);
+  }
+  if (format === "sqlite") {
+    const { SqliteTraceWriter: SqliteTraceWriter22 } = await Promise.resolve().then(() => (init_sqlite(), exports_sqlite2));
+    return new SqliteTraceWriter22(dir);
+  }
+  throw new Error(`unknown trace format: ${format}`);
+}
+init_control2();
+
+class WorkflowState {
+  inputs;
+  results;
+  loopStack;
+  workflowInputs;
+  workflowMeta;
+  executionMeta;
+  currentInput;
+  currentOutput;
+  chainValue;
+  eventPayload;
+  ancestorPaths;
+  tracer;
+  constructor(inputs = {}) {
+    this.inputs = { ...inputs };
+    this.workflowInputs = { ...inputs };
+    this.workflowMeta = {};
+    this.executionMeta = {
+      id: crypto.randomUUID(),
+      startedAt: new Date().toISOString(),
+      status: "running",
+      cwd: process.cwd()
+    };
+    this.currentInput = undefined;
+    this.currentOutput = undefined;
+    this.chainValue = undefined;
+    this.eventPayload = undefined;
+    this.ancestorPaths = new Set;
+    this.results = new Map;
+    this.loopStack = [];
+  }
+  setResult(stepName, result) {
+    this.results.set(stepName, result);
+  }
+  getResult(stepName) {
+    return this.results.get(stepName);
+  }
+  getAllResults() {
+    const out = {};
+    for (const [k, v] of this.results.entries())
+      out[k] = v;
+    return out;
+  }
+  pushLoop(as) {
+    this.loopStack.push({ index: 0, as });
+  }
+  incrementLoop() {
+    const top = this.loopStack[this.loopStack.length - 1];
+    if (top)
+      top.index += 1;
+  }
+  popLoop() {
+    this.loopStack.pop();
+  }
+  currentLoopIndex() {
+    const top = this.loopStack[this.loopStack.length - 1];
+    return top ? top.index : 0;
+  }
+  setLoopLast(last22) {
+    const top = this.loopStack[this.loopStack.length - 1];
+    if (top)
+      top.last = last22;
+  }
+  isInsideLoop() {
+    return this.loopStack.length > 0;
+  }
+  currentLoopContext() {
+    const top = this.loopStack[this.loopStack.length - 1];
+    if (!top)
+      return { index: 0, iteration: 1, first: true, last: false };
+    return {
+      index: top.index,
+      iteration: top.index + 1,
+      first: top.index === 0,
+      last: top.last ?? false,
+      as: top.as
+    };
+  }
+  toCelContext() {
+    const ctx = {};
+    for (const [name, res] of this.results.entries()) {
+      ctx[name] = {
+        output: res.parsedOutput ?? res.output,
+        status: res.status,
+        startedAt: res.startedAt,
+        finishedAt: res.finishedAt,
+        duration: res.duration,
+        retries: res.retries ?? 0,
+        error: res.error,
+        cwd: res.cwd
+      };
     }
-    if (obj.parallel && Object.keys(obj).length === 1) {
-      const parallelSteps = obj.parallel;
-      const branchSetKeys = new Map;
-      for (const [branchIdx, branch] of parallelSteps.entries()) {
-        const setKeys = collectSetKeys(branch);
-        for (const key of setKeys) {
-          const branches = branchSetKeys.get(key) ?? [];
-          branches.push(branchIdx);
-          branchSetKeys.set(key, branches);
-        }
-      }
-      for (const [key, branches] of branchSetKeys) {
-        if (branches.length > 1) {
-          warnings.push({
-            path: `${stepPath}.parallel`,
-            message: `branches [${branches.join(", ")}] both write to '${key}' via set — race condition risk`
-          });
-        }
+    ctx["workflow"] = {
+      id: this.workflowMeta.id,
+      name: this.workflowMeta.name,
+      version: this.workflowMeta.version,
+      inputs: this.workflowInputs,
+      output: null
+    };
+    ctx["execution"] = { ...this.executionMeta };
+    ctx["input"] = this.currentInput ?? {};
+    ctx["output"] = this.currentOutput ?? {};
+    ctx["env"] = { ...env };
+    const loopCtx = this.currentLoopContext();
+    const loopObj = {
+      index: loopCtx.index,
+      iteration: loopCtx.iteration,
+      first: loopCtx.first,
+      last: loopCtx.last
+    };
+    if (loopCtx.as) {
+      ctx[`_${loopCtx.as}`] = loopObj;
+    }
+    ctx["_loop"] = loopObj;
+    ctx["loop"] = loopObj;
+    ctx["event"] = this.eventPayload ?? {};
+    ctx["now"] = Math.floor(Date.now() / 1000);
+    return ctx;
+  }
+  resolveOutput(outputDef, celEvaluator) {
+    const ctx = this.toCelContext();
+    if (typeof outputDef === "object" && "map" in outputDef && "schema" in outputDef) {
+      const result2 = {};
+      for (const [k, expr] of Object.entries(outputDef.map)) {
+        result2[k] = celEvaluator(expr, ctx);
       }
-      collectFlowWarnings(parallelSteps, participants, warnings, `${stepPath}.parallel`);
-      continue;
+      return result2;
     }
-    if ("type" in obj && !obj.as) {
-      warnings.push({
-        path: stepPath,
-        message: "inline participant without 'as' — its output cannot be referenced by name"
-      });
-      continue;
+    if (typeof outputDef === "string") {
+      return celEvaluator(outputDef, ctx);
     }
-    if (obj.if && Object.keys(obj).length === 1) {
-      const ifDef = obj.if;
-      collectFlowWarnings(ifDef.then ?? [], participants, warnings, `${stepPath}.if.then`);
-      if (ifDef.else) {
-        collectFlowWarnings(ifDef.else, participants, warnings, `${stepPath}.if.else`);
+    const result = {};
+    for (const k of Object.keys(outputDef)) {
+      const expr = outputDef[k];
+      result[k] = celEvaluator(expr, ctx);
+    }
+    return result;
+  }
+}
+async function executeWorkflow(workflow, inputs = {}, basePath = process.cwd(), options = {}) {
+  const { result: inputResult, resolved } = validateInputs2(workflow.inputs, inputs);
+  if (!inputResult.valid) {
+    throw new Error(`input validation failed: ${JSON.stringify(inputResult.errors)}`);
+  }
+  const state = new WorkflowState(resolved);
+  state.workflowMeta = {
+    id: workflow.id,
+    name: workflow.name,
+    version: workflow.version
+  };
+  state.executionMeta.number = options.executionNumber ?? 1;
+  if (options.cwd) {
+    state.executionMeta.cwd = options.cwd;
+  }
+  const startedAtMs = performance.now();
+  const startedAtIso = state.executionMeta.startedAt;
+  if (options._ancestorPaths) {
+    state.ancestorPaths = options._ancestorPaths;
+  }
+  if (options.traceDir && !options._ancestorPaths) {
+    const collector = new TraceCollector2;
+    const writer = await createTraceWriter(options.traceDir, options.traceFormat ?? "json");
+    collector.writer = writer;
+    state.tracer = collector;
+    await writer.open({
+      id: state.executionMeta.id,
+      workflowId: workflow.id,
+      workflowName: workflow.name,
+      workflowVersion: workflow.version,
+      startedAt: startedAtIso,
+      inputs: resolved
+    });
+  }
+  const engineExecutor = async (subWorkflow, subInputs, subBasePath) => {
+    return executeWorkflow(subWorkflow, subInputs, subBasePath, {
+      ...options,
+      _ancestorPaths: state.ancestorPaths
+    });
+  };
+  let output;
+  let success = false;
+  try {
+    let chain;
+    for (const step of workflow.flow) {
+      chain = await executeControlStep2(workflow, state, step, basePath, engineExecutor, chain, options.hub);
+    }
+    if (workflow.output !== undefined) {
+      output = state.resolveOutput(workflow.output, evaluateCel2);
+      if (typeof workflow.output === "object" && "schema" in workflow.output && "map" in workflow.output && typeof output === "object" && output !== null) {
+        validateOutputSchema2(workflow.output.schema, output);
       }
+    } else {
+      output = chain;
+    }
+    const steps = state.getAllResults();
+    success = !Object.values(steps).some((step) => step.status === "failure");
+    state.executionMeta.status = success ? "success" : "failure";
+    return {
+      success,
+      output,
+      steps,
+      duration: Math.max(0, performance.now() - startedAtMs)
+    };
+  } finally {
+    if (state.tracer?.writer) {
+      const duration = Math.max(0, performance.now() - startedAtMs);
+      await state.tracer.writer.finalize({
+        status: success ? "success" : "failure",
+        output: output ?? null,
+        finishedAt: new Date().toISOString(),
+        duration
+      }).catch(() => {});
     }
   }
 }
-function collectSetKeys(step) {
-  if (!step || typeof step !== "object")
-    return [];
-  const obj = step;
-  if ("set" in obj && Object.keys(obj).length === 1) {
-    return Object.keys(obj.set);
+async function runWorkflowFromFile(filePath, inputs = {}, options = {}) {
+  const workflow = await parseWorkflowFile2(filePath);
+  const schemaValidation = validateSchema2(workflow);
+  if (!schemaValidation.valid) {
+    throw new Error(`schema validation failed: ${JSON.stringify(schemaValidation.errors)}`);
   }
-  const keys4 = [];
-  if (obj.loop) {
-    const loopDef = obj.loop;
-    for (const s of loopDef.steps ?? []) {
-      keys4.push(...collectSetKeys(s));
+  const workflowBasePath = dirname22(resolve32(filePath));
+  const semanticValidation = await validateSemantic2(workflow, workflowBasePath);
+  if (!semanticValidation.valid) {
+    throw new Error(`semantic validation failed: ${JSON.stringify(semanticValidation.errors)}`);
+  }
+  return executeWorkflow(workflow, inputs, workflowBasePath, options);
+}
+init_control2();
+init_sequential2();
+init_errors2();
+init_timeout2();
+init_wait2();
+
+// src/run.ts
+async function createHubFromFlags(values3) {
+  const backend = values3?.["event-backend"] ?? "memory";
+  if (backend === "memory") {
+    const { MemoryHub: MemoryHub3 } = await Promise.resolve().then(() => (init_eventhub(), exports_eventhub));
+    return new MemoryHub3;
+  }
+  if (backend === "nats") {
+    const url = values3?.["nats-url"];
+    if (!url) {
+      console.error("Error: --nats-url is required when using the NATS backend");
+      throw new Error("missing --nats-url");
+    }
+    const stream = values3?.["nats-stream"] ?? "duckflux-events";
+    try {
+      const { NatsHub } = await import("@duckflux/hub-nats");
+      return await NatsHub.create({ url, stream });
+    } catch (err) {
+      if (err instanceof Error && (err.message.includes("Cannot find module") || err.message.includes("Cannot find package"))) {
+        console.error("Error: install @duckflux/hub-nats to use the NATS backend");
+        throw new Error("@duckflux/hub-nats not installed");
+      }
+      throw err;
     }
   }
-  if (obj.if) {
-    const ifDef = obj.if;
-    for (const s of ifDef.then ?? []) {
-      keys4.push(...collectSetKeys(s));
+  if (backend === "redis") {
+    const addr = values3?.["redis-addr"] ?? "localhost:6379";
+    const db = Number(values3?.["redis-db"] ?? "0");
+    try {
+      const { RedisHub } = await import("@duckflux/hub-redis");
+      return await RedisHub.create({ addr, db });
+    } catch (err) {
+      if (err instanceof Error && (err.message.includes("Cannot find module") || err.message.includes("Cannot find package"))) {
+        console.error("Error: install @duckflux/hub-redis to use the Redis backend");
+        throw new Error("@duckflux/hub-redis not installed");
+      }
+      throw err;
     }
-    if (ifDef.else) {
-      for (const s of ifDef.else) {
-        keys4.push(...collectSetKeys(s));
+  }
+  console.error(`Error: unknown event backend "${backend}". Supported: memory, nats, redis`);
+  throw new Error(`unknown event backend: ${backend}`);
+}
+function parseInputFlags(arr) {
+  const out = {};
+  if (!arr)
+    return out;
+  for (const item of arr) {
+    const idx = item.indexOf("=");
+    if (idx === -1) {
+      out[item] = true;
+    } else {
+      const k = item.slice(0, idx);
+      const v = item.slice(idx + 1);
+      try {
+        out[k] = JSON.parse(v);
+      } catch {
+        out[k] = v;
       }
     }
   }
-  return keys4;
+  return out;
 }
-async function lintCommand(filePath) {
+async function runCommand(filePath, cliValues) {
   if (!filePath) {
-    console.error("Usage: duckflux lint <workflow.yaml>");
+    console.error("Usage: quack run <workflow.yaml> [--input k=v] [--input-file file.json] [--cwd dir]");
     return 1;
   }
+  let inputs = {};
   try {
-    const workflow = await parseWorkflowFile2(filePath);
-    const schemaRes = validateSchema2(workflow);
-    if (!schemaRes.valid) {
-      console.error("Schema validation failed:");
-      for (const e of schemaRes.errors) {
-        console.error(`  - ${e.path}: ${e.message}`);
+    if (process.stdin && !process.stdin.isTTY) {
+      let stdin = "";
+      for await (const chunk of process.stdin) {
+        stdin += chunk;
       }
-      return 1;
-    }
-    const basePath = dirname5(filePath);
-    const semanticRes = await validateSemantic2(workflow, basePath);
-    if (!semanticRes.valid) {
-      console.error("Semantic validation failed:");
-      for (const e of semanticRes.errors) {
-        console.error(`  - ${e.path}: ${e.message}`);
+      stdin = stdin.trim();
+      if (stdin.length > 0) {
+        try {
+          const parsed = JSON.parse(stdin);
+          if (typeof parsed === "object" && parsed !== null)
+            inputs = { ...inputs, ...parsed };
+        } catch {}
       }
-      return 1;
     }
-    const warnings = collectLintWarnings(workflow);
-    if (warnings.length > 0) {
-      console.warn("Warnings:");
-      for (const w of warnings) {
-        console.warn(`  - ${w.path}: ${w.message}`);
+  } catch {}
+  if (cliValues) {
+    if (cliValues["input-file"]) {
+      try {
+        const content = await readFile5(String(cliValues["input-file"]), "utf-8");
+        const parsed = JSON.parse(content);
+        if (typeof parsed === "object" && parsed !== null)
+          inputs = { ...inputs, ...parsed };
+      } catch (err) {
+        console.error("Failed to read input file:", err);
+        return 1;
       }
     }
-    console.log("valid");
-    return 0;
+    if (cliValues.input) {
+      const parsed = Array.isArray(cliValues.input) ? cliValues.input : [cliValues.input];
+      inputs = { ...inputs, ...parseInputFlags(parsed) };
+    }
+  }
+  let hub;
+  try {
+    hub = await createHubFromFlags(cliValues);
+  } catch {
+    return 1;
+  }
+  const options = {
+    hub,
+    cwd: cliValues?.cwd,
+    verbose: cliValues?.verbose,
+    quiet: cliValues?.quiet,
+    traceDir: cliValues?.["trace-dir"],
+    traceFormat: cliValues?.["trace-format"] ?? "json"
+  };
+  try {
+    const res = await runWorkflowFromFile(filePath, inputs, options);
+    const output = res.output;
+    if (output === undefined || output === null) {} else if (typeof output === "string") {
+      process.stdout.write(output);
+    } else {
+      console.log(JSON.stringify(output, null, 2));
+    }
+    return res.success ? 0 : 2;
   } catch (err) {
-    console.error("Error during lint:", err && err.message ? err.message : err);
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error("Error:", msg);
+    if (cliValues?.verbose && err instanceof Error && err.stack) {
+      console.error(err.stack);
+    }
     return 1;
+  } finally {
+    await hub?.close();
   }
 }
 
+// src/server.ts
+import { existsSync } from "node:fs";
+import { join as join6 } from "node:path";
+import { spawn as spawn3, execSync } from "node:child_process";
+import { createInterface } from "node:readline";
+async function ensureServerPackage(cwd) {
+  const serverBin = join6(cwd, "node_modules", ".bin", "duckflux-server");
+  const serverPkg = join6(cwd, "node_modules", "@duckflux", "server");
+  if (existsSync(serverBin) || existsSync(serverPkg))
+    return true;
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  const answer = await new Promise((resolve4) => {
+    rl.question(`
+@duckflux/server is not installed. Install it now? [Y/n] `, resolve4);
+  });
+  rl.close();
+  if (answer.trim().toLowerCase() === "n") {
+    console.error("Cancelled. Run `bun add @duckflux/server -D` to install manually.");
+    return false;
+  }
+  console.error("Installing @duckflux/server...");
+  try {
+    execSync("bun add @duckflux/server -D", { cwd, stdio: "inherit" });
+    return true;
+  } catch {
+    try {
+      execSync("npm install @duckflux/server --save-dev", { cwd, stdio: "inherit" });
+      return true;
+    } catch {
+      console.error("Failed to install @duckflux/server. Please install it manually.");
+      return false;
+    }
+  }
+}
+async function serverCommand(values3) {
+  const cwd = values3["cwd"] ?? process.cwd();
+  const installed = await ensureServerPackage(cwd);
+  if (!installed)
+    return 1;
+  const args = [];
+  if (values3["trace-dir"])
+    args.push("--trace-dir", values3["trace-dir"]);
+  if (values3["workflow-dir"])
+    args.push("--workflow-dir", values3["workflow-dir"]);
+  if (values3["port"])
+    args.push("--port", values3["port"]);
+  const child = spawn3("bunx", ["@duckflux/server", ...args], {
+    cwd,
+    stdio: "inherit",
+    env: process.env
+  });
+  return new Promise((resolve4) => {
+    child.on("error", (err) => {
+      console.error("Failed to start duckflux server:", err.message);
+      resolve4(1);
+    });
+    child.on("exit", (code) => resolve4(code ?? 0));
+    process.on("SIGINT", () => child.kill("SIGINT"));
+    process.on("SIGTERM", () => child.kill("SIGTERM"));
+  });
+}
+
 // src/validate.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { dirname as dirname6 } from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
 
 // src/run.ts
 function parseInputFlags2(arr) {
@@ -55066,7 +56968,7 @@ function parseInputFlags2(arr) {
 // src/validate.ts
 async function validateCommand(filePath, cliValues) {
   if (!filePath) {
-    console.error("Usage: duckflux validate <workflow.yaml> [--input k=v] [--input-file file.json]");
+    console.error("Usage: quack validate <workflow.yaml> [--input k=v] [--input-file file.json]");
     return 1;
   }
   let inputs = {};
@@ -55077,7 +56979,7 @@ async function validateCommand(filePath, cliValues) {
     }
     if (cliValues["input-file"]) {
       try {
-        const content = await readFile4(String(cliValues["input-file"]), "utf-8");
+        const content = await readFile6(String(cliValues["input-file"]), "utf-8");
         const parsed = JSON.parse(content);
         if (typeof parsed === "object" && parsed !== null)
           inputs = { ...inputs, ...parsed };
@@ -55104,8 +57006,8 @@ async function validateCommand(filePath, cliValues) {
     }
   } catch {}
   try {
-    const workflow = await parseWorkflowFile2(filePath);
-    const schemaRes = validateSchema2(workflow);
+    const workflow = await parseWorkflowFile(filePath);
+    const schemaRes = validateSchema(workflow);
     if (!schemaRes.valid) {
       console.error("Schema validation failed:");
       for (const e of schemaRes.errors) {
@@ -55113,8 +57015,8 @@ async function validateCommand(filePath, cliValues) {
       }
       return 1;
     }
-    const basePath = dirname6(filePath);
-    const semanticRes = await validateSemantic2(workflow, basePath);
+    const basePath = dirname4(filePath);
+    const semanticRes = await validateSemantic(workflow, basePath);
     if (!semanticRes.valid) {
       console.error("Semantic validation failed:");
       for (const e of semanticRes.errors) {
@@ -55122,7 +57024,7 @@ async function validateCommand(filePath, cliValues) {
       }
       return 1;
     }
-    const { result: inputsResult, resolved } = validateInputs2(workflow.inputs, inputs);
+    const { result: inputsResult, resolved } = validateInputs(workflow.inputs, inputs);
     if (!inputsResult.valid) {
       console.error("Input validation failed:");
       for (const e of inputsResult.errors) {
@@ -55141,7 +57043,7 @@ async function validateCommand(filePath, cliValues) {
 // src/main.ts
 function getVersion() {
   try {
-    const pkg = JSON.parse(readFileSync3(resolve6(dirname7(new URL(import.meta.url).pathname), "../package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync(resolve5(dirname5(new URL(import.meta.url).pathname), "../package.json"), "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -55161,7 +57063,11 @@ if (__require.main == __require.module) {
       "nats-url": { type: "string" },
       "nats-stream": { type: "string", default: "duckflux-events" },
       "redis-addr": { type: "string", default: "localhost:6379" },
-      "redis-db": { type: "string", default: "0" }
+      "redis-db": { type: "string", default: "0" },
+      "trace-dir": { type: "string" },
+      "trace-format": { type: "string", default: "json" },
+      "workflow-dir": { type: "string" },
+      port: { type: "string", default: "3000" }
     },
     allowPositionals: true
   });
@@ -55183,9 +57089,13 @@ if (__require.main == __require.module) {
     const exitCode = await validateCommand(file, values3);
     if (typeof exitCode === "number" && exitCode !== 0)
       process.exit(exitCode);
+  } else if (cmd === "server") {
+    const exitCode = await serverCommand(values3);
+    if (typeof exitCode === "number" && exitCode !== 0)
+      process.exit(exitCode);
   } else {
     console.error("Unknown command:", cmd);
-    console.error("Available commands: run, lint, validate, version");
+    console.error("Available commands: run, lint, validate, version, server");
     process.exit(1);
   }
 }