yaml-flow 2.8.0 → 3.0.0

package/dist/index.js

@@ -1,5 +1,6 @@
-import { execFile } from 'child_process';
 import addFormats from 'ajv-formats';
+import { existsSync, writeFileSync, appendFileSync, readFileSync } from 'fs';
+import { execFile } from 'child_process';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -3911,7 +3912,7 @@ var require_core = __commonJS({
         uriResolver
       };
     }
-    var Ajv2 = class {
+    var Ajv4 = class {
       constructor(opts = {}) {
         this.schemas = {};
         this.refs = {};
@@ -4281,9 +4282,9 @@ var require_core = __commonJS({
         }
       }
     };
-    Ajv2.ValidationError = validation_error_1.default;
-    Ajv2.MissingRefError = ref_error_1.default;
-    exports$1.default = Ajv2;
+    Ajv4.ValidationError = validation_error_1.default;
+    Ajv4.MissingRefError = ref_error_1.default;
+    exports$1.default = Ajv4;
     function checkOptions(checkOpts, options, msg, log = "error") {
       for (const key in checkOpts) {
         const opt = key;
@@ -6354,7 +6355,7 @@ var require_ajv = __commonJS({
     var draft7MetaSchema = require_json_schema_draft_07();
     var META_SUPPORT_DATA = ["/properties"];
     var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
-    var Ajv2 = class extends core_1.default {
+    var Ajv4 = class extends core_1.default {
       _addVocabularies() {
         super._addVocabularies();
         draft7_1.default.forEach((v) => this.addVocabulary(v));
@@ -6373,11 +6374,11 @@ var require_ajv = __commonJS({
         return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
       }
     };
-    exports$1.Ajv = Ajv2;
-    module.exports = exports$1 = Ajv2;
-    module.exports.Ajv = Ajv2;
+    exports$1.Ajv = Ajv4;
+    module.exports = exports$1 = Ajv4;
+    module.exports.Ajv = Ajv4;
     Object.defineProperty(exports$1, "__esModule", { value: true });
-    exports$1.default = Ajv2;
+    exports$1.default = Ajv4;
     var validate_1 = require_validate();
     Object.defineProperty(exports$1, "KeywordCxt", { enumerable: true, get: function() {
       return validate_1.KeywordCxt;
@@ -6911,6 +6912,188 @@ async function loadStepFlow(source) {
   return flow;
 }
 
+// schema/flow.schema.json
+var flow_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://github.com/yaml-flow/schema/flow.json",
+  title: "YamlFlow Configuration",
+  description: "Schema for yaml-flow workflow definitions",
+  type: "object",
+  required: ["settings", "steps", "terminal_states"],
+  properties: {
+    id: {
+      type: "string",
+      description: "Optional flow identifier"
+    },
+    settings: {
+      type: "object",
+      description: "Flow-level settings",
+      required: ["start_step"],
+      properties: {
+        start_step: {
+          type: "string",
+          description: "Step to start execution from"
+        },
+        max_total_steps: {
+          type: "integer",
+          minimum: 1,
+          default: 100,
+          description: "Maximum steps before forced termination"
+        },
+        timeout_ms: {
+          type: "integer",
+          minimum: 0,
+          description: "Flow timeout in milliseconds"
+        }
+      },
+      additionalProperties: false
+    },
+    steps: {
+      type: "object",
+      description: "Step definitions",
+      minProperties: 1,
+      additionalProperties: {
+        $ref: "#/definitions/step"
+      }
+    },
+    terminal_states: {
+      type: "object",
+      description: "Terminal state definitions",
+      minProperties: 1,
+      additionalProperties: {
+        $ref: "#/definitions/terminal_state"
+      }
+    }
+  },
+  additionalProperties: false,
+  definitions: {
+    step: {
+      type: "object",
+      description: "Individual step configuration",
+      required: ["transitions"],
+      properties: {
+        description: {
+          type: "string",
+          description: "Human-readable description"
+        },
+        expects_data: {
+          type: "array",
+          items: { type: "string" },
+          description: "Data keys this step expects as input"
+        },
+        produces_data: {
+          type: "array",
+          items: { type: "string" },
+          description: "Data keys this step produces as output"
+        },
+        transitions: {
+          type: "object",
+          description: "Mapping of result -> next step name",
+          additionalProperties: { type: "string" },
+          minProperties: 1
+        },
+        retry: {
+          $ref: "#/definitions/retry_config"
+        },
+        circuit_breaker: {
+          $ref: "#/definitions/circuit_breaker_config"
+        }
+      },
+      additionalProperties: false
+    },
+    terminal_state: {
+      type: "object",
+      description: "Terminal state configuration",
+      required: ["return_intent"],
+      properties: {
+        description: {
+          type: "string",
+          description: "Human-readable description"
+        },
+        return_intent: {
+          type: "string",
+          description: "Intent/status to return (e.g., 'success', 'error')"
+        },
+        return_artifacts: {
+          oneOf: [
+            { type: "string" },
+            { type: "array", items: { type: "string" } },
+            { type: "boolean", const: false }
+          ],
+          description: "Data key(s) to include in result, or false to exclude"
+        },
+        expects_data: {
+          type: "array",
+          items: { type: "string" },
+          description: "Data keys this terminal state expects"
+        }
+      },
+      additionalProperties: false
+    },
+    retry_config: {
+      type: "object",
+      description: "Retry configuration for step failures",
+      required: ["max_attempts"],
+      properties: {
+        max_attempts: {
+          type: "integer",
+          minimum: 1,
+          description: "Maximum retry attempts"
+        },
+        delay_ms: {
+          type: "integer",
+          minimum: 0,
+          description: "Delay between retries in ms"
+        },
+        backoff_multiplier: {
+          type: "number",
+          minimum: 1,
+          description: "Backoff multiplier (e.g., 2 for exponential)"
+        }
+      },
+      additionalProperties: false
+    },
+    circuit_breaker_config: {
+      type: "object",
+      description: "Circuit breaker configuration for loops",
+      required: ["max_iterations", "on_open"],
+      properties: {
+        max_iterations: {
+          type: "integer",
+          minimum: 1,
+          description: "Maximum iterations before circuit opens"
+        },
+        on_open: {
+          type: "string",
+          description: "Step to transition to when circuit opens"
+        }
+      },
+      additionalProperties: false
+    }
+  }
+};
+
+// src/step-machine/schema-validator.ts
+var import_ajv = __toESM(require_ajv());
+var _compiled = null;
+function getValidator() {
+  if (_compiled) return _compiled;
+  const ajv = new import_ajv.default({ allErrors: true });
+  addFormats(ajv);
+  _compiled = ajv.compile(flow_schema_default);
+  return _compiled;
+}
+function validateFlowSchema(config) {
+  const validate = getValidator();
+  const valid = validate(config);
+  if (valid) return { ok: true, errors: [] };
+  const errors = (validate.errors ?? []).map((e) => {
+    const path = e.instancePath || "/";
+    return `${path}: ${e.message ?? "unknown error"}`;
+  });
+  return { ok: false, errors };
+}
+
 // src/event-graph/constants.ts
 var TASK_STATUS = {
   NOT_STARTED: "not-started",
@@ -6987,15 +7170,14 @@ function isTaskCompleted(taskState) {
 function isTaskRunning(taskState) {
   return taskState?.status === TASK_STATUS.RUNNING;
 }
-function isRepeatableTask(taskConfig) {
-  return taskConfig.repeatable === true || typeof taskConfig.repeatable === "object" && taskConfig.repeatable !== null;
+function getRefreshStrategy(taskConfig, graphSettings) {
+  return taskConfig.refreshStrategy ?? graphSettings?.refreshStrategy ?? "data-changed";
 }
-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 isRerunnable(taskConfig, graphSettings) {
+  return getRefreshStrategy(taskConfig, graphSettings) !== "once";
+}
+function getMaxExecutions(taskConfig) {
+  return taskConfig.maxExecutions;
 }
 function computeAvailableOutputs(graph, taskStates) {
   const outputs = /* @__PURE__ */ new Set();
@@ -7427,48 +7609,88 @@ function getCandidateTasks(graph, state) {
   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) {
+    const strategy = getRefreshStrategy(taskConfig, graph.settings);
+    const rerunnable = strategy !== "once";
+    if (taskState?.status === TASK_STATUS.RUNNING || isNonActiveTask(taskState)) {
+      continue;
+    }
+    const maxExec = getMaxExecutions(taskConfig);
+    if (maxExec !== void 0 && taskState && taskState.executionCount >= maxExec) {
+      continue;
+    }
+    if (taskConfig.circuit_breaker && taskState && taskState.executionCount >= taskConfig.circuit_breaker.max_executions) {
+      continue;
+    }
+    if (!rerunnable) {
+      if (taskState?.status === TASK_STATUS.COMPLETED) {
         continue;
       }
-      if (taskConfig.circuit_breaker) {
-        if (taskState && taskState.executionCount >= taskConfig.circuit_breaker.max_executions) {
-          continue;
+    }
+    if (rerunnable && taskState?.status === TASK_STATUS.COMPLETED) {
+      const requires2 = getRequires(taskConfig);
+      switch (strategy) {
+        case "data-changed": {
+          if (requires2.length > 0) {
+            const hasChangedData = requires2.some((req) => {
+              for (const [otherName, otherConfig] of Object.entries(graphTasks)) {
+                if (getProvides(otherConfig).includes(req)) {
+                  const otherState = state.tasks[otherName];
+                  if (!otherState) continue;
+                  const consumed = taskState.lastConsumedHashes?.[req];
+                  if (otherState.lastDataHash == null) {
+                    return otherState.executionCount > taskState.lastEpoch;
+                  }
+                  return otherState.lastDataHash !== consumed;
+                }
+              }
+              return false;
+            });
+            if (!hasChangedData) continue;
+          } else {
+            continue;
+          }
+          break;
         }
-      }
-      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;
+        case "epoch-changed": {
+          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 {
+              return false;
+            });
+            if (!hasRefreshedInputs) continue;
+          } else {
+            continue;
+          }
+          break;
+        }
+        case "time-based": {
+          const interval = taskConfig.refreshInterval ?? 0;
+          if (interval <= 0) continue;
+          const completedAt = taskState.completedAt;
+          if (!completedAt) continue;
+          const elapsedSec = (Date.now() - Date.parse(completedAt)) / 1e3;
+          if (elapsedSec < interval) continue;
+          break;
+        }
+        case "manual": {
           continue;
         }
+        default:
+          continue;
       }
     }
     const requires = getRequires(taskConfig);
     if (!requires.every((req) => availableOutputs.includes(req))) {
       continue;
     }
-    if (!isRepeatableTask(taskConfig)) {
+    if (!rerunnable) {
       const provides = getProvides(taskConfig);
       const allAlreadyAvailable = provides.length > 0 && provides.every((output) => availableOutputs.includes(output));
       if (allAlreadyAvailable) continue;
@@ -7552,7 +7774,7 @@ function applyTaskStart(state, taskName) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function applyTaskCompletion(state, graph, taskName, result) {
+function applyTaskCompletion(state, graph, taskName, result, dataHash) {
   const existingTask = state.tasks[taskName] ?? createDefaultTaskState2();
   const taskConfig = graph.tasks[taskName];
   if (!taskConfig) {
@@ -7564,6 +7786,19 @@ function applyTaskCompletion(state, graph, taskName, result) {
   } else {
     outputTokens = getProvides(taskConfig);
   }
+  const lastConsumedHashes = { ...existingTask.lastConsumedHashes };
+  const requires = taskConfig.requires ?? [];
+  for (const token of requires) {
+    for (const [otherName, otherConfig] of Object.entries(graph.tasks)) {
+      if (getProvides(otherConfig).includes(token)) {
+        const otherState = state.tasks[otherName];
+        if (otherState?.lastDataHash) {
+          lastConsumedHashes[token] = otherState.lastDataHash;
+        }
+        break;
+      }
+    }
+  }
   const updatedTask = {
     ...existingTask,
     status: "completed",
@@ -7571,11 +7806,10 @@ function applyTaskCompletion(state, graph, taskName, result) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
     executionCount: existingTask.executionCount + 1,
     lastEpoch: existingTask.executionCount + 1,
+    lastDataHash: dataHash,
+    lastConsumedHashes,
     error: void 0
   };
-  if (isRepeatableTask(taskConfig)) {
-    updatedTask.status = "not-started";
-  }
   const newOutputs = [.../* @__PURE__ */ new Set([...state.availableOutputs, ...outputTokens])];
   return {
     ...state,
@@ -7664,7 +7898,7 @@ function apply(state, event, graph) {
     case "task-started":
       return applyTaskStart(state, event.taskName);
     case "task-completed":
-      return applyTaskCompletion(state, graph, event.taskName, event.result);
+      return applyTaskCompletion(state, graph, event.taskName, event.result, event.dataHash);
     case "task-failed":
       return applyTaskFailure(state, graph, event.taskName, event.error);
     case "task-progress":
@@ -8354,6 +8588,276 @@ function buildResult(issues) {
   };
 }
 
+// schema/event-graph.schema.json
+var event_graph_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://github.com/yaml-flow/schema/event-graph.json",
+  title: "Event Graph Configuration",
+  description: "Schema for stateless event-graph (DAG) workflow definitions in yaml-flow",
+  type: "object",
+  required: ["settings", "tasks"],
+  additionalProperties: false,
+  properties: {
+    id: {
+      type: "string",
+      description: "Optional graph identifier"
+    },
+    settings: {
+      $ref: "#/definitions/settings"
+    },
+    tasks: {
+      type: "object",
+      description: "Task definitions keyed by name",
+      minProperties: 1,
+      additionalProperties: {
+        $ref: "#/definitions/task"
+      }
+    }
+  },
+  definitions: {
+    settings: {
+      type: "object",
+      required: ["completion"],
+      properties: {
+        completion: {
+          type: "string",
+          enum: [
+            "all-tasks-done",
+            "all-outputs-done",
+            "only-resolved",
+            "goal-reached",
+            "manual"
+          ],
+          description: "Completion strategy"
+        },
+        conflict_strategy: {
+          type: "string",
+          enum: [
+            "alphabetical",
+            "priority-first",
+            "duration-first",
+            "cost-optimized",
+            "resource-aware",
+            "random-select",
+            "user-choice",
+            "parallel-all",
+            "skip-conflicts",
+            "round-robin"
+          ],
+          description: "Conflict resolution strategy"
+        },
+        execution_mode: {
+          type: "string",
+          enum: ["dependency-mode", "eligibility-mode"],
+          description: "Execution mode"
+        },
+        goal: {
+          type: "array",
+          items: { type: "string" },
+          minItems: 1,
+          description: "Goal outputs \u2014 required when completion is 'goal-reached'"
+        },
+        max_iterations: {
+          type: "integer",
+          minimum: 1,
+          description: "Max scheduler iterations (safety limit, default: 1000)"
+        },
+        timeout_ms: {
+          type: "integer",
+          minimum: 0,
+          description: "Timeout in ms (declared for drivers, not enforced by pure engine)"
+        },
+        refreshStrategy: {
+          $ref: "#/definitions/refresh_strategy",
+          description: "Default refresh strategy for all tasks (default: 'data-changed')"
+        }
+      },
+      additionalProperties: false,
+      if: {
+        properties: { completion: { const: "goal-reached" } }
+      },
+      then: {
+        required: ["completion", "goal"]
+      }
+    },
+    task: {
+      type: "object",
+      required: ["provides"],
+      properties: {
+        requires: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tokens this task needs to become eligible"
+        },
+        provides: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tokens this task produces on successful completion"
+        },
+        on: {
+          type: "object",
+          description: "Conditional provides based on handler result key",
+          additionalProperties: {
+            type: "array",
+            items: { type: "string" }
+          }
+        },
+        on_failure: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tokens to inject when this task fails"
+        },
+        method: {
+          type: "string",
+          description: "Task execution method (informational \u2014 driver concern)"
+        },
+        config: {
+          type: "object",
+          description: "Arbitrary task configuration (driver concern)"
+        },
+        priority: {
+          type: "number",
+          description: "Higher = preferred in conflict resolution"
+        },
+        estimatedDuration: {
+          type: "number",
+          minimum: 0,
+          description: "Estimated duration in ms (used by duration-first strategy)"
+        },
+        estimatedCost: {
+          type: "number",
+          minimum: 0,
+          description: "Estimated cost (used by cost-optimized strategy)"
+        },
+        estimatedResources: {
+          type: "object",
+          additionalProperties: { type: "number" },
+          description: "Resource requirements (used by resource-aware strategy)"
+        },
+        retry: {
+          $ref: "#/definitions/task_retry"
+        },
+        refreshStrategy: {
+          $ref: "#/definitions/refresh_strategy",
+          description: "Task-level refresh strategy (overrides settings default)"
+        },
+        refreshInterval: {
+          type: "number",
+          minimum: 0,
+          description: "Interval in seconds for time-based refresh strategy"
+        },
+        maxExecutions: {
+          type: "integer",
+          minimum: 1,
+          description: "Maximum number of times this task can execute"
+        },
+        circuit_breaker: {
+          $ref: "#/definitions/task_circuit_breaker"
+        },
+        description: {
+          type: "string",
+          description: "Human-readable description"
+        },
+        inference: {
+          $ref: "#/definitions/inference_hints"
+        }
+      },
+      additionalProperties: false
+    },
+    task_retry: {
+      type: "object",
+      required: ["max_attempts"],
+      properties: {
+        max_attempts: {
+          type: "integer",
+          minimum: 1,
+          description: "Maximum retry attempts"
+        },
+        delay_ms: {
+          type: "integer",
+          minimum: 0,
+          description: "Delay between retries in ms"
+        },
+        backoff_multiplier: {
+          type: "number",
+          minimum: 1,
+          description: "Backoff multiplier (e.g., 2 for exponential)"
+        }
+      },
+      additionalProperties: false
+    },
+    refresh_strategy: {
+      type: "string",
+      enum: ["data-changed", "epoch-changed", "time-based", "manual", "once"],
+      description: "Strategy for determining when a completed task should re-run"
+    },
+    task_circuit_breaker: {
+      type: "object",
+      required: ["max_executions", "on_break"],
+      properties: {
+        max_executions: {
+          type: "integer",
+          minimum: 1,
+          description: "Max executions before breaker trips"
+        },
+        on_break: {
+          type: "array",
+          items: { type: "string" },
+          minItems: 1,
+          description: "Tokens to inject when breaker trips"
+        }
+      },
+      additionalProperties: false
+    },
+    inference_hints: {
+      type: "object",
+      description: "LLM inference hints \u2014 opt-in metadata for AI-assisted completion detection",
+      properties: {
+        criteria: {
+          type: "string",
+          description: "Human-readable completion criteria"
+        },
+        keywords: {
+          type: "array",
+          items: { type: "string" },
+          description: "Keywords to help the LLM understand the domain"
+        },
+        suggestedChecks: {
+          type: "array",
+          items: { type: "string" },
+          description: "Suggested checks for verification"
+        },
+        autoDetectable: {
+          type: "boolean",
+          description: "Whether the LLM should attempt to auto-detect completion (default: false)"
+        }
+      },
+      additionalProperties: false
+    }
+  }
+};
+
+// src/event-graph/schema-validator.ts
+var import_ajv2 = __toESM(require_ajv());
+var _compiled2 = null;
+function getValidator2() {
+  if (_compiled2) return _compiled2;
+  const ajv = new import_ajv2.default({ allErrors: true });
+  addFormats(ajv);
+  _compiled2 = ajv.compile(event_graph_schema_default);
+  return _compiled2;
+}
+function validateGraphSchema(config) {
+  const validate = getValidator2();
+  const valid = validate(config);
+  if (valid) return { ok: true, errors: [] };
+  const errors = (validate.errors ?? []).map((e) => {
+    const path = e.instancePath || "/";
+    return `${path}: ${e.message ?? "unknown error"}`;
+  });
+  return { ok: false, errors };
+}
+
 // src/stores/localStorage.ts
 var LocalStorageStore = class {
   prefix;
@@ -8747,7 +9251,7 @@ function applyEvent(live, event) {
       newState = applyTaskStart(state, event.taskName);
       break;
     case "task-completed":
-      newState = applyTaskCompletion(state, config, event.taskName, event.result);
+      newState = applyTaskCompletion(state, config, event.taskName, event.result, event.dataHash);
       break;
     case "task-failed":
       newState = applyTaskFailure(state, config, event.taskName, event.error);
@@ -8770,6 +9274,9 @@ function applyEvent(live, event) {
   }
   return { config, state: newState };
 }
+function applyEvents(live, events) {
+  return events.reduce((current, event) => applyEvent(current, event), live);
+}
 function addNode(live, name, taskConfig) {
   if (live.config.tasks[name]) return live;
   return {
@@ -9014,38 +9521,84 @@ function schedule(live) {
   const blocked = [];
   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 && taskState && taskState.executionCount >= taskConfig.circuit_breaker.max_executions) {
-        continue;
-      }
-      if (taskState?.status === TASK_STATUS.COMPLETED) {
-        const requires2 = getRequires(taskConfig);
-        if (requires2.length > 0) {
-          const hasRefreshed = 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;
+    const strategy = getRefreshStrategy(taskConfig, config.settings);
+    const rerunnable = strategy !== "once";
+    if (taskState?.status === TASK_STATUS.RUNNING || isNonActiveTask(taskState)) {
+      continue;
+    }
+    const maxExec = getMaxExecutions(taskConfig);
+    if (maxExec !== void 0 && taskState && taskState.executionCount >= maxExec) {
+      continue;
+    }
+    if (taskConfig.circuit_breaker && taskState && taskState.executionCount >= taskConfig.circuit_breaker.max_executions) {
+      continue;
+    }
+    if (!rerunnable && taskState?.status === TASK_STATUS.COMPLETED) {
+      continue;
+    }
+    if (rerunnable && taskState?.status === TASK_STATUS.COMPLETED) {
+      const requires2 = getRequires(taskConfig);
+      let shouldSkip = false;
+      switch (strategy) {
+        case "data-changed": {
+          if (requires2.length > 0) {
+            const hasChangedData = requires2.some((req) => {
+              for (const [otherName, otherConfig] of Object.entries(graphTasks)) {
+                if (getProvides(otherConfig).includes(req)) {
+                  const otherState = state.tasks[otherName];
+                  if (!otherState) continue;
+                  const consumed = taskState.lastConsumedHashes?.[req];
+                  if (otherState.lastDataHash == null) {
+                    return otherState.executionCount > taskState.lastEpoch;
+                  }
+                  return otherState.lastDataHash !== consumed;
+                }
               }
-            }
-            return false;
-          });
-          if (!hasRefreshed) continue;
-        } else {
-          continue;
+              return false;
+            });
+            if (!hasChangedData) shouldSkip = true;
+          } else {
+            shouldSkip = true;
+          }
+          break;
         }
+        case "epoch-changed": {
+          if (requires2.length > 0) {
+            const hasRefreshed = 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 (!hasRefreshed) shouldSkip = true;
+          } else {
+            shouldSkip = true;
+          }
+          break;
+        }
+        case "time-based": {
+          const interval = taskConfig.refreshInterval ?? 0;
+          if (interval <= 0) {
+            shouldSkip = true;
+            break;
+          }
+          const completedAt = taskState.completedAt;
+          if (!completedAt) {
+            shouldSkip = true;
+            break;
+          }
+          const elapsedSec = (Date.now() - Date.parse(completedAt)) / 1e3;
+          if (elapsedSec < interval) shouldSkip = true;
+          break;
+        }
+        case "manual":
+          shouldSkip = true;
+          break;
       }
+      if (shouldSkip) continue;
     }
     const requires = getRequires(taskConfig);
     if (requires.length === 0) {
@@ -9440,6 +9993,300 @@ function getDownstream(live, nodeName) {
   }));
   return { nodeName, nodes, tokens: [...tokenSet] };
 }
+var MemoryJournal = class {
+  buffer = [];
+  append(event) {
+    this.buffer.push(event);
+  }
+  drain() {
+    const events = this.buffer;
+    this.buffer = [];
+    return events;
+  }
+  get size() {
+    return this.buffer.length;
+  }
+};
+var FileJournal = class {
+  constructor(path) {
+    this.path = path;
+    if (!existsSync(path)) {
+      writeFileSync(path, "", "utf-8");
+    }
+  }
+  path;
+  pending = 0;
+  append(event) {
+    appendFileSync(this.path, JSON.stringify(event) + "\n", "utf-8");
+    this.pending++;
+  }
+  drain() {
+    const content = readFileSync(this.path, "utf-8").trim();
+    writeFileSync(this.path, "", "utf-8");
+    this.pending = 0;
+    if (!content) return [];
+    return content.split("\n").map((line) => JSON.parse(line));
+  }
+  get size() {
+    try {
+      const content = readFileSync(this.path, "utf-8").trim();
+      if (!content) return 0;
+      return content.split("\n").length;
+    } catch {
+      return this.pending;
+    }
+  }
+};
+
+// src/continuous-event-graph/reactive.ts
+function createReactiveGraph(config, options, executionId) {
+  const {
+    handlers: initialHandlers,
+    maxDispatchRetries = 3,
+    defaultTimeoutMs = 3e4,
+    journal = new MemoryJournal(),
+    onDispatchFailed,
+    onAbandoned,
+    onDrain
+  } = options;
+  let live = createLiveGraph(config, executionId);
+  let disposed = false;
+  const handlers = new Map(Object.entries(initialHandlers));
+  const dispatched = /* @__PURE__ */ new Map();
+  const timeoutTimers = /* @__PURE__ */ new Map();
+  let draining = false;
+  let drainQueued = false;
+  function drain() {
+    if (disposed) return;
+    if (draining) {
+      drainQueued = true;
+      return;
+    }
+    draining = true;
+    try {
+      do {
+        drainQueued = false;
+        drainOnce();
+      } while (drainQueued);
+    } finally {
+      draining = false;
+    }
+  }
+  function drainOnce() {
+    sweepTimeouts();
+    const events = journal.drain();
+    for (const event of events) {
+      if (event.type === "task-completed" || event.type === "task-failed") {
+        const taskName = event.taskName;
+        dispatched.delete(taskName);
+        clearTimeout(timeoutTimers.get(taskName));
+        timeoutTimers.delete(taskName);
+      }
+    }
+    if (events.length > 0) {
+      live = applyEvents(live, events);
+    }
+    const result = schedule(live);
+    if (onDrain && events.length > 0) {
+      onDrain(events, live, result);
+    }
+    for (const taskName of result.eligible) {
+      if (dispatched.has(taskName)) continue;
+      dispatchTask(taskName);
+    }
+    for (const [taskName, entry] of dispatched) {
+      if (entry.status === "retry-queued") {
+        dispatchTask(taskName);
+      }
+    }
+  }
+  function dispatchTask(taskName) {
+    const handler = handlers.get(taskName);
+    if (!handler) {
+      journal.append({
+        type: "task-failed",
+        taskName,
+        error: `No handler registered for task "${taskName}"`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      drainQueued = true;
+      return;
+    }
+    const existing = dispatched.get(taskName);
+    const attempt = existing ? existing.dispatchAttempts + 1 : 1;
+    if (attempt > maxDispatchRetries) {
+      dispatched.set(taskName, {
+        status: "abandoned",
+        dispatchedAt: existing?.dispatchedAt ?? Date.now(),
+        dispatchAttempts: attempt - 1,
+        lastError: existing?.lastError
+      });
+      onAbandoned?.(taskName);
+      journal.append({
+        type: "task-failed",
+        taskName,
+        error: `dispatch-abandoned: handler unreachable after ${attempt - 1} attempts${existing?.lastError ? ` (${existing.lastError})` : ""}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      drainQueued = true;
+      return;
+    }
+    dispatched.set(taskName, {
+      status: "initiated",
+      dispatchedAt: Date.now(),
+      dispatchAttempts: attempt
+    });
+    journal.append({
+      type: "task-started",
+      taskName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (defaultTimeoutMs > 0) {
+      const timer = setTimeout(() => {
+        if (disposed) return;
+        const entry = dispatched.get(taskName);
+        if (entry?.status === "initiated") {
+          dispatched.set(taskName, {
+            ...entry,
+            status: "timed-out"
+          });
+          dispatched.set(taskName, {
+            ...entry,
+            status: entry.dispatchAttempts >= maxDispatchRetries ? "abandoned" : "retry-queued"
+          });
+          if (entry.dispatchAttempts >= maxDispatchRetries) {
+            onAbandoned?.(taskName);
+            journal.append({
+              type: "task-failed",
+              taskName,
+              error: `dispatch-timeout: no callback after ${defaultTimeoutMs}ms (${entry.dispatchAttempts} attempts)`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          drain();
+        }
+      }, defaultTimeoutMs);
+      timeoutTimers.set(taskName, timer);
+    }
+    const ctx = {
+      taskName,
+      live,
+      config: live.config.tasks[taskName]
+    };
+    try {
+      const promise = handler(ctx);
+      promise.then(
+        (handlerResult) => {
+          if (disposed) return;
+          clearTimeout(timeoutTimers.get(taskName));
+          timeoutTimers.delete(taskName);
+          journal.append({
+            type: "task-completed",
+            taskName,
+            result: handlerResult.result,
+            data: handlerResult.data,
+            dataHash: handlerResult.dataHash,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          drain();
+        },
+        (error) => {
+          if (disposed) return;
+          clearTimeout(timeoutTimers.get(taskName));
+          timeoutTimers.delete(taskName);
+          journal.append({
+            type: "task-failed",
+            taskName,
+            error: error.message ?? String(error),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          drain();
+        }
+      );
+    } catch (syncError) {
+      const err = syncError instanceof Error ? syncError : new Error(String(syncError));
+      dispatched.set(taskName, {
+        status: "dispatch-failed",
+        dispatchedAt: Date.now(),
+        dispatchAttempts: attempt,
+        lastError: err.message
+      });
+      onDispatchFailed?.(taskName, err, attempt);
+      dispatched.set(taskName, {
+        ...dispatched.get(taskName),
+        status: "retry-queued"
+      });
+      drainQueued = true;
+    }
+  }
+  function sweepTimeouts() {
+    const now = Date.now();
+    for (const [taskName, entry] of dispatched) {
+      if (entry.status !== "initiated") continue;
+      if (defaultTimeoutMs <= 0) continue;
+      if (now - entry.dispatchedAt >= defaultTimeoutMs) {
+        dispatched.set(taskName, {
+          ...entry,
+          status: entry.dispatchAttempts >= maxDispatchRetries ? "abandoned" : "retry-queued"
+        });
+        if (entry.dispatchAttempts >= maxDispatchRetries) {
+          onAbandoned?.(taskName);
+          journal.append({
+            type: "task-failed",
+            taskName,
+            error: `dispatch-timeout: no callback after ${defaultTimeoutMs}ms (${entry.dispatchAttempts} attempts)`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        clearTimeout(timeoutTimers.get(taskName));
+        timeoutTimers.delete(taskName);
+      }
+    }
+  }
+  return {
+    push(event) {
+      if (disposed) return;
+      live = applyEvent(live, event);
+      drain();
+    },
+    pushAll(events) {
+      if (disposed) return;
+      if (events.length === 0) return;
+      live = applyEvents(live, events);
+      drain();
+    },
+    addNode(name, taskConfig, handler) {
+      if (disposed) return;
+      live = addNode(live, name, taskConfig);
+      handlers.set(name, handler);
+      drain();
+    },
+    removeNode(name) {
+      if (disposed) return;
+      live = removeNode(live, name);
+      handlers.delete(name);
+      dispatched.delete(name);
+      clearTimeout(timeoutTimers.get(name));
+      timeoutTimers.delete(name);
+    },
+    getState() {
+      return live;
+    },
+    getSchedule() {
+      return schedule(live);
+    },
+    getDispatchState() {
+      return dispatched;
+    },
+    dispose() {
+      disposed = true;
+      for (const timer of timeoutTimers.values()) {
+        clearTimeout(timer);
+      }
+      timeoutTimers.clear();
+    }
+  };
+}
 
 // src/inference/core.ts
 var DEFAULT_THRESHOLD = 0.5;
@@ -10005,17 +10852,17 @@ var live_cards_schema_default = {
 };
 
 // src/card-compute/schema-validator.ts
-var import_ajv = __toESM(require_ajv());
-var _compiled = null;
-function getValidator() {
-  if (_compiled) return _compiled;
-  const ajv = new import_ajv.default({ allErrors: true });
+var import_ajv3 = __toESM(require_ajv());
+var _compiled3 = null;
+function getValidator3() {
+  if (_compiled3) return _compiled3;
+  const ajv = new import_ajv3.default({ allErrors: true });
   addFormats(ajv);
-  _compiled = ajv.compile(live_cards_schema_default);
-  return _compiled;
+  _compiled3 = ajv.compile(live_cards_schema_default);
+  return _compiled3;
 }
 function validateLiveCardSchema(node) {
-  const validate = getValidator();
+  const validate = getValidator3();
   const valid = validate(node);
   if (valid) return { ok: true, errors: [] };
   const errors = (validate.errors ?? []).map((e) => {
@@ -10472,6 +11319,6 @@ var CardCompute = {
   }
 };
 
-export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, CardCompute, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, addNode, addProvides, addRequires, apply, applyAll, applyEvent, applyInferences, applyStepResult, batch, buildInferencePrompt, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createCliAdapter, createDefaultTaskState, createStepMachine as createEngine, createHttpAdapter, createInitialExecutionState, createInitialState, createLiveGraph, createStepMachine, detectStuckState, disableNode, drainTokens, enableNode, exportGraphConfig, exportGraphConfigToFile, extractReturnData, flowToMermaid, getAllTasks, getCandidateTasks, getDownstream, getNode, getProvides, getRequires, getTask, getUnreachableNodes, getUnreachableTokens, getUpstream, graphToMermaid, hasTask, inferAndApply, inferCompletions, injectTokens, inspect, isExecutionComplete, isNonActiveTask, isRepeatableTask, isTaskCompleted, isTaskRunning, loadGraphConfig, loadStepFlow, next, planExecution, removeNode, removeProvides, removeRequires, resetNode, resolveConfigTemplates, resolveVariables, restore, schedule, snapshot, validateGraph, validateGraphConfig, validateLiveCardSchema, validateStepFlowConfig };
+export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, CardCompute, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileJournal, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryJournal, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, addNode, addProvides, addRequires, apply, applyAll, applyEvent, applyEvents, applyInferences, applyStepResult, batch, buildInferencePrompt, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createCliAdapter, createDefaultTaskState, createStepMachine as createEngine, createHttpAdapter, createInitialExecutionState, createInitialState, createLiveGraph, createReactiveGraph, createStepMachine, detectStuckState, disableNode, drainTokens, enableNode, exportGraphConfig, exportGraphConfigToFile, extractReturnData, flowToMermaid, getAllTasks, getCandidateTasks, getDownstream, getMaxExecutions, getNode, getProvides, getRefreshStrategy, getRequires, getTask, getUnreachableNodes, getUnreachableTokens, getUpstream, graphToMermaid, hasTask, inferAndApply, inferCompletions, injectTokens, inspect, isExecutionComplete, isNonActiveTask, isRerunnable, isTaskCompleted, isTaskRunning, loadGraphConfig, loadStepFlow, next, planExecution, removeNode, removeProvides, removeRequires, resetNode, resolveConfigTemplates, resolveVariables, restore, schedule, snapshot, validateFlowSchema, validateGraph, validateGraphConfig, validateGraphSchema, validateLiveCardSchema, validateStepFlowConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map