yaml-flow 1.0.0 → 2.0.0

package/dist/index.cjs

@@ -1,5 +1,138 @@
 'use strict';
 
+// src/step-machine/reducer.ts
+function applyStepResult(flow, state, stepName, stepResult) {
+  const stepConfig = flow.steps[stepName];
+  if (!stepConfig) {
+    throw new Error(`Step "${stepName}" not found in flow configuration`);
+  }
+  if (stepResult.result === "failure" && stepConfig.retry) {
+    const retryCount = state.retryCounts[stepName] ?? 0;
+    if (retryCount < stepConfig.retry.max_attempts) {
+      return {
+        newState: {
+          ...state,
+          retryCounts: {
+            ...state.retryCounts,
+            [stepName]: retryCount + 1
+          },
+          updatedAt: Date.now()
+        },
+        nextStep: stepName,
+        isTerminal: false,
+        isCircuitBroken: false,
+        shouldRetry: true
+      };
+    }
+  }
+  const nextStep = stepConfig.transitions[stepResult.result];
+  if (!nextStep) {
+    throw new Error(
+      `No transition defined for result "${stepResult.result}" in step "${stepName}"`
+    );
+  }
+  const isTerminal = !!flow.terminal_states[nextStep];
+  return {
+    newState: {
+      ...state,
+      currentStep: nextStep,
+      stepHistory: [...state.stepHistory, stepName],
+      retryCounts: {
+        ...state.retryCounts,
+        [stepName]: 0
+      },
+      updatedAt: Date.now()
+    },
+    nextStep,
+    isTerminal,
+    isCircuitBroken: false,
+    shouldRetry: false
+  };
+}
+function checkCircuitBreaker(flow, state, stepName) {
+  const stepConfig = flow.steps[stepName];
+  if (!stepConfig?.circuit_breaker) {
+    return {
+      broken: false,
+      newState: {
+        ...state,
+        iterationCounts: {
+          ...state.iterationCounts,
+          [stepName]: (state.iterationCounts[stepName] ?? 0) + 1
+        },
+        updatedAt: Date.now()
+      }
+    };
+  }
+  const count = state.iterationCounts[stepName] ?? 0;
+  if (count >= stepConfig.circuit_breaker.max_iterations) {
+    return {
+      broken: true,
+      redirectStep: stepConfig.circuit_breaker.on_open,
+      newState: {
+        ...state,
+        currentStep: stepConfig.circuit_breaker.on_open,
+        updatedAt: Date.now()
+      }
+    };
+  }
+  return {
+    broken: false,
+    newState: {
+      ...state,
+      iterationCounts: {
+        ...state.iterationCounts,
+        [stepName]: count + 1
+      },
+      updatedAt: Date.now()
+    }
+  };
+}
+function computeStepInput(flow, stepName, allData) {
+  const stepConfig = flow.steps[stepName];
+  if (!stepConfig) {
+    throw new Error(`Step "${stepName}" not found`);
+  }
+  if (stepConfig.expects_data) {
+    const input = {};
+    for (const key of stepConfig.expects_data) {
+      input[key] = allData[key];
+    }
+    return input;
+  }
+  return { ...allData };
+}
+function extractReturnData(returnArtifacts, allData) {
+  if (returnArtifacts === false || returnArtifacts === void 0) {
+    return {};
+  }
+  if (typeof returnArtifacts === "string") {
+    return { [returnArtifacts]: allData[returnArtifacts] };
+  }
+  if (Array.isArray(returnArtifacts)) {
+    const result = {};
+    for (const key of returnArtifacts) {
+      result[key] = allData[key];
+    }
+    return result;
+  }
+  return {};
+}
+function createInitialState(flow, runId) {
+  const now = Date.now();
+  return {
+    runId,
+    flowId: flow.id ?? "unnamed",
+    currentStep: flow.settings.start_step,
+    status: "running",
+    stepHistory: [],
+    iterationCounts: {},
+    retryCounts: {},
+    startedAt: now,
+    updatedAt: now
+  };
+}
+
 // src/stores/memory.ts
 var MemoryStore = class {
   runs = /* @__PURE__ */ new Map();
@@ -43,7 +176,7 @@ var MemoryStore = class {
   }
 };
 
-// src/core/engine.ts
+// src/step-machine/StepMachine.ts
 function generateRunId() {
   if (typeof crypto !== "undefined" && crypto.randomUUID) {
     return crypto.randomUUID();
@@ -54,7 +187,7 @@ function generateRunId() {
     return v.toString(16);
   });
 }
