agentflow-core 0.1.4 → 0.2.0

package/dist/chunk-TRKBUPIN.js

@@ -0,0 +1,933 @@
+// src/graph-builder.ts
+import { randomUUID } from "crypto";
+function deepFreeze(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (obj instanceof Map) {
+    Object.freeze(obj);
+    for (const value of obj.values()) {
+      deepFreeze(value);
+    }
+    return obj;
+  }
+  Object.freeze(obj);
+  const record = obj;
+  for (const key of Object.keys(record)) {
+    const value = record[key];
+    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+      deepFreeze(value);
+    }
+  }
+  return obj;
+}
+function createCounterIdGenerator() {
+  let counter = 0;
+  return () => {
+    counter++;
+    return `node_${String(counter).padStart(3, "0")}`;
+  };
+}
+function createGraphBuilder(config) {
+  const generateId = config?.idGenerator ?? createCounterIdGenerator();
+  const agentId = config?.agentId ?? "unknown";
+  const trigger = config?.trigger ?? "manual";
+  const spanId = randomUUID();
+  const traceId = config?.traceId ?? (typeof process !== "undefined" ? process.env?.AGENTFLOW_TRACE_ID : void 0) ?? randomUUID();
+  const parentSpanId = config?.parentSpanId ?? (typeof process !== "undefined" ? process.env?.AGENTFLOW_PARENT_SPAN_ID : void 0) ?? null;
+  const graphId = generateId();
+  const startTime = Date.now();
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const events = [];
+  const parentStack = [];
+  let rootNodeId = null;
+  let built = false;
+  function assertNotBuilt() {
+    if (built) {
+      throw new Error("GraphBuilder: cannot mutate after build() has been called");
+    }
+  }
+  function getNode2(nodeId) {
+    const node = nodes.get(nodeId);
+    if (!node) {
+      throw new Error(`GraphBuilder: node "${nodeId}" does not exist`);
+    }
+    return node;
+  }
+  function recordEvent(nodeId, eventType, data = {}) {
+    events.push({
+      timestamp: Date.now(),
+      eventType,
+      nodeId,
+      data
+    });
+  }
+  function buildGraph() {
+    if (rootNodeId === null) {
+      throw new Error("GraphBuilder: cannot build a graph with no nodes");
+    }
+    let graphStatus = "completed";
+    for (const node of nodes.values()) {
+      if (node.status === "failed" || node.status === "timeout" || node.status === "hung") {
+        graphStatus = "failed";
+        break;
+      }
+      if (node.status === "running") {
+        graphStatus = "running";
+      }
+    }
+    const endTime = graphStatus === "running" ? null : Date.now();
+    const frozenNodes = new Map(
+      [...nodes.entries()].map(([id, mNode]) => [
+        id,
+        {
+          id: mNode.id,
+          type: mNode.type,
+          name: mNode.name,
+          startTime: mNode.startTime,
+          endTime: mNode.endTime,
+          status: mNode.status,
+          parentId: mNode.parentId,
+          children: [...mNode.children],
+          metadata: { ...mNode.metadata },
+          state: { ...mNode.state }
+        }
+      ])
+    );
+    const graph = {
+      id: graphId,
+      rootNodeId,
+      nodes: frozenNodes,
+      edges: [...edges],
+      startTime,
+      endTime,
+      status: graphStatus,
+      trigger,
+      agentId,
+      events: [...events],
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    return deepFreeze(graph);
+  }
+  const builder = {
+    get graphId() {
+      return graphId;
+    },
+    get traceContext() {
+      return { traceId, spanId };
+    },
+    startNode(opts) {
+      assertNotBuilt();
+      const id = generateId();
+      const parentId = opts.parentId ?? parentStack[parentStack.length - 1] ?? null;
+      if (parentId !== null && !nodes.has(parentId)) {
+        throw new Error(`GraphBuilder: parent node "${parentId}" does not exist`);
+      }
+      const node = {
+        id,
+        type: opts.type,
+        name: opts.name,
+        startTime: Date.now(),
+        endTime: null,
+        status: "running",
+        parentId,
+        children: [],
+        metadata: opts.metadata ? { ...opts.metadata } : {},
+        state: {}
+      };
+      nodes.set(id, node);
+      if (parentId !== null) {
+        const parent = nodes.get(parentId);
+        if (parent) {
+          parent.children.push(id);
+        }
+        edges.push({ from: parentId, to: id, type: "spawned" });
+      }
+      if (rootNodeId === null) {
+        rootNodeId = id;
+      }
+      recordEvent(id, "agent_start", { type: opts.type, name: opts.name });
+      return id;
+    },
+    endNode(nodeId, status = "completed") {
+      assertNotBuilt();
+      const node = getNode2(nodeId);
+      if (node.endTime !== null) {
+        throw new Error(
+          `GraphBuilder: node "${nodeId}" has already ended (status: ${node.status})`
+        );
+      }
+      node.endTime = Date.now();
+      node.status = status;
+      recordEvent(nodeId, "agent_end", { status });
+    },
+    failNode(nodeId, error) {
+      assertNotBuilt();
+      const node = getNode2(nodeId);
+      if (node.endTime !== null) {
+        throw new Error(
+          `GraphBuilder: node "${nodeId}" has already ended (status: ${node.status})`
+        );
+      }
+      const errorMessage = error instanceof Error ? error.message : error;
+      const errorStack = error instanceof Error ? error.stack : void 0;
+      node.endTime = Date.now();
+      node.status = "failed";
+      node.metadata.error = errorMessage;
+      if (errorStack) {
+        node.metadata.errorStack = errorStack;
+      }
+      recordEvent(nodeId, "tool_error", { error: errorMessage });
+    },
+    addEdge(from, to, type) {
+      assertNotBuilt();
+      getNode2(from);
+      getNode2(to);
+      edges.push({ from, to, type });
+      recordEvent(from, "custom", { to, type, action: "edge_add" });
+    },
+    pushEvent(event) {
+      assertNotBuilt();
+      getNode2(event.nodeId);
+      events.push({
+        ...event,
+        timestamp: Date.now()
+      });
+    },
+    updateState(nodeId, state) {
+      assertNotBuilt();
+      const node = getNode2(nodeId);
+      Object.assign(node.state, state);
+      recordEvent(nodeId, "custom", { action: "state_update", ...state });
+    },
+    withParent(parentId, fn) {
+      assertNotBuilt();
+      getNode2(parentId);
+      parentStack.push(parentId);
+      try {
+        return fn();
+      } finally {
+        parentStack.pop();
+      }
+    },
+    getSnapshot() {
+      return buildGraph();
+    },
+    build() {
+      assertNotBuilt();
+      const graph = buildGraph();
+      built = true;
+      return graph;
+    }
+  };
+  return builder;
+}
+
+// src/loader.ts
+function toNodesMap(raw) {
+  if (raw instanceof Map) return raw;
+  if (Array.isArray(raw)) {
+    return new Map(raw);
+  }
+  if (raw !== null && typeof raw === "object") {
+    return new Map(Object.entries(raw));
+  }
+  return /* @__PURE__ */ new Map();
+}
+function loadGraph(input) {
+  const raw = typeof input === "string" ? JSON.parse(input) : input;
+  const nodes = toNodesMap(raw.nodes);
+  return {
+    id: raw.id ?? "",
+    rootNodeId: raw.rootNodeId ?? raw.rootId ?? "",
+    nodes,
+    edges: raw.edges ?? [],
+    startTime: raw.startTime ?? 0,
+    endTime: raw.endTime ?? null,
+    status: raw.status ?? "completed",
+    trigger: raw.trigger ?? "unknown",
+    agentId: raw.agentId ?? "unknown",
+    events: raw.events ?? [],
+    traceId: raw.traceId,
+    spanId: raw.spanId,
+    parentSpanId: raw.parentSpanId
+  };
+}
+function graphToJson(graph) {
+  const nodesObj = {};
+  for (const [id, node] of graph.nodes) {
+    nodesObj[id] = node;
+  }
+  return {
+    id: graph.id,
+    rootNodeId: graph.rootNodeId,
+    nodes: nodesObj,
+    edges: graph.edges,
+    startTime: graph.startTime,
+    endTime: graph.endTime,
+    status: graph.status,
+    trigger: graph.trigger,
+    agentId: graph.agentId,
+    events: graph.events,
+    traceId: graph.traceId,
+    spanId: graph.spanId,
+    parentSpanId: graph.parentSpanId
+  };
+}
+
+// src/runner.ts
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from "fs";
+import { basename, join, resolve } from "path";
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`);
+}
+function snapshotDir(dir, patterns) {
+  const result = /* @__PURE__ */ new Map();
+  if (!existsSync(dir)) return result;
+  for (const entry of readdirSync(dir)) {
+    if (!patterns.some((re) => re.test(entry))) continue;
+    const full = join(dir, entry);
+    try {
+      const stat = statSync(full);
+      if (stat.isFile()) {
+        result.set(full, stat.mtimeMs);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function agentIdFromFilename(filePath) {
+  const base = basename(filePath, ".json");
+  const cleaned = base.replace(/-state$/, "");
+  return `alfred-${cleaned}`;
+}
+function deriveAgentId(command) {
+  return "orchestrator";
+}
+function fileTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\.\d+Z$/, "");
+}
+async function runTraced(config) {
+  const {
+    command,
+    agentId = deriveAgentId(command),
+    trigger = "cli",
+    tracesDir = "./traces",
+    watchDirs = [],
+    watchPatterns = ["*.json"]
+  } = config;
+  if (command.length === 0) {
+    throw new Error("runTraced: command must not be empty");
+  }
+  const resolvedTracesDir = resolve(tracesDir);
+  const patterns = watchPatterns.map(globToRegex);
+  const orchestrator = createGraphBuilder({ agentId, trigger });
+  const { traceId, spanId } = orchestrator.traceContext;
+  const beforeSnapshots = /* @__PURE__ */ new Map();
+  for (const dir of watchDirs) {
+    beforeSnapshots.set(dir, snapshotDir(dir, patterns));
+  }
+  const rootId = orchestrator.startNode({ type: "agent", name: agentId });
+  const dispatchId = orchestrator.startNode({
+    type: "tool",
+    name: "dispatch-command",
+    parentId: rootId
+  });
+  orchestrator.updateState(dispatchId, { command: command.join(" ") });
+  const monitorId = orchestrator.startNode({
+    type: "tool",
+    name: "state-monitor",
+    parentId: rootId
+  });
+  orchestrator.updateState(monitorId, {
+    watchDirs,
+    watchPatterns
+  });
+  const startMs = Date.now();
+  const execCmd = command[0] ?? "";
+  const execArgs = command.slice(1);
+  process.env.AGENTFLOW_TRACE_ID = traceId;
+  process.env.AGENTFLOW_PARENT_SPAN_ID = spanId;
+  const result = spawnSync(execCmd, execArgs, { stdio: "inherit" });
+  delete process.env.AGENTFLOW_TRACE_ID;
+  delete process.env.AGENTFLOW_PARENT_SPAN_ID;
+  const exitCode = result.status ?? 1;
+  const duration = (Date.now() - startMs) / 1e3;
+  const stateChanges = [];
+  for (const dir of watchDirs) {
+    const before = beforeSnapshots.get(dir) ?? /* @__PURE__ */ new Map();
+    const after = snapshotDir(dir, patterns);
+    for (const [filePath, mtime] of after) {
+      const prevMtime = before.get(filePath);
+      if (prevMtime === void 0 || mtime > prevMtime) {
+        stateChanges.push(filePath);
+      }
+    }
+  }
+  orchestrator.updateState(monitorId, { stateChanges });
+  orchestrator.endNode(monitorId);
+  if (exitCode === 0) {
+    orchestrator.endNode(dispatchId);
+  } else {
+    orchestrator.failNode(dispatchId, `Command exited with code ${exitCode}`);
+  }
+  orchestrator.updateState(rootId, {
+    exitCode,
+    duration,
+    stateChanges
+  });
+  if (exitCode === 0) {
+    orchestrator.endNode(rootId);
+  } else {
+    orchestrator.failNode(rootId, `Command exited with code ${exitCode}`);
+  }
+  const orchestratorGraph = orchestrator.build();
+  const allGraphs = [orchestratorGraph];
+  for (const filePath of stateChanges) {
+    const childAgentId = agentIdFromFilename(filePath);
+    const childBuilder = createGraphBuilder({
+      agentId: childAgentId,
+      trigger: "state-change",
+      traceId,
+      parentSpanId: spanId
+    });
+    const childRootId = childBuilder.startNode({
+      type: "agent",
+      name: childAgentId
+    });
+    childBuilder.updateState(childRootId, {
+      stateFile: filePath,
+      detectedBy: "runner-state-monitor"
+    });
+    childBuilder.endNode(childRootId);
+    allGraphs.push(childBuilder.build());
+  }
+  if (!existsSync(resolvedTracesDir)) {
+    mkdirSync(resolvedTracesDir, { recursive: true });
+  }
+  const ts = fileTimestamp();
+  const tracePaths = [];
+  for (const graph of allGraphs) {
+    const filename = `${graph.agentId}-${ts}.json`;
+    const outPath = join(resolvedTracesDir, filename);
+    writeFileSync(outPath, JSON.stringify(graphToJson(graph), null, 2), "utf-8");
+    tracePaths.push(outPath);
+  }
+  return {
+    exitCode,
+    traceId,
+    spanId,
+    tracePaths,
+    stateChanges,
+    duration
+  };
+}
+
+// src/graph-query.ts
+function getNode(graph, nodeId) {
+  return graph.nodes.get(nodeId);
+}
+function getChildren(graph, nodeId) {
+  const node = graph.nodes.get(nodeId);
+  if (!node) return [];
+  const result = [];
+  for (const childId of node.children) {
+    const child = graph.nodes.get(childId);
+    if (child) result.push(child);
+  }
+  return result;
+}
+function getParent(graph, nodeId) {
+  const node = graph.nodes.get(nodeId);
+  if (!node || node.parentId === null) return void 0;
+  return graph.nodes.get(node.parentId);
+}
+function getFailures(graph) {
+  const failureStatuses = /* @__PURE__ */ new Set(["failed", "hung", "timeout"]);
+  return [...graph.nodes.values()].filter((node) => failureStatuses.has(node.status));
+}
+function getHungNodes(graph) {
+  return [...graph.nodes.values()].filter(
+    (node) => node.status === "running" && node.endTime === null
+  );
+}
+function getCriticalPath(graph) {
+  const root = graph.nodes.get(graph.rootNodeId);
+  if (!root) return [];
+  function nodeDuration(node) {
+    const end = node.endTime ?? Date.now();
+    return end - node.startTime;
+  }
+  function dfs(node) {
+    if (node.children.length === 0) {
+      return { duration: nodeDuration(node), path: [node] };
+    }
+    let bestChild = { duration: -1, path: [] };
+    for (const childId of node.children) {
+      const child = graph.nodes.get(childId);
+      if (!child) continue;
+      const result = dfs(child);
+      if (result.duration > bestChild.duration) {
+        bestChild = result;
+      }
+    }
+    return {
+      duration: nodeDuration(node) + bestChild.duration,
+      path: [node, ...bestChild.path]
+    };
+  }
+  return dfs(root).path;
+}
+function findWaitingOn(graph, nodeId) {
+  const results = [];
+  for (const edge of graph.edges) {
+    if (edge.from === nodeId && edge.type === "waited_on") {
+      const node = graph.nodes.get(edge.to);
+      if (node) results.push(node);
+    }
+  }
+  return results;
+}
+function getSubtree(graph, nodeId) {
+  const startNode = graph.nodes.get(nodeId);
+  if (!startNode) return [];
+  const result = [];
+  const queue = [...startNode.children];
+  while (queue.length > 0) {
+    const currentId = queue.shift();
+    if (currentId === void 0) break;
+    const current = graph.nodes.get(currentId);
+    if (!current) continue;
+    result.push(current);
+    queue.push(...current.children);
+  }
+  return result;
+}
+function getDuration(graph) {
+  const end = graph.endTime ?? Date.now();
+  return end - graph.startTime;
+}
+function getDepth(graph) {
+  const root = graph.nodes.get(graph.rootNodeId);
+  if (!root) return -1;
+  function dfs(node, depth) {
+    if (node.children.length === 0) return depth;
+    let maxDepth = depth;
+    for (const childId of node.children) {
+      const child = graph.nodes.get(childId);
+      if (!child) continue;
+      const childDepth = dfs(child, depth + 1);
+      if (childDepth > maxDepth) maxDepth = childDepth;
+    }
+    return maxDepth;
+  }
+  return dfs(root, 0);
+}
+function getStats(graph) {
+  const byStatus = {
+    running: 0,
+    completed: 0,
+    failed: 0,
+    hung: 0,
+    timeout: 0
+  };
+  const byType = {
+    agent: 0,
+    tool: 0,
+    subagent: 0,
+    wait: 0,
+    decision: 0,
+    custom: 0
+  };
+  let failureCount = 0;
+  let hungCount = 0;
+  for (const node of graph.nodes.values()) {
+    byStatus[node.status]++;
+    byType[node.type]++;
+    if (node.status === "failed" || node.status === "timeout" || node.status === "hung") {
+      failureCount++;
+    }
+    if (node.status === "running" && node.endTime === null) {
+      hungCount++;
+    }
+  }
+  return {
+    totalNodes: graph.nodes.size,
+    byStatus,
+    byType,
+    depth: getDepth(graph),
+    duration: getDuration(graph),
+    failureCount,
+    hungCount
+  };
+}
+
+// src/graph-stitch.ts
+function groupByTraceId(graphs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const g of graphs) {
+    if (!g.traceId) continue;
+    const arr = groups.get(g.traceId) ?? [];
+    arr.push(g);
+    groups.set(g.traceId, arr);
+  }
+  return groups;
+}
+function stitchTrace(graphs) {
+  if (graphs.length === 0) throw new Error("No graphs to stitch");
+  const traceId = graphs[0].traceId ?? "";
+  const graphsBySpan = /* @__PURE__ */ new Map();
+  const childMap = /* @__PURE__ */ new Map();
+  let rootGraph = null;
+  for (const g of graphs) {
+    if (g.spanId) graphsBySpan.set(g.spanId, g);
+    if (!g.parentSpanId) {
+      if (!rootGraph || g.startTime < rootGraph.startTime) rootGraph = g;
+    }
+    if (g.parentSpanId) {
+      const siblings = childMap.get(g.parentSpanId) ?? [];
+      if (g.spanId) siblings.push(g.spanId);
+      childMap.set(g.parentSpanId, siblings);
+    }
+  }
+  if (!rootGraph) rootGraph = graphs[0];
+  let status = "completed";
+  let endTime = 0;
+  let startTime = Infinity;
+  for (const g of graphs) {
+    startTime = Math.min(startTime, g.startTime);
+    if (g.status === "failed") status = "failed";
+    else if (g.status === "running" && status !== "failed") status = "running";
+    if (g.endTime === null) endTime = null;
+    else if (endTime !== null) endTime = Math.max(endTime, g.endTime);
+  }
+  const frozenChildMap = /* @__PURE__ */ new Map();
+  for (const [k, v] of childMap) frozenChildMap.set(k, Object.freeze([...v]));
+  return Object.freeze({
+    traceId,
+    graphs: graphsBySpan,
+    rootGraph,
+    childMap: frozenChildMap,
+    startTime,
+    endTime,
+    status
+  });
+}
+function getTraceTree(trace) {
+  const result = [];
+  function walk(spanId) {
+    const graph = trace.graphs.get(spanId);
+    if (graph) result.push(graph);
+    const children = trace.childMap.get(spanId) ?? [];
+    for (const childSpan of children) walk(childSpan);
+  }
+  if (trace.rootGraph.spanId) walk(trace.rootGraph.spanId);
+  else result.push(trace.rootGraph);
+  return result;
+}
+
+// src/live.ts
+import { readdirSync as readdirSync2, readFileSync, statSync as statSync2, watch, existsSync as existsSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+var C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[90m",
+  under: "\x1B[4m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+};
+function parseArgs(argv) {
+  const config = {
+    tracesDir: "./traces",
+    refreshMs: 3e3
+  };
+  const args = argv.slice(0);
+  if (args[0] === "live") args.shift();
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      printUsage();
+      process.exit(0);
+    } else if (arg === "--refresh" || arg === "-r") {
+      i++;
+      const val = parseInt(args[i] ?? "", 10);
+      if (!isNaN(val) && val > 0) config.refreshMs = val * 1e3;
+      i++;
+    } else if (arg === "--traces-dir" || arg === "-t") {
+      i++;
+      config.tracesDir = args[i] ?? config.tracesDir;
+      i++;
+    } else if (!arg.startsWith("-")) {
+      config.tracesDir = arg;
+      i++;
+    } else {
+      i++;
+    }
+  }
+  config.tracesDir = resolve2(config.tracesDir);
+  return config;
+}
+function printUsage() {
+  console.log(`
+AgentFlow Live Monitor \u2014 real-time terminal dashboard for agent systems.
+
+Usage:
+  agentflow live [traces-dir] [options]
+
+Arguments:
+  traces-dir              Path to the traces directory (default: ./traces)
+
+Options:
+  -r, --refresh <secs>    Refresh interval in seconds (default: 3)
+  -t, --traces-dir <path> Explicit traces directory path
+  -h, --help              Show this help message
+
+Examples:
+  agentflow live
+  agentflow live ./my-traces --refresh 5
+  agentflow live /var/log/agentflow/traces -r 10
+`.trim());
+}
+function listTraceFiles(tracesDir) {
+  try {
+    return readdirSync2(tracesDir).filter((f) => f.endsWith(".json")).map((f) => {
+      const fp = join2(tracesDir, f);
+      const stat = statSync2(fp);
+      return { filename: f, path: fp, mtime: stat.mtime.getTime() };
+    }).sort((a, b) => b.mtime - a.mtime);
+  } catch {
+    return [];
+  }
+}
+function safeLoadTrace(fp) {
+  try {
+    return loadGraph(readFileSync(fp, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function analyze(trace) {
+  try {
+    const stats = getStats(trace);
+    const fails = getFailures(trace);
+    const hung = getHungNodes(trace);
+    return {
+      agentId: trace.agentId,
+      trigger: trace.trigger,
+      traceId: trace.traceId,
+      spanId: trace.spanId,
+      parentSpanId: trace.parentSpanId,
+      nodes: stats.totalNodes,
+      success: fails.length === 0 && hung.length === 0,
+      failures: fails.length,
+      hung: hung.length
+    };
+  } catch {
+    return null;
+  }
+}
+function getDistributedDepth(dt, spanId) {
+  if (!spanId) return 0;
+  const graph = dt.graphs.get(spanId);
+  if (!graph || !graph.parentSpanId) return 0;
+  return 1 + getDistributedDepth(dt, graph.parentSpanId);
+}
+var prevFileCount = 0;
+var newExecCount = 0;
+var sessionStart = Date.now();
+function render(config) {
+  const files = listTraceFiles(config.tracesDir);
+  if (files.length > prevFileCount && prevFileCount > 0) {
+    newExecCount += files.length - prevFileCount;
+  }
+  prevFileCount = files.length;
+  const allTraces = [];
+  const agents = {};
+  for (const f of files.slice(0, 200)) {
+    const trace = safeLoadTrace(f.path);
+    if (!trace) continue;
+    allTraces.push(trace);
+    const a = analyze(trace);
+    if (!a) continue;
+    if (!agents[a.agentId]) {
+      agents[a.agentId] = { name: a.agentId, total: 0, ok: 0, fail: 0, lastTs: 0 };
+    }
+    const ag = agents[a.agentId];
+    ag.total++;
+    a.success ? ag.ok++ : ag.fail++;
+    if (f.mtime > ag.lastTs) ag.lastTs = f.mtime;
+  }
+  const agentList = Object.values(agents).sort((a, b) => b.total - a.total);
+  const totExec = agentList.reduce((s, a) => s + a.total, 0);
+  const totFail = agentList.reduce((s, a) => s + a.fail, 0);
+  const sysRate = totExec > 0 ? ((totExec - totFail) / totExec * 100).toFixed(1) : "100.0";
+  const recent = [];
+  for (const f of files.slice(0, 15)) {
+    const trace = safeLoadTrace(f.path);
+    if (!trace) continue;
+    const a = analyze(trace);
+    if (a) recent.push({ ...a, ts: f.mtime });
+  }
+  const now = Date.now();
+  const buckets = new Array(12).fill(0);
+  const failBuckets = new Array(12).fill(0);
+  for (const f of files) {
+    const age = now - f.mtime;
+    if (age > 36e5) continue;
+    const idx = 11 - Math.floor(age / 3e5);
+    if (idx >= 0 && idx < 12) {
+      const trace = safeLoadTrace(f.path);
+      if (!trace) continue;
+      const a = analyze(trace);
+      if (!a) continue;
+      buckets[idx]++;
+      if (!a.success) failBuckets[idx]++;
+    }
+  }
+  const maxBucket = Math.max(...buckets, 1);
+  const sparkChars = " \u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+  const spark = buckets.map((v, i) => {
+    const level = Math.round(v / maxBucket * 8);
+    return (failBuckets[i] > 0 ? C.red : C.green) + sparkChars[level] + C.reset;
+  }).join("");
+  const traceGroups = groupByTraceId(allTraces);
+  const distributedTraces = [];
+  for (const [_traceId, graphs] of traceGroups) {
+    if (graphs.length > 1) {
+      try {
+        distributedTraces.push(stitchTrace(graphs));
+      } catch {
+      }
+    }
+  }
+  distributedTraces.sort((a, b) => b.startTime - a.startTime);
+  const upSec = Math.floor((Date.now() - sessionStart) / 1e3);
+  const upMin = Math.floor(upSec / 60);
+  const upStr = upMin > 0 ? `${upMin}m ${upSec % 60}s` : `${upSec}s`;
+  const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  process.stdout.write("\x1B[2J\x1B[H");
+  console.log(`${C.bold}${C.cyan}\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557${C.reset}`);
+  console.log(`${C.bold}${C.cyan}\u2551${C.reset}  ${C.bold}${C.white}AGENTFLOW LIVE${C.reset}                               ${C.green}\u25CF LIVE${C.reset}  ${C.dim}${time}${C.reset}  ${C.bold}${C.cyan}\u2551${C.reset}`);
+  const metaLine = `Refresh: ${config.refreshMs / 1e3}s \xB7 Up: ${upStr}`;
+  const pad1 = Math.max(0, 64 - metaLine.length);
+  console.log(`${C.bold}${C.cyan}\u2551${C.reset}  ${C.dim}${metaLine}${C.reset}${" ".repeat(pad1)}${C.bold}${C.cyan}\u2551${C.reset}`);
+  console.log(`${C.bold}${C.cyan}\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D${C.reset}`);
+  const sc = totFail === 0 ? C.green : C.yellow;
+  console.log("");
+  console.log(`  ${C.bold}Agents${C.reset} ${sc}${agentList.length}${C.reset}    ${C.bold}Executions${C.reset} ${sc}${totExec}${C.reset}    ${C.bold}Success${C.reset} ${sc}${sysRate}%${C.reset}    ${C.bold}Traces${C.reset} ${sc}${files.length}${C.reset}    ${C.bold}New${C.reset} ${C.yellow}+${newExecCount}${C.reset}    ${C.bold}Distributed${C.reset} ${C.magenta}${distributedTraces.length}${C.reset}`);
+  console.log("");
+  console.log(`  ${C.bold}Activity (1h)${C.reset}  ${spark}  ${C.dim}\u2190 now${C.reset}`);
+  console.log("");
+  console.log(`  ${C.bold}${C.under}Agent                          Runs   OK  Fail  Rate     Last Active${C.reset}`);
+  for (const ag of agentList) {
+    const rate = (ag.ok / ag.total * 100).toFixed(0);
+    const lastTime = new Date(ag.lastTs).toLocaleTimeString();
+    const isRecent = Date.now() - ag.lastTs < 3e5;
+    let status;
+    if (ag.fail > 0) status = `${C.red}\u25CF${C.reset}`;
+    else if (isRecent) status = `${C.green}\u25CF${C.reset}`;
+    else status = `${C.dim}\u25CB${C.reset}`;
+    const name = ag.name.padEnd(28);
+    const runs = String(ag.total).padStart(5);
+    const ok = String(ag.ok).padStart(5);
+    const fail = ag.fail > 0 ? `${C.red}${String(ag.fail).padStart(4)}${C.reset}` : String(ag.fail).padStart(4);
+    const rateStr = (rate + "%").padStart(5);
+    const activeStr = isRecent ? `${C.green}${lastTime}${C.reset}` : `${C.dim}${lastTime}${C.reset}`;
+    console.log(`  ${status} ${name}${runs}${ok}${fail}  ${rateStr}     ${activeStr}`);
+  }
+  if (distributedTraces.length > 0) {
+    console.log("");
+    console.log(`  ${C.bold}${C.under}Distributed Traces (multi-agent workflows)${C.reset}`);
+    for (const dt of distributedTraces.slice(0, 5)) {
+      const traceTime = new Date(dt.startTime).toLocaleTimeString();
+      const statusIcon = dt.status === "completed" ? `${C.green}\u2713${C.reset}` : dt.status === "failed" ? `${C.red}\u2717${C.reset}` : `${C.yellow}\u23F3${C.reset}`;
+      const dur = dt.endTime ? `${dt.endTime - dt.startTime}ms` : "running";
+      const tid = dt.traceId.slice(0, 8);
+      console.log(`  ${statusIcon}  ${C.magenta}trace:${tid}${C.reset}  ${C.dim}${traceTime}${C.reset}  ${C.dim}${dur}${C.reset}  ${C.dim}(${dt.graphs.size} agents)${C.reset}`);
+      const tree = getTraceTree(dt);
+      for (let i = 0; i < tree.length; i++) {
+        const g = tree[i];
+        const depth = getDistributedDepth(dt, g.spanId);
+        const indent = "     " + "\u2502  ".repeat(Math.max(0, depth - 1));
+        const isLast = i === tree.length - 1 || getDistributedDepth(dt, tree[i + 1]?.spanId) <= depth;
+        const connector = depth === 0 ? "  " : isLast ? "\u2514\u2500 " : "\u251C\u2500 ";
+        const gStatus = g.status === "completed" ? `${C.green}\u2713${C.reset}` : g.status === "failed" ? `${C.red}\u2717${C.reset}` : `${C.yellow}\u23F3${C.reset}`;
+        const gDur = g.endTime ? `${g.endTime - g.startTime}ms` : "running";
+        console.log(`${indent}${connector}${gStatus} ${C.bold}${g.agentId}${C.reset} ${C.dim}[${g.trigger}] ${gDur}${C.reset}`);
+      }
+    }
+  }
+  console.log("");
+  console.log(`  ${C.bold}${C.under}Recent Executions${C.reset}`);
+  for (const ex of recent.slice(0, 8)) {
+    const icon = ex.success ? `${C.green}\u2713${C.reset}` : `${C.red}\u2717${C.reset}`;
+    const t = new Date(ex.ts).toLocaleTimeString();
+    const agent = ex.agentId.padEnd(28);
+    const age = Math.floor((Date.now() - ex.ts) / 1e3);
+    const ageStr = age < 60 ? age + "s ago" : Math.floor(age / 60) + "m ago";
+    const traceTag = ex.traceId ? ` ${C.magenta}\u29EB${C.reset}` : "";
+    console.log(`  ${icon}  ${agent} ${C.dim}${t}  ${ageStr.padStart(8)}  ${ex.nodes} nodes${C.reset}${traceTag}`);
+  }
+  if (files.length === 0) {
+    console.log(`  ${C.dim}No trace files found. Waiting for traces in:${C.reset}`);
+    console.log(`  ${C.dim}${config.tracesDir}${C.reset}`);
+  }
+  console.log("");
+  console.log(`  ${C.dim}Watching: ${config.tracesDir}${C.reset}`);
+  console.log(`  ${C.dim}Press Ctrl+C to exit${C.reset}`);
+}
+function startLive(argv) {
+  const config = parseArgs(argv);
+  if (!existsSync2(config.tracesDir)) {
+    console.error(`Traces directory does not exist: ${config.tracesDir}`);
+    console.error("Create it or specify a different path: agentflow live <traces-dir>");
+    process.exit(1);
+  }
+  render(config);
+  let debounce = null;
+  try {
+    watch(config.tracesDir, () => {
+      if (debounce) clearTimeout(debounce);
+      debounce = setTimeout(() => render(config), 500);
+    });
+  } catch {
+  }
+  setInterval(() => render(config), config.refreshMs);
+  process.on("SIGINT", () => {
+    console.log("\n" + C.dim + "Monitor stopped." + C.reset);
+    process.exit(0);
+  });
+}
+
+export {
+  createGraphBuilder,
+  loadGraph,
+  graphToJson,
+  runTraced,
+  getNode,
+  getChildren,
+  getParent,
+  getFailures,
+  getHungNodes,
+  getCriticalPath,
+  findWaitingOn,
+  getSubtree,
+  getDuration,
+  getDepth,
+  getStats,
+  groupByTraceId,
+  stitchTrace,
+  getTraceTree,
+  startLive
+};