yaml-flow 2.2.0 → 2.4.0

package/dist/index.cjs

@@ -1735,6 +1735,213 @@ ${serialized}`;
   return String(obj);
 }
 
+// src/event-graph/validate.ts
+function buildProducerMap2(tasks) {
+  const map = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    for (const token of getProvides(config)) {
+      if (!map[token]) map[token] = [];
+      map[token].push(name);
+    }
+    if (config.on) {
+      for (const tokens of Object.values(config.on)) {
+        for (const token of tokens) {
+          if (!map[token]) map[token] = [];
+          if (!map[token].includes(name)) map[token].push(name);
+        }
+      }
+    }
+    if (config.on_failure) {
+      for (const token of config.on_failure) {
+        if (!map[token]) map[token] = [];
+        if (!map[token].includes(name)) map[token].push(name);
+      }
+    }
+  }
+  return map;
+}
+function buildTaskDeps(tasks, producerMap) {
+  const deps = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    deps[name] = /* @__PURE__ */ new Set();
+    for (const token of getRequires(config)) {
+      for (const producer of producerMap[token] || []) {
+        if (producer !== name) deps[name].add(producer);
+      }
+    }
+  }
+  return deps;
+}
+function detectCycles(taskNames, deps) {
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const color = {};
+  const parent = {};
+  const cycles = [];
+  for (const name of taskNames) {
+    color[name] = WHITE;
+    parent[name] = null;
+  }
+  function dfs(node) {
+    color[node] = GRAY;
+    for (const dep of deps[node] || []) {
+      if (color[dep] === GRAY) {
+        const cycle = [dep];
+        let cur = node;
+        while (cur !== dep) {
+          cycle.push(cur);
+          cur = parent[cur];
+        }
+        cycle.push(dep);
+        cycle.reverse();
+        cycles.push(cycle);
+      } else if (color[dep] === WHITE) {
+        parent[dep] = node;
+        dfs(dep);
+      }
+    }
+    color[node] = BLACK;
+  }
+  for (const name of taskNames) {
+    if (color[name] === WHITE) {
+      dfs(name);
+    }
+  }
+  return cycles;
+}
+function validateGraph(graph) {
+  const issues = [];
+  const tasks = getAllTasks(graph);
+  const taskNames = Object.keys(tasks);
+  if (taskNames.length === 0) {
+    issues.push({
+      severity: "error",
+      code: "EMPTY_GRAPH",
+      message: "Graph has no tasks"
+    });
+    return buildResult(issues);
+  }
+  const producerMap = buildProducerMap2(tasks);
+  const deps = buildTaskDeps(tasks, producerMap);
+  for (const [name, config] of Object.entries(tasks)) {
+    for (const token of getRequires(config)) {
+      if (!producerMap[token]) {
+        issues.push({
+          severity: "error",
+          code: "DANGLING_REQUIRES",
+          message: `Task "${name}" requires token "${token}" but no task produces it`,
+          tasks: [name],
+          tokens: [token]
+        });
+      }
+    }
+  }
+  const cycles = detectCycles(taskNames, deps);
+  for (const cycle of cycles) {
+    issues.push({
+      severity: "error",
+      code: "CIRCULAR_DEPENDENCY",
+      message: `Circular dependency: ${cycle.join(" \u2192 ")}`,
+      tasks: cycle.filter((_t, i) => i < cycle.length - 1)
+      // dedupe last = first
+    });
+  }
+  for (const [name, config] of Object.entries(tasks)) {
+    const req = getRequires(config);
+    const prov = getProvides(config);
+    const self = req.filter((token) => prov.includes(token));
+    if (self.length > 0) {
+      issues.push({
+        severity: "error",
+        code: "SELF_DEPENDENCY",
+        message: `Task "${name}" requires tokens it provides itself: [${self.join(", ")}]`,
+        tasks: [name],
+        tokens: self
+      });
+    }
+  }
+  for (const [token, producers] of Object.entries(producerMap)) {
+    if (producers.length > 1) {
+      issues.push({
+        severity: "warning",
+        code: "PROVIDE_CONFLICT",
+        message: `Token "${token}" is produced by multiple tasks: [${producers.join(", ")}]. This requires a conflict strategy.`,
+        tasks: producers,
+        tokens: [token]
+      });
+    }
+  }
+  if (graph.settings.completion === "goal-reached" && graph.settings.goal) {
+    for (const goalToken of graph.settings.goal) {
+      if (!producerMap[goalToken]) {
+        issues.push({
+          severity: "error",
+          code: "UNREACHABLE_GOAL",
+          message: `Goal token "${goalToken}" cannot be produced by any task`,
+          tokens: [goalToken]
+        });
+      }
+    }
+  }
+  if (taskNames.length > 1) {
+    for (const [name, config] of Object.entries(tasks)) {
+      const prov = getProvides(config);
+      const onProv = config.on ? Object.values(config.on).flat() : [];
+      const failProv = config.on_failure || [];
+      if (prov.length === 0 && onProv.length === 0 && failProv.length === 0) {
+        issues.push({
+          severity: "warning",
+          code: "DEAD_END_TASK",
+          message: `Task "${name}" has no provides \u2014 it cannot unblock any downstream task`,
+          tasks: [name]
+        });
+      }
+    }
+  }
+  const allRequired = /* @__PURE__ */ new Set();
+  for (const config of Object.values(tasks)) {
+    for (const token of getRequires(config)) {
+      allRequired.add(token);
+    }
+  }
+  for (const [name, config] of Object.entries(tasks)) {
+    const req = getRequires(config);
+    const prov = getProvides(config);
+    const onProv = config.on ? Object.values(config.on).flat() : [];
+    const allProv = [...prov, ...onProv];
+    const isEntryPoint = req.length === 0;
+    const hasDownstream = allProv.some((token) => allRequired.has(token));
+    if (isEntryPoint && !hasDownstream && taskNames.length > 1) {
+      const isGoalRelevant = graph.settings.completion === "goal-reached" && graph.settings.goal?.some((g) => allProv.includes(g));
+      if (!isGoalRelevant) {
+        issues.push({
+          severity: "info",
+          code: "ISOLATED_TASK",
+          message: `Task "${name}" is disconnected \u2014 it has no requires and nothing depends on its provides`,
+          tasks: [name]
+        });
+      }
+    }
+  }
+  if (graph.settings.completion === "goal-reached" && !graph.settings.goal) {
+    issues.push({
+      severity: "error",
+      code: "MISSING_GOAL",
+      message: 'Completion strategy is "goal-reached" but no goal tokens are defined'
+    });
+  }
+  return buildResult(issues);
+}
+function buildResult(issues) {
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  return {
+    valid: errors.length === 0,
+    issues,
+    errors,
+    warnings
+  };
+}
+
 // src/stores/localStorage.ts
 var LocalStorageStore = class {
   prefix;
@@ -2095,6 +2302,733 @@ function resolveConfigTemplates(config) {
   return result;
 }
 
+// src/continuous-event-graph/core.ts
+function createLiveGraph(config, executionId) {
+  const id = executionId ?? `live-${Date.now()}`;
+  const tasks = {};
+  for (const taskName of Object.keys(config.tasks)) {
+    tasks[taskName] = createDefaultTaskState3();
+  }
+  const state = {
+    status: "running",
+    tasks,
+    availableOutputs: [],
+    stuckDetection: { is_stuck: false, stuck_description: null, outputs_unresolvable: [], tasks_blocked: [] },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    executionId: id,
+    executionConfig: {
+      executionMode: config.settings.execution_mode ?? "eligibility-mode",
+      conflictStrategy: config.settings.conflict_strategy ?? "alphabetical",
+      completionStrategy: config.settings.completion
+    }
+  };
+  return { config, state };
+}
+function applyEvent(live, event) {
+  const { config, state } = live;
+  if ("executionId" in event && event.executionId && event.executionId !== state.executionId) {
+    return live;
+  }
+  let newState;
+  switch (event.type) {
+    case "task-started":
+      newState = applyTaskStart(state, event.taskName);
+      break;
+    case "task-completed":
+      newState = applyTaskCompletion(state, config, event.taskName, event.result);
+      break;
+    case "task-failed":
+      newState = applyTaskFailure(state, config, event.taskName, event.error);
+      break;
+    case "task-progress":
+      newState = applyTaskProgress(state, event.taskName, event.message, event.progress);
+      break;
+    case "inject-tokens":
+      newState = {
+        ...state,
+        availableOutputs: [.../* @__PURE__ */ new Set([...state.availableOutputs, ...event.tokens])],
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      break;
+    case "agent-action":
+      newState = applyAgentAction2(state, event.action);
+      break;
+    default:
+      return live;
+  }
+  return { config, state: newState };
+}
+function addNode(live, name, taskConfig) {
+  if (live.config.tasks[name]) return live;
+  return {
+    config: {
+      ...live.config,
+      tasks: { ...live.config.tasks, [name]: taskConfig }
+    },
+    state: {
+      ...live.state,
+      tasks: { ...live.state.tasks, [name]: createDefaultTaskState3() },
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function removeNode(live, name) {
+  if (!live.config.tasks[name]) return live;
+  const { [name]: _removedConfig, ...remainingTasks } = live.config.tasks;
+  const { [name]: _removedState, ...remainingStates } = live.state.tasks;
+  return {
+    config: {
+      ...live.config,
+      tasks: remainingTasks
+    },
+    state: {
+      ...live.state,
+      tasks: remainingStates,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function addRequires(live, nodeName, tokens) {
+  const task = live.config.tasks[nodeName];
+  if (!task) return live;
+  const current = getRequires(task);
+  const toAdd = tokens.filter((t) => !current.includes(t));
+  if (toAdd.length === 0) return live;
+  return {
+    config: {
+      ...live.config,
+      tasks: {
+        ...live.config.tasks,
+        [nodeName]: { ...task, requires: [...current, ...toAdd] }
+      }
+    },
+    state: live.state
+  };
+}
+function removeRequires(live, nodeName, tokens) {
+  const task = live.config.tasks[nodeName];
+  if (!task) return live;
+  const current = getRequires(task);
+  const remaining = current.filter((t) => !tokens.includes(t));
+  if (remaining.length === current.length) return live;
+  return {
+    config: {
+      ...live.config,
+      tasks: {
+        ...live.config.tasks,
+        [nodeName]: { ...task, requires: remaining }
+      }
+    },
+    state: live.state
+  };
+}
+function addProvides(live, nodeName, tokens) {
+  const task = live.config.tasks[nodeName];
+  if (!task) return live;
+  const current = getProvides(task);
+  const toAdd = tokens.filter((t) => !current.includes(t));
+  if (toAdd.length === 0) return live;
+  return {
+    config: {
+      ...live.config,
+      tasks: {
+        ...live.config.tasks,
+        [nodeName]: { ...task, provides: [...current, ...toAdd] }
+      }
+    },
+    state: live.state
+  };
+}
+function removeProvides(live, nodeName, tokens) {
+  const task = live.config.tasks[nodeName];
+  if (!task) return live;
+  const current = getProvides(task);
+  const remaining = current.filter((t) => !tokens.includes(t));
+  if (remaining.length === current.length) return live;
+  return {
+    config: {
+      ...live.config,
+      tasks: {
+        ...live.config.tasks,
+        [nodeName]: { ...task, provides: remaining }
+      }
+    },
+    state: live.state
+  };
+}
+function injectTokens(live, tokens) {
+  return applyEvent(live, {
+    type: "inject-tokens",
+    tokens,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function drainTokens(live, tokens) {
+  const toRemove = new Set(tokens);
+  const remaining = live.state.availableOutputs.filter((t) => !toRemove.has(t));
+  if (remaining.length === live.state.availableOutputs.length) return live;
+  return {
+    config: live.config,
+    state: {
+      ...live.state,
+      availableOutputs: remaining,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function resetNode(live, name) {
+  if (!live.config.tasks[name] || !live.state.tasks[name]) return live;
+  return {
+    config: live.config,
+    state: {
+      ...live.state,
+      tasks: {
+        ...live.state.tasks,
+        [name]: createDefaultTaskState3()
+      },
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function disableNode(live, name) {
+  const taskState = live.state.tasks[name];
+  if (!taskState || taskState.status === "inactivated") return live;
+  return {
+    config: live.config,
+    state: {
+      ...live.state,
+      tasks: {
+        ...live.state.tasks,
+        [name]: { ...taskState, status: "inactivated", lastUpdated: (/* @__PURE__ */ new Date()).toISOString() }
+      },
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function enableNode(live, name) {
+  const taskState = live.state.tasks[name];
+  if (!taskState || taskState.status !== "inactivated") return live;
+  return {
+    config: live.config,
+    state: {
+      ...live.state,
+      tasks: {
+        ...live.state.tasks,
+        [name]: { ...taskState, status: "not-started", lastUpdated: (/* @__PURE__ */ new Date()).toISOString() }
+      },
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function getNode(live, name) {
+  const config = live.config.tasks[name];
+  if (!config) return void 0;
+  const state = live.state.tasks[name] ?? createDefaultTaskState3();
+  return { name, config, state };
+}
+function snapshot(live) {
+  return {
+    version: 1,
+    config: live.config,
+    state: live.state,
+    snapshotAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function restore(data) {
+  if (!data || typeof data !== "object") {
+    throw new Error("Invalid snapshot: expected an object");
+  }
+  const snap = data;
+  if (!snap.config || typeof snap.config !== "object") {
+    throw new Error('Invalid snapshot: missing or invalid "config"');
+  }
+  if (!snap.state || typeof snap.state !== "object") {
+    throw new Error('Invalid snapshot: missing or invalid "state"');
+  }
+  const config = snap.config;
+  const state = snap.state;
+  if (!config.settings || typeof config.settings !== "object") {
+    throw new Error("Invalid snapshot: config.settings missing");
+  }
+  if (!config.tasks || typeof config.tasks !== "object") {
+    throw new Error("Invalid snapshot: config.tasks missing");
+  }
+  if (!state.tasks || typeof state.tasks !== "object") {
+    throw new Error("Invalid snapshot: state.tasks missing");
+  }
+  if (!Array.isArray(state.availableOutputs)) {
+    throw new Error("Invalid snapshot: state.availableOutputs must be an array");
+  }
+  return { config, state };
+}
+function createDefaultTaskState3() {
+  return {
+    status: "not-started",
+    executionCount: 0,
+    retryCount: 0,
+    lastEpoch: 0,
+    messages: [],
+    progress: null
+  };
+}
+function applyAgentAction2(state, action) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  switch (action) {
+    case "stop":
+      return { ...state, status: "stopped", lastUpdated: now };
+    case "pause":
+      return { ...state, status: "paused", lastUpdated: now };
+    case "resume":
+      return { ...state, status: "running", lastUpdated: now };
+    default:
+      return state;
+  }
+}
+
+// src/continuous-event-graph/schedule.ts
+function schedule(live) {
+  const { config, state } = live;
+  const graphTasks = getAllTasks(config);
+  const taskNames = Object.keys(graphTasks);
+  if (taskNames.length === 0) {
+    return { eligible: [], pending: [], unresolved: [], blocked: [], conflicts: {} };
+  }
+  const producerMap = buildProducerMap3(graphTasks);
+  const computedOutputs = computeAvailableOutputs(config, state.tasks);
+  const availableOutputs = /* @__PURE__ */ new Set([...computedOutputs, ...state.availableOutputs]);
+  const eligible = [];
+  const pending = [];
+  const unresolved = [];
+  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;
+              }
+            }
+            return false;
+          });
+          if (!hasRefreshed) continue;
+        } else {
+          continue;
+        }
+      }
+    }
+    const requires = getRequires(taskConfig);
+    if (requires.length === 0) {
+      eligible.push(taskName);
+      continue;
+    }
+    const missingTokens = [];
+    const pendingTokens = [];
+    const failedTokenInfo = [];
+    for (const token of requires) {
+      if (availableOutputs.has(token)) continue;
+      const producers = producerMap[token] || [];
+      if (producers.length === 0) {
+        missingTokens.push(token);
+      } else {
+        const allFailed = producers.every((p) => isNonActiveTask(state.tasks[p]));
+        if (allFailed) {
+          failedTokenInfo.push({ token, failedProducer: producers[0] });
+        } else {
+          pendingTokens.push(token);
+        }
+      }
+    }
+    if (missingTokens.length > 0) {
+      unresolved.push({ taskName, missingTokens });
+    } else if (failedTokenInfo.length > 0) {
+      blocked.push({
+        taskName,
+        failedTokens: failedTokenInfo.map((f) => f.token),
+        failedProducers: [...new Set(failedTokenInfo.map((f) => f.failedProducer))]
+      });
+    } else if (pendingTokens.length > 0) {
+      pending.push({ taskName, waitingOn: pendingTokens });
+    } else {
+      eligible.push(taskName);
+    }
+  }
+  const conflicts = {};
+  if (eligible.length > 1) {
+    const outputGroups = groupTasksByProvides(eligible, graphTasks);
+    for (const [outputKey, groupTasks] of Object.entries(outputGroups)) {
+      if (groupTasks.length > 1) {
+        conflicts[outputKey] = groupTasks;
+      }
+    }
+  }
+  return { eligible, pending, unresolved, blocked, conflicts };
+}
+function buildProducerMap3(tasks) {
+  const map = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    for (const token of getProvides(config)) {
+      if (!map[token]) map[token] = [];
+      map[token].push(name);
+    }
+    if (config.on) {
+      for (const tokens of Object.values(config.on)) {
+        for (const token of tokens) {
+          if (!map[token]) map[token] = [];
+          if (!map[token].includes(name)) map[token].push(name);
+        }
+      }
+    }
+    if (config.on_failure) {
+      for (const token of config.on_failure) {
+        if (!map[token]) map[token] = [];
+        if (!map[token].includes(name)) map[token].push(name);
+      }
+    }
+  }
+  return map;
+}
+
+// src/continuous-event-graph/inspect.ts
+function inspect(live) {
+  const { config, state } = live;
+  const graphTasks = getAllTasks(config);
+  const taskNames = Object.keys(graphTasks);
+  let running = 0, completed = 0, failed = 0, waiting = 0, notStarted = 0, disabled = 0;
+  for (const taskName of taskNames) {
+    const ts = state.tasks[taskName];
+    if (!ts || ts.status === TASK_STATUS.NOT_STARTED) {
+      notStarted++;
+    } else {
+      switch (ts.status) {
+        case TASK_STATUS.RUNNING:
+          running++;
+          break;
+        case TASK_STATUS.COMPLETED:
+          completed++;
+          break;
+        case TASK_STATUS.FAILED:
+          failed++;
+          break;
+        case "inactivated":
+          disabled++;
+          break;
+        default:
+          waiting++;
+      }
+    }
+  }
+  const producerMap = {};
+  for (const [name, taskConfig] of Object.entries(graphTasks)) {
+    for (const token of getProvides(taskConfig)) {
+      if (!producerMap[token]) producerMap[token] = [];
+      producerMap[token].push(name);
+    }
+    if (taskConfig.on) {
+      for (const tokens of Object.values(taskConfig.on)) {
+        for (const token of tokens) {
+          if (!producerMap[token]) producerMap[token] = [];
+          if (!producerMap[token].includes(name)) producerMap[token].push(name);
+        }
+      }
+    }
+    if (taskConfig.on_failure) {
+      for (const token of taskConfig.on_failure) {
+        if (!producerMap[token]) producerMap[token] = [];
+        if (!producerMap[token].includes(name)) producerMap[token].push(name);
+      }
+    }
+  }
+  const openDeps = /* @__PURE__ */ new Set();
+  let unresolvedCount = 0;
+  let blockedCount = 0;
+  for (const [taskName, taskConfig] of Object.entries(graphTasks)) {
+    const ts = state.tasks[taskName];
+    if (ts?.status === TASK_STATUS.COMPLETED || ts?.status === TASK_STATUS.RUNNING) continue;
+    let hasOpen = false;
+    let hasBlocked = false;
+    for (const token of getRequires(taskConfig)) {
+      const producers = producerMap[token] || [];
+      if (producers.length === 0) {
+        openDeps.add(token);
+        hasOpen = true;
+      } else {
+        const allFailed = producers.every((p) => {
+          const ps = state.tasks[p];
+          return ps?.status === TASK_STATUS.FAILED || ps?.status === "inactivated";
+        });
+        if (allFailed) hasBlocked = true;
+      }
+    }
+    if (hasOpen) unresolvedCount++;
+    if (hasBlocked && !hasOpen) blockedCount++;
+  }
+  const conflictTokens = [];
+  for (const [token, producers] of Object.entries(producerMap)) {
+    if (producers.length > 1) conflictTokens.push(token);
+  }
+  const deps = buildTaskDeps2(graphTasks, producerMap);
+  const cycles = detectCycles2(taskNames, deps);
+  return {
+    totalNodes: taskNames.length,
+    running,
+    completed,
+    failed,
+    waiting,
+    notStarted,
+    disabled,
+    unresolvedCount,
+    blockedCount,
+    openDependencies: [...openDeps],
+    cycles,
+    conflictTokens
+  };
+}
+function buildTaskDeps2(tasks, producerMap) {
+  const deps = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    deps[name] = /* @__PURE__ */ new Set();
+    for (const token of getRequires(config)) {
+      for (const producer of producerMap[token] || []) {
+        if (producer !== name) deps[name].add(producer);
+      }
+    }
+  }
+  return deps;
+}
+function detectCycles2(taskNames, deps) {
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const color = {};
+  const parent = {};
+  const cycles = [];
+  for (const name of taskNames) {
+    color[name] = WHITE;
+    parent[name] = null;
+  }
+  function dfs(node) {
+    color[node] = GRAY;
+    for (const dep of deps[node] || []) {
+      if (color[dep] === GRAY) {
+        const cycle = [dep];
+        let cur = node;
+        while (cur !== dep) {
+          cycle.push(cur);
+          cur = parent[cur];
+        }
+        cycle.push(dep);
+        cycle.reverse();
+        cycles.push(cycle);
+      } else if (color[dep] === WHITE) {
+        parent[dep] = node;
+        dfs(dep);
+      }
+    }
+    color[node] = BLACK;
+  }
+  for (const name of taskNames) {
+    if (color[name] === WHITE) dfs(name);
+  }
+  return cycles;
+}
+function buildProducerMap4(tasks) {
+  const map = {};
+  for (const [name, config] of Object.entries(tasks)) {
+    for (const token of getProvides(config)) {
+      if (!map[token]) map[token] = [];
+      map[token].push(name);
+    }
+    if (config.on) {
+      for (const tokens of Object.values(config.on)) {
+        for (const token of tokens) {
+          if (!map[token]) map[token] = [];
+          if (!map[token].includes(name)) map[token].push(name);
+        }
+      }
+    }
+    if (config.on_failure) {
+      for (const token of config.on_failure) {
+        if (!map[token]) map[token] = [];
+        if (!map[token].includes(name)) map[token].push(name);
+      }
+    }
+  }
+  return map;
+}
+function getUnreachableTokens(live) {
+  const { config, state } = live;
+  const graphTasks = getAllTasks(config);
+  const producerMap = buildProducerMap4(graphTasks);
+  const available = /* @__PURE__ */ new Set([...state.availableOutputs]);
+  for (const [taskName, taskState] of Object.entries(state.tasks)) {
+    if (taskState.status === "completed") {
+      const tc = graphTasks[taskName];
+      if (tc) getProvides(tc).forEach((t) => available.add(t));
+    }
+  }
+  const allRequired = /* @__PURE__ */ new Set();
+  for (const taskConfig of Object.values(graphTasks)) {
+    for (const token of getRequires(taskConfig)) {
+      allRequired.add(token);
+    }
+  }
+  const unreachable = /* @__PURE__ */ new Set();
+  const unreachableNodes = /* @__PURE__ */ new Set();
+  for (const token of allRequired) {
+    if (available.has(token)) continue;
+    const producers = producerMap[token] || [];
+    if (producers.length === 0) {
+      unreachable.add(token);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [name, taskConfig] of Object.entries(graphTasks)) {
+      if (unreachableNodes.has(name)) continue;
+      const ts = state.tasks[name];
+      if (ts?.status === "completed") continue;
+      const isNonActive = isNonActiveTask(ts);
+      const requires = getRequires(taskConfig);
+      const hasUnreachableDep = requires.some((t) => unreachable.has(t));
+      if (isNonActive || hasUnreachableDep) {
+        if (!unreachableNodes.has(name)) {
+          unreachableNodes.add(name);
+          changed = true;
+        }
+      }
+    }
+    for (const token of allRequired) {
+      if (unreachable.has(token) || available.has(token)) continue;
+      const producers = producerMap[token] || [];
+      const allProducersUnreachable = producers.length > 0 && producers.every((p) => unreachableNodes.has(p) || isNonActiveTask(state.tasks[p]));
+      if (producers.length === 0 || allProducersUnreachable) {
+        if (!unreachable.has(token)) {
+          unreachable.add(token);
+          changed = true;
+        }
+      }
+    }
+  }
+  const tokens = [];
+  for (const token of unreachable) {
+    const producers = producerMap[token] || [];
+    let reason;
+    if (producers.length === 0) {
+      reason = "no-producer";
+    } else {
+      const allFailed = producers.every((p) => isNonActiveTask(state.tasks[p]));
+      reason = allFailed ? "all-producers-failed" : "transitive";
+    }
+    tokens.push({ token, reason, producers });
+  }
+  return { tokens };
+}
+function getUnreachableNodes(live) {
+  const { config, state } = live;
+  const graphTasks = getAllTasks(config);
+  const { tokens: unreachableTokens } = getUnreachableTokens(live);
+  const unreachableTokenSet = new Set(unreachableTokens.map((t) => t.token));
+  const nodes = [];
+  for (const [name, taskConfig] of Object.entries(graphTasks)) {
+    const ts = state.tasks[name];
+    if (ts?.status === "completed") continue;
+    const requires = getRequires(taskConfig);
+    const missingTokens = requires.filter((t) => unreachableTokenSet.has(t));
+    if (missingTokens.length > 0) {
+      nodes.push({ nodeName: name, missingTokens });
+    } else if (isNonActiveTask(ts)) {
+      nodes.push({ nodeName: name, missingTokens: [] });
+    }
+  }
+  return { nodes };
+}
+function getUpstream(live, nodeName) {
+  const graphTasks = getAllTasks(live.config);
+  if (!graphTasks[nodeName]) return { nodeName, nodes: [], tokens: [] };
+  const producerMap = buildProducerMap4(graphTasks);
+  const visited = /* @__PURE__ */ new Set();
+  const tokenSet = /* @__PURE__ */ new Set();
+  const nodeEntries = /* @__PURE__ */ new Map();
+  function walk(current) {
+    const taskConfig = graphTasks[current];
+    if (!taskConfig) return;
+    for (const token of getRequires(taskConfig)) {
+      const producers = producerMap[token] || [];
+      for (const producer of producers) {
+        if (producer === nodeName) continue;
+        tokenSet.add(token);
+        if (!nodeEntries.has(producer)) nodeEntries.set(producer, /* @__PURE__ */ new Set());
+        nodeEntries.get(producer).add(token);
+        if (!visited.has(producer)) {
+          visited.add(producer);
+          walk(producer);
+        }
+      }
+    }
+  }
+  walk(nodeName);
+  const nodes = [...nodeEntries.entries()].map(([name, tokens]) => ({
+    nodeName: name,
+    providesTokens: [...tokens]
+  }));
+  return { nodeName, nodes, tokens: [...tokenSet] };
+}
+function getDownstream(live, nodeName) {
+  const graphTasks = getAllTasks(live.config);
+  if (!graphTasks[nodeName]) return { nodeName, nodes: [], tokens: [] };
+  const consumerMap = {};
+  for (const [name, config] of Object.entries(graphTasks)) {
+    for (const token of getRequires(config)) {
+      if (!consumerMap[token]) consumerMap[token] = [];
+      consumerMap[token].push(name);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const tokenSet = /* @__PURE__ */ new Set();
+  const nodeEntries = /* @__PURE__ */ new Map();
+  function walk(current) {
+    const taskConfig = graphTasks[current];
+    if (!taskConfig) return;
+    for (const token of getProvides(taskConfig)) {
+      const consumers = consumerMap[token] || [];
+      for (const consumer of consumers) {
+        if (consumer === nodeName) continue;
+        tokenSet.add(token);
+        if (!nodeEntries.has(consumer)) nodeEntries.set(consumer, /* @__PURE__ */ new Set());
+        nodeEntries.get(consumer).add(token);
+        if (!visited.has(consumer)) {
+          visited.add(consumer);
+          walk(consumer);
+        }
+      }
+    }
+  }
+  walk(nodeName);
+  const nodes = [...nodeEntries.entries()].map(([name, tokens]) => ({
+    nodeName: name,
+    requiresTokens: [...tokens]
+  }));
+  return { nodeName, nodes, tokens: [...tokenSet] };
+}
+
 exports.COMPLETION_STRATEGIES = COMPLETION_STRATEGIES;
 exports.CONFLICT_STRATEGIES = CONFLICT_STRATEGIES;
 exports.DEFAULTS = DEFAULTS;
@@ -2107,8 +3041,12 @@ exports.MemoryStore = MemoryStore;
 exports.StepMachine = StepMachine;
 exports.TASK_STATUS = TASK_STATUS;
 exports.addDynamicTask = addDynamicTask;
+exports.addNode = addNode;
+exports.addProvides = addProvides;
+exports.addRequires = addRequires;
 exports.apply = apply;
 exports.applyAll = applyAll;
+exports.applyEvent = applyEvent;
 exports.applyStepResult = applyStepResult;
 exports.batch = batch;
 exports.checkCircuitBreaker = checkCircuitBreaker;
@@ -2118,19 +3056,30 @@ exports.createDefaultTaskState = createDefaultTaskState;
 exports.createEngine = createStepMachine;
 exports.createInitialExecutionState = createInitialExecutionState;
 exports.createInitialState = createInitialState;
+exports.createLiveGraph = createLiveGraph;
 exports.createStepMachine = createStepMachine;
 exports.detectStuckState = detectStuckState;
+exports.disableNode = disableNode;
+exports.drainTokens = drainTokens;
+exports.enableNode = enableNode;
 exports.exportGraphConfig = exportGraphConfig;
 exports.exportGraphConfigToFile = exportGraphConfigToFile;
 exports.extractReturnData = extractReturnData;
 exports.flowToMermaid = flowToMermaid;
 exports.getAllTasks = getAllTasks;
 exports.getCandidateTasks = getCandidateTasks;
+exports.getDownstream = getDownstream;
+exports.getNode = getNode;
 exports.getProvides = getProvides;
 exports.getRequires = getRequires;
 exports.getTask = getTask;
+exports.getUnreachableNodes = getUnreachableNodes;
+exports.getUnreachableTokens = getUnreachableTokens;
+exports.getUpstream = getUpstream;
 exports.graphToMermaid = graphToMermaid;
 exports.hasTask = hasTask;
+exports.injectTokens = injectTokens;
+exports.inspect = inspect;
 exports.isExecutionComplete = isExecutionComplete;
 exports.isNonActiveTask = isNonActiveTask;
 exports.isRepeatableTask = isRepeatableTask;
@@ -2140,8 +3089,16 @@ exports.loadGraphConfig = loadGraphConfig;
 exports.loadStepFlow = loadStepFlow;
 exports.next = next;
 exports.planExecution = planExecution;
+exports.removeNode = removeNode;
+exports.removeProvides = removeProvides;
+exports.removeRequires = removeRequires;
+exports.resetNode = resetNode;
 exports.resolveConfigTemplates = resolveConfigTemplates;
 exports.resolveVariables = resolveVariables;
+exports.restore = restore;
+exports.schedule = schedule;
+exports.snapshot = snapshot;
+exports.validateGraph = validateGraph;
 exports.validateGraphConfig = validateGraphConfig;
 exports.validateStepFlowConfig = validateStepFlowConfig;
 //# sourceMappingURL=index.cjs.map