yaml-flow 2.3.0 → 2.5.0

package/README.md

@@ -839,6 +839,352 @@ Use `validateGraphConfig()` for structural checks (JSON shape) and `validateGrap
 
 ---
 
+## Continuous Event Graph
+
+A **long-lived, evolving** event-graph where both the graph config and execution state mutate over time. Ideal for dashboards, monitoring systems, and any scenario where the workflow has no fixed endpoint.
+
+The core type is `LiveGraph` — it bundles `config` + `state` so they can't get out of sync. Every function is pure: `f(LiveGraph, input) → LiveGraph`.
+
+```typescript
+import {
+  createLiveGraph, applyEvent,
+  addNode, removeNode,
+  addRequires, removeRequires, addProvides, removeProvides,
+  injectTokens, drainTokens,
+  schedule, inspect,
+  resetNode, disableNode, enableNode, getNode,
+  snapshot, restore,
+  getUnreachableTokens, getUnreachableNodes,
+  getUpstream, getDownstream,
+} from 'yaml-flow/continuous-event-graph';
+```
+
+### Quick Start
+
+```typescript
+import { createLiveGraph, applyEvent, addNode, schedule, inspect } from 'yaml-flow/continuous-event-graph';
+
+// 1. Bootstrap
+let live = createLiveGraph({
+  settings: { completion: 'manual' },
+  tasks: {
+    fetch_prices: { provides: ['price-data'] },
+    compute:      { requires: ['price-data'], provides: ['indicators'] },
+  },
+});
+
+// 2. Schedule — what's ready?
+schedule(live).eligible;  // ['fetch_prices']
+
+// 3. Apply events — immutable state transitions
+live = applyEvent(live, { type: 'task-started', taskName: 'fetch_prices', timestamp: new Date().toISOString() });
+live = applyEvent(live, { type: 'task-completed', taskName: 'fetch_prices', timestamp: new Date().toISOString() });
+schedule(live).eligible;  // ['compute']
+
+// 4. Evolve — add a node at runtime
+live = addNode(live, 'alert', { requires: ['indicators'], provides: ['alert-sent'] });
+
+// 5. Health check
+inspect(live);  // { totalNodes: 3, running: 0, completed: 1, ... }
+```
+
+### Graph Mutations
+
+| Function | Description |
+|---|---|
+| `addNode(live, name, config)` | Add a task to the graph (config + state) |
+| `removeNode(live, name)` | Remove a task from the graph |
+| `addRequires(live, node, tokens)` | Add requires tokens to a node |
+| `removeRequires(live, node, tokens)` | Remove requires tokens from a node |
+| `addProvides(live, node, tokens)` | Add provides tokens to a node |
+| `removeProvides(live, node, tokens)` | Remove provides tokens from a node |
+
+### Token Management
+
+```typescript
+// Inject external data/signals
+live = injectTokens(live, ['market-open', 'price-data']);
+
+// Drain stale/expired tokens
+live = drainTokens(live, ['price-data']);  // forces re-fetch before downstream can run
+```
+
+### Node Lifecycle
+
+| Function | Description |
+|---|---|
+| `resetNode(live, name)` | Reset a node to `not-started` (for retry) |
+| `disableNode(live, name)` | Set a node to `inactivated` (scheduler skips it) |
+| `enableNode(live, name)` | Re-enable a disabled node |
+| `getNode(live, name)` | Get config + state for a single node |
+
+### Graph Traversal
+
+```typescript
+// "What feeds into generate_signals?"
+const upstream = getUpstream(live, 'generate_signals');
+upstream.nodes;   // [{ nodeName: 'fetch_prices', providesTokens: ['price-data'] }, ...]
+upstream.tokens;  // ['price-data', 'indicators', ...]
+
+// "What breaks if fetch_prices goes down?"
+const downstream = getDownstream(live, 'fetch_prices');
+downstream.nodes;   // [{ nodeName: 'compute', requiresTokens: ['price-data'] }, ...]
+downstream.tokens;  // ['price-data', 'indicators', ...]
+```
+
+### Reachability Analysis
+
+```typescript
+// Tokens that can never be produced given the current state
+const unreachableTokens = getUnreachableTokens(live);
+unreachableTokens.tokens;  // [{ token: 'ghost', reason: 'no-producer', producers: [] }]
+
+// Nodes that can never become eligible
+const unreachableNodes = getUnreachableNodes(live);
+unreachableNodes.nodes;  // [{ nodeName: 'orphan', missingTokens: ['ghost'] }]
+```
+
+### Persistence
+
+```typescript
+// Save
+const snap = snapshot(live);        // JSON-safe object
+localStorage.setItem('graph', JSON.stringify(snap));
+
+// Restore
+const data = JSON.parse(localStorage.getItem('graph')!);
+const restored = restore(data);     // → LiveGraph (validates shape)
+```
+
+### Continuous Event Graph API Reference
+
+| Function | Description |
+|---|---|
+| `createLiveGraph(config, id?)` | Bootstrap a LiveGraph from a GraphConfig |
+| `applyEvent(live, event)` | Apply an execution event (task-started, task-completed, etc.) |
+| `addNode(live, name, config)` | Add a node (both config + state) |
+| `removeNode(live, name)` | Remove a node |
+| `addRequires / removeRequires` | Wire/unwire requires tokens |
+| `addProvides / removeProvides` | Wire/unwire provides tokens |
+| `injectTokens(live, tokens)` | Add tokens to available outputs |
+| `drainTokens(live, tokens)` | Remove tokens from available outputs |
+| `schedule(live)` | Classify tasks: eligible / pending / unresolved / blocked / conflicts |
+| `inspect(live)` | Health report: statuses, cycles, open deps, conflicts |
+| `resetNode(live, name)` | Reset node to not-started |
+| `disableNode(live, name)` | Disable a node (inactivated) |
+| `enableNode(live, name)` | Re-enable a disabled node |
+| `getNode(live, name)` | Get a node's config + state |
+| `getUpstream(live, name)` | Transitive upstream: what feeds into this node? |
+| `getDownstream(live, name)` | Transitive downstream: what depends on this node? |
+| `getUnreachableTokens(live)` | Tokens that can never be produced |
+| `getUnreachableNodes(live)` | Nodes that can never become eligible |
+| `snapshot(live)` | Serialize to a JSON-safe snapshot |
+| `restore(data)` | Restore a LiveGraph from a snapshot |
+
+---
+
+## LLM Inference
+
+Pluggable AI-assisted completion detection. The caller provides the LLM via an `InferenceAdapter` — yaml-flow builds the prompt, parses the response, and applies the results. Core stays pure; inference is opt-in.
+
+```typescript
+import {
+  buildInferencePrompt, inferCompletions, applyInferences, inferAndApply,
+} from 'yaml-flow/inference';
+```
+
+### Inference Hints on Nodes
+
+Add optional `inference` metadata to any `TaskConfig`:
+
+```typescript
+const config = {
+  settings: { completion: 'all-tasks' },
+  tasks: {
+    'infra-provisioned': {
+      provides: ['infra-ready'],
+      inference: {
+        criteria: 'All Azure resources provisioned successfully',
+        keywords: ['azure', 'deployment', 'provisioning'],
+        suggestedChecks: ['scan logs for "Deployment Succeeded"'],
+        autoDetectable: true,   // LLM will analyze this node
+      },
+    },
+    'app-deployed': {
+      requires: ['infra-ready'],
+      provides: ['app-ready'],
+      inference: {
+        criteria: 'Health check returns HTTP 200',
+        autoDetectable: true,
+      },
+    },
+    'monitoring': {                         // no inference → LLM skips it
+      requires: ['app-ready'],
+      provides: ['monitored'],
+    },
+  },
+};
+```
+
+### Pluggable Adapter
+
+Implement one method — `analyze(prompt) → string`:
+
+```typescript
+import type { InferenceAdapter } from 'yaml-flow/inference';
+
+// OpenAI
+const openaiAdapter: InferenceAdapter = {
+  analyze: async (prompt) => {
+    const res = await openai.chat.completions.create({
+      model: 'gpt-4o', messages: [{ role: 'user', content: prompt }],
+    });
+    return res.choices[0].message.content ?? '[]';
+  },
+};
+
+// Anthropic
+const claudeAdapter: InferenceAdapter = {
+  analyze: async (prompt) => {
+    const res = await anthropic.messages.create({
+      model: 'claude-sonnet-4-20250514', max_tokens: 1024,
+      messages: [{ role: 'user', content: prompt }],
+    });
+    return res.content[0].type === 'text' ? res.content[0].text : '[]';
+  },
+};
+
+// Any HTTP endpoint
+const customAdapter: InferenceAdapter = {
+  analyze: async (prompt) => {
+    const res = await fetch('https://my-llm/analyze', {
+      method: 'POST', body: JSON.stringify({ prompt }),
+    });
+    return (await res.json()).response;
+  },
+};
+```
+
+### Built-in Adapter Factories
+
+Zero-boilerplate adapters for common patterns:
+
+```typescript
+import { createCliAdapter, createHttpAdapter } from 'yaml-flow/inference';
+
+// Ollama via HTTP
+const ollama = createHttpAdapter({
+  url: 'http://localhost:11434/api/generate',
+  buildBody: (prompt) => ({ model: 'llama3', prompt, stream: false }),
+  extractResponse: (json) => json.response,
+});
+
+// Ollama via CLI
+const ollamaCli = createCliAdapter({
+  command: 'ollama',
+  args: (prompt) => ['run', 'llama3', prompt],
+});
+
+// Simon Willison's llm CLI (stdin mode for long prompts)
+const llm = createCliAdapter({
+  command: 'llm',
+  args: () => ['--no-stream'],
+  stdin: true,
+});
+
+// Custom Python script
+const custom = createCliAdapter({
+  command: 'python',
+  args: (prompt) => ['scripts/infer.py', '--json', prompt],
+  cwd: '/path/to/project',
+  env: { MODEL: 'gpt-4o' },
+  timeout: 60_000,
+});
+```
+
+**`createCliAdapter(options)`** — spawns a child process, captures stdout:
+| Option | Type | Description |
+|--------|------|-------------|
+| `command` | `string` | Executable to run (`ollama`, `llm`, `python`, `gh`, …) |
+| `args` | `(prompt) => string[]` | Build argument list from the prompt |
+| `stdin` | `boolean` | Pipe prompt via stdin instead of args (default: `false`) |
+| `timeout` | `number` | Kill after N ms (default: `30000`) |
+| `cwd` | `string` | Working directory |
+| `env` | `Record<string, string>` | Extra environment variables |
+
+**`createHttpAdapter(options)`** — POSTs to an HTTP endpoint:
+| Option | Type | Description |
+|--------|------|-------------|
+| `url` | `string` | Endpoint URL |
+| `headers` | `Record<string, string>` | Request headers |
+| `buildBody` | `(prompt) => object` | Build request body (default: `{ prompt }`) |
+| `extractResponse` | `(json) => string` | Extract text from response JSON |
+| `timeout` | `number` | Abort after N ms (default: `30000`) |
+```
+
+### Three APIs: Build → Suggest → Apply
+
+```typescript
+import { createLiveGraph } from 'yaml-flow/continuous-event-graph';
+import { buildInferencePrompt, inferCompletions, applyInferences } from 'yaml-flow/inference';
+
+let live = createLiveGraph(config);
+
+// 1. BUILD: Generate the prompt (pure, sync)
+const prompt = buildInferencePrompt(live, {
+  context: 'Deployment log: "Deployment Succeeded", health check: HTTP 200',
+});
+
+// 2. SUGGEST: Ask the LLM (async)
+const result = await inferCompletions(live, adapter, {
+  threshold: 0.8,
+  context: 'Deployment log: ...',
+});
+result.suggestions;  // [{ taskName, confidence, reasoning, detectionMethod }]
+
+// 3. APPLY: Accept high-confidence suggestions (pure, sync)
+live = applyInferences(live, result, 0.8);  // only applies >= 80% confidence
+```
+
+### One-Shot Convenience
+
+```typescript
+import { inferAndApply } from 'yaml-flow/inference';
+
+const { live: updated, applied, skipped, inference } = await inferAndApply(
+  live, adapter, { threshold: 0.8, context: 'deployment logs...' }
+);
+
+console.log('Auto-completed:', applied.map(s => s.taskName));
+console.log('Skipped (low confidence):', skipped.map(s => `${s.taskName} (${s.confidence})`));
+```
+
+### Inference API Reference
+
+| Function | Description |
+|---|---|
+| `buildInferencePrompt(live, opts?)` | Build LLM prompt from graph state (pure, sync) |
+| `inferCompletions(live, adapter, opts?)` | Ask LLM to suggest completions (async) |
+| `applyInferences(live, result, threshold?)` | Apply suggestions above threshold (pure, sync) |
+| `inferAndApply(live, adapter, opts?)` | Infer + apply in one step (async, convenience) |
+| `createCliAdapter(opts)` | Factory: adapter that spawns a CLI command |
+| `createHttpAdapter(opts)` | Factory: adapter that POSTs to an HTTP endpoint |
+
+### Inference Types
+
+| Type | Description |
+|---|---|
+| `InferenceAdapter` | `{ analyze(prompt: string): Promise<string> }` — pluggable LLM bridge |
+| `InferenceHints` | `criteria`, `keywords`, `suggestedChecks`, `autoDetectable` on a TaskConfig |
+| `InferenceOptions` | `threshold`, `scope`, `context`, `systemPrompt` |
+| `InferenceResult` | `suggestions[]`, `promptUsed`, `rawResponse`, `analyzedNodes` |
+| `InferredCompletion` | `taskName`, `confidence`, `reasoning`, `detectionMethod: 'llm-inferred'` |
+| `InferAndApplyResult` | `live`, `inference`, `applied[]`, `skipped[]` |
+| `CliAdapterOptions` | `command`, `args`, `stdin`, `timeout`, `cwd`, `env` |
+| `HttpAdapterOptions` | `url`, `headers`, `buildBody`, `extractResponse`, `timeout` |
+
+---
+
 ## Loading & Exporting Graph Configs
 
 ```typescript
@@ -886,6 +1232,23 @@ import type { BatchOptions, BatchResult, BatchItemResult, BatchProgress } from '
 // Config utilities
 import { resolveVariables, resolveConfigTemplates } from 'yaml-flow/config';
 
+// Continuous Event Graph (long-lived evolving workflows)
+import {
+  createLiveGraph, applyEvent, addNode, removeNode,
+  addRequires, removeRequires, addProvides, removeProvides,
+  injectTokens, drainTokens, schedule, inspect,
+  resetNode, disableNode, enableNode, getNode,
+  snapshot, restore,
+  getUnreachableTokens, getUnreachableNodes,
+  getUpstream, getDownstream,
+} from 'yaml-flow/continuous-event-graph';
+
+// LLM Inference (AI-assisted completion detection)
+import {
+  buildInferencePrompt, inferCompletions, applyInferences, inferAndApply,
+} from 'yaml-flow/inference';
+import type { InferenceAdapter, InferenceResult, InferenceOptions } from 'yaml-flow/inference';
+
 // Backward compatibility (v1 names → v2)
 import { FlowEngine, createEngine } from 'yaml-flow';  // aliases for StepMachine, createStepMachine
 ```
