yaml-flow 2.3.0 → 2.5.0

package/dist/index.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+var child_process = require('child_process');
+
 // src/step-machine/reducer.ts
 function applyStepResult(flow, state, stepName, stepResult) {
   const stepConfig = flow.steps[stepName];
@@ -2302,6 +2304,984 @@ 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] };
+}
+
+// src/inference/core.ts
+var DEFAULT_THRESHOLD = 0.5;
+var DEFAULT_SYSTEM_PROMPT = `You are a workflow completion analyzer. Given a graph of tasks with their current states, evidence, and inference hints, determine which tasks appear to be completed based on the available evidence.
+
+For each task you analyze, provide a JSON response. Be conservative \u2014 only mark tasks as completed when the evidence strongly supports it.`;
+function buildInferencePrompt(live, options = {}) {
+  const { scope, context, systemPrompt } = options;
+  const graphTasks = getAllTasks(live.config);
+  const { state } = live;
+  const candidates = getAnalyzableCandidates(live, scope);
+  if (candidates.length === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push(systemPrompt || DEFAULT_SYSTEM_PROMPT);
+  lines.push("");
+  lines.push("## Graph State");
+  lines.push("");
+  lines.push(`Available tokens: ${state.availableOutputs.length > 0 ? state.availableOutputs.join(", ") : "(none)"}`);
+  lines.push("");
+  const completedTasks = Object.entries(state.tasks).filter(([_, ts]) => ts.status === "completed").map(([name]) => name);
+  if (completedTasks.length > 0) {
+    lines.push(`Completed tasks: ${completedTasks.join(", ")}`);
+    lines.push("");
+  }
+  lines.push("## Tasks to Analyze");
+  lines.push("");
+  for (const taskName of candidates) {
+    const taskConfig = graphTasks[taskName];
+    const taskState = state.tasks[taskName];
+    lines.push(`### ${taskName}`);
+    if (taskConfig.description) {
+      lines.push(`Description: ${taskConfig.description}`);
+    }
+    const requires = getRequires(taskConfig);
+    const provides = getProvides(taskConfig);
+    if (requires.length > 0) lines.push(`Requires: ${requires.join(", ")}`);
+    if (provides.length > 0) lines.push(`Provides: ${provides.join(", ")}`);
+    lines.push(`Current status: ${taskState?.status || "not-started"}`);
+    const hints = taskConfig.inference;
+    if (hints) {
+      if (hints.criteria) lines.push(`Completion criteria: ${hints.criteria}`);
+      if (hints.keywords?.length) lines.push(`Keywords: ${hints.keywords.join(", ")}`);
+      if (hints.suggestedChecks?.length) lines.push(`Suggested checks: ${hints.suggestedChecks.join("; ")}`);
+    }
+    lines.push("");
+  }
+  if (context) {
+    lines.push("## Additional Context / Evidence");
+    lines.push("");
+    lines.push(context);
+    lines.push("");
+  }
+  lines.push("## Response Format");
+  lines.push("");
+  lines.push("Respond with a JSON array of objects, one per task you have evidence for:");
+  lines.push("```json");
+  lines.push("[");
+  lines.push("  {");
+  lines.push('    "taskName": "task-name",');
+  lines.push('    "confidence": 0.0 to 1.0,');
+  lines.push('    "reasoning": "explanation of why you believe this task is complete or not"');
+  lines.push("  }");
+  lines.push("]");
+  lines.push("```");
+  lines.push("");
+  lines.push("Rules:");
+  lines.push('- Only include tasks from the "Tasks to Analyze" section');
+  lines.push("- confidence 0.0 = no evidence of completion, 1.0 = certain it is complete");
+  lines.push("- If you have no evidence for a task, omit it from the array");
+  lines.push("- Be conservative \u2014 require clear evidence before high confidence");
+  lines.push("- Respond ONLY with the JSON array, no additional text");
+  return lines.join("\n");
+}
+async function inferCompletions(live, adapter, options = {}) {
+  options.threshold ?? DEFAULT_THRESHOLD;
+  const analyzedNodes = getAnalyzableCandidates(live, options.scope);
+  if (analyzedNodes.length === 0) {
+    return { suggestions: [], promptUsed: "", rawResponse: "", analyzedNodes: [] };
+  }
+  const prompt = buildInferencePrompt(live, options);
+  const rawResponse = await adapter.analyze(prompt);
+  const suggestions = parseInferenceResponse(rawResponse, analyzedNodes);
+  return {
+    suggestions,
+    promptUsed: prompt,
+    rawResponse,
+    analyzedNodes
+  };
+}
+function applyInferences(live, result, threshold = DEFAULT_THRESHOLD) {
+  let current = live;
+  for (const suggestion of result.suggestions) {
+    if (suggestion.confidence < threshold) continue;
+    const taskState = current.state.tasks[suggestion.taskName];
+    if (!taskState) continue;
+    if (taskState.status === "completed" || taskState.status === "running") continue;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    current = applyEvent(current, {
+      type: "task-started",
+      taskName: suggestion.taskName,
+      timestamp: now
+    });
+    current = applyEvent(current, {
+      type: "task-completed",
+      taskName: suggestion.taskName,
+      timestamp: now,
+      result: "llm-inferred"
+    });
+  }
+  return current;
+}
+async function inferAndApply(live, adapter, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  const inference = await inferCompletions(live, adapter, options);
+  const updated = applyInferences(live, inference, threshold);
+  const applied = inference.suggestions.filter((s) => s.confidence >= threshold);
+  const skipped = inference.suggestions.filter((s) => s.confidence < threshold);
+  return {
+    live: updated,
+    inference,
+    applied,
+    skipped
+  };
+}
+function getAnalyzableCandidates(live, scope) {
+  const graphTasks = getAllTasks(live.config);
+  const { state } = live;
+  const candidates = [];
+  for (const [name, config] of Object.entries(graphTasks)) {
+    const taskState = state.tasks[name];
+    if (taskState?.status === "completed" || taskState?.status === "running") continue;
+    if (scope) {
+      if (scope.includes(name)) candidates.push(name);
+    } else {
+      if (config.inference?.autoDetectable) candidates.push(name);
+    }
+  }
+  return candidates;
+}
+function parseInferenceResponse(rawResponse, validNodes, _threshold) {
+  const validSet = new Set(validNodes);
+  try {
+    const jsonStr = extractJson(rawResponse);
+    if (!jsonStr) return [];
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed)) return [];
+    const suggestions = [];
+    for (const item of parsed) {
+      if (!item || typeof item !== "object") continue;
+      if (typeof item.taskName !== "string") continue;
+      if (typeof item.confidence !== "number") continue;
+      if (!validSet.has(item.taskName)) continue;
+      const confidence = Math.max(0, Math.min(1, item.confidence));
+      suggestions.push({
+        taskName: item.taskName,
+        confidence,
+        reasoning: typeof item.reasoning === "string" ? item.reasoning : "",
+        detectionMethod: "llm-inferred"
+      });
+    }
+    return suggestions;
+  } catch {
+    return [];
+  }
+}
+function extractJson(text) {
+  if (!text || typeof text !== "string") return null;
+  const trimmed = text.trim();
+  const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+  if (fenceMatch) return fenceMatch[1].trim();
+  const firstBracket = trimmed.indexOf("[");
+  const lastBracket = trimmed.lastIndexOf("]");
+  if (firstBracket !== -1 && lastBracket > firstBracket) {
+    return trimmed.slice(firstBracket, lastBracket + 1);
+  }
+  if (trimmed.startsWith("[")) return trimmed;
+  return null;
+}
+function createCliAdapter(opts) {
+  const timeout = opts.timeout ?? 6e4;
+  return {
+    analyze: (prompt) => {
+      return new Promise((resolve, reject) => {
+        const args = opts.args(prompt);
+        const child = child_process.execFile(
+          opts.command,
+          opts.stdin ? opts.args("") : args,
+          {
+            timeout,
+            cwd: opts.cwd,
+            env: opts.env ? { ...process.env, ...opts.env } : void 0,
+            maxBuffer: 10 * 1024 * 1024
+            // 10MB
+          },
+          (error, stdout, stderr) => {
+            if (error) {
+              reject(new Error(
+                `CLI adapter failed: ${opts.command} exited with ${error.code ?? "error"}` + (stderr ? `
+stderr: ${stderr.slice(0, 500)}` : "") + `
+${error.message}`
+              ));
+            } else {
+              resolve(stdout);
+            }
+          }
+        );
+        if (opts.stdin && child.stdin) {
+          child.stdin.write(prompt);
+          child.stdin.end();
+        }
+      });
+    }
+  };
+}
+function createHttpAdapter(opts) {
+  const timeout = opts.timeout ?? 6e4;
+  return {
+    analyze: async (prompt) => {
+      const body = opts.buildBody ? opts.buildBody(prompt) : { prompt };
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(opts.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...opts.headers ?? {}
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          throw new Error(`HTTP ${response.status}: ${text.slice(0, 500)}`);
+        }
+        const json = await response.json();
+        if (opts.extractResponse) {
+          return opts.extractResponse(json);
+        }
+        if (typeof json.response === "string") return json.response;
+        if (typeof json.text === "string") return json.text;
+        if (typeof json.content === "string") return json.content;
+        return JSON.stringify(json);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+
 exports.COMPLETION_STRATEGIES = COMPLETION_STRATEGIES;
 exports.CONFLICT_STRATEGIES = CONFLICT_STRATEGIES;
 exports.DEFAULTS = DEFAULTS;
@@ -2314,30 +3294,51 @@ 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.applyInferences = applyInferences;
 exports.applyStepResult = applyStepResult;
 exports.batch = batch;
+exports.buildInferencePrompt = buildInferencePrompt;
 exports.checkCircuitBreaker = checkCircuitBreaker;
 exports.computeAvailableOutputs = computeAvailableOutputs;
 exports.computeStepInput = computeStepInput;
+exports.createCliAdapter = createCliAdapter;
 exports.createDefaultTaskState = createDefaultTaskState;
 exports.createEngine = createStepMachine;
+exports.createHttpAdapter = createHttpAdapter;
 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.inferAndApply = inferAndApply;
+exports.inferCompletions = inferCompletions;
+exports.injectTokens = injectTokens;
+exports.inspect = inspect;
 exports.isExecutionComplete = isExecutionComplete;
 exports.isNonActiveTask = isNonActiveTask;
 exports.isRepeatableTask = isRepeatableTask;
@@ -2347,8 +3348,15 @@ 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;