-var FlowEngine = class {
+var StepMachine = class {
   flow;
   handlers;
   store;
@@ -75,9 +208,6 @@ var FlowEngine = class {
     }
     this.validateFlow();
   }
-  /**
-   * Validate the flow configuration
-   */
   validateFlow() {
     const { settings, steps, terminal_states } = this.flow;
     if (!settings?.start_step) {
@@ -90,7 +220,7 @@ var FlowEngine = class {
       throw new Error("Flow must have at least one terminal_state defined");
     }
     if (!steps[settings.start_step] && !terminal_states[settings.start_step]) {
-      throw new Error(`Start step "${settings.start_step}" not found in steps or terminal_states`);
+      throw new Error(`Start step "${settings.start_step}" not found`);
     }
     for (const [stepName, stepConfig] of Object.entries(steps)) {
       for (const [result, target] of Object.entries(stepConfig.transitions)) {
@@ -102,23 +232,32 @@ var FlowEngine = class {
       }
     }
   }
-  /**
-   * Run the flow from the start
-   */
+  on(eventType, listener) {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(eventType).add(listener);
+  }
+  off(eventType, listener) {
+    this.listeners.get(eventType)?.delete(listener);
+  }
+  emit(event) {
+    const typeListeners = this.listeners.get(event.type);
+    if (typeListeners) {
+      for (const listener of typeListeners) {
+        try {
+          listener(event);
+        } catch {
+        }
+      }
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
   async run(initialData) {
     const runId = generateRunId();
-    const startedAt = Date.now();
-    const runState = {
-      runId,
-      flowId: this.flow.id ?? "unnamed",
-      currentStep: this.flow.settings.start_step,
-      status: "running",
-      stepHistory: [],
-      iterationCounts: {},
-      retryCounts: {},
-      startedAt,
-      updatedAt: startedAt
-    };
+    let runState = createInitialState(this.flow, runId);
     await this.store.saveRunState(runId, runState);
     if (initialData) {
       for (const [key, value] of Object.entries(initialData)) {
@@ -128,22 +267,16 @@ var FlowEngine = class {
     this.emit({
       type: "flow:start",
       runId,
-      timestamp: startedAt,
-      data: { initialData }
+      timestamp: runState.startedAt,
+      data: { initialData: initialData ?? {} }
     });
     try {
-      return await this.executeLoop(runId, runState, startedAt);
+      return await this.executeLoop(runId, runState);
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
-      this.emit({
-        type: "flow:error",
-        runId,
-        timestamp: Date.now(),
-        data: { error: err.message }
-      });
+      this.emit({ type: "flow:error", runId, timestamp: Date.now(), data: { error: err.message } });
       this.options.onError?.(err);
-      runState.status = "failed";
-      runState.updatedAt = Date.now();
+      runState = { ...runState, status: "failed", updatedAt: Date.now() };
       await this.store.saveRunState(runId, runState);
       return {
         runId,
@@ -151,309 +284,135 @@ var FlowEngine = class {
         data: await this.store.getAllData(runId),
         finalStep: runState.currentStep,
         stepHistory: runState.stepHistory,
-        durationMs: Date.now() - startedAt,
+        durationMs: Date.now() - runState.startedAt,
         error: err
       };
     }
   }
-  /**
-   * Resume a paused or interrupted flow
-   */
   async resume(runId) {
     const runState = await this.store.loadRunState(runId);
-    if (!runState) {
-      throw new Error(`No run found with ID: ${runId}`);
-    }
+    if (!runState) throw new Error(`No run found with ID: ${runId}`);
     if (runState.status === "completed" || runState.status === "failed") {
       throw new Error(`Cannot resume a ${runState.status} run`);
     }
-    const startedAt = runState.startedAt;
-    runState.status = "running";
-    runState.pausedAt = void 0;
-    runState.updatedAt = Date.now();
-    await this.store.saveRunState(runId, runState);
-    this.emit({
-      type: "flow:resumed",
-      runId,
-      timestamp: Date.now(),
-      data: { currentStep: runState.currentStep }
-    });
-    return this.executeLoop(runId, runState, startedAt);
+    const updated = { ...runState, status: "running", pausedAt: void 0, updatedAt: Date.now() };
+    await this.store.saveRunState(runId, updated);
+    this.emit({ type: "flow:resumed", runId, timestamp: Date.now(), data: { currentStep: updated.currentStep } });
+    return this.executeLoop(runId, updated);
   }
-  /**
-   * Pause a running flow
-   */
   async pause(runId) {
     const runState = await this.store.loadRunState(runId);
-    if (!runState) {
-      throw new Error(`No run found with ID: ${runId}`);
-    }
-    runState.status = "paused";
-    runState.pausedAt = Date.now();
-    runState.updatedAt = Date.now();
-    await this.store.saveRunState(runId, runState);
-    this.emit({
-      type: "flow:paused",
-      runId,
-      timestamp: Date.now(),
-      data: { currentStep: runState.currentStep }
-    });
+    if (!runState) throw new Error(`No run found with ID: ${runId}`);
+    const updated = { ...runState, status: "paused", pausedAt: Date.now(), updatedAt: Date.now() };
+    await this.store.saveRunState(runId, updated);
+    this.emit({ type: "flow:paused", runId, timestamp: Date.now(), data: { currentStep: updated.currentStep } });
   }
-  /**
-   * Main execution loop
-   */
-  async executeLoop(runId, runState, startedAt) {
+  async executeLoop(runId, runState) {
     const maxSteps = this.flow.settings.max_total_steps ?? 100;
     const timeoutMs = this.flow.settings.timeout_ms;
+    let current = runState;
     let iterations = 0;
     while (iterations < maxSteps) {
       if (this.aborted) {
-        runState.status = "cancelled";
-        runState.updatedAt = Date.now();
-        await this.store.saveRunState(runId, runState);
-        return {
-          runId,
-          status: "cancelled",
-          data: await this.store.getAllData(runId),
-          finalStep: runState.currentStep,
-          stepHistory: runState.stepHistory,
-          durationMs: Date.now() - startedAt
-        };
+        current = { ...current, status: "cancelled", updatedAt: Date.now() };
+        await this.store.saveRunState(runId, current);
+        return { runId, status: "cancelled", data: await this.store.getAllData(runId), finalStep: current.currentStep, stepHistory: current.stepHistory, durationMs: Date.now() - current.startedAt };
       }
-      if (timeoutMs && Date.now() - startedAt > timeoutMs) {
-        runState.status = "completed";
-        runState.updatedAt = Date.now();
-        await this.store.saveRunState(runId, runState);
-        return {
-          runId,
-          status: "timeout",
-          intent: "timeout",
-          data: await this.store.getAllData(runId),
-          finalStep: runState.currentStep,
-          stepHistory: runState.stepHistory,
-          durationMs: Date.now() - startedAt
-        };
+      if (timeoutMs && Date.now() - current.startedAt > timeoutMs) {
+        current = { ...current, status: "completed", updatedAt: Date.now() };
+        await this.store.saveRunState(runId, current);
+        return { runId, status: "timeout", intent: "timeout", data: await this.store.getAllData(runId), finalStep: current.currentStep, stepHistory: current.stepHistory, durationMs: Date.now() - current.startedAt };
       }
-      const currentStep = runState.currentStep;
-      const terminalState = this.flow.terminal_states[currentStep];
+      const stepName = current.currentStep;
+      const terminalState = this.flow.terminal_states[stepName];
       if (terminalState) {
-        runState.status = "completed";
-        runState.updatedAt = Date.now();
-        await this.store.saveRunState(runId, runState);
-        const allData = await this.store.getAllData(runId);
-        const returnData = this.extractReturnData(terminalState.return_artifacts, allData);
+        current = { ...current, status: "completed", updatedAt: Date.now() };
+        await this.store.saveRunState(runId, current);
+        const allData2 = await this.store.getAllData(runId);
         const result = {
           runId,
           status: "completed",
           intent: terminalState.return_intent,
-          data: returnData,
-          finalStep: currentStep,
-          stepHistory: runState.stepHistory,
-          durationMs: Date.now() - startedAt
+          data: extractReturnData(terminalState.return_artifacts, allData2),
+          finalStep: stepName,
+          stepHistory: current.stepHistory,
+          durationMs: Date.now() - current.startedAt
         };
-        this.emit({
-          type: "flow:complete",
-          runId,
-          timestamp: Date.now(),
-          data: { ...result }
-        });
+        this.emit({ type: "flow:complete", runId, timestamp: Date.now(), data: { ...result } });
         this.options.onComplete?.(result);
         return result;
       }
-      const stepConfig = this.flow.steps[currentStep];
-      if (!stepConfig) {
-        throw new Error(`Step "${currentStep}" not found in flow configuration`);
-      }
-      if (stepConfig.circuit_breaker) {
-        const count = runState.iterationCounts[currentStep] ?? 0;
-        if (count >= stepConfig.circuit_breaker.max_iterations) {
-          runState.currentStep = stepConfig.circuit_breaker.on_open;
-          runState.updatedAt = Date.now();
-          await this.store.saveRunState(runId, runState);
-          iterations++;
-          continue;
-        }
-      }
-      runState.iterationCounts[currentStep] = (runState.iterationCounts[currentStep] ?? 0) + 1;
-      const stepResult = await this.executeStep(runId, currentStep, stepConfig);
-      if (stepResult.result === "failure" && stepConfig.retry) {
-        const retryCount = runState.retryCounts[currentStep] ?? 0;
-        if (retryCount < stepConfig.retry.max_attempts) {
-          runState.retryCounts[currentStep] = retryCount + 1;
-          if (stepConfig.retry.delay_ms) {
-            const delay = stepConfig.retry.backoff_multiplier ? stepConfig.retry.delay_ms * Math.pow(stepConfig.retry.backoff_multiplier, retryCount) : stepConfig.retry.delay_ms;
-            await this.sleep(delay);
-          }
-          iterations++;
-          continue;
-        }
-      }
-      const nextStep = stepConfig.transitions[stepResult.result];
-      if (!nextStep) {
-        throw new Error(
-          `No transition defined for result "${stepResult.result}" in step "${currentStep}"`
-        );
+      const cbResult = checkCircuitBreaker(this.flow, current, stepName);
+      if (cbResult.broken) {
+        current = cbResult.newState;
+        await this.store.saveRunState(runId, current);
+        iterations++;
+        continue;
       }
-      runState.stepHistory.push(currentStep);
-      runState.currentStep = nextStep;
-      runState.updatedAt = Date.now();
-      runState.retryCounts[currentStep] = 0;
-      await this.store.saveRunState(runId, runState);
-      this.emit({
-        type: "transition",
+      current = cbResult.newState;
+      const allData = await this.store.getAllData(runId);
+      const input = computeStepInput(this.flow, stepName, allData);
+      const context = {
         runId,
-        timestamp: Date.now(),
-        data: { from: currentStep, to: nextStep, result: stepResult.result }
-      });
-      this.options.onTransition?.(currentStep, nextStep);
-      iterations++;
-    }
-    runState.status = "completed";
-    runState.updatedAt = Date.now();
-    await this.store.saveRunState(runId, runState);
-    return {
-      runId,
-      status: "max_iterations",
-      intent: "max_iterations",
-      data: await this.store.getAllData(runId),
-      finalStep: runState.currentStep,
-      stepHistory: runState.stepHistory,
-      durationMs: Date.now() - startedAt
-    };
-  }
-  /**
-   * Execute a single step
-   */
-  async executeStep(runId, stepName, stepConfig) {
-    const handler = this.handlers.get(stepName);
-    if (!handler) {
-      throw new Error(`No handler registered for step "${stepName}"`);
-    }
-    const allData = await this.store.getAllData(runId);
-    const input = {};
-    if (stepConfig.expects_data) {
-      for (const key of stepConfig.expects_data) {
-        input[key] = allData[key];
-      }
-    } else {
-      Object.assign(input, allData);
-    }
-    const context = {
-      runId,
-      stepName,
-      components: this.components,
-      store: this.store,
-      signal: this.options.signal,
-      emit: (event, data) => {
-        this.emit({
-          type: "step:complete",
-          // Custom events map to step:complete
-          runId,
-          timestamp: Date.now(),
-          data: { event, payload: data }
-        });
+        stepName,
+        components: this.components,
+        store: this.store,
+        signal: this.options.signal,
+        emit: (event, data) => {
+          this.emit({ type: "step:complete", runId, timestamp: Date.now(), data: { event, payload: data } });
+        }
+      };
+      this.emit({ type: "step:start", runId, timestamp: Date.now(), data: { step: stepName, input } });
+      let stepResult;
+      try {
+        const handler = this.handlers.get(stepName);
+        if (!handler) throw new Error(`No handler registered for step "${stepName}"`);
+        stepResult = await handler(input, context);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.emit({ type: "step:error", runId, timestamp: Date.now(), data: { step: stepName, error: err.message } });
+        stepResult = { result: "failure", data: { error: err.message } };
       }
-    };
-    this.emit({
-      type: "step:start",
-      runId,
-      timestamp: Date.now(),
-      data: { step: stepName, input }
-    });
-    try {
-      const result = await handler(input, context);
-      if (result.data) {
-        for (const [key, value] of Object.entries(result.data)) {
+      if (stepResult.data) {
+        for (const [key, value] of Object.entries(stepResult.data)) {
           await this.store.setData(runId, key, value);
         }
       }
-      this.emit({
-        type: "step:complete",
-        runId,
-        timestamp: Date.now(),
-        data: { step: stepName, result: result.result, outputKeys: Object.keys(result.data ?? {}) }
-      });
-      this.options.onStep?.(stepName, result);
-      return result;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.emit({
-        type: "step:error",
-        runId,
-        timestamp: Date.now(),
-        data: { step: stepName, error: err.message }
-      });
-      return { result: "failure", data: { error: err.message } };
-    }
-  }
-  /**
-   * Extract data to return based on return_artifacts configuration
-   */
-  extractReturnData(returnArtifacts, allData) {
-    if (returnArtifacts === false || returnArtifacts === void 0) {
-      return {};
-    }
-    if (typeof returnArtifacts === "string") {
-      return { [returnArtifacts]: allData[returnArtifacts] };
-    }
-    if (Array.isArray(returnArtifacts)) {
-      const result = {};
-      for (const key of returnArtifacts) {
-        result[key] = allData[key];
-      }
-      return result;
-    }
-    return allData;
-  }
-  /**
-   * Sleep helper
-   */
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  /**
-   * Subscribe to flow events
-   */
-  on(type, listener) {
-    if (!this.listeners.has(type)) {
-      this.listeners.set(type, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(type).add(listener);
-    return () => {
-      this.listeners.get(type)?.delete(listener);
-    };
-  }
-  /**
-   * Emit an event
-   */
-  emit(event) {
-    const typeListeners = this.listeners.get(event.type);
-    if (typeListeners) {
-      for (const listener of typeListeners) {
-        try {
-          listener(event);
-        } catch {
+      this.emit({ type: "step:complete", runId, timestamp: Date.now(), data: { step: stepName, result: stepResult.result } });
+      this.options.onStep?.(stepName, stepResult);
+      const reducerResult = applyStepResult(this.flow, current, stepName, stepResult);
+      current = reducerResult.newState;
+      if (reducerResult.shouldRetry) {
+        await this.store.saveRunState(runId, current);
+        const stepConfig = this.flow.steps[stepName];
+        if (stepConfig.retry?.delay_ms) {
+          const retryCount = current.retryCounts[stepName] ?? 0;
+          const delay = stepConfig.retry.backoff_multiplier ? stepConfig.retry.delay_ms * Math.pow(stepConfig.retry.backoff_multiplier, retryCount - 1) : stepConfig.retry.delay_ms;
+          await this.sleep(delay);
         }
+        iterations++;
+        continue;
       }
+      await this.store.saveRunState(runId, current);
+      this.emit({ type: "transition", runId, timestamp: Date.now(), data: { from: stepName, to: current.currentStep, result: stepResult.result } });
+      this.options.onTransition?.(stepName, current.currentStep);
+      iterations++;
     }
-  }
-  /**
-   * Get the current store instance
-   */
-  getStore() {
-    return this.store;
+    current = { ...current, status: "completed", updatedAt: Date.now() };
+    await this.store.saveRunState(runId, current);
+    return { runId, status: "max_iterations", intent: "max_iterations", data: await this.store.getAllData(runId), finalStep: current.currentStep, stepHistory: current.stepHistory, durationMs: Date.now() - current.startedAt };
   }
 };
-function createEngine(flow, handlers, options) {
-  return new FlowEngine(flow, handlers, options);
+function createStepMachine(flow, handlers, options) {
+  return new StepMachine(flow, handlers, options);
 }
 
-// src/core/loader.ts
-async function parseYaml(yamlString) {
+// src/step-machine/loader.ts
+async function parseStepFlowYaml(yamlString) {
   const yaml = await import('yaml');
   return yaml.parse(yamlString);
 }
-async function loadFlowFromUrl(url) {
+async function loadStepFlowFromUrl(url) {
   const response = await fetch(url);
   if (!response.ok) {
     throw new Error(`Failed to load flow from ${url}: ${response.statusText}`);
@@ -463,17 +422,17 @@ async function loadFlowFromUrl(url) {
   if (contentType.includes("json") || url.endsWith(".json")) {
     return JSON.parse(text);
   }
-  return parseYaml(text);
+  return parseStepFlowYaml(text);
 }
-async function loadFlowFromFile(filePath) {
+async function loadStepFlowFromFile(filePath) {
   const fs = await import('fs/promises');
   const text = await fs.readFile(filePath, "utf-8");
   if (filePath.endsWith(".json")) {
     return JSON.parse(text);
   }
-  return parseYaml(text);
+  return parseStepFlowYaml(text);
 }
-function validateFlowConfig(flow) {
+function validateStepFlowConfig(flow) {
   const errors = [];
   if (!flow || typeof flow !== "object") {
     return ["Flow must be an object"];
@@ -486,12 +445,6 @@ function validateFlowConfig(flow) {
     if (typeof settings.start_step !== "string") {
       errors.push("settings.start_step must be a string");
     }
-    if (settings.max_total_steps !== void 0 && typeof settings.max_total_steps !== "number") {
-      errors.push("settings.max_total_steps must be a number");
-    }
-    if (settings.timeout_ms !== void 0 && typeof settings.timeout_ms !== "number") {
-      errors.push("settings.timeout_ms must be a number");
-    }
   }
   if (!f.steps || typeof f.steps !== "object") {
     errors.push('Flow must have a "steps" object');
@@ -525,27 +478,861 @@ function validateFlowConfig(flow) {
   }
   return errors;
 }
-async function loadFlow(source) {
+async function loadStepFlow(source) {
   let flow;
   if (typeof source === "string") {
     if (source.startsWith("http://") || source.startsWith("https://")) {
-      flow = await loadFlowFromUrl(source);
+      flow = await loadStepFlowFromUrl(source);
     } else if (source.includes("{")) {
       flow = JSON.parse(source);
     } else {
-      flow = await loadFlowFromFile(source);
+      flow = await loadStepFlowFromFile(source);
     }
   } else {
     flow = source;
   }
-  const errors = validateFlowConfig(flow);
+  const errors = validateStepFlowConfig(flow);
   if (errors.length > 0) {
-    throw new Error(`Invalid flow configuration:
+    throw new Error(`Invalid step flow configuration:
 - ${errors.join("\n- ")}`);
   }
   return flow;
 }
 
+// src/event-graph/constants.ts
+var TASK_STATUS = {
+  NOT_STARTED: "not-started",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  INACTIVATED: "inactivated"
+};
+var EXECUTION_STATUS = {
+  CREATED: "created",
+  RUNNING: "running",
+  PAUSED: "paused",
+  STOPPED: "stopped",
+  COMPLETED: "completed",
+  FAILED: "failed"
+};
+var COMPLETION_STRATEGIES = {
+  ALL_TASKS_DONE: "all-tasks-done",
+  ALL_OUTPUTS_DONE: "all-outputs-done",
+  ONLY_RESOLVED: "only-resolved",
+  GOAL_REACHED: "goal-reached",
+  MANUAL: "manual"
+};
+var EXECUTION_MODES = {
+  DEPENDENCY_MODE: "dependency-mode",
+  ELIGIBILITY_MODE: "eligibility-mode"
+};
+var CONFLICT_STRATEGIES = {
+  ALPHABETICAL: "alphabetical",
+  PRIORITY_FIRST: "priority-first",
+  DURATION_FIRST: "duration-first",
+  COST_OPTIMIZED: "cost-optimized",
+  RESOURCE_AWARE: "resource-aware",
+  RANDOM_SELECT: "random-select",
+  USER_CHOICE: "user-choice",
+  PARALLEL_ALL: "parallel-all",
+  SKIP_CONFLICTS: "skip-conflicts",
+  ROUND_ROBIN: "round-robin"
+};
+var DEFAULTS = {
+  EXECUTION_MODE: "eligibility-mode",
+  CONFLICT_STRATEGY: "alphabetical",
+  COMPLETION_STRATEGY: "all-outputs-done",
+  MAX_ITERATIONS: 1e3
+};
+
+// src/event-graph/graph-helpers.ts
+function getProvides(task) {
+  if (!task) return [];
+  if (Array.isArray(task.provides)) return task.provides;
+  return [];
+}
+function getRequires(task) {
+  if (!task) return [];
+  if (Array.isArray(task.requires)) return task.requires;
+  return [];
+}
+function getAllTasks(graph) {
+  return graph.tasks ?? {};
+}
+function getTask(graph, taskName) {
+  return graph.tasks[taskName];
+}
+function hasTask(graph, taskName) {
+  return taskName in graph.tasks;
+}
+function isNonActiveTask(taskState) {
+  if (!taskState) return false;
+  return taskState.status === TASK_STATUS.FAILED || taskState.status === TASK_STATUS.INACTIVATED;
+}
+function isTaskCompleted(taskState) {
+  return taskState?.status === TASK_STATUS.COMPLETED;
+}
+function isTaskRunning(taskState) {
+  return taskState?.status === TASK_STATUS.RUNNING;
+}
+function isRepeatableTask(taskConfig) {
+  return taskConfig.repeatable === true || typeof taskConfig.repeatable === "object" && taskConfig.repeatable !== null;
+}
+function getRepeatableMax(taskConfig) {
+  if (taskConfig.repeatable === true) return void 0;
+  if (typeof taskConfig.repeatable === "object" && taskConfig.repeatable !== null) {
+    return taskConfig.repeatable.max;
+  }
+  return void 0;
+}
+function computeAvailableOutputs(graph, taskStates) {
+  const outputs = /* @__PURE__ */ new Set();
+  for (const [taskName, taskState] of Object.entries(taskStates)) {
+    if (taskState.status === TASK_STATUS.COMPLETED) {
+      const taskConfig = graph.tasks[taskName];
+      if (taskConfig) {
+        const provides = getProvides(taskConfig);
+        provides.forEach((output) => outputs.add(output));
+      }
+    }
+  }
+  return Array.from(outputs);
+}
+function groupTasksByProvides(candidateTaskNames, tasks) {
+  const outputGroups = {};
+  candidateTaskNames.forEach((taskName) => {
+    const task = tasks[taskName];
+    if (!task) return;
+    const provides = getProvides(task);
+    provides.forEach((output) => {
+      if (!outputGroups[output]) {
+        outputGroups[output] = [];
+      }
+      outputGroups[output].push(taskName);
+    });
+  });
+  return outputGroups;
+}
+function hasOutputConflict(taskName, taskProvides, candidates, tasks) {
+  for (const otherName of candidates) {
+    if (otherName === taskName) continue;
+    const otherProvides = getProvides(tasks[otherName]);
+    const overlapping = taskProvides.some((output) => otherProvides.includes(output));
+    if (overlapping) return true;
+  }
+  return false;
+}
+function addDynamicTask(graph, taskName, taskConfig) {
+  return {
+    ...graph,
+    tasks: {
+      ...graph.tasks,
+      [taskName]: taskConfig
+    }
+  };
+}
+function createDefaultTaskState() {
+  return {
+    status: "not-started",
+    executionCount: 0,
+    retryCount: 0,
+    lastEpoch: 0,
+    messages: [],
+    progress: null
+  };
+}
+function createInitialExecutionState(graph, executionId) {
+  const tasks = {};
+  for (const taskName of Object.keys(graph.tasks)) {
+    tasks[taskName] = createDefaultTaskState();
+  }
+  return {
+    status: "running",
+    tasks,
+    availableOutputs: [],
+    stuckDetection: { is_stuck: false, stuck_description: null, outputs_unresolvable: [], tasks_blocked: [] },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    executionId,
+    executionConfig: {
+      executionMode: graph.settings.execution_mode ?? "eligibility-mode",
+      conflictStrategy: graph.settings.conflict_strategy ?? "alphabetical",
+      completionStrategy: graph.settings.completion
+    }
+  };
+}
+
+// src/event-graph/conflict-resolution.ts
+function selectBestAlternative(alternatives, graphTasks, _executionState, strategy) {
+  switch (strategy) {
+    case "alphabetical":
+      return selectByAlphabetical(alternatives);
+    case "priority-first":
+      return selectByPriorityFirst(alternatives, graphTasks);
+    case "duration-first":
+      return selectByDurationFirst(alternatives, graphTasks);
+    case "cost-optimized":
+      return selectByCostOptimized(alternatives, graphTasks);
+    case "resource-aware":
+      return selectByResourceAware(alternatives, graphTasks);
+    case "round-robin":
+      return selectByRoundRobin(alternatives, _executionState);
+    default:
+      return selectByAlphabetical(alternatives);
+  }
+}
+function selectByAlphabetical(alternatives) {
+  return [...alternatives].sort((a, b) => a.localeCompare(b))[0];
+}
+function selectByPriorityFirst(alternatives, graphTasks) {
+  return [...alternatives].sort((a, b) => {
+    const pA = graphTasks[a]?.priority ?? 0;
+    const pB = graphTasks[b]?.priority ?? 0;
+    if (pA !== pB) return pB - pA;
+    const dA = getEstimatedDuration(graphTasks[a]);
+    const dB = getEstimatedDuration(graphTasks[b]);
+    if (dA !== dB) return dA - dB;
+    return a.localeCompare(b);
+  })[0];
+}
+function selectByDurationFirst(alternatives, graphTasks) {
+  return [...alternatives].sort((a, b) => {
+    const dA = getEstimatedDuration(graphTasks[a]);
+    const dB = getEstimatedDuration(graphTasks[b]);
+    if (dA !== dB) return dA - dB;
+    const pA = graphTasks[a]?.priority ?? 0;
+    const pB = graphTasks[b]?.priority ?? 0;
+    if (pA !== pB) return pB - pA;
+    return a.localeCompare(b);
+  })[0];
+}
+function selectByCostOptimized(alternatives, graphTasks) {
+  return [...alternatives].sort((a, b) => {
+    const cA = graphTasks[a]?.estimatedCost ?? 0;
+    const cB = graphTasks[b]?.estimatedCost ?? 0;
+    if (cA !== cB) return cA - cB;
+    const pA = graphTasks[a]?.priority ?? 0;
+    const pB = graphTasks[b]?.priority ?? 0;
+    if (pA !== pB) return pB - pA;
+    return a.localeCompare(b);
+  })[0];
+}
+function selectByResourceAware(alternatives, graphTasks) {
+  return [...alternatives].sort((a, b) => {
+    const rA = graphTasks[a]?.estimatedResources?.cpu ?? 1;
+    const rB = graphTasks[b]?.estimatedResources?.cpu ?? 1;
+    if (rA !== rB) return rA - rB;
+    const pA = graphTasks[a]?.priority ?? 0;
+    const pB = graphTasks[b]?.priority ?? 0;
+    if (pA !== pB) return pB - pA;
+    return a.localeCompare(b);
+  })[0];
+}
+function selectByRoundRobin(alternatives, executionState) {
+  const totalExecs = Object.values(executionState.tasks).reduce((sum, t) => sum + t.executionCount, 0);
+  const sorted = [...alternatives].sort();
+  return sorted[totalExecs % sorted.length];
+}
+function getEstimatedDuration(taskConfig) {
+  return taskConfig?.estimatedDuration ?? Infinity;
+}
+function getNonConflictingTasks(candidates, graphTasks) {
+  return candidates.filter((taskName) => {
+    const provides = getProvides(graphTasks[taskName]);
+    return !hasOutputConflict(taskName, provides, candidates, graphTasks);
+  });
+}
+function selectRandomTasks(candidates, graphTasks) {
+  const outputGroups = groupTasksByProvides(candidates, graphTasks);
+  const selected = [];
+  for (const groupTasks of Object.values(outputGroups)) {
+    if (groupTasks.length === 1) {
+      selected.push(...groupTasks);
+    } else {
+      const idx = Math.floor(Math.random() * groupTasks.length);
+      selected.push(groupTasks[idx]);
+    }
+  }
+  const nonConflicting = getNonConflictingTasks(candidates, graphTasks);
+  nonConflicting.forEach((t) => {
+    if (!selected.includes(t)) selected.push(t);
+  });
+  return selected;
+}
+
+// src/event-graph/completion.ts
+function isExecutionComplete(graph, state) {
+  const strategy = state.executionConfig.completionStrategy;
+  switch (strategy) {
+    case "all-tasks-done":
+      return checkAllTasksDone(graph, state);
+    case "all-outputs-done":
+      return checkAllOutputsDone(graph, state);
+    case "only-resolved":
+      return checkOnlyResolved(graph, state);
+    case "goal-reached":
+      return checkGoalReached(graph, state);
+    case "manual":
+      return { isComplete: false, expectedCompletion: { taskNames: [], outputs: [] } };
+    default:
+      return checkAllOutputsDone(graph, state);
+  }
+}
+function checkAllTasksDone(graph, state) {
+  const graphTasks = getAllTasks(graph);
+  const allTaskNames = Object.keys(graphTasks);
+  if (allTaskNames.length === 0) {
+    return { isComplete: true, expectedCompletion: { taskNames: [], outputs: [] } };
+  }
+  const allDone = allTaskNames.every((taskName) => {
+    const taskState = state.tasks[taskName];
+    return taskState?.status === TASK_STATUS.COMPLETED || isNonActiveTask(taskState);
+  });
+  return {
+    isComplete: allDone,
+    expectedCompletion: { taskNames: allTaskNames, outputs: [] }
+  };
+}
+function checkAllOutputsDone(graph, state) {
+  const graphTasks = getAllTasks(graph);
+  const allPossibleOutputs = /* @__PURE__ */ new Set();
+  for (const taskConfig of Object.values(graphTasks)) {
+    getProvides(taskConfig).forEach((output) => allPossibleOutputs.add(output));
+  }
+  const availableOutputs = computeAvailableOutputs(graph, state.tasks);
+  const allProduced = [...allPossibleOutputs].every((output) => availableOutputs.includes(output));
+  return {
+    isComplete: allProduced,
+    expectedCompletion: { taskNames: [], outputs: [...allPossibleOutputs] }
+  };
+}
+function checkOnlyResolved(graph, state) {
+  const graphTasks = getAllTasks(graph);
+  const availableOutputs = computeAvailableOutputs(graph, state.tasks);
+  const allPossibleOutputs = /* @__PURE__ */ new Set();
+  const tasksByOutput = {};
+  for (const [taskName, taskConfig] of Object.entries(graphTasks)) {
+    const provides = getProvides(taskConfig);
+    provides.forEach((output) => {
+      allPossibleOutputs.add(output);
+      if (!tasksByOutput[output]) tasksByOutput[output] = [];
+      tasksByOutput[output].push(taskName);
+    });
+  }
+  for (const output of allPossibleOutputs) {
+    if (availableOutputs.includes(output)) continue;
+    const producers = tasksByOutput[output] ?? [];
+    const canStillProduce = producers.some((taskName) => {
+      const taskState = state.tasks[taskName];
+      if (taskState?.status === TASK_STATUS.COMPLETED || isNonActiveTask(taskState)) {
+        return false;
+      }
+      const taskConfig = graphTasks[taskName];
+      const requires = getRequires(taskConfig);
+      return requires.every((req) => availableOutputs.includes(req));
+    });
+    if (canStillProduce) {
+      return { isComplete: false, expectedCompletion: { taskNames: [], outputs: [] } };
+    }
+  }
+  const eligibleTasks = getEligibleCandidates(graph, state);
+  if (eligibleTasks.length > 0) {
+    return { isComplete: false, expectedCompletion: { taskNames: eligibleTasks, outputs: [] } };
+  }
+  const completedCount = Object.values(state.tasks).filter((t) => t.status === TASK_STATUS.COMPLETED).length;
+  return {
+    isComplete: completedCount > 0 || availableOutputs.length > 0,
+    expectedCompletion: { taskNames: [], outputs: [] }
+  };
+}
+function checkGoalReached(graph, state) {
+  const goal = graph.settings.goal ?? [];
+  if (goal.length === 0) {
+    return checkAllOutputsDone(graph, state);
+  }
+  const availableOutputs = computeAvailableOutputs(graph, state.tasks);
+  const goalReached = goal.every((output) => availableOutputs.includes(output));
+  return {
+    isComplete: goalReached,
+    expectedCompletion: { taskNames: [], outputs: goal }
+  };
+}
+function getEligibleCandidates(graph, state) {
+  const graphTasks = getAllTasks(graph);
+  const availableOutputs = computeAvailableOutputs(graph, state.tasks);
+  const candidates = [];
+  for (const [taskName, taskConfig] of Object.entries(graphTasks)) {
+    const taskState = state.tasks[taskName];
+    if (taskState?.status === TASK_STATUS.COMPLETED || taskState?.status === TASK_STATUS.RUNNING || isNonActiveTask(taskState)) {
+      continue;
+    }
+    const requires = getRequires(taskConfig);
+    if (requires.every((req) => availableOutputs.includes(req))) {
+      const provides = getProvides(taskConfig);
+      const allAlreadyAvailable = provides.length > 0 && provides.every((output) => availableOutputs.includes(output));
+      if (!allAlreadyAvailable) {
+        candidates.push(taskName);
+      }
+    }
+  }
+  return candidates;
+}
+
+// src/event-graph/stuck-detection.ts
+function detectStuckState(params) {
+  const { graph, state, eligibleTasks, completionResult } = params;
+  const tasks = state.tasks;
+  const graphTasks = getAllTasks(graph);
+  const availableOutputs = computeAvailableOutputs(graph, tasks);
+  if (eligibleTasks.length > 0) {
+    return { is_stuck: false, stuck_description: null, outputs_unresolvable: [], tasks_blocked: [] };
+  }
+  const hasRunningTasks = Object.values(tasks).some((t) => t.status === TASK_STATUS.RUNNING);
+  if (hasRunningTasks) {
+    return { is_stuck: false, stuck_description: null, outputs_unresolvable: [], tasks_blocked: [] };
+  }
+  if (completionResult?.expectedCompletion) {
+    const { taskNames = [], outputs = [] } = completionResult.expectedCompletion;
+    if (taskNames.length > 0) {
+      const expectedFailed = taskNames.filter((tn) => isNonActiveTask(tasks[tn]));
+      if (expectedFailed.length > 0 && expectedFailed.length === taskNames.length) {
+        return {
+          is_stuck: true,
+          stuck_description: `Completion expects tasks ${taskNames.join(", ")} but all are failed`,
+          tasks_blocked: expectedFailed,
+          outputs_unresolvable: outputs
+        };
+      }
+    }
+    if (outputs.length > 0 && state.executionConfig.completionStrategy !== "only-resolved") {
+      const missingOutputs2 = outputs.filter((o) => !availableOutputs.includes(o));
+      if (missingOutputs2.length > 0) {
+        const unprovidable = [];
+        for (const output of missingOutputs2) {
+          const providers = Object.entries(graphTasks).filter(([, config]) => getProvides(config).includes(output)).map(([name]) => name);
+          const viable = providers.filter((p) => !isNonActiveTask(tasks[p]));
+          if (viable.length === 0) {
+            unprovidable.push(output);
+          }
+        }
+        if (unprovidable.length > 0) {
+          return {
+            is_stuck: true,
+            stuck_description: `Completion expects outputs '${unprovidable.join("', '")}' but no viable tasks can provide them`,
+            tasks_blocked: [],
+            outputs_unresolvable: unprovidable
+          };
+        }
+      }
+    }
+  }
+  const blockedTasks = [];
+  const missingOutputs = /* @__PURE__ */ new Set();
+  for (const [taskName, taskConfig] of Object.entries(graphTasks)) {
+    const taskState = tasks[taskName];
+    if (taskState?.status === TASK_STATUS.COMPLETED || isNonActiveTask(taskState) || taskState?.status === TASK_STATUS.RUNNING) {
+      continue;
+    }
+    const requires = getRequires(taskConfig);
+    const unmet = requires.filter((req) => !availableOutputs.includes(req));
+    if (unmet.length > 0) {
+      const canBeProvided = unmet.every((req) => {
+        const providers = Object.entries(graphTasks).filter(([, config]) => getProvides(config).includes(req)).map(([name]) => name);
+        return providers.some((p) => !isNonActiveTask(tasks[p]) && tasks[p]?.status !== TASK_STATUS.COMPLETED);
+      });
+      if (!canBeProvided) {
+        blockedTasks.push(taskName);
+        unmet.forEach((u) => missingOutputs.add(u));
+      }
+    }
+  }
+  if (blockedTasks.length > 0) {
+    return {
+      is_stuck: true,
+      stuck_description: `Tasks [${blockedTasks.join(", ")}] blocked by unresolvable dependencies: ${[...missingOutputs].join(", ")}`,
+      tasks_blocked: blockedTasks,
+      outputs_unresolvable: [...missingOutputs]
+    };
+  }
+  return { is_stuck: false, stuck_description: null, outputs_unresolvable: [], tasks_blocked: [] };
+}
+
+// src/event-graph/scheduler.ts
+function next(graph, state) {
+  const processingLog = [];
+  const graphTasks = getAllTasks(graph);
+  if (Object.keys(graphTasks).length === 0) {
+    return {
+      eligibleTasks: [],
+      isComplete: true,
+      stuckDetection: { is_stuck: false, stuck_description: null, outputs_unresolvable: [], tasks_blocked: [] },
+      hasConflicts: false,
+      conflicts: {},
+      strategy: state.executionConfig.conflictStrategy,
+      processingLog: ["No tasks defined"]
+    };
+  }
+  const mode = state.executionConfig.executionMode;
+  const conflictStrategy = state.executionConfig.conflictStrategy;
+  const candidates = getCandidateTasks(graph, state);
+  processingLog.push(`Found ${candidates.length} candidate tasks: ${candidates.join(", ") || "none"}`);
+  let eligible;
+  let hasConflicts = false;
+  let conflicts = {};
+  if (mode === "dependency-mode") {
+    eligible = candidates;
+  } else {
+    const selection = selectOptimalTasks(candidates, graph, state, conflictStrategy);
+    eligible = selection.eligibleTasks;
+    hasConflicts = selection.hasConflicts;
+    conflicts = selection.conflicts;
+  }
+  processingLog.push(`Eligible after conflict resolution: ${eligible.join(", ") || "none"}`);
+  const completionResult = isExecutionComplete(graph, state);
+  processingLog.push(`Execution complete: ${completionResult.isComplete}`);
+  const stuckDetection = detectStuckState({
+    graph,
+    state,
+    eligibleTasks: eligible,
+    completionResult
+  });
+  if (stuckDetection.is_stuck) {
+    processingLog.push(`STUCK: ${stuckDetection.stuck_description}`);
+  }
+  return {
+    eligibleTasks: eligible,
+    isComplete: completionResult.isComplete,
+    stuckDetection,
+    hasConflicts,
+    conflicts,
+    strategy: conflictStrategy,
+    processingLog
+  };
+}
+function getCandidateTasks(graph, state) {
+  const graphTasks = getAllTasks(graph);
+  const computedOutputs = computeAvailableOutputs(graph, state.tasks);
+  const availableOutputs = [.../* @__PURE__ */ new Set([...computedOutputs, ...state.availableOutputs])];
+  const candidates = [];
+  for (const [taskName, taskConfig] of Object.entries(graphTasks)) {
+    const taskState = state.tasks[taskName];
+    if (!isRepeatableTask(taskConfig)) {
+      if (taskState?.status === TASK_STATUS.COMPLETED || taskState?.status === TASK_STATUS.RUNNING || isNonActiveTask(taskState)) {
+        continue;
+      }
+    } else {
+      if (taskState?.status === TASK_STATUS.RUNNING || isNonActiveTask(taskState)) {
+        continue;
+      }
+      const maxExec = getRepeatableMax(taskConfig);
+      if (maxExec !== void 0 && taskState && taskState.executionCount >= maxExec) {
+        continue;
+      }
+      if (taskConfig.circuit_breaker) {
+        if (taskState && taskState.executionCount >= taskConfig.circuit_breaker.max_executions) {
+          continue;
+        }
+      }
+      if (taskState?.status === TASK_STATUS.COMPLETED) {
+        const requires2 = getRequires(taskConfig);
+        if (requires2.length > 0) {
+          const hasRefreshedInputs = requires2.some((req) => {
+            for (const [otherName, otherConfig] of Object.entries(graphTasks)) {
+              if (getProvides(otherConfig).includes(req)) {
+                const otherState = state.tasks[otherName];
+                if (otherState && otherState.executionCount > taskState.lastEpoch) {
+                  return true;
+                }
+              }
+            }
+            return false;
+          });
+          if (!hasRefreshedInputs) continue;
+        } else {
+          continue;
+        }
+      }
+    }
+    const requires = getRequires(taskConfig);
+    if (!requires.every((req) => availableOutputs.includes(req))) {
+      continue;
+    }
+    if (!isRepeatableTask(taskConfig)) {
+      const provides = getProvides(taskConfig);
+      const allAlreadyAvailable = provides.length > 0 && provides.every((output) => availableOutputs.includes(output));
+      if (allAlreadyAvailable) continue;
+    }
+    candidates.push(taskName);
+  }
+  return candidates;
+}
+function selectOptimalTasks(candidates, graph, state, conflictStrategy) {
+  const result = { eligibleTasks: [], hasConflicts: false, conflicts: {} };
+  if (candidates.length === 0) return result;
+  const graphTasks = getAllTasks(graph);
+  switch (conflictStrategy) {
+    case "parallel-all":
+      result.eligibleTasks = candidates;
+      return result;
+    case "user-choice": {
+      result.eligibleTasks = candidates;
+      if (candidates.length > 1) {
+        const outputGroups2 = groupTasksByProvides(candidates, graphTasks);
+        for (const [outputKey, groupTasks] of Object.entries(outputGroups2)) {
+          if (groupTasks.length > 1) {
+            result.conflicts[outputKey] = groupTasks;
+            result.hasConflicts = true;
+          }
+        }
+      }
+      return result;
+    }
+    case "skip-conflicts":
+      result.eligibleTasks = getNonConflictingTasks(candidates, graphTasks);
+      return result;
+    case "random-select":
+      result.eligibleTasks = selectRandomTasks(candidates, graphTasks);
+      return result;
+  }
+  const outputGroups = groupTasksByProvides(candidates, graphTasks);
+  const runningOutputs = /* @__PURE__ */ new Set();
+  for (const [taskName, taskState] of Object.entries(state.tasks)) {
+    if (taskState.status === TASK_STATUS.RUNNING) {
+      const taskConfig = graph.tasks[taskName];
+      if (taskConfig) {
+        getProvides(taskConfig).forEach((o) => runningOutputs.add(o));
+      }
+    }
+  }
+  const selectedTasks = [];
+  const tasksInConflictGroups = /* @__PURE__ */ new Set();
+  for (const [outputKey, groupTasks] of Object.entries(outputGroups)) {
+    if (runningOutputs.has(outputKey)) continue;
+    if (groupTasks.length === 1) {
+      selectedTasks.push(groupTasks[0]);
+    } else {
+      const selected = selectBestAlternative(groupTasks, graphTasks, state, conflictStrategy);
+      selectedTasks.push(selected);
+    }
+    groupTasks.forEach((t) => tasksInConflictGroups.add(t));
+  }
+  const nonConflicting = candidates.filter((t) => !tasksInConflictGroups.has(t));
+  nonConflicting.forEach((t) => {
+    if (!selectedTasks.includes(t)) selectedTasks.push(t);
+  });
+  result.eligibleTasks = selectedTasks;
+  return result;
+}
+
+// src/event-graph/task-transitions.ts
+function applyTaskStart(state, taskName) {
+  const existingTask = state.tasks[taskName] ?? createDefaultTaskState2();
+  const updatedTask = {
+    ...existingTask,
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    progress: 0,
+    error: void 0
+  };
+  return {
+    ...state,
+    tasks: { ...state.tasks, [taskName]: updatedTask },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function applyTaskCompletion(state, graph, taskName, result) {
+  const existingTask = state.tasks[taskName] ?? createDefaultTaskState2();
+  const taskConfig = graph.tasks[taskName];
+  if (!taskConfig) {
+    throw new Error(`Task "${taskName}" not found in graph`);
+  }
+  let outputTokens;
+  if (result && taskConfig.on && taskConfig.on[result]) {
+    outputTokens = taskConfig.on[result];
+  } else {
+    outputTokens = getProvides(taskConfig);
+  }
+  const updatedTask = {
+    ...existingTask,
+    status: "completed",
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    executionCount: existingTask.executionCount + 1,
+    lastEpoch: existingTask.executionCount + 1,
+    error: void 0
+  };
+  if (isRepeatableTask(taskConfig)) {
+    updatedTask.status = "not-started";
+  }
+  const newOutputs = [.../* @__PURE__ */ new Set([...state.availableOutputs, ...outputTokens])];
+  return {
+    ...state,
+    tasks: { ...state.tasks, [taskName]: updatedTask },
+    availableOutputs: newOutputs,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function applyTaskFailure(state, graph, taskName, error) {
+  const existingTask = state.tasks[taskName] ?? createDefaultTaskState2();
+  const taskConfig = graph.tasks[taskName];
+  if (taskConfig?.retry) {
+    const retryCount = existingTask.retryCount + 1;
+    if (retryCount <= taskConfig.retry.max_attempts) {
+      const updatedTask2 = {
+        ...existingTask,
+        status: "not-started",
+        retryCount,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        error
+      };
+      return {
+        ...state,
+        tasks: { ...state.tasks, [taskName]: updatedTask2 },
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  const updatedTask = {
+    ...existingTask,
+    status: "failed",
+    failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    error,
+    executionCount: existingTask.executionCount + 1
+  };
+  let newOutputs = state.availableOutputs;
+  if (taskConfig?.on_failure && taskConfig.on_failure.length > 0) {
+    newOutputs = [.../* @__PURE__ */ new Set([...state.availableOutputs, ...taskConfig.on_failure])];
+  }
+  if (taskConfig?.circuit_breaker && updatedTask.executionCount >= taskConfig.circuit_breaker.max_executions) {
+    const breakTokens = taskConfig.circuit_breaker.on_break;
+    newOutputs = [.../* @__PURE__ */ new Set([...newOutputs, ...breakTokens])];
+  }
+  return {
+    ...state,
+    tasks: { ...state.tasks, [taskName]: updatedTask },
+    availableOutputs: newOutputs,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function applyTaskProgress(state, taskName, message, progress) {
+  const existingTask = state.tasks[taskName] ?? createDefaultTaskState2();
+  const updatedTask = {
+    ...existingTask,
+    progress: typeof progress === "number" ? progress : existingTask.progress,
+    messages: [
+      ...existingTask.messages ?? [],
+      ...message ? [{ message, timestamp: (/* @__PURE__ */ new Date()).toISOString(), status: existingTask.status }] : []
+    ],
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    ...state,
+    tasks: { ...state.tasks, [taskName]: updatedTask },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createDefaultTaskState2() {
+  return {
+    status: "not-started",
+    executionCount: 0,
+    retryCount: 0,
+    lastEpoch: 0,
+    messages: [],
+    progress: null
+  };
+}
+
+// src/event-graph/reducer.ts
+function apply(state, event, graph) {
+  if ("executionId" in event && event.executionId && event.executionId !== state.executionId) {
+    return state;
+  }
+  switch (event.type) {
+    case "task-started":
+      return applyTaskStart(state, event.taskName);
+    case "task-completed":
+      return applyTaskCompletion(state, graph, event.taskName, event.result);
+    case "task-failed":
+      return applyTaskFailure(state, graph, event.taskName, event.error);
+    case "task-progress":
+      return applyTaskProgress(state, event.taskName, event.message, event.progress);
+    case "inject-tokens":
+      return applyInjectTokens(state, event.tokens);
+    case "agent-action":
+      return applyAgentAction(state, event.action, graph, event.config);
+    case "task-creation":
+      return applyTaskCreation(state, event.taskName, event.taskConfig);
+    default:
+      return state;
+  }
+}
+function applyAll(state, events, graph) {
+  return events.reduce((s, e) => apply(s, e, graph), state);
+}
+function applyInjectTokens(state, tokens) {
+  return {
+    ...state,
+    availableOutputs: [.../* @__PURE__ */ new Set([...state.availableOutputs, ...tokens])],
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function applyAgentAction(state, action, graph, config) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  switch (action) {
+    case "start": {
+      const executionId = `exec-${Date.now()}`;
+      const fresh = createInitialExecutionState(graph, executionId);
+      if (config) {
+        if (config.executionMode) {
+          fresh.executionConfig.executionMode = config.executionMode;
+        }
+        if (config.conflictStrategy) {
+          fresh.executionConfig.conflictStrategy = config.conflictStrategy;
+        }
+        if (config.completionStrategy) {
+          fresh.executionConfig.completionStrategy = config.completionStrategy;
+        }
+      }
+      return fresh;
+    }
+    case "stop":
+      return {
+        ...state,
+        status: "stopped",
+        executionId: null,
+        lastUpdated: now
+      };
+    case "pause":
+      return {
+        ...state,
+        status: "paused",
+        lastUpdated: now
+      };
+    case "resume":
+      return {
+        ...state,
+        status: "running",
+        lastUpdated: now
+      };
+    default:
+      return state;
+  }
+}
+function applyTaskCreation(state, taskName, taskConfig) {
+  if (!taskName || !taskConfig || !Array.isArray(taskConfig.provides)) {
+    return state;
+  }
+  return {
+    ...state,
+    tasks: {
+      ...state.tasks,
+      [taskName]: createDefaultTaskState()
+    },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
 // src/stores/localStorage.ts
 var LocalStorageStore = class {
   prefix;
@@ -728,15 +1515,44 @@ var FileStore = class {
   }
 };
 
+exports.COMPLETION_STRATEGIES = COMPLETION_STRATEGIES;
+exports.CONFLICT_STRATEGIES = CONFLICT_STRATEGIES;
+exports.DEFAULTS = DEFAULTS;
+exports.EXECUTION_MODES = EXECUTION_MODES;
+exports.EXECUTION_STATUS = EXECUTION_STATUS;
 exports.FileStore = FileStore;
-exports.FlowEngine = FlowEngine;
+exports.FlowEngine = StepMachine;
 exports.LocalStorageStore = LocalStorageStore;
 exports.MemoryStore = MemoryStore;
-exports.createEngine = createEngine;
-exports.loadFlow = loadFlow;
-exports.loadFlowFromFile = loadFlowFromFile;
-exports.loadFlowFromUrl = loadFlowFromUrl;
-exports.parseYaml = parseYaml;
-exports.validateFlowConfig = validateFlowConfig;
+exports.StepMachine = StepMachine;
+exports.TASK_STATUS = TASK_STATUS;
+exports.addDynamicTask = addDynamicTask;
+exports.apply = apply;
+exports.applyAll = applyAll;
+exports.applyStepResult = applyStepResult;
+exports.checkCircuitBreaker = checkCircuitBreaker;
+exports.computeAvailableOutputs = computeAvailableOutputs;
+exports.computeStepInput = computeStepInput;
+exports.createDefaultTaskState = createDefaultTaskState;
+exports.createEngine = createStepMachine;
+exports.createInitialExecutionState = createInitialExecutionState;
+exports.createInitialState = createInitialState;
+exports.createStepMachine = createStepMachine;
+exports.detectStuckState = detectStuckState;
+exports.extractReturnData = extractReturnData;
+exports.getAllTasks = getAllTasks;
+exports.getCandidateTasks = getCandidateTasks;
+exports.getProvides = getProvides;
+exports.getRequires = getRequires;
+exports.getTask = getTask;
+exports.hasTask = hasTask;
+exports.isExecutionComplete = isExecutionComplete;
+exports.isNonActiveTask = isNonActiveTask;
+exports.isRepeatableTask = isRepeatableTask;
+exports.isTaskCompleted = isTaskCompleted;
+exports.isTaskRunning = isTaskRunning;
+exports.loadStepFlow = loadStepFlow;
+exports.next = next;
+exports.validateStepFlowConfig = validateStepFlowConfig;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map