@@ -957,6 +1320,11 @@ See the [examples/](./examples) directory:
 | [Batch Tickets](./examples/batch/batch-step-machine.ts) | Batch | Concurrent processing, progress tracking |
 | [URL Pipeline](./examples/graph-of-graphs/url-processing-pipeline.ts) | Graph-of-Graphs | Outer event-graph → batch × inner event-graph per item |
 | [Multi-Stage ETL](./examples/graph-of-graphs/multi-stage-etl.ts) | Graph-of-Graphs | Mixed modes: event-graph outer → step-machine + event-graph subs |
+| [Stock Dashboard](./examples/continuous-event-graph/stock-dashboard.ts) | Continuous Event Graph | Runtime mutations, token drain, upstream/downstream, snapshot |
+| [Azure Deployment](./examples/inference/azure-deployment.ts) | Inference | LLM analyzes deployment logs, auto-completes checkpoints |
+| [Data Pipeline](./examples/inference/data-pipeline.ts) | Inference | Iterative inference — evidence arrives in waves |
+| [Pluggable Adapters](./examples/inference/pluggable-adapters.ts) | Inference | OpenAI, Anthropic, Azure, CLI, HTTP adapter factories |
+| [Copilot CLI](./examples/inference/copilot-cli.ts) | Inference | GitHub Copilot CLI as inference adapter via `createCliAdapter` |
 | [Order Processing](./examples/flows/order-processing.yaml) | Step Machine | YAML flow definition |
 | [Browser Demo](./examples/browser/index.html) | Step Machine | In-browser usage |
 

