yaml-flow 3.0.0 → 3.1.1

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 var addFormats = require('ajv-formats');
 var fs = require('fs');
+var crypto$1 = require('crypto');
 var child_process = require('child_process');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -7231,7 +7232,7 @@ function addDynamicTask(graph, taskName, taskConfig) {
     }
   };
 }
-function createDefaultTaskState() {
+function createDefaultGraphEngineStore() {
   return {
     status: "not-started",
     executionCount: 0,
@@ -7244,7 +7245,7 @@ function createDefaultTaskState() {
 function createInitialExecutionState(graph, executionId) {
   const tasks = {};
   for (const taskName of Object.keys(graph.tasks)) {
-    tasks[taskName] = createDefaultTaskState();
+    tasks[taskName] = createDefaultGraphEngineStore();
   }
   return {
     status: "running",
@@ -7765,7 +7766,7 @@ function selectOptimalTasks(candidates, graph, state, conflictStrategy) {
 
 // src/event-graph/task-transitions.ts
 function applyTaskStart(state, taskName) {
-  const existingTask = state.tasks[taskName] ?? createDefaultTaskState2();
+  const existingTask = state.tasks[taskName] ?? createDefaultGraphEngineStore2();
   const updatedTask = {
     ...existingTask,
     status: "running",
@@ -7780,8 +7781,8 @@ function applyTaskStart(state, taskName) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function applyTaskCompletion(state, graph, taskName, result, dataHash) {
-  const existingTask = state.tasks[taskName] ?? createDefaultTaskState2();
+function applyTaskCompletion(state, graph, taskName, result, dataHash, data) {
+  const existingTask = state.tasks[taskName] ?? createDefaultGraphEngineStore2();
   const taskConfig = graph.tasks[taskName];
   if (!taskConfig) {
     throw new Error(`Task "${taskName}" not found in graph`);
@@ -7813,6 +7814,7 @@ function applyTaskCompletion(state, graph, taskName, result, dataHash) {
     executionCount: existingTask.executionCount + 1,
     lastEpoch: existingTask.executionCount + 1,
     lastDataHash: dataHash,
+    data,
     lastConsumedHashes,
     error: void 0
   };
@@ -7825,7 +7827,7 @@ function applyTaskCompletion(state, graph, taskName, result, dataHash) {
   };
 }
 function applyTaskFailure(state, graph, taskName, error) {
-  const existingTask = state.tasks[taskName] ?? createDefaultTaskState2();
+  const existingTask = state.tasks[taskName] ?? createDefaultGraphEngineStore2();
   const taskConfig = graph.tasks[taskName];
   if (taskConfig?.retry) {
     const retryCount = existingTask.retryCount + 1;
@@ -7868,7 +7870,7 @@ function applyTaskFailure(state, graph, taskName, error) {
   };
 }
 function applyTaskProgress(state, taskName, message, progress) {
-  const existingTask = state.tasks[taskName] ?? createDefaultTaskState2();
+  const existingTask = state.tasks[taskName] ?? createDefaultGraphEngineStore2();
   const updatedTask = {
     ...existingTask,
     progress: typeof progress === "number" ? progress : existingTask.progress,
@@ -7884,7 +7886,27 @@ function applyTaskProgress(state, taskName, message, progress) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function createDefaultTaskState2() {
+function applyTaskRestart(state, taskName) {
+  const existingTask = state.tasks[taskName];
+  if (!existingTask) return state;
+  const updatedTask = {
+    ...existingTask,
+    status: "not-started",
+    startedAt: void 0,
+    completedAt: void 0,
+    failedAt: void 0,
+    error: void 0,
+    data: void 0,
+    progress: null,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    ...state,
+    tasks: { ...state.tasks, [taskName]: updatedTask },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createDefaultGraphEngineStore2() {
   return {
     status: "not-started",
     executionCount: 0,
@@ -7904,11 +7926,13 @@ function apply(state, event, graph) {
     case "task-started":
       return applyTaskStart(state, event.taskName);
     case "task-completed":
-      return applyTaskCompletion(state, graph, event.taskName, event.result, event.dataHash);
+      return applyTaskCompletion(state, graph, event.taskName, event.result, event.dataHash, event.data);
     case "task-failed":
       return applyTaskFailure(state, graph, event.taskName, event.error);
     case "task-progress":
       return applyTaskProgress(state, event.taskName, event.message, event.progress);
+    case "task-restart":
+      return applyTaskRestart(state, event.taskName);
     case "inject-tokens":
       return applyInjectTokens(state, event.tokens);
     case "agent-action":
@@ -7979,7 +8003,7 @@ function applyTaskCreation(state, taskName, taskConfig) {
     ...state,
     tasks: {
       ...state.tasks,
-      [taskName]: createDefaultTaskState()
+      [taskName]: createDefaultGraphEngineStore()
     },
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -9229,7 +9253,7 @@ function createLiveGraph(config, executionId) {
   const id = executionId ?? `live-${Date.now()}`;
   const tasks = {};
   for (const taskName of Object.keys(config.tasks)) {
-    tasks[taskName] = createDefaultTaskState3();
+    tasks[taskName] = createDefaultGraphEngineStore3();
   }
   const state = {
     status: "running",
@@ -9257,7 +9281,7 @@ function applyEvent(live, event) {
       newState = applyTaskStart(state, event.taskName);
       break;
     case "task-completed":
-      newState = applyTaskCompletion(state, config, event.taskName, event.result, event.dataHash);
+      newState = applyTaskCompletion(state, config, event.taskName, event.result, event.dataHash, event.data);
       break;
     case "task-failed":
       newState = applyTaskFailure(state, config, event.taskName, event.error);
@@ -9265,6 +9289,9 @@ function applyEvent(live, event) {
     case "task-progress":
       newState = applyTaskProgress(state, event.taskName, event.message, event.progress);
       break;
+    case "task-restart":
+      newState = applyTaskRestart(state, event.taskName);
+      break;
     case "inject-tokens":
       newState = {
         ...state,
@@ -9292,7 +9319,7 @@ function addNode(live, name, taskConfig) {
     },
     state: {
       ...live.state,
-      tasks: { ...live.state.tasks, [name]: createDefaultTaskState3() },
+      tasks: { ...live.state.tasks, [name]: createDefaultGraphEngineStore3() },
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
     }
   };
@@ -9409,7 +9436,7 @@ function resetNode(live, name) {
       ...live.state,
       tasks: {
         ...live.state.tasks,
-        [name]: createDefaultTaskState3()
+        [name]: createDefaultGraphEngineStore3()
       },
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
     }
@@ -9448,7 +9475,7 @@ function enableNode(live, name) {
 function getNode(live, name) {
   const config = live.config.tasks[name];
   if (!config) return void 0;
-  const state = live.state.tasks[name] ?? createDefaultTaskState3();
+  const state = live.state.tasks[name] ?? createDefaultGraphEngineStore3();
   return { name, config, state };
 }
 function snapshot(live) {
@@ -9486,7 +9513,7 @@ function restore(data) {
   }
   return { config, state };
 }
-function createDefaultTaskState3() {
+function createDefaultGraphEngineStore3() {
   return {
     status: "not-started",
     executionCount: 0,
@@ -10043,23 +10070,43 @@ var FileJournal = class {
     }
   }
 };
-
-// src/continuous-event-graph/reactive.ts
+function computeDataHash(data) {
+  const json = stableStringify(data);
+  return crypto$1.createHash("sha256").update(json).digest("hex").slice(0, 16);
+}
+function stableStringify(value) {
+  if (value === null || value === void 0 || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map(stableStringify).join(",") + "]";
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+function encodeCallbackToken(taskName) {
+  const payload = JSON.stringify({ t: taskName, n: Date.now().toString(36) + Math.random().toString(36).slice(2, 6) });
+  return Buffer.from(payload).toString("base64url");
+}
+function decodeCallbackToken(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token, "base64url").toString());
+    if (typeof payload?.t === "string") return { taskName: payload.t };
+    return null;
+  } catch {
+    return null;
+  }
+}
 function createReactiveGraph(config, options, executionId) {
   const {
     handlers: initialHandlers,
-    maxDispatchRetries = 3,
-    defaultTimeoutMs = 3e4,
     journal = new MemoryJournal(),
-    onDispatchFailed,
-    onAbandoned,
     onDrain
   } = options;
   let live = createLiveGraph(config, executionId);
   let disposed = false;
   const handlers = new Map(Object.entries(initialHandlers));
-  const dispatched = /* @__PURE__ */ new Map();
-  const timeoutTimers = /* @__PURE__ */ new Map();
   let draining = false;
   let drainQueued = false;
   function drain() {
@@ -10079,201 +10126,183 @@ function createReactiveGraph(config, options, executionId) {
     }
   }
   function drainOnce() {
-    sweepTimeouts();
     const events = journal.drain();
-    for (const event of events) {
-      if (event.type === "task-completed" || event.type === "task-failed") {
-        const taskName = event.taskName;
-        dispatched.delete(taskName);
-        clearTimeout(timeoutTimers.get(taskName));
-        timeoutTimers.delete(taskName);
-      }
-    }
     if (events.length > 0) {
       live = applyEvents(live, events);
     }
     const result = schedule(live);
-    if (onDrain && events.length > 0) {
-      onDrain(events, live, result);
+    if (events.length > 0) {
+      onDrain?.(events, live, result);
     }
     for (const taskName of result.eligible) {
-      if (dispatched.has(taskName)) continue;
       dispatchTask(taskName);
     }
-    for (const [taskName, entry] of dispatched) {
-      if (entry.status === "retry-queued") {
-        dispatchTask(taskName);
+  }
+  function resolveUpstreamState(taskName) {
+    const taskConfig = live.config.tasks[taskName];
+    const requires = taskConfig.requires ?? [];
+    const tokenToTask = /* @__PURE__ */ new Map();
+    for (const [name, cfg] of Object.entries(live.config.tasks)) {
+      for (const token of cfg.provides ?? []) {
+        tokenToTask.set(token, name);
+      }
+    }
+    const state = {};
+    for (const token of requires) {
+      const producerTask = tokenToTask.get(token);
+      if (producerTask) {
+        state[token] = live.state.tasks[producerTask]?.data;
+      } else {
+        state[token] = void 0;
+      }
+    }
+    return state;
+  }
+  async function runPipeline(taskName, callbackToken) {
+    const taskConfig = live.config.tasks[taskName];
+    const handlerNames = taskConfig.taskHandlers ?? [];
+    const upstreamState = resolveUpstreamState(taskName);
+    for (const handlerName of handlerNames) {
+      const handler = handlers.get(handlerName);
+      if (!handler) {
+        throw new Error(`Handler '${handlerName}' not found in registry (task '${taskName}')`);
+      }
+      const input = {
+        nodeId: taskName,
+        state: upstreamState,
+        taskState: live.state.tasks[taskName],
+        config: taskConfig,
+        callbackToken
+      };
+      const status = await handler(input);
+      if (status === "task-initiate-failure") {
+        throw new Error(`Handler '${handlerName}' returned task-initiate-failure (task '${taskName}')`);
       }
     }
   }
   function dispatchTask(taskName) {
-    const handler = handlers.get(taskName);
-    if (!handler) {
-      journal.append({
-        type: "task-failed",
-        taskName,
-        error: `No handler registered for task "${taskName}"`,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      drainQueued = true;
-      return;
-    }
-    const existing = dispatched.get(taskName);
-    const attempt = existing ? existing.dispatchAttempts + 1 : 1;
-    if (attempt > maxDispatchRetries) {
-      dispatched.set(taskName, {
-        status: "abandoned",
-        dispatchedAt: existing?.dispatchedAt ?? Date.now(),
-        dispatchAttempts: attempt - 1,
-        lastError: existing?.lastError
-      });
-      onAbandoned?.(taskName);
-      journal.append({
-        type: "task-failed",
-        taskName,
-        error: `dispatch-abandoned: handler unreachable after ${attempt - 1} attempts${existing?.lastError ? ` (${existing.lastError})` : ""}`,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      drainQueued = true;
+    const taskConfig = live.config.tasks[taskName];
+    const handlerNames = taskConfig?.taskHandlers;
+    if (!handlerNames || handlerNames.length === 0) {
       return;
     }
-    dispatched.set(taskName, {
-      status: "initiated",
-      dispatchedAt: Date.now(),
-      dispatchAttempts: attempt
-    });
     journal.append({
       type: "task-started",
       taskName,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    if (defaultTimeoutMs > 0) {
-      const timer = setTimeout(() => {
-        if (disposed) return;
-        const entry = dispatched.get(taskName);
-        if (entry?.status === "initiated") {
-          dispatched.set(taskName, {
-            ...entry,
-            status: "timed-out"
-          });
-          dispatched.set(taskName, {
-            ...entry,
-            status: entry.dispatchAttempts >= maxDispatchRetries ? "abandoned" : "retry-queued"
-          });
-          if (entry.dispatchAttempts >= maxDispatchRetries) {
-            onAbandoned?.(taskName);
-            journal.append({
-              type: "task-failed",
-              taskName,
-              error: `dispatch-timeout: no callback after ${defaultTimeoutMs}ms (${entry.dispatchAttempts} attempts)`,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-          drain();
-        }
-      }, defaultTimeoutMs);
-      timeoutTimers.set(taskName, timer);
-    }
-    const ctx = {
-      taskName,
-      live,
-      config: live.config.tasks[taskName]
-    };
-    try {
-      const promise = handler(ctx);
-      promise.then(
-        (handlerResult) => {
-          if (disposed) return;
-          clearTimeout(timeoutTimers.get(taskName));
-          timeoutTimers.delete(taskName);
-          journal.append({
-            type: "task-completed",
-            taskName,
-            result: handlerResult.result,
-            data: handlerResult.data,
-            dataHash: handlerResult.dataHash,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          drain();
-        },
-        (error) => {
-          if (disposed) return;
-          clearTimeout(timeoutTimers.get(taskName));
-          timeoutTimers.delete(taskName);
-          journal.append({
-            type: "task-failed",
-            taskName,
-            error: error.message ?? String(error),
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          drain();
-        }
-      );
-    } catch (syncError) {
-      const err = syncError instanceof Error ? syncError : new Error(String(syncError));
-      dispatched.set(taskName, {
-        status: "dispatch-failed",
-        dispatchedAt: Date.now(),
-        dispatchAttempts: attempt,
-        lastError: err.message
-      });
-      onDispatchFailed?.(taskName, err, attempt);
-      dispatched.set(taskName, {
-        ...dispatched.get(taskName),
-        status: "retry-queued"
+    const callbackToken = encodeCallbackToken(taskName);
+    runPipeline(taskName, callbackToken).catch((error) => {
+      if (disposed) return;
+      journal.append({
+        type: "task-failed",
+        taskName,
+        error: error.message ?? String(error),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
-      drainQueued = true;
-    }
-  }
-  function sweepTimeouts() {
-    const now = Date.now();
-    for (const [taskName, entry] of dispatched) {
-      if (entry.status !== "initiated") continue;
-      if (defaultTimeoutMs <= 0) continue;
-      if (now - entry.dispatchedAt >= defaultTimeoutMs) {
-        dispatched.set(taskName, {
-          ...entry,
-          status: entry.dispatchAttempts >= maxDispatchRetries ? "abandoned" : "retry-queued"
-        });
-        if (entry.dispatchAttempts >= maxDispatchRetries) {
-          onAbandoned?.(taskName);
-          journal.append({
-            type: "task-failed",
-            taskName,
-            error: `dispatch-timeout: no callback after ${defaultTimeoutMs}ms (${entry.dispatchAttempts} attempts)`,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-        clearTimeout(timeoutTimers.get(taskName));
-        timeoutTimers.delete(taskName);
-      }
-    }
+      drain();
+    });
   }
   return {
     push(event) {
       if (disposed) return;
-      live = applyEvent(live, event);
+      if (event.type === "task-completed" && event.data && !event.dataHash) {
+        event = { ...event, dataHash: computeDataHash(event.data) };
+      }
+      journal.append(event);
       drain();
     },
     pushAll(events) {
       if (disposed) return;
-      if (events.length === 0) return;
-      live = applyEvents(live, events);
+      for (const event of events) {
+        if (event.type === "task-completed" && event.data && !event.dataHash) {
+          journal.append({ ...event, dataHash: computeDataHash(event.data) });
+        } else {
+          journal.append(event);
+        }
+      }
+      drain();
+    },
+    resolveCallback(callbackToken, data, errors) {
+      if (disposed) return;
+      const decoded = decodeCallbackToken(callbackToken);
+      if (!decoded) return;
+      const { taskName } = decoded;
+      if (!live.config.tasks[taskName]) return;
+      if (errors && errors.length > 0) {
+        journal.append({
+          type: "task-failed",
+          taskName,
+          error: errors.join("; "),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } else {
+        const dataHash = data && Object.keys(data).length > 0 ? computeDataHash(data) : void 0;
+        journal.append({
+          type: "task-completed",
+          taskName,
+          data,
+          dataHash,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
       drain();
     },
-    addNode(name, taskConfig, handler) {
+    addNode(name, taskConfig) {
       if (disposed) return;
       live = addNode(live, name, taskConfig);
-      handlers.set(name, handler);
       drain();
     },
     removeNode(name) {
       if (disposed) return;
       live = removeNode(live, name);
+    },
+    addRequires(nodeName, tokens) {
+      if (disposed) return;
+      live = addRequires(live, nodeName, tokens);
+      drain();
+    },
+    removeRequires(nodeName, tokens) {
+      if (disposed) return;
+      live = removeRequires(live, nodeName, tokens);
+      drain();
+    },
+    addProvides(nodeName, tokens) {
+      if (disposed) return;
+      live = addProvides(live, nodeName, tokens);
+      drain();
+    },
+    removeProvides(nodeName, tokens) {
+      if (disposed) return;
+      live = removeProvides(live, nodeName, tokens);
+    },
+    registerHandler(name, fn) {
+      handlers.set(name, fn);
+    },
+    unregisterHandler(name) {
       handlers.delete(name);
-      dispatched.delete(name);
-      clearTimeout(timeoutTimers.get(name));
-      timeoutTimers.delete(name);
+    },
+    retrigger(taskName) {
+      if (disposed) return;
+      if (!live.config.tasks[taskName]) return;
+      journal.append({
+        type: "task-restart",
+        taskName,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      drain();
+    },
+    retriggerAll(taskNames) {
+      if (disposed) return;
+      for (const name of taskNames) {
+        if (!live.config.tasks[name]) continue;
+        journal.append({
+          type: "task-restart",
+          taskName: name,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      drain();
     },
     getState() {
       return live;
@@ -10281,267 +10310,360 @@ function createReactiveGraph(config, options, executionId) {
     getSchedule() {
       return schedule(live);
     },
-    getDispatchState() {
-      return dispatched;
-    },
     dispose() {
       disposed = true;
-      for (const timer of timeoutTimers.values()) {
-        clearTimeout(timer);
-      }
-      timeoutTimers.clear();
     }
   };
 }
 
-// src/inference/core.ts
-var DEFAULT_THRESHOLD = 0.5;
-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 "";
+// src/continuous-event-graph/validate.ts
+function validateLiveGraph(live) {
+  const issues = [];
+  const { config, state } = live;
+  const tasks = getAllTasks(config);
+  const taskNames = Object.keys(tasks);
+  for (const name of taskNames) {
+    if (!state.tasks[name]) {
+      issues.push({
+        severity: "error",
+        code: "MISSING_STATE",
+        message: `Task "${name}" exists in config but has no state entry`,
+        tasks: [name]
+      });
+    }
   }
-  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("");
+  for (const name of Object.keys(state.tasks)) {
+    if (!tasks[name]) {
+      issues.push({
+        severity: "warning",
+        code: "ORPHAN_STATE",
+        message: `State entry "${name}" has no corresponding task config`,
+        tasks: [name]
+      });
+    }
   }
-  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}`);
+  for (const name of taskNames) {
+    const ts = state.tasks[name];
+    if (!ts) continue;
+    if (ts.status === TASK_STATUS.RUNNING && !ts.startedAt) {
+      issues.push({
+        severity: "warning",
+        code: "RUNNING_WITHOUT_START",
+        message: `Task "${name}" is running but has no startedAt timestamp`,
+        tasks: [name]
+      });
     }
-    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("; ")}`);
+    if (ts.status === TASK_STATUS.COMPLETED && !ts.completedAt) {
+      issues.push({
+        severity: "warning",
+        code: "COMPLETED_WITHOUT_TIMESTAMP",
+        message: `Task "${name}" is completed but has no completedAt timestamp`,
+        tasks: [name]
+      });
+    }
+    if (ts.status === TASK_STATUS.FAILED) {
+      if (!ts.failedAt) {
+        issues.push({
+          severity: "warning",
+          code: "FAILED_WITHOUT_INFO",
+          message: `Task "${name}" is failed but has no failedAt timestamp`,
+          tasks: [name]
+        });
+      }
+      if (!ts.error) {
+        issues.push({
+          severity: "info",
+          code: "FAILED_WITHOUT_INFO",
+          message: `Task "${name}" is failed but has no error message`,
+          tasks: [name]
+        });
+      }
     }
-    lines.push("");
   }
-  if (context) {
-    lines.push("## Additional Context / Evidence");
-    lines.push("");
-    lines.push(context);
-    lines.push("");
+  const expectedOutputs = /* @__PURE__ */ new Set();
+  for (const name of taskNames) {
+    const ts = state.tasks[name];
+    if (ts?.status === TASK_STATUS.COMPLETED) {
+      for (const token of getProvides(tasks[name])) {
+        expectedOutputs.add(token);
+      }
+    }
   }
-  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 actualOutputs = new Set(state.availableOutputs);
+  const allProducible = /* @__PURE__ */ new Set();
+  for (const taskConfig of Object.values(tasks)) {
+    for (const t of getProvides(taskConfig)) allProducible.add(t);
+    if (taskConfig.on) {
+      for (const tokens of Object.values(taskConfig.on)) {
+        for (const t of tokens) allProducible.add(t);
+      }
+    }
+    if (taskConfig.on_failure) {
+      for (const t of taskConfig.on_failure) allProducible.add(t);
+    }
   }
-  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"
-    });
+  for (const token of actualOutputs) {
+    if (!expectedOutputs.has(token) && !allProducible.has(token)) {
+      issues.push({
+        severity: "info",
+        code: "INJECTED_TOKEN",
+        message: `Token "${token}" is available but no task in the graph can produce it (likely injected)`,
+        tokens: [token]
+      });
+    }
   }
-  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);
+  for (const token of expectedOutputs) {
+    if (!actualOutputs.has(token)) {
+      issues.push({
+        severity: "warning",
+        code: "MISSING_OUTPUT",
+        message: `Token "${token}" should be available (its producer completed) but is not in availableOutputs`,
+        tokens: [token]
+      });
     }
   }
-  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"
+  for (const name of taskNames) {
+    const ts = state.tasks[name];
+    if (!ts) continue;
+    if (ts.executionCount < 0) {
+      issues.push({
+        severity: "error",
+        code: "INVALID_EXECUTION_COUNT",
+        message: `Task "${name}" has negative execution count: ${ts.executionCount}`,
+        tasks: [name]
+      });
+    }
+    const maxExec = tasks[name].maxExecutions;
+    if (maxExec !== void 0 && ts.executionCount > maxExec) {
+      issues.push({
+        severity: "error",
+        code: "EXCEEDED_MAX_EXECUTIONS",
+        message: `Task "${name}" executed ${ts.executionCount} times, exceeding maxExecutions of ${maxExec}`,
+        tasks: [name]
       });
     }
-    return suggestions;
-  } catch {
-    return [];
   }
+  return buildResult2(issues);
 }
-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);
+function validateReactiveGraph(input) {
+  const { graph, handlers } = input;
+  const live = graph.getState();
+  const issues = [];
+  const tasks = getAllTasks(live.config);
+  const taskNames = Object.keys(tasks);
+  const handlerNames = new Set(Object.keys(handlers));
+  const referencedHandlers = /* @__PURE__ */ new Set();
+  for (const name of taskNames) {
+    const taskHandlers = tasks[name].taskHandlers;
+    if (taskHandlers) {
+      for (const h of taskHandlers) {
+        referencedHandlers.add(h);
+      }
+    }
   }
-  if (trimmed.startsWith("[")) return trimmed;
-  return null;
-}
-function createCliAdapter(opts) {
-  const timeout = opts.timeout ?? 6e4;
-  return {
-    analyze: (prompt) => {
-      return new Promise((resolve2, 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 {
-              resolve2(stdout);
-            }
-          }
-        );
-        if (opts.stdin && child.stdin) {
-          child.stdin.write(prompt);
-          child.stdin.end();
-        }
+  for (const name of taskNames) {
+    const taskHandlers = tasks[name].taskHandlers;
+    if (!taskHandlers) continue;
+    for (const h of taskHandlers) {
+      if (!handlers[h]) {
+        issues.push({
+          severity: "error",
+          code: "MISSING_HANDLER",
+          message: `Task "${name}" references handler "${h}" but it is not in the registry`,
+          tasks: [name]
+        });
+      }
+    }
+  }
+  for (const name of handlerNames) {
+    if (!referencedHandlers.has(name)) {
+      issues.push({
+        severity: "warning",
+        code: "ORPHAN_HANDLER",
+        message: `Handler "${name}" is registered but not referenced by any task's taskHandlers`,
+        tasks: [name]
       });
     }
-  };
+  }
+  const liveResult = validateLiveGraph(live);
+  issues.push(...liveResult.issues);
+  return buildResult2(issues);
 }
-function createHttpAdapter(opts) {
-  const timeout = opts.timeout ?? 6e4;
+function buildResult2(issues) {
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
   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)}`);
+    valid: errors.length === 0,
+    issues,
+    errors,
+    warnings
+  };
+}
+
+// src/continuous-event-graph/mutate.ts
+function mutateGraph(live, mutations) {
+  let current = live;
+  for (const mutation of mutations) {
+    current = applySingleMutation(current, mutation);
+  }
+  return current;
+}
+function applySingleMutation(live, mutation) {
+  switch (mutation.type) {
+    case "add-node":
+      return addNode(live, mutation.name, mutation.config);
+    case "remove-node":
+      return removeNode(live, mutation.name);
+    case "add-requires":
+      return addRequires(live, mutation.taskName, mutation.tokens);
+    case "remove-requires":
+      return removeRequires(live, mutation.taskName, mutation.tokens);
+    case "add-provides":
+      return addProvides(live, mutation.taskName, mutation.tokens);
+    case "remove-provides":
+      return removeProvides(live, mutation.taskName, mutation.tokens);
+    case "inject-tokens":
+      return injectTokens(live, mutation.tokens);
+    case "drain-tokens":
+      return drainTokens(live, mutation.tokens);
+    case "reset-node":
+      return resetNode(live, mutation.name);
+    case "disable-node":
+      return disableNode(live, mutation.name);
+    case "enable-node":
+      return enableNode(live, mutation.name);
+    case "apply-events":
+      return applyEvents(live, mutation.events);
+    default:
+      throw new Error(`Unknown mutation type: ${mutation.type}`);
+  }
+}
+function createCallbackHandler(fn, getResolve) {
+  return async (input) => {
+    const { callbackToken } = input;
+    Promise.resolve(fn(input)).then((data) => getResolve()(callbackToken, data)).catch((err) => getResolve()(callbackToken, {}, [err instanceof Error ? err.message : String(err)]));
+    return "task-initiated";
+  };
+}
+function createFireAndForgetHandler(fn, getResolve) {
+  return async (input) => {
+    const { callbackToken } = input;
+    Promise.resolve(fn(input)).then(() => getResolve()(callbackToken, {})).catch(() => getResolve()(callbackToken, {}));
+    return "task-initiated";
+  };
+}
+function createShellHandler(options) {
+  const {
+    command: commandTemplate,
+    cwd,
+    env,
+    timeoutMs = 3e4,
+    exitCodeMap,
+    captureOutput = false,
+    getResolve
+  } = options;
+  return async (input) => {
+    const { callbackToken, nodeId } = input;
+    const command = commandTemplate.replace(/\$\{taskName\}/g, nodeId);
+    child_process.exec(
+      command,
+      {
+        cwd,
+        env: env ? { ...process.env, ...env } : void 0,
+        timeout: timeoutMs,
+        maxBuffer: 10 * 1024 * 1024
+        // 10MB
+      },
+      (error, stdout, stderr) => {
+        const exitCode = error?.code ?? (error ? 1 : 0);
+        if (exitCode !== 0 && !exitCodeMap?.[exitCode]) {
+          getResolve()(callbackToken, {}, [`Command exited with code ${exitCode}: ${stderr || error?.message}`]);
+          return;
         }
-        const json = await response.json();
-        if (opts.extractResponse) {
-          return opts.extractResponse(json);
+        const data = {};
+        if (captureOutput) {
+          data.stdout = stdout;
+          data.stderr = stderr;
+          data.exitCode = exitCode;
         }
-        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);
+        getResolve()(callbackToken, data);
       }
-    }
+    );
+    return "task-initiated";
+  };
+}
+function detectRuntime(scriptPath) {
+  if (scriptPath.endsWith(".js") || scriptPath.endsWith(".mjs") || scriptPath.endsWith(".ts")) return "node";
+  if (scriptPath.endsWith(".py")) return "python3";
+  if (scriptPath.endsWith(".sh")) return "bash";
+  return "bash";
+}
+function createScriptHandler(options) {
+  const {
+    scriptPath,
+    runtime,
+    args = [],
+    cwd,
+    timeoutMs = 6e4,
+    captureOutput = false,
+    getResolve
+  } = options;
+  const resolvedRuntime = runtime ?? detectRuntime(scriptPath);
+  const shellArgs = [ctx_taskName_placeholder, ...args].join(" ");
+  const command = `${resolvedRuntime} ${scriptPath} ${shellArgs}`;
+  return createShellHandler({
+    command: command.replace(ctx_taskName_placeholder, "${taskName}"),
+    cwd,
+    timeoutMs,
+    captureOutput,
+    getResolve
+  });
+}
+var ctx_taskName_placeholder = "__TASK_NAME__";
+function createWebhookHandler(options) {
+  const {
+    url: urlTemplate,
+    method = "POST",
+    headers = {},
+    timeoutMs = 3e4,
+    failOnNon2xx = true,
+    getResolve
+  } = options;
+  return async (input) => {
+    const { callbackToken, nodeId, config } = input;
+    const url = urlTemplate.replace(/\$\{taskName\}/g, nodeId);
+    const body = JSON.stringify({
+      taskName: nodeId,
+      callbackToken,
+      config
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    fetch(url, {
+      method,
+      headers: { "Content-Type": "application/json", ...headers },
+      body,
+      signal: controller.signal
+    }).then(async (response) => {
+      clearTimeout(timer);
+      if (failOnNon2xx && !response.ok) {
+        const text = await response.text().catch(() => "");
+        getResolve()(callbackToken, {}, [`HTTP ${response.status}: ${text}`]);
+        return;
+      }
+      const data = await response.json().catch(() => ({}));
+      getResolve()(callbackToken, data);
+    }).catch((err) => {
+      clearTimeout(timer);
+      getResolve()(callbackToken, {}, [err instanceof Error ? err.message : String(err)]);
+    });
+    return "task-initiated";
+  };
+}
+function createNoopHandler(getResolve, staticData) {
+  return async (input) => {
+    getResolve()(input.callbackToken, staticData ?? {});
+    return "task-initiated";
   };
 }
 
@@ -11325,6 +11447,405 @@ var CardCompute = {
   }
 };
 
+// src/continuous-event-graph/live-cards-bridge.ts
+function liveCardsToReactiveGraph(input, options = {}) {
+  let cards;
+  let boardSettings = {};
+  let boardId;
+  if (!Array.isArray(input) && "nodes" in input) {
+    const board = input;
+    cards = board.nodes;
+    boardId = board.id;
+    boardSettings = board.settings ?? {};
+  } else {
+    cards = input;
+  }
+  const {
+    sourceHandlers = {},
+    defaultSourceHandler,
+    cardHandlers = {},
+    reactiveOptions = {},
+    graphSettings = {},
+    executionId
+  } = options;
+  const cardMap = /* @__PURE__ */ new Map();
+  for (const card of cards) {
+    if (cardMap.has(card.id)) {
+      throw new Error(`Duplicate card ID: "${card.id}"`);
+    }
+    cardMap.set(card.id, card);
+  }
+  const sharedState = options.sharedState ?? /* @__PURE__ */ new Map();
+  const tasks = {};
+  for (const card of cards) {
+    const requires = card.data?.requires ?? [];
+    for (const req of requires) {
+      if (!cardMap.has(req)) {
+        throw new Error(`Card "${card.id}" requires "${req}" but no card with that ID exists`);
+      }
+    }
+    tasks[card.id] = {
+      requires: requires.length > 0 ? requires : void 0,
+      provides: [card.id],
+      taskHandlers: [card.id],
+      // each card has a named handler matching its ID
+      description: card.meta?.title ?? `${card.type}: ${card.id}`
+    };
+  }
+  const config = {
+    id: boardId ?? `live-cards-${Date.now()}`,
+    settings: {
+      completion: "manual",
+      execution_mode: "eligibility-mode",
+      ...boardSettings,
+      ...graphSettings
+    },
+    tasks
+  };
+  const handlers = {};
+  let graphRef = null;
+  const getResolve = () => (token, data, errors) => {
+    graphRef.resolveCallback(token, data, errors);
+  };
+  for (const card of cards) {
+    if (card.type === "source") {
+      handlers[card.id] = buildSourceHandler(card, sourceHandlers, defaultSourceHandler, sharedState, getResolve);
+    } else {
+      handlers[card.id] = buildCardHandler(card, cardHandlers, sharedState, cardMap, getResolve);
+    }
+  }
+  const graph = createReactiveGraph(
+    config,
+    {
+      ...reactiveOptions,
+      handlers
+    },
+    executionId
+  );
+  graphRef = graph;
+  return { graph, config, handlers, cards: cardMap, sharedState };
+}
+function buildSourceHandler(card, sourceHandlers, defaultSourceHandler, sharedState, getResolve) {
+  if (sourceHandlers[card.id]) {
+    const userHandler = sourceHandlers[card.id];
+    return async (input) => {
+      return userHandler(input);
+    };
+  }
+  if (defaultSourceHandler) {
+    const factoryHandler = defaultSourceHandler(card);
+    return async (input) => {
+      return factoryHandler(input);
+    };
+  }
+  return async (input) => {
+    const state = { ...card.state };
+    sharedState.set(card.id, state);
+    getResolve()(input.callbackToken, state);
+    return "task-initiated";
+  };
+}
+function buildCardHandler(card, cardHandlers, sharedState, cardMap, getResolve) {
+  if (cardHandlers[card.id]) {
+    const userHandler = cardHandlers[card.id];
+    return async (input) => {
+      return userHandler(input);
+    };
+  }
+  return async (input) => {
+    const computeNode = {
+      id: card.id,
+      state: { ...card.state },
+      compute: card.compute
+    };
+    const requires = card.data?.requires ?? [];
+    for (const upstreamId of requires) {
+      const upstreamState = sharedState.get(upstreamId);
+      if (upstreamState) {
+        computeNode.state[upstreamId] = upstreamState;
+      }
+      const upstreamCard = cardMap.get(upstreamId);
+      if (upstreamCard?.data?.provides && upstreamState) {
+        for (const [key, bindRef] of Object.entries(upstreamCard.data.provides)) {
+          if (typeof bindRef === "string" && bindRef.startsWith("state.")) {
+            const path = bindRef.slice(6);
+            const value = deepGet2(upstreamState, path);
+            if (value !== void 0) {
+              computeNode.state[key] = value;
+            }
+          }
+        }
+      }
+    }
+    CardCompute.run(computeNode);
+    const resultState = { ...computeNode.state };
+    sharedState.set(card.id, resultState);
+    getResolve()(input.callbackToken, resultState);
+    return "task-initiated";
+  };
+}
+function deepGet2(obj, path) {
+  if (!path || !obj) return void 0;
+  const parts = path.split(".");
+  let cur = obj;
+  for (const part of parts) {
+    if (cur == null) return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+
+// 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((resolve2, 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 {
+              resolve2(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.CardCompute = CardCompute;
@@ -11354,15 +11875,21 @@ exports.buildInferencePrompt = buildInferencePrompt;
 exports.checkCircuitBreaker = checkCircuitBreaker;
 exports.computeAvailableOutputs = computeAvailableOutputs;
 exports.computeStepInput = computeStepInput;
+exports.createCallbackHandler = createCallbackHandler;
 exports.createCliAdapter = createCliAdapter;
-exports.createDefaultTaskState = createDefaultTaskState;
+exports.createDefaultGraphEngineStore = createDefaultGraphEngineStore;
 exports.createEngine = createStepMachine;
+exports.createFireAndForgetHandler = createFireAndForgetHandler;
 exports.createHttpAdapter = createHttpAdapter;
 exports.createInitialExecutionState = createInitialExecutionState;
 exports.createInitialState = createInitialState;
 exports.createLiveGraph = createLiveGraph;
+exports.createNoopHandler = createNoopHandler;
 exports.createReactiveGraph = createReactiveGraph;
+exports.createScriptHandler = createScriptHandler;
+exports.createShellHandler = createShellHandler;
 exports.createStepMachine = createStepMachine;
+exports.createWebhookHandler = createWebhookHandler;
 exports.detectStuckState = detectStuckState;
 exports.disableNode = disableNode;
 exports.drainTokens = drainTokens;
@@ -11394,8 +11921,10 @@ exports.isNonActiveTask = isNonActiveTask;
 exports.isRerunnable = isRerunnable;
 exports.isTaskCompleted = isTaskCompleted;
 exports.isTaskRunning = isTaskRunning;
+exports.liveCardsToReactiveGraph = liveCardsToReactiveGraph;
 exports.loadGraphConfig = loadGraphConfig;
 exports.loadStepFlow = loadStepFlow;
+exports.mutateGraph = mutateGraph;
 exports.next = next;
 exports.planExecution = planExecution;
 exports.removeNode = removeNode;
@@ -11412,6 +11941,8 @@ exports.validateGraph = validateGraph;
 exports.validateGraphConfig = validateGraphConfig;
 exports.validateGraphSchema = validateGraphSchema;
 exports.validateLiveCardSchema = validateLiveCardSchema;
+exports.validateLiveGraph = validateLiveGraph;
+exports.validateReactiveGraph = validateReactiveGraph;
 exports.validateStepFlowConfig = validateStepFlowConfig;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map