yaml-flow 2.3.0 → 2.5.0

package/dist/index.js

@@ -1,3 +1,5 @@
+import { execFile } from 'child_process';
+
 // src/step-machine/reducer.ts
 function applyStepResult(flow, state, stepName, stepResult) {
   const stepConfig = flow.steps[stepName];
@@ -2300,6 +2302,984 @@ function resolveConfigTemplates(config) {
   return result;
 }
 
-export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, apply, applyAll, applyStepResult, batch, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createDefaultTaskState, createStepMachine as createEngine, createInitialExecutionState, createInitialState, createStepMachine, detectStuckState, exportGraphConfig, exportGraphConfigToFile, extractReturnData, flowToMermaid, getAllTasks, getCandidateTasks, getProvides, getRequires, getTask, graphToMermaid, hasTask, isExecutionComplete, isNonActiveTask, isRepeatableTask, isTaskCompleted, isTaskRunning, loadGraphConfig, loadStepFlow, next, planExecution, resolveConfigTemplates, resolveVariables, validateGraph, validateGraphConfig, validateStepFlowConfig };
+// 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 = 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);
+      }
+    }
+  };
+}
+
+export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, addNode, addProvides, addRequires, apply, applyAll, applyEvent, applyInferences, applyStepResult, batch, buildInferencePrompt, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createCliAdapter, createDefaultTaskState, createStepMachine as createEngine, createHttpAdapter, createInitialExecutionState, createInitialState, createLiveGraph, createStepMachine, detectStuckState, disableNode, drainTokens, enableNode, exportGraphConfig, exportGraphConfigToFile, extractReturnData, flowToMermaid, getAllTasks, getCandidateTasks, getDownstream, getNode, getProvides, getRequires, getTask, getUnreachableNodes, getUnreachableTokens, getUpstream, graphToMermaid, hasTask, inferAndApply, inferCompletions, injectTokens, inspect, isExecutionComplete, isNonActiveTask, isRepeatableTask, isTaskCompleted, isTaskRunning, loadGraphConfig, loadStepFlow, next, planExecution, removeNode, removeProvides, removeRequires, resetNode, resolveConfigTemplates, resolveVariables, restore, schedule, snapshot, validateGraph, validateGraphConfig, validateStepFlowConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map