package/dist/{constants-DMbnp--H.d.ts → constants-BEbO2_OK.d.ts}

@@ -1,191 +1,6 @@
+import { G as GraphConfig, c as ExecutionState, S as SchedulerResult, e as GraphEvent, T as TaskConfig, l as TaskState, g as StuckDetection, C as CompletionStrategy, a as ConflictStrategy, b as ExecutionMode, d as ExecutionStatus, m as TaskStatus } from './types-DAI_a2as.js';
 import { e as StepFlowConfig } from './types-FZ_eyErS.js';
 
-/**
- * Event Graph — Core Types
- *
- * Type definitions for the stateless event-graph engine.
- * Pure: f(state, event) → newState
- */
-interface GraphConfig {
-    id?: string;
-    settings: GraphSettings;
-    tasks: Record<string, TaskConfig>;
-}
-interface GraphSettings {
-    /** Completion strategy */
-    completion: CompletionStrategy;
-    /** Conflict resolution strategy */
-    conflict_strategy?: ConflictStrategy;
-    /** Execution mode */
-    execution_mode?: ExecutionMode;
-    /** Goal outputs — used with 'goal-reached' completion */
-    goal?: string[];
-    /** Max total scheduler iterations (safety limit, default: 1000) */
-    max_iterations?: number;
-    /** Timeout in ms (declared for drivers, not enforced by pure engine) */
-    timeout_ms?: number;
-}
-interface TaskConfig {
-    /** What this task needs to become eligible */
-    requires?: string[];
-    /** What this task produces on successful completion */
-    provides: string[];
-    /** Conditional provides based on handler result */
-    on?: Record<string, string[]>;
-    /** Tokens to inject into available outputs on failure */
-    on_failure?: string[];
-    /** Task execution method (informational — driver concern) */
-    method?: string;
-    /** Arbitrary task configuration (driver concern) */
-    config?: Record<string, unknown>;
-    /** Task priority (higher = preferred in conflict resolution) */
-    priority?: number;
-    /** Estimated duration in ms (used by duration-first strategy) */
-    estimatedDuration?: number;
-    /** Estimated cost (used by cost-optimized strategy) */
-    estimatedCost?: number;
-    /** Resource requirements (used by resource-aware strategy) */
-    estimatedResources?: Record<string, number>;
-    /** Retry configuration */
-    retry?: TaskRetryConfig;
-    /** Repeatable task configuration */
-    repeatable?: boolean | RepeatableConfig;
-    /** Circuit breaker: max executions before breaking */
-    circuit_breaker?: TaskCircuitBreakerConfig;
-    /** Description */
-    description?: string;
-}
-interface TaskRetryConfig {
-    max_attempts: number;
-    delay_ms?: number;
-    backoff_multiplier?: number;
-}
-interface RepeatableConfig {
-    /** Max times this task can repeat (undefined = unlimited) */
-    max?: number;
-}
-interface TaskCircuitBreakerConfig {
-    /** Max executions before injecting break tokens */
-    max_executions: number;
-    /** Tokens to inject when breaker trips */
-    on_break: string[];
-}
-interface ExecutionState {
-    /** Current status of the execution */
-    status: ExecutionStatus;
-    /** Task states keyed by task name */
-    tasks: Record<string, TaskState>;
-    /** Tokens currently available in the system */
-    availableOutputs: string[];
-    /** Stuck detection result */
-    stuckDetection: StuckDetection;
-    /** Last update timestamp */
-    lastUpdated: string;
-    /** Execution ID for this run */
-    executionId: string | null;
-    /** Execution configuration */
-    executionConfig: ExecutionConfig;
-}
-interface ExecutionConfig {
-    executionMode: ExecutionMode;
-    conflictStrategy: ConflictStrategy;
-    completionStrategy: CompletionStrategy;
-}
-interface TaskState {
-    status: TaskStatus;
-    executionCount: number;
-    retryCount: number;
-    lastEpoch: number;
-    startedAt?: string;
-    completedAt?: string;
-    failedAt?: string;
-    lastUpdated?: string;
-    error?: string;
-    messages?: TaskMessage[];
-    progress?: number | null;
-}
-interface TaskMessage {
-    message: string;
-    timestamp: string;
-    status: string;
-}
-interface StuckDetection {
-    is_stuck: boolean;
-    stuck_description: string | null;
-    outputs_unresolvable: string[];
-    tasks_blocked: string[];
-}
-type GraphEvent = TaskStartedEvent | TaskCompletedEvent | TaskFailedEvent | TaskProgressEvent | InjectTokensEvent | AgentActionEvent | TaskCreationEvent;
-interface TaskStartedEvent {
-    type: 'task-started';
-    taskName: string;
-    timestamp: string;
-    executionId?: string;
-}
-interface TaskCompletedEvent {
-    type: 'task-completed';
-    taskName: string;
-    /** Handler result key — used for conditional routing via `on` */
-    result?: string;
-    /** Data payload from task execution */
-    data?: Record<string, unknown>;
-    timestamp: string;
-    executionId?: string;
-}
-interface TaskFailedEvent {
-    type: 'task-failed';
-    taskName: string;
-    error: string;
-    timestamp: string;
-    executionId?: string;
-}
-interface TaskProgressEvent {
-    type: 'task-progress';
-    taskName: string;
-    message?: string;
-    progress?: number;
-    timestamp: string;
-    executionId?: string;
-}
-interface InjectTokensEvent {
-    type: 'inject-tokens';
-    tokens: string[];
-    timestamp: string;
-}
-interface AgentActionEvent {
-    type: 'agent-action';
-    action: 'start' | 'stop' | 'pause' | 'resume';
-    timestamp: string;
-    config?: Partial<ExecutionConfig>;
-}
-interface TaskCreationEvent {
-    type: 'task-creation';
-    taskName: string;
-    taskConfig: TaskConfig;
-    timestamp: string;
-}
-interface SchedulerResult {
-    /** Tasks eligible for execution */
-    eligibleTasks: string[];
-    /** Whether the graph execution is complete */
-    isComplete: boolean;
-    /** Stuck detection result */
-    stuckDetection: StuckDetection;
-    /** Whether conflicts were detected */
-    hasConflicts: boolean;
-    /** Conflict groups: output → competing task names */
-    conflicts: Record<string, string[]>;
-    /** Strategy used for conflict resolution */
-    strategy: ConflictStrategy;
-    /** Processing log for diagnostics */
-    processingLog: string[];
-}
-type TaskStatus = 'not-started' | 'running' | 'completed' | 'failed' | 'inactivated';
-type ExecutionStatus = 'created' | 'running' | 'paused' | 'stopped' | 'completed' | 'failed';
-type CompletionStrategy = 'all-tasks-done' | 'all-outputs-done' | 'only-resolved' | 'goal-reached' | 'manual';
-type ExecutionMode = 'dependency-mode' | 'eligibility-mode';
-type ConflictStrategy = 'alphabetical' | 'priority-first' | 'duration-first' | 'cost-optimized' | 'resource-aware' | 'random-select' | 'user-choice' | 'parallel-all' | 'skip-conflicts' | 'round-robin';
-
 /**
  * Event Graph — Scheduler
  *
@@ -504,4 +319,4 @@ declare const DEFAULTS: {
     readonly MAX_ITERATIONS: 1000;
 };
 
-export { isTaskCompleted as $, type AgentActionEvent as A, applyAll as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, computeAvailableOutputs as F, type GraphConfig as G, createDefaultTaskState as H, type InjectTokensEvent as I, createInitialExecutionState as J, detectStuckState as K, exportGraphConfig as L, type MermaidOptions as M, exportGraphConfigToFile as N, flowToMermaid as O, getAllTasks as P, getCandidateTasks as Q, getProvides as R, type SchedulerResult as S, type TaskConfig as T, getRequires as U, getTask as V, graphToMermaid as W, hasTask as X, isExecutionComplete as Y, isNonActiveTask as Z, isRepeatableTask as _, CONFLICT_STRATEGIES as a, isTaskRunning as a0, loadGraphConfig as a1, next as a2, planExecution as a3, validateGraph as a4, validateGraphConfig as a5, type RepeatableConfig as a6, type TaskCircuitBreakerConfig as a7, type TaskMessage as a8, type TaskProgressEvent as a9, type TaskRetryConfig as aa, addKeyToProvides as ab, addKeyToRequires as ac, getRepeatableMax as ad, groupTasksByProvides as ae, hasOutputConflict as af, removeKeyFromProvides as ag, removeKeyFromRequires as ah, type CompletionResult as b, type CompletionStrategy as c, type ConflictStrategy as d, EXECUTION_STATUS as e, type ExecutionConfig as f, type ExecutionMode as g, type ExecutionPlan as h, type ExecutionState as i, type ExecutionStatus as j, type ExportOptions as k, type GraphEvent as l, type GraphIssue as m, type GraphSettings as n, type GraphValidationResult as o, type IssueSeverity as p, type StuckDetection as q, TASK_STATUS as r, type TaskCompletedEvent as s, type TaskCreationEvent as t, type TaskFailedEvent as u, type TaskStartedEvent as v, type TaskState as w, type TaskStatus as x, addDynamicTask as y, apply as z };
+export { isTaskCompleted as A, isTaskRunning as B, COMPLETION_STRATEGIES as C, DEFAULTS as D, EXECUTION_MODES as E, loadGraphConfig as F, type GraphIssue as G, next as H, type IssueSeverity as I, planExecution as J, validateGraph as K, validateGraphConfig as L, type MermaidOptions as M, addKeyToProvides as N, addKeyToRequires as O, getRepeatableMax as P, groupTasksByProvides as Q, hasOutputConflict as R, removeKeyFromProvides as S, TASK_STATUS as T, removeKeyFromRequires as U, CONFLICT_STRATEGIES as a, type CompletionResult as b, EXECUTION_STATUS as c, type ExecutionPlan as d, type ExportOptions as e, type GraphValidationResult as f, addDynamicTask as g, apply as h, applyAll as i, computeAvailableOutputs as j, createDefaultTaskState as k, createInitialExecutionState as l, detectStuckState as m, exportGraphConfig as n, exportGraphConfigToFile as o, flowToMermaid as p, getAllTasks as q, getCandidateTasks as r, getProvides as s, getRequires as t, getTask as u, graphToMermaid as v, hasTask as w, isExecutionComplete as x, isNonActiveTask as y, isRepeatableTask as z };