yaml-flow 1.0.0 → 2.1.0

package/dist/event-graph/index.js

@@ -0,0 +1,855 @@
+// 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 addKeyToProvides(task, key) {
+  const current = getProvides(task);
+  if (current.includes(key)) return task;
+  return { ...task, provides: [...current, key] };
+}
+function removeKeyFromProvides(task, key) {
+  const current = getProvides(task);
+  return { ...task, provides: current.filter((p) => p !== key) };
+}
+function addKeyToRequires(task, key) {
+  const current = getRequires(task);
+  if (current.includes(key)) return task;
+  return { ...task, requires: [...current, key] };
+}
+function removeKeyFromRequires(task, key) {
+  const current = getRequires(task);
+  return { ...task, requires: current.filter((r) => r !== key) };
+}
+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()
+  };
+}
+
+export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, TASK_STATUS, addDynamicTask, addKeyToProvides, addKeyToRequires, apply, applyAll, applyTaskCompletion, applyTaskFailure, applyTaskProgress, applyTaskStart, computeAvailableOutputs, createDefaultTaskState, createInitialExecutionState, detectStuckState, getAllTasks, getCandidateTasks, getNonConflictingTasks, getProvides, getRepeatableMax, getRequires, getTask, groupTasksByProvides, hasOutputConflict, hasTask, isExecutionComplete, isNonActiveTask, isRepeatableTask, isTaskCompleted, isTaskRunning, next, removeKeyFromProvides, removeKeyFromRequires, selectBestAlternative, selectRandomTasks };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map