agentflow-core 0.3.3 → 0.5.0

package/dist/index.cjs

@@ -20,7 +20,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  checkGuards: () => checkGuards,
   createGraphBuilder: () => createGraphBuilder,
+  createTraceStore: () => createTraceStore,
   findWaitingOn: () => findWaitingOn,
   getChildren: () => getChildren,
   getCriticalPath: () => getCriticalPath,
@@ -39,7 +41,10 @@ __export(index_exports, {
   runTraced: () => runTraced,
   startLive: () => startLive,
   startWatch: () => startWatch,
-  stitchTrace: () => stitchTrace
+  stitchTrace: () => stitchTrace,
+  toAsciiTree: () => toAsciiTree,
+  toTimeline: () => toTimeline,
+  withGuards: () => withGuards
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -269,213 +274,6 @@ function createGraphBuilder(config) {
   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
-var import_node_child_process = require("child_process");
-var import_node_fs = require("fs");
-var import_node_path = require("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 (!(0, import_node_fs.existsSync)(dir)) return result;
-  for (const entry of (0, import_node_fs.readdirSync)(dir)) {
-    if (!patterns.some((re) => re.test(entry))) continue;
-    const full = (0, import_node_path.join)(dir, entry);
-    try {
-      const stat = (0, import_node_fs.statSync)(full);
-      if (stat.isFile()) {
-        result.set(full, stat.mtimeMs);
-      }
-    } catch {
-    }
-  }
-  return result;
-}
-function agentIdFromFilename(filePath) {
-  const base = (0, import_node_path.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 = (0, import_node_path.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 = (0, import_node_child_process.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 (!(0, import_node_fs.existsSync)(resolvedTracesDir)) {
-    (0, import_node_fs.mkdirSync)(resolvedTracesDir, { recursive: true });
-  }
-  const ts = fileTimestamp();
-  const tracePaths = [];
-  for (const graph of allGraphs) {
-    const filename = `${graph.agentId}-${ts}.json`;
-    const outPath = (0, import_node_path.join)(resolvedTracesDir, filename);
-    (0, import_node_fs.writeFileSync)(outPath, JSON.stringify(graphToJson(graph), null, 2), "utf-8");
-    tracePaths.push(outPath);
-  }
-  return {
-    exitCode,
-    traceId,
-    spanId,
-    tracePaths,
-    stateChanges,
-    duration
-  };
-}
-
-// src/live.ts
-var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
-
 // src/graph-query.ts
 function getNode(graph, nodeId) {
   return graph.nodes.get(nodeId);
@@ -507,13 +305,13 @@ function getHungNodes(graph) {
 function getCriticalPath(graph) {
   const root = graph.nodes.get(graph.rootNodeId);
   if (!root) return [];
-  function nodeDuration(node) {
+  function nodeDuration2(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] };
+      return { duration: nodeDuration2(node), path: [node] };
     }
     let bestChild = { duration: -1, path: [] };
     for (const childId of node.children) {
@@ -525,7 +323,7 @@ function getCriticalPath(graph) {
       }
     }
     return {
-      duration: nodeDuration(node) + bestChild.duration,
+      duration: nodeDuration2(node) + bestChild.duration,
       path: [node, ...bestChild.path]
     };
   }
@@ -674,9 +472,224 @@ function getTraceTree(trace) {
     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;
+  if (trace.rootGraph.spanId) walk(trace.rootGraph.spanId);
+  else result.push(trace.rootGraph);
+  return result;
+}
+
+// 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();
+    }
+  };
+}
+
+// src/live.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_child_process = require("child_process");
+
+// 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/live.ts
@@ -712,17 +725,18 @@ function parseArgs(argv) {
       config.recursive = true;
       i++;
     } else if (!arg.startsWith("-")) {
-      config.dirs.push((0, import_node_path2.resolve)(arg));
+      config.dirs.push((0, import_node_path.resolve)(arg));
       i++;
     } else {
       i++;
     }
   }
-  if (config.dirs.length === 0) config.dirs.push((0, import_node_path2.resolve)("."));
+  if (config.dirs.length === 0) config.dirs.push((0, import_node_path.resolve)("."));
   return config;
 }
 function printUsage() {
-  console.log(`
+  console.log(
+    `
 AgentFlow Live Monitor \u2014 real-time terminal dashboard for agent systems.
 
 Auto-detects agent traces, state files, job schedulers, and session logs
@@ -743,20 +757,21 @@ Examples:
   agentflow live ./data
   agentflow live ./traces ./cron ./workers --refresh 5
   agentflow live /var/lib/myagent -R
-`.trim());
+`.trim()
+  );
 }
 function scanFiles(dirs, recursive) {
   const results = [];
   const seen = /* @__PURE__ */ new Set();
   function scanDir(d, topLevel) {
     try {
-      for (const f of (0, import_node_fs2.readdirSync)(d)) {
+      for (const f of (0, import_node_fs.readdirSync)(d)) {
         if (f.startsWith(".")) continue;
-        const fp = (0, import_node_path2.join)(d, f);
+        const fp = (0, import_node_path.join)(d, f);
         if (seen.has(fp)) continue;
         let stat;
         try {
-          stat = (0, import_node_fs2.statSync)(fp);
+          stat = (0, import_node_fs.statSync)(fp);
         } catch {
           continue;
         }
@@ -782,20 +797,22 @@ function scanFiles(dirs, recursive) {
 }
 function safeReadJson(fp) {
   try {
-    return JSON.parse((0, import_node_fs2.readFileSync)(fp, "utf8"));
+    return JSON.parse((0, import_node_fs.readFileSync)(fp, "utf8"));
   } catch {
     return null;
   }
 }
 function nameFromFile(filename) {
-  return (0, import_node_path2.basename)(filename).replace(/\.(json|jsonl)$/, "").replace(/-state$/, "");
+  return (0, import_node_path.basename)(filename).replace(/\.(json|jsonl)$/, "").replace(/-state$/, "");
 }
 function normalizeStatus(val) {
   if (typeof val !== "string") return "unknown";
   const s = val.toLowerCase();
   if (["ok", "success", "completed", "done", "passed", "healthy", "good"].includes(s)) return "ok";
-  if (["error", "failed", "failure", "crashed", "unhealthy", "bad", "timeout"].includes(s)) return "error";
-  if (["running", "active", "in_progress", "started", "pending", "processing"].includes(s)) return "running";
+  if (["error", "failed", "failure", "crashed", "unhealthy", "bad", "timeout"].includes(s))
+    return "error";
+  if (["running", "active", "in_progress", "started", "pending", "processing"].includes(s))
+    return "running";
   return "unknown";
 }
 function findStatus(obj) {
@@ -811,7 +828,17 @@ function findStatus(obj) {
   return "unknown";
 }
 function findTimestamp(obj) {
-  for (const key of ["ts", "timestamp", "lastRunAtMs", "last_run", "lastExecution", "updated_at", "started_at", "endTime", "startTime"]) {
+  for (const key of [
+    "ts",
+    "timestamp",
+    "lastRunAtMs",
+    "last_run",
+    "lastExecution",
+    "updated_at",
+    "started_at",
+    "endTime",
+    "startTime"
+  ]) {
     const val = obj[key];
     if (typeof val === "number") return val > 1e12 ? val : val * 1e3;
     if (typeof val === "string") {
@@ -823,7 +850,16 @@ function findTimestamp(obj) {
 }
 function extractDetail(obj) {
   const parts = [];
-  for (const key of ["summary", "message", "description", "lastError", "error", "name", "jobId", "id"]) {
+  for (const key of [
+    "summary",
+    "message",
+    "description",
+    "lastError",
+    "error",
+    "name",
+    "jobId",
+    "id"
+  ]) {
     const val = obj[key];
     if (typeof val === "string" && val.length > 0 && val.length < 200) {
       parts.push(val.slice(0, 80));
@@ -883,7 +919,14 @@ function processJsonFile(file) {
       const status2 = findStatus(state);
       const ts2 = findTimestamp(state) || file.mtime;
       const detail2 = extractDetail(state);
-      records.push({ id: String(name), source: "jobs", status: status2, lastActive: ts2, detail: detail2, file: file.filename });
+      records.push({
+        id: String(name),
+        source: "jobs",
+        status: status2,
+        lastActive: ts2,
+        detail: detail2,
+        file: file.filename
+      });
     }
     return records;
   }
@@ -897,8 +940,26 @@ function processJsonFile(file) {
         const status2 = findStatus(w);
         const ts2 = findTimestamp(w) || findTimestamp(obj) || file.mtime;
         const pid = w.pid;
-        const detail2 = pid ? `pid: ${pid}` : extractDetail(w);
-        records.push({ id: name, source: "workers", status: status2, lastActive: ts2, detail: detail2, file: file.filename });
+        let validatedStatus = status2;
+        let pidAlive = true;
+        if (pid && (status2 === "running" || status2 === "ok")) {
+          try {
+            (0, import_node_child_process.execSync)(`kill -0 ${pid} 2>/dev/null`, { stdio: "ignore" });
+          } catch {
+            pidAlive = false;
+            validatedStatus = "error";
+          }
+        }
+        const pidLabel = pid ? pidAlive ? `pid: ${pid}` : `pid: ${pid} (dead)` : "";
+        const detail2 = pidLabel || extractDetail(w);
+        records.push({
+          id: name,
+          source: "workers",
+          status: validatedStatus,
+          lastActive: ts2,
+          detail: detail2,
+          file: file.filename
+        });
       }
       return records;
     }
@@ -906,12 +967,19 @@ function processJsonFile(file) {
   const status = findStatus(obj);
   const ts = findTimestamp(obj) || file.mtime;
   const detail = extractDetail(obj);
-  records.push({ id: nameFromFile(file.filename), source: "state", status, lastActive: ts, detail, file: file.filename });
+  records.push({
+    id: nameFromFile(file.filename),
+    source: "state",
+    status,
+    lastActive: ts,
+    detail,
+    file: file.filename
+  });
   return records;
 }
 function processJsonlFile(file) {
   try {
-    const content = (0, import_node_fs2.readFileSync)(file.path, "utf8").trim();
+    const content = (0, import_node_fs.readFileSync)(file.path, "utf8").trim();
     if (!content) return [];
     const lines = content.split("\n");
     const lineCount = lines.length;
@@ -922,13 +990,22 @@ function processJsonlFile(file) {
       const ts2 = findTimestamp(lastObj) || file.mtime;
       const action = lastObj.action;
       const detail2 = action ? `${action} (${lineCount} entries)` : `${lineCount} entries`;
-      return [{ id: String(name), source: "session", status: status2, lastActive: ts2, detail: detail2, file: file.filename }];
+      return [
+        {
+          id: String(name),
+          source: "session",
+          status: status2,
+          lastActive: ts2,
+          detail: detail2,
+          file: file.filename
+        }
+      ];
     }
     const tail = lines.slice(Math.max(0, lineCount - 30));
     let model = "";
     let totalTokens = 0;
     let totalCost = 0;
-    let toolCalls = [];
+    const toolCalls = [];
     let lastUserMsg = "";
     let lastAssistantMsg = "";
     let errorCount = 0;
@@ -1027,7 +1104,16 @@ function processJsonlFile(file) {
     const status = errorCount > lineCount / 4 ? "error" : lastRole === "assistant" ? "ok" : "running";
     const ts = findTimestamp(lastObj) || file.mtime;
     const sessionName = sessionId ? sessionId.slice(0, 8) : nameFromFile(file.filename);
-    return [{ id: String(name !== "unknown" ? name : sessionName), source: "session", status, lastActive: ts, detail, file: file.filename }];
+    return [
+      {
+        id: String(name !== "unknown" ? name : sessionName),
+        source: "session",
+        status,
+        lastActive: ts,
+        detail,
+        file: file.filename
+      }
+    ];
   } catch {
     return [];
   }
@@ -1060,8 +1146,30 @@ function render(config) {
       if (r.traceData) allTraces.push(r.traceData);
     }
   }
-  const byFile = /* @__PURE__ */ new Map();
+  const deduped = [];
+  const seenAgents = /* @__PURE__ */ new Map();
   for (const r of allRecords) {
+    if (r.source === "jobs" || r.source === "workers" || r.source === "state") {
+      deduped.push(r);
+      continue;
+    }
+    const key = `${r.source}:${r.id}`;
+    const existing = seenAgents.get(key);
+    if (!existing || r.lastActive > existing.lastActive) {
+      seenAgents.set(key, r);
+    }
+  }
+  for (const r of seenAgents.values()) deduped.push(r);
+  const STALE_THRESHOLD_MS = 2 * 60 * 60 * 1e3;
+  const now = Date.now();
+  const filtered = deduped.filter((r) => {
+    if (r.source === "jobs" || r.source === "workers") return true;
+    if (r.status === "running") return true;
+    return now - r.lastActive < STALE_THRESHOLD_MS;
+  });
+  const activeRecords = filtered;
+  const byFile = /* @__PURE__ */ new Map();
+  for (const r of activeRecords) {
     const arr = byFile.get(r.file) ?? [];
     arr.push(r);
     byFile.set(r.file, arr);
@@ -1108,15 +1216,14 @@ function render(config) {
     }
   }
   groups.sort((a, b) => b.lastTs - a.lastTs);
-  const totExec = allRecords.length;
-  const totFail = allRecords.filter((r) => r.status === "error").length;
-  const totRunning = allRecords.filter((r) => r.status === "running").length;
-  const uniqueAgents = new Set(allRecords.map((r) => r.id)).size;
+  const totExec = activeRecords.length;
+  const totFail = activeRecords.filter((r) => r.status === "error").length;
+  const totRunning = activeRecords.filter((r) => r.status === "running").length;
+  const uniqueAgents = new Set(activeRecords.map((r) => r.id)).size;
   const sysRate = totExec > 0 ? ((totExec - totFail) / totExec * 100).toFixed(1) : "100.0";
-  const now = Date.now();
   const buckets = new Array(12).fill(0);
   const failBuckets = new Array(12).fill(0);
-  for (const r of allRecords) {
+  for (const r of activeRecords) {
     const age = now - r.lastActive;
     if (age > 36e5 || age < 0) continue;
     const idx = 11 - Math.floor(age / 3e5);
@@ -1159,7 +1266,8 @@ function render(config) {
     if (g.fail > 0 && g.ok === 0 && g.running === 0) return `${C.red}error${C.reset}`;
     if (g.running > 0) return `${C.green}running${C.reset}`;
     if (g.fail > 0) return `${C.yellow}${g.ok}ok/${g.fail}err${C.reset}`;
-    if (g.ok > 0) return g.total > 1 ? `${C.green}${g.ok}/${g.total} ok${C.reset}` : `${C.green}ok${C.reset}`;
+    if (g.ok > 0)
+      return g.total > 1 ? `${C.green}${g.ok}/${g.total} ok${C.reset}` : `${C.green}ok${C.reset}`;
     return `${C.dim}idle${C.reset}`;
   }
   function sourceTag(s) {
@@ -1191,18 +1299,30 @@ function render(config) {
   }
   const L = [];
   writeLine(L, `${C.bold}${C.cyan}\u2554${"\u2550".repeat(70)}\u2557${C.reset}`);
-  writeLine(L, `${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}`);
+  writeLine(
+    L,
+    `${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} \xB7 Files: ${files.length}`;
   const pad1 = Math.max(0, 64 - metaLine.length);
-  writeLine(L, `${C.bold}${C.cyan}\u2551${C.reset}  ${C.dim}${metaLine}${C.reset}${" ".repeat(pad1)}${C.bold}${C.cyan}\u2551${C.reset}`);
+  writeLine(
+    L,
+    `${C.bold}${C.cyan}\u2551${C.reset}  ${C.dim}${metaLine}${C.reset}${" ".repeat(pad1)}${C.bold}${C.cyan}\u2551${C.reset}`
+  );
   writeLine(L, `${C.bold}${C.cyan}\u255A${"\u2550".repeat(70)}\u255D${C.reset}`);
   const sc = totFail === 0 ? C.green : C.yellow;
   writeLine(L, "");
-  writeLine(L, `  ${C.bold}Agents${C.reset} ${sc}${uniqueAgents}${C.reset}    ${C.bold}Records${C.reset} ${sc}${totExec}${C.reset}    ${C.bold}Success${C.reset} ${sc}${sysRate}%${C.reset}    ${C.bold}Running${C.reset} ${C.green}${totRunning}${C.reset}    ${C.bold}Errors${C.reset} ${totFail > 0 ? C.red : C.dim}${totFail}${C.reset}    ${C.bold}New${C.reset} ${C.yellow}+${newExecCount}${C.reset}`);
+  writeLine(
+    L,
+    `  ${C.bold}Agents${C.reset} ${sc}${uniqueAgents}${C.reset}    ${C.bold}Records${C.reset} ${sc}${totExec}${C.reset}    ${C.bold}Success${C.reset} ${sc}${sysRate}%${C.reset}    ${C.bold}Running${C.reset} ${C.green}${totRunning}${C.reset}    ${C.bold}Errors${C.reset} ${totFail > 0 ? C.red : C.dim}${totFail}${C.reset}    ${C.bold}New${C.reset} ${C.yellow}+${newExecCount}${C.reset}`
+  );
   writeLine(L, "");
   writeLine(L, `  ${C.bold}Activity (1h)${C.reset}  ${spark}  ${C.dim}\u2190 now${C.reset}`);
   writeLine(L, "");
-  writeLine(L, `  ${C.bold}${C.under}Agent                        Status      Last Active  Detail${C.reset}`);
+  writeLine(
+    L,
+    `  ${C.bold}${C.under}Agent                        Status      Last Active  Detail${C.reset}`
+  );
   let lineCount = 0;
   for (const g of groups) {
     if (lineCount > 35) break;
@@ -1213,13 +1333,19 @@ function render(config) {
       const name = truncate(g.name, 26).padEnd(26);
       const st = statusText(g);
       const det = truncate(g.detail, detailWidth);
-      writeLine(L, `  ${icon} ${name}  ${st.padEnd(20)}  ${active.padEnd(20)}  ${C.dim}${det}${C.reset}`);
+      writeLine(
+        L,
+        `  ${icon} ${name}  ${st.padEnd(20)}  ${active.padEnd(20)}  ${C.dim}${det}${C.reset}`
+      );
       lineCount++;
     } else {
       const name = truncate(g.name, 24).padEnd(24);
       const st = statusText(g);
       const tag = sourceTag(g.source);
-      writeLine(L, `  ${icon} ${C.bold}${name}${C.reset}  ${st.padEnd(20)}  ${active.padEnd(20)}  ${tag} ${C.dim}(${g.children.length} agents)${C.reset}`);
+      writeLine(
+        L,
+        `  ${icon} ${C.bold}${name}${C.reset}  ${st.padEnd(20)}  ${active.padEnd(20)}  ${tag} ${C.dim}(${g.children.length} agents)${C.reset}`
+      );
       lineCount++;
       const kids = g.children.slice(0, 12);
       for (let i = 0; i < kids.length; i++) {
@@ -1231,7 +1357,10 @@ function render(config) {
         const cName = truncate(child.id, 22).padEnd(22);
         const cActive = `${C.dim}${timeStr(child.lastActive)}${C.reset}`;
         const cDet = truncate(child.detail, detailWidth - 5);
-        writeLine(L, `     ${C.dim}${connector}${C.reset} ${cIcon} ${cName}  ${cActive.padEnd(20)}  ${C.dim}${cDet}${C.reset}`);
+        writeLine(
+          L,
+          `     ${C.dim}${connector}${C.reset} ${cIcon} ${cName}  ${cActive.padEnd(20)}  ${C.dim}${cDet}${C.reset}`
+        );
         lineCount++;
       }
       if (g.children.length > 12) {
@@ -1248,7 +1377,10 @@ function render(config) {
       const si = 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);
-      writeLine(L, `  ${si}  ${C.magenta}trace:${tid}${C.reset}  ${C.dim}${traceTime}  ${dur}  (${dt.graphs.size} agents)${C.reset}`);
+      writeLine(
+        L,
+        `  ${si}  ${C.magenta}trace:${tid}${C.reset}  ${C.dim}${traceTime}  ${dur}  (${dt.graphs.size} agents)${C.reset}`
+      );
       const tree = getTraceTree(dt);
       for (let i = 0; i < Math.min(tree.length, 6); i++) {
         const tg = tree[i];
@@ -1258,11 +1390,14 @@ function render(config) {
         const conn = depth === 0 ? "  " : isLast ? "\u2514\u2500 " : "\u251C\u2500 ";
         const gs = tg.status === "completed" ? `${C.green}\u2713${C.reset}` : tg.status === "failed" ? `${C.red}\u2717${C.reset}` : `${C.yellow}\u23F3${C.reset}`;
         const gd = tg.endTime ? `${tg.endTime - tg.startTime}ms` : "running";
-        writeLine(L, `${indent}${conn}${gs} ${C.bold}${tg.agentId}${C.reset} ${C.dim}[${tg.trigger}] ${gd}${C.reset}`);
+        writeLine(
+          L,
+          `${indent}${conn}${gs} ${C.bold}${tg.agentId}${C.reset} ${C.dim}[${tg.trigger}] ${gd}${C.reset}`
+        );
       }
     }
   }
-  const recentRecords = allRecords.filter((r) => r.lastActive > 0).sort((a, b) => b.lastActive - a.lastActive).slice(0, 6);
+  const recentRecords = activeRecords.filter((r) => r.lastActive > 0).sort((a, b) => b.lastActive - a.lastActive).slice(0, 6);
   if (recentRecords.length > 0) {
     writeLine(L, "");
     writeLine(L, `  ${C.bold}${C.under}Recent Activity${C.reset}`);
@@ -1273,7 +1408,10 @@ function render(config) {
       const age = Math.floor((Date.now() - r.lastActive) / 1e3);
       const ageStr = age < 60 ? age + "s ago" : age < 3600 ? Math.floor(age / 60) + "m ago" : Math.floor(age / 3600) + "h ago";
       const det = truncate(r.detail, detailWidth);
-      writeLine(L, `  ${icon}  ${agent} ${C.dim}${t}  ${ageStr.padStart(8)}${C.reset}  ${C.dim}${det}${C.reset}`);
+      writeLine(
+        L,
+        `  ${icon}  ${agent} ${C.dim}${t}  ${ageStr.padStart(8)}${C.reset}  ${C.dim}${det}${C.reset}`
+      );
     }
   }
   if (files.length === 0) {
@@ -1295,39 +1433,540 @@ function getDistDepth(dt, spanId) {
 }
 function startLive(argv) {
   const config = parseArgs(argv);
-  const valid = config.dirs.filter((d) => (0, import_node_fs2.existsSync)(d));
+  const valid = config.dirs.filter((d) => (0, import_node_fs.existsSync)(d));
   if (valid.length === 0) {
     console.error(`No valid directories found: ${config.dirs.join(", ")}`);
     console.error("Specify directories containing JSON/JSONL files: agentflow live <dir> [dir...]");
     process.exit(1);
   }
-  const invalid = config.dirs.filter((d) => !(0, import_node_fs2.existsSync)(d));
-  if (invalid.length > 0) {
-    console.warn(`Skipping non-existent: ${invalid.join(", ")}`);
+  const invalid = config.dirs.filter((d) => !(0, import_node_fs.existsSync)(d));
+  if (invalid.length > 0) {
+    console.warn(`Skipping non-existent: ${invalid.join(", ")}`);
+  }
+  config.dirs = valid;
+  render(config);
+  let debounce = null;
+  for (const dir of config.dirs) {
+    try {
+      (0, import_node_fs.watch)(dir, { recursive: config.recursive }, () => {
+        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);
+  });
+}
+
+// src/runner.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("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 (!(0, import_node_fs2.existsSync)(dir)) return result;
+  for (const entry of (0, import_node_fs2.readdirSync)(dir)) {
+    if (!patterns.some((re) => re.test(entry))) continue;
+    const full = (0, import_node_path2.join)(dir, entry);
+    try {
+      const stat = (0, import_node_fs2.statSync)(full);
+      if (stat.isFile()) {
+        result.set(full, stat.mtimeMs);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function agentIdFromFilename(filePath) {
+  const base = (0, import_node_path2.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 = (0, import_node_path2.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 = (0, import_node_child_process2.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 (!(0, import_node_fs2.existsSync)(resolvedTracesDir)) {
+    (0, import_node_fs2.mkdirSync)(resolvedTracesDir, { recursive: true });
+  }
+  const ts = fileTimestamp();
+  const tracePaths = [];
+  for (const graph of allGraphs) {
+    const filename = `${graph.agentId}-${ts}.json`;
+    const outPath = (0, import_node_path2.join)(resolvedTracesDir, filename);
+    (0, import_node_fs2.writeFileSync)(outPath, JSON.stringify(graphToJson(graph), null, 2), "utf-8");
+    tracePaths.push(outPath);
+  }
+  if (tracePaths.length > 0) {
+    console.log(`\u{1F50D} Run "agentflow trace show ${orchestratorGraph.id} --traces-dir ${resolvedTracesDir}" to inspect`);
+  }
+  return {
+    exitCode,
+    traceId,
+    spanId,
+    tracePaths,
+    stateChanges,
+    duration
+  };
+}
+
+// src/trace-store.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+function createTraceStore(dir) {
+  async function ensureDir() {
+    await (0, import_promises.mkdir)(dir, { recursive: true });
+  }
+  async function loadAll() {
+    await ensureDir();
+    let files;
+    try {
+      files = await (0, import_promises.readdir)(dir);
+    } catch {
+      return [];
+    }
+    const graphs = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const content = await (0, import_promises.readFile)((0, import_path.join)(dir, file), "utf-8");
+        const graph = loadGraph(content);
+        graphs.push(graph);
+      } catch {
+      }
+    }
+    return graphs;
+  }
+  return {
+    async save(graph) {
+      await ensureDir();
+      const json = graphToJson(graph);
+      const filePath = (0, import_path.join)(dir, `${graph.id}.json`);
+      await (0, import_promises.writeFile)(filePath, JSON.stringify(json, null, 2), "utf-8");
+      return filePath;
+    },
+    async get(graphId) {
+      await ensureDir();
+      const filePath = (0, import_path.join)(dir, `${graphId}.json`);
+      try {
+        const content = await (0, import_promises.readFile)(filePath, "utf-8");
+        return loadGraph(content);
+      } catch {
+      }
+      const all = await loadAll();
+      return all.find((g) => g.id === graphId) ?? null;
+    },
+    async list(opts) {
+      let graphs = await loadAll();
+      if (opts?.status) {
+        graphs = graphs.filter((g) => g.status === opts.status);
+      }
+      graphs.sort((a, b) => b.startTime - a.startTime);
+      if (opts?.limit && opts.limit > 0) {
+        graphs = graphs.slice(0, opts.limit);
+      }
+      return graphs;
+    },
+    async getStuckSpans() {
+      const graphs = await loadAll();
+      const stuck = [];
+      for (const graph of graphs) {
+        for (const node of graph.nodes.values()) {
+          if (node.status === "running" || node.status === "hung" || node.status === "timeout") {
+            stuck.push(node);
+          }
+        }
+      }
+      return stuck;
+    },
+    async getReasoningLoops(threshold = 25) {
+      const graphs = await loadAll();
+      const results = [];
+      for (const graph of graphs) {
+        const loops = findLoopsInGraph(graph, threshold);
+        if (loops.length > 0) {
+          results.push({ graphId: graph.id, nodes: loops });
+        }
+      }
+      return results;
+    }
+  };
+}
+function findLoopsInGraph(graph, threshold) {
+  const loopNodes = [];
+  function walk(nodeId, consecutiveCount, consecutiveType) {
+    const node = graph.nodes.get(nodeId);
+    if (!node) return;
+    const newCount = node.type === consecutiveType ? consecutiveCount + 1 : 1;
+    if (newCount > threshold) {
+      loopNodes.push(node);
+    }
+    for (const childId of node.children) {
+      walk(childId, newCount, node.type);
+    }
+  }
+  walk(graph.rootNodeId, 0, null);
+  return loopNodes;
+}
+
+// src/visualize.ts
+var STATUS_ICONS = {
+  completed: "\u2713",
+  failed: "\u2717",
+  running: "\u231B",
+  hung: "\u231B",
+  timeout: "\u231B"
+};
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  if (ms < 36e5) return `${(ms / 6e4).toFixed(1)}m`;
+  return `${(ms / 36e5).toFixed(1)}h`;
+}
+function nodeDuration(node, graphEndTime) {
+  const end = node.endTime ?? graphEndTime;
+  return formatDuration(end - node.startTime);
+}
+function getGenAiInfo(node) {
+  const parts = [];
+  const meta = node.metadata;
+  if (meta["gen_ai.request.model"]) {
+    parts.push(String(meta["gen_ai.request.model"]));
+  }
+  const tokens = meta["gen_ai.usage.prompt_tokens"] ?? meta["gen_ai.usage.completion_tokens"];
+  if (tokens !== void 0) {
+    const prompt = meta["gen_ai.usage.prompt_tokens"] ?? 0;
+    const completion = meta["gen_ai.usage.completion_tokens"] ?? 0;
+    if (prompt || completion) {
+      parts.push(`${prompt + completion} tok`);
+    }
+  }
+  return parts.length > 0 ? ` [${parts.join(", ")}]` : "";
+}
+function hasViolation(node, graph) {
+  return graph.events.some(
+    (e) => e.nodeId === node.id && e.eventType === "custom" && e.data.guardViolation !== void 0
+  );
+}
+function toAsciiTree(graph) {
+  if (graph.nodes.size === 0) return "(empty graph)";
+  const now = Date.now();
+  const endTime = graph.endTime ?? now;
+  const lines = [];
+  function renderNode(nodeId, prefix, isLast, isRoot) {
+    const node = graph.nodes.get(nodeId);
+    if (!node) return;
+    const icon = STATUS_ICONS[node.status];
+    const duration = nodeDuration(node, endTime);
+    const genAi = getGenAiInfo(node);
+    const violation = hasViolation(node, graph) ? " \u26A0" : "";
+    const errorInfo = node.status === "failed" && node.metadata.error ? ` \u2014 ${node.metadata.error}` : "";
+    const timeoutInfo = node.status === "timeout" ? " [TIMEOUT]" : "";
+    const hungInfo = node.status === "hung" ? " [HUNG]" : "";
+    const connector = isRoot ? "" : isLast ? "\u2514\u2500 " : "\u251C\u2500 ";
+    const line = `${prefix}${connector}${icon} ${node.name} (${node.type}) ${duration}${genAi}${violation}${timeoutInfo}${hungInfo}${errorInfo}`;
+    lines.push(line);
+    const children = getChildren(graph, nodeId);
+    const childPrefix = isRoot ? "" : prefix + (isLast ? "   " : "\u2502  ");
+    for (let i = 0; i < children.length; i++) {
+      renderNode(children[i].id, childPrefix, i === children.length - 1, false);
+    }
+  }
+  renderNode(graph.rootNodeId, "", true, true);
+  return lines.join("\n");
+}
+function toTimeline(graph) {
+  if (graph.nodes.size === 0) return "(empty graph)";
+  const now = Date.now();
+  const graphStart = graph.startTime;
+  const graphEnd = graph.endTime ?? now;
+  const totalDuration = graphEnd - graphStart;
+  if (totalDuration <= 0) return "(zero duration)";
+  const barWidth = 60;
+  const lines = [];
+  const scaleLabels = [];
+  const tickCount = Math.min(5, Math.max(2, Math.floor(barWidth / 10)));
+  for (let i = 0; i <= tickCount; i++) {
+    const t = totalDuration * i / tickCount;
+    scaleLabels.push(formatDuration(t));
+  }
+  let header = "";
+  for (let i = 0; i < scaleLabels.length; i++) {
+    const pos = Math.round(barWidth * i / tickCount);
+    while (header.length < pos) header += " ";
+    header += scaleLabels[i];
+  }
+  lines.push(header);
+  let tickLine = "";
+  for (let i = 0; i < barWidth; i++) {
+    const tickPos = tickCount > 0 ? i * tickCount / barWidth : 0;
+    if (Number.isInteger(Math.round(tickPos * 100) / 100) && Math.abs(tickPos - Math.round(tickPos)) < 0.01) {
+      tickLine += "\u253C";
+    } else {
+      tickLine += "\u2500";
+    }
+  }
+  lines.push(tickLine);
+  const orderedNodes = [];
+  function collectNodes(nodeId) {
+    const node = graph.nodes.get(nodeId);
+    if (!node) return;
+    orderedNodes.push(node);
+    const children = getChildren(graph, nodeId);
+    for (const child of children) {
+      collectNodes(child.id);
+    }
   }
-  config.dirs = valid;
-  render(config);
-  let debounce = null;
-  for (const dir of config.dirs) {
-    try {
-      (0, import_node_fs2.watch)(dir, { recursive: config.recursive }, () => {
-        if (debounce) clearTimeout(debounce);
-        debounce = setTimeout(() => render(config), 500);
-      });
-    } catch {
+  collectNodes(graph.rootNodeId);
+  for (const node of orderedNodes) {
+    const nodeStart = node.startTime - graphStart;
+    const nodeEnd = (node.endTime ?? now) - graphStart;
+    const startCol = Math.round(nodeStart / totalDuration * barWidth);
+    const endCol = Math.max(startCol + 1, Math.round(nodeEnd / totalDuration * barWidth));
+    let bar = "";
+    for (let i = 0; i < barWidth; i++) {
+      if (i >= startCol && i < endCol) {
+        bar += "\u2588";
+      } else {
+        bar += " ";
+      }
     }
+    const icon = STATUS_ICONS[node.status];
+    const duration = nodeDuration(node, graphEnd);
+    const violation = hasViolation(node, graph) ? " \u26A0" : "";
+    lines.push(`${bar} ${icon} ${node.name} (${duration})${violation}`);
   }
-  setInterval(() => render(config), config.refreshMs);
-  process.on("SIGINT", () => {
-    console.log("\n" + C.dim + "Monitor stopped." + C.reset);
-    process.exit(0);
-  });
+  return lines.join("\n");
 }
 
 // src/watch.ts
 var import_node_fs4 = require("fs");
-var import_node_path3 = require("path");
 var import_node_os = require("os");
+var import_node_path3 = require("path");
+
+// src/watch-alerts.ts
+var import_node_child_process3 = require("child_process");
+var import_node_http = require("http");
+var import_node_https = require("https");
+function formatAlertMessage(payload) {
+  const time = new Date(payload.timestamp).toISOString();
+  const arrow = `${payload.previousStatus} \u2192 ${payload.currentStatus}`;
+  return [
+    `[ALERT] ${payload.condition}: "${payload.agentId}"`,
+    `  Status:  ${arrow}`,
+    payload.detail ? `  Detail:  ${payload.detail}` : null,
+    `  File:    ${payload.file}`,
+    `  Time:    ${time}`
+  ].filter(Boolean).join("\n");
+}
+function formatTelegram(payload) {
+  const icon = payload.condition === "recovery" ? "\u2705" : "\u26A0\uFE0F";
+  const time = new Date(payload.timestamp).toLocaleTimeString();
+  return [
+    `${icon} *AgentFlow Alert*`,
+    `*${payload.condition}*: \`${payload.agentId}\``,
+    `Status: ${payload.previousStatus} \u2192 ${payload.currentStatus}`,
+    payload.detail ? `Detail: ${payload.detail.slice(0, 200)}` : null,
+    `Time: ${time}`
+  ].filter(Boolean).join("\n");
+}
+async function sendAlert(payload, channel) {
+  try {
+    switch (channel.type) {
+      case "stdout":
+        sendStdout(payload);
+        break;
+      case "telegram":
+        await sendTelegram(payload, channel.botToken, channel.chatId);
+        break;
+      case "webhook":
+        await sendWebhook(payload, channel.url);
+        break;
+      case "command":
+        await sendCommand(payload, channel.cmd);
+        break;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[agentflow] Failed to send ${channel.type} alert: ${msg}`);
+  }
+}
+function sendStdout(payload) {
+  console.log(formatAlertMessage(payload));
+}
+function sendTelegram(payload, botToken, chatId) {
+  const body = JSON.stringify({
+    chat_id: chatId,
+    text: formatTelegram(payload),
+    parse_mode: "Markdown"
+  });
+  return new Promise((resolve4, reject) => {
+    const req = (0, import_node_https.request)(
+      `https://api.telegram.org/bot${botToken}/sendMessage`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) }
+      },
+      (res) => {
+        res.resume();
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) resolve4();
+        else reject(new Error(`Telegram API returned ${res.statusCode}`));
+      }
+    );
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+function sendWebhook(payload, url) {
+  const body = JSON.stringify(payload);
+  const isHttps = url.startsWith("https");
+  const doRequest = isHttps ? import_node_https.request : import_node_http.request;
+  return new Promise((resolve4, reject) => {
+    const req = doRequest(
+      url,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) }
+      },
+      (res) => {
+        res.resume();
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) resolve4();
+        else reject(new Error(`Webhook returned ${res.statusCode}`));
+      }
+    );
+    req.on("error", reject);
+    req.setTimeout(1e4, () => {
+      req.destroy(new Error("Webhook timeout"));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+function sendCommand(payload, cmd) {
+  return new Promise((resolve4, reject) => {
+    const env = {
+      ...process.env,
+      AGENTFLOW_ALERT_AGENT: payload.agentId,
+      AGENTFLOW_ALERT_CONDITION: payload.condition,
+      AGENTFLOW_ALERT_STATUS: payload.currentStatus,
+      AGENTFLOW_ALERT_PREVIOUS_STATUS: payload.previousStatus,
+      AGENTFLOW_ALERT_DETAIL: payload.detail,
+      AGENTFLOW_ALERT_FILE: payload.file,
+      AGENTFLOW_ALERT_TIMESTAMP: String(payload.timestamp)
+    };
+    (0, import_node_child_process3.exec)(cmd, { env, timeout: 3e4 }, (err) => {
+      if (err) reject(err);
+      else resolve4();
+    });
+  });
+}
 
 // src/watch-state.ts
 var import_node_fs3 = require("fs");
@@ -1393,7 +2032,9 @@ function detectTransitions(previous, currentRecords, config, now) {
   const hasError = config.alertConditions.some((c) => c.type === "error");
   const hasRecovery = config.alertConditions.some((c) => c.type === "recovery");
   const staleConditions = config.alertConditions.filter((c) => c.type === "stale");
-  const consecutiveConditions = config.alertConditions.filter((c) => c.type === "consecutive-errors");
+  const consecutiveConditions = config.alertConditions.filter(
+    (c) => c.type === "consecutive-errors"
+  );
   const byAgent = /* @__PURE__ */ new Map();
   for (const r of currentRecords) {
     const existing = byAgent.get(r.id);
@@ -1417,14 +2058,16 @@ function detectTransitions(previous, currentRecords, config, now) {
     for (const cond of consecutiveConditions) {
       if (newConsec === cond.threshold) {
         if (canAlert(prev, `consecutive-errors:${cond.threshold}`, config.cooldownMs, now)) {
-          alerts.push(makePayload(
-            agentId,
-            `consecutive-errors (${cond.threshold})`,
-            prevStatus,
-            currStatus,
-            { ...record, detail: `${newConsec} consecutive errors. ${record.detail}` },
-            config.dirs
-          ));
+          alerts.push(
+            makePayload(
+              agentId,
+              `consecutive-errors (${cond.threshold})`,
+              prevStatus,
+              currStatus,
+              { ...record, detail: `${newConsec} consecutive errors. ${record.detail}` },
+              config.dirs
+            )
+          );
         }
       }
     }
@@ -1433,14 +2076,16 @@ function detectTransitions(previous, currentRecords, config, now) {
       if (sinceActive > cond.durationMs && record.lastActive > 0) {
         if (canAlert(prev, "stale", config.cooldownMs, now)) {
           const mins = Math.floor(sinceActive / 6e4);
-          alerts.push(makePayload(
-            agentId,
-            "stale",
-            prevStatus,
-            currStatus,
-            { ...record, detail: `No update for ${mins}m. ${record.detail}` },
-            config.dirs
-          ));
+          alerts.push(
+            makePayload(
+              agentId,
+              "stale",
+              prevStatus,
+              currStatus,
+              { ...record, detail: `No update for ${mins}m. ${record.detail}` },
+              config.dirs
+            )
+          );
         }
       }
     }
@@ -1453,14 +2098,19 @@ function detectTransitions(previous, currentRecords, config, now) {
           if (canAlert(prev, "stale-auto", config.cooldownMs, now)) {
             const mins = Math.floor(sinceActive / 6e4);
             const expectedMins = Math.floor(expectedInterval / 6e4);
-            alerts.push(makePayload(
-              agentId,
-              "stale (auto)",
-              prevStatus,
-              currStatus,
-              { ...record, detail: `No update for ${mins}m (expected every ~${expectedMins}m). ${record.detail}` },
-              config.dirs
-            ));
+            alerts.push(
+              makePayload(
+                agentId,
+                "stale (auto)",
+                prevStatus,
+                currStatus,
+                {
+                  ...record,
+                  detail: `No update for ${mins}m (expected every ~${expectedMins}m). ${record.detail}`
+                },
+                config.dirs
+              )
+            );
           }
         }
       }
@@ -1519,118 +2169,6 @@ function makePayload(agentId, condition, previousStatus, currentStatus, record,
   };
 }
 
-// src/watch-alerts.ts
-var import_node_https = require("https");
-var import_node_http = require("http");
-var import_node_child_process2 = require("child_process");
-function formatAlertMessage(payload) {
-  const time = new Date(payload.timestamp).toISOString();
-  const arrow = `${payload.previousStatus} \u2192 ${payload.currentStatus}`;
-  return [
-    `[ALERT] ${payload.condition}: "${payload.agentId}"`,
-    `  Status:  ${arrow}`,
-    payload.detail ? `  Detail:  ${payload.detail}` : null,
-    `  File:    ${payload.file}`,
-    `  Time:    ${time}`
-  ].filter(Boolean).join("\n");
-}
-function formatTelegram(payload) {
-  const icon = payload.condition === "recovery" ? "\u2705" : "\u26A0\uFE0F";
-  const time = new Date(payload.timestamp).toLocaleTimeString();
-  return [
-    `${icon} *AgentFlow Alert*`,
-    `*${payload.condition}*: \`${payload.agentId}\``,
-    `Status: ${payload.previousStatus} \u2192 ${payload.currentStatus}`,
-    payload.detail ? `Detail: ${payload.detail.slice(0, 200)}` : null,
-    `Time: ${time}`
-  ].filter(Boolean).join("\n");
-}
-async function sendAlert(payload, channel) {
-  try {
-    switch (channel.type) {
-      case "stdout":
-        sendStdout(payload);
-        break;
-      case "telegram":
-        await sendTelegram(payload, channel.botToken, channel.chatId);
-        break;
-      case "webhook":
-        await sendWebhook(payload, channel.url);
-        break;
-      case "command":
-        await sendCommand(payload, channel.cmd);
-        break;
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`[agentflow] Failed to send ${channel.type} alert: ${msg}`);
-  }
-}
-function sendStdout(payload) {
-  console.log(formatAlertMessage(payload));
-}
-function sendTelegram(payload, botToken, chatId) {
-  const body = JSON.stringify({
-    chat_id: chatId,
-    text: formatTelegram(payload),
-    parse_mode: "Markdown"
-  });
-  return new Promise((resolve4, reject) => {
-    const req = (0, import_node_https.request)(
-      `https://api.telegram.org/bot${botToken}/sendMessage`,
-      { method: "POST", headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
-      (res) => {
-        res.resume();
-        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) resolve4();
-        else reject(new Error(`Telegram API returned ${res.statusCode}`));
-      }
-    );
-    req.on("error", reject);
-    req.write(body);
-    req.end();
-  });
-}
-function sendWebhook(payload, url) {
-  const body = JSON.stringify(payload);
-  const isHttps = url.startsWith("https");
-  const doRequest = isHttps ? import_node_https.request : import_node_http.request;
-  return new Promise((resolve4, reject) => {
-    const req = doRequest(
-      url,
-      { method: "POST", headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
-      (res) => {
-        res.resume();
-        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) resolve4();
-        else reject(new Error(`Webhook returned ${res.statusCode}`));
-      }
-    );
-    req.on("error", reject);
-    req.setTimeout(1e4, () => {
-      req.destroy(new Error("Webhook timeout"));
-    });
-    req.write(body);
-    req.end();
-  });
-}
-function sendCommand(payload, cmd) {
-  return new Promise((resolve4, reject) => {
-    const env = {
-      ...process.env,
-      AGENTFLOW_ALERT_AGENT: payload.agentId,
-      AGENTFLOW_ALERT_CONDITION: payload.condition,
-      AGENTFLOW_ALERT_STATUS: payload.currentStatus,
-      AGENTFLOW_ALERT_PREVIOUS_STATUS: payload.previousStatus,
-      AGENTFLOW_ALERT_DETAIL: payload.detail,
-      AGENTFLOW_ALERT_FILE: payload.file,
-      AGENTFLOW_ALERT_TIMESTAMP: String(payload.timestamp)
-    };
-    (0, import_node_child_process2.exec)(cmd, { env, timeout: 3e4 }, (err) => {
-      if (err) reject(err);
-      else resolve4();
-    });
-  });
-}
-
 // src/watch.ts
 function parseWatchArgs(argv) {
   const dirs = [];
@@ -1672,7 +2210,9 @@ function parseWatchArgs(argv) {
         if (botToken && chatId) {
           notifyChannels.push({ type: "telegram", botToken, chatId });
         } else {
-          console.error("Warning: --notify telegram requires AGENTFLOW_TELEGRAM_BOT_TOKEN and AGENTFLOW_TELEGRAM_CHAT_ID env vars");
+          console.error(
+            "Warning: --notify telegram requires AGENTFLOW_TELEGRAM_BOT_TOKEN and AGENTFLOW_TELEGRAM_CHAT_ID env vars"
+          );
         }
       } else if (val.startsWith("webhook:")) {
         notifyChannels.push({ type: "webhook", url: val.slice(8) });
@@ -1724,7 +2264,8 @@ function parseWatchArgs(argv) {
   };
 }
 function printWatchUsage() {
-  console.log(`
+  console.log(
+    `
 AgentFlow Watch \u2014 headless alert system for agent infrastructure.
 
 Polls directories for JSON/JSONL files, detects failures and stale
@@ -1767,7 +2308,8 @@ Examples:
   agentflow watch ./data ./cron --notify telegram --poll 60
   agentflow watch ./traces --notify webhook:https://hooks.slack.com/... --alert-on consecutive-errors:3
   agentflow watch ./data --notify "command:curl -X POST https://my-pagerduty/alert"
-`.trim());
+`.trim()
+  );
 }
 function startWatch(argv) {
   const config = parseWatchArgs(argv);
@@ -1796,7 +2338,9 @@ agentflow watch started`);
   console.log(`  Directories:  ${valid.join(", ")}`);
   console.log(`  Poll:         ${config.pollIntervalMs / 1e3}s`);
   console.log(`  Alert on:     ${condLabels.join(", ")}`);
-  console.log(`  Notify:       stdout${channelLabels.length > 0 ? ", " + channelLabels.join(", ") : ""}`);
+  console.log(
+    `  Notify:       stdout${channelLabels.length > 0 ? ", " + channelLabels.join(", ") : ""}`
+  );
   console.log(`  Cooldown:     ${Math.floor(config.cooldownMs / 6e4)}m`);
   console.log(`  State:        ${config.stateFilePath}`);
   console.log(`  Hostname:     ${(0, import_node_os.hostname)()}`);
@@ -1822,9 +2366,13 @@ agentflow watch started`);
     if (pollCount % 10 === 0) {
       const agentCount = Object.keys(state.agents).length;
       const errorCount = Object.values(state.agents).filter((a) => a.lastStatus === "error").length;
-      const runningCount = Object.values(state.agents).filter((a) => a.lastStatus === "running").length;
+      const runningCount = Object.values(state.agents).filter(
+        (a) => a.lastStatus === "running"
+      ).length;
       const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
-      console.log(`[${time}] heartbeat: ${agentCount} agents, ${runningCount} running, ${errorCount} errors, ${files.length} files`);
+      console.log(
+        `[${time}] heartbeat: ${agentCount} agents, ${runningCount} running, ${errorCount} errors, ${files.length} files`
+      );
     }
   }
   poll();
@@ -1841,7 +2389,9 @@ agentflow watch started`);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  checkGuards,
   createGraphBuilder,
+  createTraceStore,
   findWaitingOn,
   getChildren,
   getCriticalPath,
@@ -1860,5 +2410,8 @@ agentflow watch started`);
   runTraced,
   startLive,
   startWatch,
-  stitchTrace
+  stitchTrace,
+  toAsciiTree,
+  toTimeline,
+  withGuards
 });