agentflow-core 0.3.3 → 0.5.0

package/dist/index.d.ts

@@ -276,6 +276,224 @@ interface MutableExecutionNode {
  */
 declare function createGraphBuilder(config?: AgentFlowConfig): GraphBuilder;
 
+/**
+ * Pure query functions for interrogating a built `ExecutionGraph`.
+ * Every function takes a frozen graph and returns derived data without mutation.
+ * @module
+ */
+
+/**
+ * Find a node by its ID.
+ *
+ * @param graph - The execution graph to search.
+ * @param nodeId - The node ID to look up.
+ * @returns The node, or `undefined` if not found.
+ *
+ * @example
+ * ```ts
+ * const node = getNode(graph, 'node_002');
+ * if (node) console.log(node.name);
+ * ```
+ */
+declare function getNode(graph: ExecutionGraph, nodeId: string): ExecutionNode | undefined;
+/**
+ * Get the direct children of a node.
+ *
+ * @param graph - The execution graph to search.
+ * @param nodeId - The parent node ID.
+ * @returns Array of child nodes (may be empty).
+ *
+ * @example
+ * ```ts
+ * const children = getChildren(graph, rootId);
+ * ```
+ */
+declare function getChildren(graph: ExecutionGraph, nodeId: string): ExecutionNode[];
+/**
+ * Get the parent of a node.
+ *
+ * @param graph - The execution graph to search.
+ * @param nodeId - The child node ID.
+ * @returns The parent node, or `undefined` if root or not found.
+ *
+ * @example
+ * ```ts
+ * const parent = getParent(graph, toolId);
+ * ```
+ */
+declare function getParent(graph: ExecutionGraph, nodeId: string): ExecutionNode | undefined;
+/**
+ * Find all nodes with a failure-category status: `failed`, `hung`, or `timeout`.
+ *
+ * @param graph - The execution graph to search.
+ * @returns Array of nodes with failure statuses (may be empty).
+ */
+declare function getFailures(graph: ExecutionGraph): ExecutionNode[];
+/**
+ * Find all nodes that are still running (status `'running'`, no endTime).
+ *
+ * @param graph - The execution graph to search.
+ * @returns Array of running/hung nodes.
+ */
+declare function getHungNodes(graph: ExecutionGraph): ExecutionNode[];
+/**
+ * Find the critical path: the longest-duration path from the root to any leaf node.
+ * Uses node duration (endTime - startTime) as the weight.
+ * Running nodes use `Date.now()` as a provisional endTime.
+ *
+ * @param graph - The execution graph to analyse.
+ * @returns Nodes ordered from root to the deepest leaf on the longest path.
+ */
+declare function getCriticalPath(graph: ExecutionGraph): ExecutionNode[];
+/**
+ * Find what a node is waiting on.
+ * Returns nodes connected via `waited_on` edges where the given nodeId is the `from` side.
+ *
+ * @param graph - The execution graph to search.
+ * @param nodeId - The node that is doing the waiting.
+ * @returns Array of nodes that are being waited on.
+ */
+declare function findWaitingOn(graph: ExecutionGraph, nodeId: string): ExecutionNode[];
+/**
+ * Get all descendants of a node (children, grandchildren, etc.) in breadth-first order.
+ * The given node itself is NOT included.
+ *
+ * @param graph - The execution graph to search.
+ * @param nodeId - The ancestor node ID.
+ * @returns All descendant nodes in BFS order.
+ */
+declare function getSubtree(graph: ExecutionGraph, nodeId: string): ExecutionNode[];
+/**
+ * Total wall-clock duration of the graph in milliseconds.
+ * If the graph is still running, uses `Date.now()` as the provisional end.
+ *
+ * @param graph - The execution graph.
+ * @returns Duration in milliseconds.
+ */
+declare function getDuration(graph: ExecutionGraph): number;
+/**
+ * Maximum nesting depth of the graph. The root node is depth 0.
+ *
+ * @param graph - The execution graph.
+ * @returns The maximum depth (0 for a single-node graph, -1 for empty).
+ */
+declare function getDepth(graph: ExecutionGraph): number;
+/**
+ * Compute aggregate statistics for the execution graph.
+ *
+ * @param graph - The execution graph to analyse.
+ * @returns Statistics including node counts by type and status, depth, duration, and failure counts.
+ *
+ * @example
+ * ```ts
+ * const stats = getStats(graph);
+ * console.log(`${stats.totalNodes} nodes, ${stats.failureCount} failures`);
+ * ```
+ */
+declare function getStats(graph: ExecutionGraph): GraphStats;
+
+declare function groupByTraceId(graphs: ExecutionGraph[]): Map<string, ExecutionGraph[]>;
+declare function stitchTrace(graphs: ExecutionGraph[]): DistributedTrace;
+declare function getTraceTree(trace: DistributedTrace): ExecutionGraph[];
+
+/**
+ * Runtime guards for detecting problematic agent behaviors during graph construction.
+ *
+ * Guards operate on ExecutionGraph snapshots and detect three types of violations:
+ * - Long-running spans: nodes that exceed timeout thresholds for their type
+ * - Reasoning loops: consecutive nodes of the same type in a parent-child chain
+ * - Spawn explosion: excessive depth or agent/subagent spawn counts
+ *
+ * @module
+ */
+
+/**
+ * Configuration for runtime guard detection.
+ */
+interface GuardConfig {
+    /** Timeout thresholds per node type in milliseconds. */
+    readonly timeouts?: Partial<Record<NodeType, number>>;
+    /** Maximum consecutive same-type nodes before flagging reasoning loop (default: 25). */
+    readonly maxReasoningSteps?: number;
+    /** Maximum graph depth before flagging spawn explosion (default: 10). */
+    readonly maxDepth?: number;
+    /** Maximum total agent/subagent nodes before flagging spawn explosion (default: 50). */
+    readonly maxAgentSpawns?: number;
+    /** Action to take when guard violations are detected. */
+    readonly onViolation?: 'warn' | 'error' | 'abort';
+    /** Custom logger for warnings (defaults to console.warn). */
+    readonly logger?: (message: string) => void;
+}
+/**
+ * A detected guard violation.
+ */
+interface GuardViolation {
+    readonly type: 'timeout' | 'reasoning-loop' | 'spawn-explosion';
+    readonly nodeId: string;
+    readonly message: string;
+    readonly timestamp: number;
+}
+/**
+ * Check an execution graph for guard violations.
+ *
+ * This is a pure function that analyzes a graph snapshot and returns detected violations
+ * without modifying the graph or producing side effects.
+ *
+ * @param graph - The execution graph to analyze.
+ * @param config - Optional guard configuration.
+ * @returns Array of detected violations (may be empty).
+ *
+ * @example
+ * ```ts
+ * const violations = checkGuards(graph, { maxDepth: 5 });
+ * if (violations.length > 0) {
+ *   console.log(`Found ${violations.length} violations`);
+ * }
+ * ```
+ */
+declare function checkGuards(graph: ExecutionGraph, config?: GuardConfig): readonly GuardViolation[];
+/**
+ * Create a guard-aware wrapper around a GraphBuilder.
+ *
+ * The returned builder has an identical interface to the original but intercepts
+ * `endNode` and `build` calls to check for guard violations. Violations are handled
+ * according to the `onViolation` configuration.
+ *
+ * @param builder - The original GraphBuilder to wrap.
+ * @param config - Guard configuration.
+ * @returns A GraphBuilder with identical interface but guard protection.
+ *
+ * @example
+ * ```ts
+ * const raw = createGraphBuilder({ agentId: 'test' });
+ * const guarded = withGuards(raw, { maxDepth: 5, onViolation: 'abort' });
+ *
+ * // Use exactly like a normal builder
+ * const root = guarded.startNode({ type: 'agent', name: 'main' });
+ * guarded.endNode(root); // Will check for violations
+ * ```
+ */
+declare function withGuards(builder: GraphBuilder, config?: GuardConfig): GraphBuilder;
+
+/**
+ * AgentFlow Live Monitor — real-time terminal dashboard for any agent system.
+ *
+ * Auto-detects and displays data from any JSON/JSONL files in the watched
+ * directory. Works with agentflow traces, generic state files, job
+ * schedulers, session logs — no configuration needed.
+ *
+ * File detection:
+ *   .json with `nodes` + `agentId`          → AgentFlow trace (full analysis)
+ *   .json with array of objects with `state` → Job/task list (per-item status)
+ *   .json with `status`/`pid`/`tools`        → Process/worker state
+ *   .json with any other structure            → Generic state (mtime-based)
+ *   .jsonl                                    → Session log (last entry status)
+ *
+ * @module
+ */
+
+declare function startLive(argv: string[]): void;
+
 /**
  * Load and deserialize execution graphs from JSON.
  *
@@ -378,23 +596,89 @@ interface RunResult {
 declare function runTraced(config: RunConfig): Promise<RunResult>;
 
 /**
- * AgentFlow Live Monitor — real-time terminal dashboard for any agent system.
+ * JSON file-based trace storage for ExecutionGraphs.
  *
- * Auto-detects and displays data from any JSON/JSONL files in the watched
- * directory. Works with agentflow traces, generic state files, job
- * schedulers, session logs — no configuration needed.
+ * One JSON file per graph, using existing graphToJson/loadGraph for serialization.
+ * Compatible with `agentflow watch` auto-detection.
  *
- * File detection:
- *   .json with `nodes` + `agentId`          → AgentFlow trace (full analysis)
- *   .json with array of objects with `state` → Job/task list (per-item status)
- *   .json with `status`/`pid`/`tools`        → Process/worker state
- *   .json with any other structure            → Generic state (mtime-based)
- *   .jsonl                                    → Session log (last entry status)
+ * @module
+ */
+
+/**
+ * Trace storage interface for saving, loading, and querying execution graphs.
+ */
+interface TraceStore {
+    /** Save a graph to disk. Returns the file path. */
+    save(graph: ExecutionGraph): Promise<string>;
+    /** Load a graph by ID. Returns null if not found. */
+    get(graphId: string): Promise<ExecutionGraph | null>;
+    /** List all stored graphs, optionally filtered by status. */
+    list(opts?: {
+        status?: GraphStatus;
+        limit?: number;
+    }): Promise<ExecutionGraph[]>;
+    /** Find all nodes with stuck status (running/hung/timeout) across all stored traces. */
+    getStuckSpans(): Promise<ExecutionNode[]>;
+    /** Find reasoning loops: consecutive same-type node sequences exceeding threshold. */
+    getReasoningLoops(threshold?: number): Promise<ReadonlyArray<{
+        graphId: string;
+        nodes: ExecutionNode[];
+    }>>;
+}
+/**
+ * Create a JSON file-based trace store.
+ *
+ * @param dir - Directory to store trace JSON files.
+ * @returns A TraceStore instance.
+ *
+ * @example
+ * ```ts
+ * const store = createTraceStore('./traces');
+ * await store.save(graph);
+ * const loaded = await store.get(graph.id);
+ * ```
+ */
+declare function createTraceStore(dir: string): TraceStore;
+
+/**
+ * Trace visualization: ASCII tree and timeline rendering for ExecutionGraphs.
+ *
+ * All functions are pure — they take an ExecutionGraph and return formatted strings.
  *
  * @module
  */
 
-declare function startLive(argv: string[]): void;
+/**
+ * Render an ExecutionGraph as an ASCII tree showing parent-child hierarchy.
+ *
+ * @param graph - The execution graph to render.
+ * @returns A multi-line string showing the tree with status icons, durations, and metadata.
+ *
+ * @example
+ * ```ts
+ * console.log(toAsciiTree(graph));
+ * // ✓ main (agent) 4.2s
+ * // ├─ ✓ search (tool) 1.1s
+ * // └─ ✗ analyze (tool) 0.5s — Error: rate limit
+ * ```
+ */
+declare function toAsciiTree(graph: ExecutionGraph): string;
+/**
+ * Render an ExecutionGraph as a horizontal timeline/waterfall.
+ *
+ * @param graph - The execution graph to render.
+ * @returns A multi-line string showing spans as horizontal bars relative to graph start.
+ *
+ * @example
+ * ```ts
+ * console.log(toTimeline(graph));
+ * // 0s        1s        2s        3s
+ * // ├─────────┼─────────┼─────────┤
+ * // ████████████████████████████████ main (4.2s)
+ * //  ██████████                      search (1.1s)
+ * ```
+ */
+declare function toTimeline(graph: ExecutionGraph): string;
 
 /**
  * AgentFlow Watch — headless alert system for agent infrastructure.
@@ -459,124 +743,4 @@ interface AlertPayload {
     readonly dirs: readonly string[];
 }
 
-declare function groupByTraceId(graphs: ExecutionGraph[]): Map<string, ExecutionGraph[]>;
-declare function stitchTrace(graphs: ExecutionGraph[]): DistributedTrace;
-declare function getTraceTree(trace: DistributedTrace): ExecutionGraph[];
-
-/**
- * Pure query functions for interrogating a built `ExecutionGraph`.
- * Every function takes a frozen graph and returns derived data without mutation.
- * @module
- */
-
-/**
- * Find a node by its ID.
- *
- * @param graph - The execution graph to search.
- * @param nodeId - The node ID to look up.
- * @returns The node, or `undefined` if not found.
- *
- * @example
- * ```ts
- * const node = getNode(graph, 'node_002');
- * if (node) console.log(node.name);
- * ```
- */
-declare function getNode(graph: ExecutionGraph, nodeId: string): ExecutionNode | undefined;
-/**
- * Get the direct children of a node.
- *
- * @param graph - The execution graph to search.
- * @param nodeId - The parent node ID.
- * @returns Array of child nodes (may be empty).
- *
- * @example
- * ```ts
- * const children = getChildren(graph, rootId);
- * ```
- */
-declare function getChildren(graph: ExecutionGraph, nodeId: string): ExecutionNode[];
-/**
- * Get the parent of a node.
- *
- * @param graph - The execution graph to search.
- * @param nodeId - The child node ID.
- * @returns The parent node, or `undefined` if root or not found.
- *
- * @example
- * ```ts
- * const parent = getParent(graph, toolId);
- * ```
- */
-declare function getParent(graph: ExecutionGraph, nodeId: string): ExecutionNode | undefined;
-/**
- * Find all nodes with a failure-category status: `failed`, `hung`, or `timeout`.
- *
- * @param graph - The execution graph to search.
- * @returns Array of nodes with failure statuses (may be empty).
- */
-declare function getFailures(graph: ExecutionGraph): ExecutionNode[];
-/**
- * Find all nodes that are still running (status `'running'`, no endTime).
- *
- * @param graph - The execution graph to search.
- * @returns Array of running/hung nodes.
- */
-declare function getHungNodes(graph: ExecutionGraph): ExecutionNode[];
-/**
- * Find the critical path: the longest-duration path from the root to any leaf node.
- * Uses node duration (endTime - startTime) as the weight.
- * Running nodes use `Date.now()` as a provisional endTime.
- *
- * @param graph - The execution graph to analyse.
- * @returns Nodes ordered from root to the deepest leaf on the longest path.
- */
-declare function getCriticalPath(graph: ExecutionGraph): ExecutionNode[];
-/**
- * Find what a node is waiting on.
- * Returns nodes connected via `waited_on` edges where the given nodeId is the `from` side.
- *
- * @param graph - The execution graph to search.
- * @param nodeId - The node that is doing the waiting.
- * @returns Array of nodes that are being waited on.
- */
-declare function findWaitingOn(graph: ExecutionGraph, nodeId: string): ExecutionNode[];
-/**
- * Get all descendants of a node (children, grandchildren, etc.) in breadth-first order.
- * The given node itself is NOT included.
- *
- * @param graph - The execution graph to search.
- * @param nodeId - The ancestor node ID.
- * @returns All descendant nodes in BFS order.
- */
-declare function getSubtree(graph: ExecutionGraph, nodeId: string): ExecutionNode[];
-/**
- * Total wall-clock duration of the graph in milliseconds.
- * If the graph is still running, uses `Date.now()` as the provisional end.
- *
- * @param graph - The execution graph.
- * @returns Duration in milliseconds.
- */
-declare function getDuration(graph: ExecutionGraph): number;
-/**
- * Maximum nesting depth of the graph. The root node is depth 0.
- *
- * @param graph - The execution graph.
- * @returns The maximum depth (0 for a single-node graph, -1 for empty).
- */
-declare function getDepth(graph: ExecutionGraph): number;
-/**
- * Compute aggregate statistics for the execution graph.
- *
- * @param graph - The execution graph to analyse.
- * @returns Statistics including node counts by type and status, depth, duration, and failure counts.
- *
- * @example
- * ```ts
- * const stats = getStats(graph);
- * console.log(`${stats.totalNodes} nodes, ${stats.failureCount} failures`);
- * ```
- */
-declare function getStats(graph: ExecutionGraph): GraphStats;
-
-export { type Adapter, type AgentFlowConfig, type AlertCondition, type AlertPayload, type DistributedTrace, type EdgeType, type ExecutionEdge, type ExecutionGraph, type ExecutionNode, type GraphBuilder, type GraphStats, type GraphStatus, type MutableExecutionNode, type NodeStatus, type NodeType, type NotifyChannel, type RunConfig, type RunResult, type StartNodeOptions, type TraceEvent, type TraceEventType, type WatchConfig, type Writer, createGraphBuilder, findWaitingOn, getChildren, getCriticalPath, getDepth, getDuration, getFailures, getHungNodes, getNode, getParent, getStats, getSubtree, getTraceTree, graphToJson, groupByTraceId, loadGraph, runTraced, startLive, startWatch, stitchTrace };
+export { type Adapter, type AgentFlowConfig, type AlertCondition, type AlertPayload, type DistributedTrace, type EdgeType, type ExecutionEdge, type ExecutionGraph, type ExecutionNode, type GraphBuilder, type GraphStats, type GraphStatus, type GuardConfig, type GuardViolation, type MutableExecutionNode, type NodeStatus, type NodeType, type NotifyChannel, type RunConfig, type RunResult, type StartNodeOptions, type TraceEvent, type TraceEventType, type TraceStore, type WatchConfig, type Writer, checkGuards, createGraphBuilder, createTraceStore, findWaitingOn, getChildren, getCriticalPath, getDepth, getDuration, getFailures, getHungNodes, getNode, getParent, getStats, getSubtree, getTraceTree, graphToJson, groupByTraceId, loadGraph, runTraced, startLive, startWatch, stitchTrace, toAsciiTree, toTimeline, withGuards };

package/dist/index.js

@@ -1,5 +1,6 @@
 import {
   createGraphBuilder,
+  createTraceStore,
   findWaitingOn,
   getChildren,
   getCriticalPath,
@@ -12,16 +13,180 @@ import {
   getStats,
   getSubtree,
   getTraceTree,
-  graphToJson,
   groupByTraceId,
-  loadGraph,
   runTraced,
   startLive,
   startWatch,
-  stitchTrace
-} from "./chunk-M5CGDXAO.js";
+  stitchTrace,
+  toAsciiTree,
+  toTimeline
+} from "./chunk-T2BYYGA4.js";
+import {
+  graphToJson,
+  loadGraph
+} from "./chunk-DY7YHFIB.js";
+
+// src/guards.ts
+var DEFAULT_TIMEOUTS = {
+  tool: 3e4,
+  // 30s
+  agent: 3e5,
+  // 5m
+  subagent: 3e5,
+  // 5m
+  wait: 6e5,
+  // 10m
+  decision: 3e4,
+  // 30s
+  custom: 3e4
+  // 30s
+};
+function checkGuards(graph, config) {
+  const violations = [];
+  const now = Date.now();
+  const timeouts = { ...DEFAULT_TIMEOUTS, ...config?.timeouts };
+  const maxReasoningSteps = config?.maxReasoningSteps ?? 25;
+  const maxDepth = config?.maxDepth ?? 10;
+  const maxAgentSpawns = config?.maxAgentSpawns ?? 50;
+  for (const node of graph.nodes.values()) {
+    if (node.status === "running" && node.endTime === null) {
+      const timeoutThreshold = timeouts[node.type];
+      const elapsed = now - node.startTime;
+      if (elapsed > timeoutThreshold) {
+        violations.push({
+          type: "timeout",
+          nodeId: node.id,
+          message: `Node ${node.id} (${node.type}: ${node.name}) has been running for ${elapsed}ms, exceeding timeout of ${timeoutThreshold}ms`,
+          timestamp: now
+        });
+      }
+    }
+  }
+  const depth = getDepth(graph);
+  if (depth > maxDepth) {
+    violations.push({
+      type: "spawn-explosion",
+      nodeId: graph.rootNodeId,
+      message: `Graph depth ${depth} exceeds maximum depth of ${maxDepth}`,
+      timestamp: now
+    });
+  }
+  let agentCount = 0;
+  for (const node of graph.nodes.values()) {
+    if (node.type === "agent" || node.type === "subagent") {
+      agentCount++;
+    }
+  }
+  if (agentCount > maxAgentSpawns) {
+    violations.push({
+      type: "spawn-explosion",
+      nodeId: graph.rootNodeId,
+      message: `Total agent/subagent count ${agentCount} exceeds maximum of ${maxAgentSpawns}`,
+      timestamp: now
+    });
+  }
+  violations.push(...detectReasoningLoops(graph, maxReasoningSteps, now));
+  return violations;
+}
+function detectReasoningLoops(graph, maxSteps, timestamp) {
+  const violations = [];
+  const reported = /* @__PURE__ */ new Set();
+  function walk(nodeId, consecutiveCount, consecutiveType) {
+    const node = getNode(graph, nodeId);
+    if (!node) return;
+    let newCount;
+    let newType;
+    if (node.type === consecutiveType) {
+      newCount = consecutiveCount + 1;
+      newType = node.type;
+    } else {
+      newCount = 1;
+      newType = node.type;
+    }
+    if (newCount > maxSteps && !reported.has(newType)) {
+      reported.add(newType);
+      violations.push({
+        type: "reasoning-loop",
+        nodeId: node.id,
+        message: `Detected ${newCount} consecutive ${newType} nodes along path to ${node.name}`,
+        timestamp
+      });
+    }
+    const children = getChildren(graph, nodeId);
+    for (const child of children) {
+      walk(child.id, newCount, newType);
+    }
+  }
+  walk(graph.rootNodeId, 0, null);
+  return violations;
+}
+function withGuards(builder, config) {
+  const logger = config?.logger ?? ((msg) => console.warn(`[AgentFlow Guard] ${msg}`));
+  const onViolation = config?.onViolation ?? "warn";
+  function handleViolations(violations) {
+    if (violations.length === 0) return;
+    for (const violation of violations) {
+      const message = `Guard violation: ${violation.message}`;
+      switch (onViolation) {
+        case "warn":
+          logger(message);
+          break;
+        case "error":
+          logger(message);
+          builder.pushEvent({
+            eventType: "custom",
+            nodeId: violation.nodeId,
+            data: {
+              guardViolation: violation.type,
+              message: violation.message,
+              severity: "error"
+            }
+          });
+          break;
+        case "abort":
+          throw new Error(`AgentFlow guard violation: ${violation.message}`);
+        default:
+          logger(message);
+      }
+    }
+  }
+  return {
+    get graphId() {
+      return builder.graphId;
+    },
+    get traceContext() {
+      return builder.traceContext;
+    },
+    startNode: (opts) => builder.startNode(opts),
+    endNode: (nodeId, status) => {
+      builder.endNode(nodeId, status);
+      const snapshot = builder.getSnapshot();
+      const violations = checkGuards(snapshot, config);
+      handleViolations(violations);
+    },
+    failNode: (nodeId, error) => {
+      builder.failNode(nodeId, error);
+      const snapshot = builder.getSnapshot();
+      const violations = checkGuards(snapshot, config);
+      handleViolations(violations);
+    },
+    addEdge: (from, to, type) => builder.addEdge(from, to, type),
+    pushEvent: (event) => builder.pushEvent(event),
+    updateState: (nodeId, state) => builder.updateState(nodeId, state),
+    withParent: (parentId, fn) => builder.withParent(parentId, fn),
+    getSnapshot: () => builder.getSnapshot(),
+    build: () => {
+      const snapshot = builder.getSnapshot();
+      const violations = checkGuards(snapshot, config);
+      handleViolations(violations);
+      return builder.build();
+    }
+  };
+}
 export {
+  checkGuards,
   createGraphBuilder,
+  createTraceStore,
   findWaitingOn,
   getChildren,
   getCriticalPath,
@@ -40,5 +205,8 @@ export {
   runTraced,
   startLive,
   startWatch,
-  stitchTrace
+  stitchTrace,
+  toAsciiTree,
+  toTimeline,
+  withGuards
 };

package/dist/loader-LYRR6LMM.js

@@ -0,0 +1,8 @@
+import {
+  graphToJson,
+  loadGraph
+} from "./chunk-DY7YHFIB.js";
+export {
+  graphToJson,
+  loadGraph
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentflow-core",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "description": "Monitor any AI agent system. Auto-detects failures, sends alerts. Zero config, zero dependencies.",
   "type": "module",
   "main": "./dist/index.cjs",