yaml-flow 2.8.0 → 3.0.0

package/dist/index.cjs

@@ -1,7 +1,8 @@
 'use strict';
 
-var child_process = require('child_process');
 var addFormats = require('ajv-formats');
+var fs = require('fs');
+var child_process = require('child_process');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -3917,7 +3918,7 @@ var require_core = __commonJS({
         uriResolver
       };
     }
-    var Ajv2 = class {
+    var Ajv4 = class {
       constructor(opts = {}) {
         this.schemas = {};
         this.refs = {};
@@ -4287,9 +4288,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;
@@ -6360,7 +6361,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));
@@ -6379,11 +6380,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;
@@ -6917,6 +6918,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__default.default(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",
@@ -6993,15 +7176,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();
@@ -7433,48 +7615,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;
@@ -7558,7 +7780,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) {
@@ -7570,6 +7792,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",
@@ -7577,11 +7812,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,
@@ -7670,7 +7904,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":
@@ -8360,6 +8594,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__default.default(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;
@@ -8753,7 +9257,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);
@@ -8776,6 +9280,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 {
@@ -9020,38 +9527,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) {
@@ -9446,6 +9999,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 (!fs.existsSync(path)) {
+      fs.writeFileSync(path, "", "utf-8");
+    }
+  }
+  path;
+  pending = 0;
+  append(event) {
+    fs.appendFileSync(this.path, JSON.stringify(event) + "\n", "utf-8");
+    this.pending++;
+  }
+  drain() {
+    const content = fs.readFileSync(this.path, "utf-8").trim();
+    fs.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 = fs.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;
@@ -10011,17 +10858,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__default.default(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) => {
@@ -10484,9 +11331,11 @@ exports.CardCompute = CardCompute;
 exports.DEFAULTS = DEFAULTS;
 exports.EXECUTION_MODES = EXECUTION_MODES;
 exports.EXECUTION_STATUS = EXECUTION_STATUS;
+exports.FileJournal = FileJournal;
 exports.FileStore = FileStore;
 exports.FlowEngine = StepMachine;
 exports.LocalStorageStore = LocalStorageStore;
+exports.MemoryJournal = MemoryJournal;
 exports.MemoryStore = MemoryStore;
 exports.StepMachine = StepMachine;
 exports.TASK_STATUS = TASK_STATUS;
@@ -10497,6 +11346,7 @@ exports.addRequires = addRequires;
 exports.apply = apply;
 exports.applyAll = applyAll;
 exports.applyEvent = applyEvent;
+exports.applyEvents = applyEvents;
 exports.applyInferences = applyInferences;
 exports.applyStepResult = applyStepResult;
 exports.batch = batch;
@@ -10511,6 +11361,7 @@ exports.createHttpAdapter = createHttpAdapter;
 exports.createInitialExecutionState = createInitialExecutionState;
 exports.createInitialState = createInitialState;
 exports.createLiveGraph = createLiveGraph;
+exports.createReactiveGraph = createReactiveGraph;
 exports.createStepMachine = createStepMachine;
 exports.detectStuckState = detectStuckState;
 exports.disableNode = disableNode;
@@ -10523,8 +11374,10 @@ exports.flowToMermaid = flowToMermaid;
 exports.getAllTasks = getAllTasks;
 exports.getCandidateTasks = getCandidateTasks;
 exports.getDownstream = getDownstream;
+exports.getMaxExecutions = getMaxExecutions;
 exports.getNode = getNode;
 exports.getProvides = getProvides;
+exports.getRefreshStrategy = getRefreshStrategy;
 exports.getRequires = getRequires;
 exports.getTask = getTask;
 exports.getUnreachableNodes = getUnreachableNodes;
@@ -10538,7 +11391,7 @@ exports.injectTokens = injectTokens;
 exports.inspect = inspect;
 exports.isExecutionComplete = isExecutionComplete;
 exports.isNonActiveTask = isNonActiveTask;
-exports.isRepeatableTask = isRepeatableTask;
+exports.isRerunnable = isRerunnable;
 exports.isTaskCompleted = isTaskCompleted;
 exports.isTaskRunning = isTaskRunning;
 exports.loadGraphConfig = loadGraphConfig;
@@ -10554,8 +11407,10 @@ exports.resolveVariables = resolveVariables;
 exports.restore = restore;
 exports.schedule = schedule;
 exports.snapshot = snapshot;
+exports.validateFlowSchema = validateFlowSchema;
 exports.validateGraph = validateGraph;
 exports.validateGraphConfig = validateGraphConfig;
+exports.validateGraphSchema = validateGraphSchema;
 exports.validateLiveCardSchema = validateLiveCardSchema;
 exports.validateStepFlowConfig = validateStepFlowConfig;
 //# sourceMappingURL=index.cjs.map