agentflow-core 0.3.3 → 0.4.0

package/dist/cli.cjs

@@ -1,241 +1,41 @@
 #!/usr/bin/env node
 "use strict";
-
-// src/cli.ts
-var import_path = require("path");
-
-// src/runner.ts
-var import_node_child_process = require("child_process");
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-
-// src/graph-builder.ts
-var import_crypto = require("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 = (0, import_crypto.randomUUID)();
-  const traceId = config?.traceId ?? (typeof process !== "undefined" ? process.env?.AGENTFLOW_TRACE_ID : void 0) ?? (0, import_crypto.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 getNode(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);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  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 = getNode(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 = getNode(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();
-      getNode(from);
-      getNode(to);
-      edges.push({ from, to, type });
-      recordEvent(from, "custom", { to, type, action: "edge_add" });
-    },
-    pushEvent(event) {
-      assertNotBuilt();
-      getNode(event.nodeId);
-      events.push({
-        ...event,
-        timestamp: Date.now()
-      });
-    },
-    updateState(nodeId, state) {
-      assertNotBuilt();
-      const node = getNode(nodeId);
-      Object.assign(node.state, state);
-      recordEvent(nodeId, "custom", { action: "state_update", ...state });
-    },
-    withParent(parentId, fn) {
-      assertNotBuilt();
-      getNode(parentId);
-      parentStack.push(parentId);
-      try {
-        return fn();
-      } finally {
-        parentStack.pop();
-      }
-    },
-    getSnapshot() {
-      return buildGraph();
-    },
-    build() {
-      assertNotBuilt();
-      const graph = buildGraph();
-      built = true;
-      return graph;
-    }
-  };
-  return builder;
-}
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  graphToJson: () => graphToJson,
+  loadGraph: () => loadGraph
+});
 function toNodesMap(raw) {
   if (raw instanceof Map) return raw;
   if (Array.isArray(raw)) {
@@ -286,160 +86,30 @@ function graphToJson(graph) {
     parentSpanId: graph.parentSpanId
   };
 }
+var init_loader = __esm({
+  "src/loader.ts"() {
+    "use strict";
+  }
+});
 
-// src/runner.ts
-function globToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${escaped}$`);
+// src/cli.ts
+var import_path3 = require("path");
+
+// src/live.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/graph-query.ts
+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 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 getFailures(graph) {
   const failureStatuses = /* @__PURE__ */ new Set(["failed", "hung", "timeout"]);
   return [...graph.nodes.values()].filter((node) => failureStatuses.has(node.status));
@@ -573,6 +243,7 @@ function getTraceTree(trace) {
 }
 
 // src/live.ts
+init_loader();
 var C = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -605,17 +276,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
@@ -636,20 +308,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;
         }
@@ -675,20 +348,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) {
@@ -704,7 +379,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") {
@@ -716,7 +401,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));
@@ -776,7 +470,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;
   }
@@ -791,7 +492,14 @@ function processJsonFile(file) {
         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 });
+        records.push({
+          id: name,
+          source: "workers",
+          status: status2,
+          lastActive: ts2,
+          detail: detail2,
+          file: file.filename
+        });
       }
       return records;
     }
@@ -799,12 +507,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;
@@ -815,13 +530,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;
@@ -920,7 +644,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 [];
   }
@@ -1052,7 +785,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) {
@@ -1084,18 +818,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;
@@ -1106,13 +852,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++) {
@@ -1124,7 +876,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) {
@@ -1141,7 +896,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];
@@ -1151,7 +909,10 @@ 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}`
+        );
       }
     }
   }
@@ -1166,7 +927,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) {
@@ -1188,13 +952,13 @@ 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));
+  const invalid = config.dirs.filter((d) => !(0, import_node_fs.existsSync)(d));
   if (invalid.length > 0) {
     console.warn(`Skipping non-existent: ${invalid.join(", ")}`);
   }
@@ -1203,24 +967,947 @@ function startLive(argv) {
   let debounce = null;
   for (const dir of config.dirs) {
     try {
-      (0, import_node_fs2.watch)(dir, { recursive: config.recursive }, () => {
+      (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);
-  });
+  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_process = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+
+// src/graph-builder.ts
+var import_crypto = require("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 = (0, import_crypto.randomUUID)();
+  const traceId = config?.traceId ?? (typeof process !== "undefined" ? process.env?.AGENTFLOW_TRACE_ID : void 0) ?? (0, import_crypto.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 getNode(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 = getNode(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 = getNode(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();
+      getNode(from);
+      getNode(to);
+      edges.push({ from, to, type });
+      recordEvent(from, "custom", { to, type, action: "edge_add" });
+    },
+    pushEvent(event) {
+      assertNotBuilt();
+      getNode(event.nodeId);
+      events.push({
+        ...event,
+        timestamp: Date.now()
+      });
+    },
+    updateState(nodeId, state) {
+      assertNotBuilt();
+      const node = getNode(nodeId);
+      Object.assign(node.state, state);
+      recordEvent(nodeId, "custom", { action: "state_update", ...state });
+    },
+    withParent(parentId, fn) {
+      assertNotBuilt();
+      getNode(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/runner.ts
+init_loader();
+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_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_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-cli.ts
+var import_path2 = require("path");
+
+// src/trace-store.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+init_loader();
+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);
+    }
+  }
+  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}`);
+  }
+  return lines.join("\n");
+}
+
+// src/trace-cli.ts
+function getTracesDir(argv) {
+  const idx = argv.indexOf("--traces-dir");
+  if (idx !== -1 && argv[idx + 1]) {
+    return (0, import_path2.resolve)(argv[idx + 1]);
+  }
+  return (0, import_path2.resolve)("./traces");
+}
+function getFlag(argv, name) {
+  const idx = argv.indexOf(name);
+  if (idx !== -1 && argv[idx + 1]) {
+    return argv[idx + 1];
+  }
+  return void 0;
+}
+function printTraceHelp() {
+  console.log(
+    `
+AgentFlow Trace \u2014 inspect saved execution traces.
+
+Usage:
+  agentflow trace <command> [options]
+
+Commands:
+  list [--status <status>] [--limit <n>]    List saved traces
+  show <graph-id>                           Show trace as ASCII tree
+  timeline <graph-id>                       Show trace as timeline waterfall
+  stuck                                     Show all stuck/hung/timeout spans
+  loops [--threshold <n>]                   Detect reasoning loops
+
+Options:
+  --traces-dir <path>   Directory containing trace files (default: ./traces)
+
+Examples:
+  agentflow trace list --status failed --limit 10
+  agentflow trace show abc-123
+  agentflow trace timeline abc-123
+  agentflow trace stuck
+  agentflow trace loops --threshold 10
+`.trim()
+  );
+}
+async function traceList(argv) {
+  const dir = getTracesDir(argv);
+  const store = createTraceStore(dir);
+  const status = getFlag(argv, "--status");
+  const limitStr = getFlag(argv, "--limit");
+  const limit = limitStr ? Number.parseInt(limitStr, 10) : void 0;
+  const graphs = await store.list({ status, limit });
+  if (graphs.length === 0) {
+    console.log("No traces found.");
+    return;
+  }
+  console.log(`Found ${graphs.length} trace(s) in ${dir}:
+`);
+  for (const g of graphs) {
+    const duration = g.endTime ? `${((g.endTime - g.startTime) / 1e3).toFixed(1)}s` : "running";
+    const date = new Date(g.startTime).toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+    const icon = g.status === "completed" ? "\u2713" : g.status === "failed" ? "\u2717" : "\u231B";
+    console.log(
+      `  ${icon} ${g.id}  ${g.status.padEnd(10)} ${duration.padEnd(8)} ${date}  ${g.agentId}`
+    );
+  }
+}
+async function traceShow(argv) {
+  const dir = getTracesDir(argv);
+  const store = createTraceStore(dir);
+  const showIdx = argv.indexOf("show");
+  const graphId = showIdx !== -1 ? argv[showIdx + 1] : void 0;
+  if (!graphId || graphId.startsWith("--")) {
+    console.error("Usage: agentflow trace show <graph-id>");
+    process.exit(1);
+  }
+  let graph = await store.get(graphId);
+  if (!graph) {
+    const { readFile: readFile2 } = await import("fs/promises");
+    const { join: join5 } = await import("path");
+    const fname = graphId.endsWith(".json") ? graphId : `${graphId}.json`;
+    try {
+      const { loadGraph: loadGraph2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+      const content = await readFile2(join5(dir, fname), "utf-8");
+      graph = loadGraph2(content);
+    } catch {
+    }
+  }
+  if (!graph) {
+    console.error(`Trace "${graphId}" not found in ${dir}`);
+    process.exit(1);
+  }
+  console.log(`Trace: ${graph.id} (${graph.status})
+`);
+  console.log(toAsciiTree(graph));
+}
+async function traceTimeline(argv) {
+  const dir = getTracesDir(argv);
+  const store = createTraceStore(dir);
+  const timelineIdx = argv.indexOf("timeline");
+  const graphId = timelineIdx !== -1 ? argv[timelineIdx + 1] : void 0;
+  if (!graphId || graphId.startsWith("--")) {
+    console.error("Usage: agentflow trace timeline <graph-id>");
+    process.exit(1);
+  }
+  let graph = await store.get(graphId);
+  if (!graph) {
+    const { readFile: readFile2 } = await import("fs/promises");
+    const { join: join5 } = await import("path");
+    const fname = graphId.endsWith(".json") ? graphId : `${graphId}.json`;
+    try {
+      const { loadGraph: loadGraph2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+      const content = await readFile2(join5(dir, fname), "utf-8");
+      graph = loadGraph2(content);
+    } catch {
+    }
+  }
+  if (!graph) {
+    console.error(`Trace "${graphId}" not found in ${dir}`);
+    process.exit(1);
+  }
+  console.log(`Trace: ${graph.id} (${graph.status})
+`);
+  console.log(toTimeline(graph));
+}
+async function traceStuck(argv) {
+  const dir = getTracesDir(argv);
+  const store = createTraceStore(dir);
+  const stuck = await store.getStuckSpans();
+  if (stuck.length === 0) {
+    console.log("No stuck spans found.");
+    return;
+  }
+  console.log(`Found ${stuck.length} stuck span(s):
+`);
+  for (const node of stuck) {
+    const elapsed = Date.now() - node.startTime;
+    const icon = node.status === "timeout" ? "\u231B" : node.status === "hung" ? "\u231B" : "\u231B";
+    console.log(
+      `  ${icon} ${node.id}  ${node.type.padEnd(10)} ${node.name.padEnd(20)} ${node.status.padEnd(8)} ${(elapsed / 1e3).toFixed(0)}s`
+    );
+  }
+}
+async function traceLoops(argv) {
+  const dir = getTracesDir(argv);
+  const store = createTraceStore(dir);
+  const thresholdStr = getFlag(argv, "--threshold");
+  const threshold = thresholdStr ? Number.parseInt(thresholdStr, 10) : void 0;
+  const loops = await store.getReasoningLoops(threshold);
+  if (loops.length === 0) {
+    console.log("No reasoning loops detected.");
+    return;
+  }
+  console.log(`Found reasoning loops in ${loops.length} trace(s):
+`);
+  for (const { graphId, nodes } of loops) {
+    console.log(`  Graph: ${graphId}`);
+    for (const node of nodes) {
+      console.log(`    - ${node.id} (${node.type}: ${node.name})`);
+    }
+    console.log("");
+  }
+}
+async function handleTrace(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printTraceHelp();
+    return;
+  }
+  const traceIdx = argv.indexOf("trace");
+  const subcommand = traceIdx !== -1 ? argv[traceIdx + 1] : void 0;
+  switch (subcommand) {
+    case "list":
+      await traceList(argv);
+      break;
+    case "show":
+      await traceShow(argv);
+      break;
+    case "timeline":
+      await traceTimeline(argv);
+      break;
+    case "stuck":
+      await traceStuck(argv);
+      break;
+    case "loops":
+      await traceLoops(argv);
+      break;
+    default:
+      printTraceHelp();
+      break;
+  }
 }
 
 // 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_process2 = 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((resolve6, 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) resolve6();
+        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((resolve6, 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) resolve6();
+        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((resolve6, 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 resolve6();
+    });
+  });
+}
 
 // src/watch-state.ts
 var import_node_fs3 = require("fs");
@@ -1286,7 +1973,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);
@@ -1310,14 +1999,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
+            )
+          );
         }
       }
     }
@@ -1326,14 +2017,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
+            )
+          );
         }
       }
     }
@@ -1346,14 +2039,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
+              )
+            );
           }
         }
       }
@@ -1412,118 +2110,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((resolve5, 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) resolve5();
-        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((resolve5, 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) resolve5();
-        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((resolve5, 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 resolve5();
-    });
-  });
-}
-
 // src/watch.ts
 function parseWatchArgs(argv) {
   const dirs = [];
@@ -1565,7 +2151,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) });
@@ -1617,7 +2205,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
@@ -1660,7 +2249,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);
@@ -1689,7 +2279,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)()}`);
@@ -1715,9 +2307,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();
@@ -1735,7 +2331,8 @@ agentflow watch started`);
 
 // src/cli.ts
 function printHelp() {
-  console.log(`
+  console.log(
+    `
 AgentFlow CLI \u2014 execution tracing and live monitoring for AI agent systems.
 
 Usage:
@@ -1745,6 +2342,7 @@ Commands:
   run    [options] -- <cmd>       Wrap a command with automatic execution tracing
   live   [dir...] [options]      Real-time terminal monitor (auto-detects any JSON/JSONL)
   watch  [dir...] [options]      Headless alert system \u2014 detects failures, sends notifications
+  trace  <command> [options]     Inspect saved execution traces (list, show, timeline, stuck, loops)
 
 Run \`agentflow <command> --help\` for command-specific options.
 
@@ -1754,7 +2352,8 @@ Examples:
   agentflow live ./traces ./cron ./workers -R
   agentflow watch ./data --alert-on error --notify telegram
   agentflow watch ./data ./cron --alert-on stale:15m --notify webhook:https://...
-`.trim());
+`.trim()
+  );
 }
 function parseRunArgs(argv) {
   const result = {
@@ -1815,7 +2414,8 @@ function parseRunArgs(argv) {
   return result;
 }
 function printRunUsage() {
-  console.log(`
+  console.log(
+    `
 AgentFlow Run \u2014 wrap any command with automatic execution tracing.
 
 Usage:
@@ -1833,7 +2433,8 @@ Examples:
   agentflow run -- python -m myagent process
   agentflow run --watch-dir ./data -- python worker.py
   agentflow run --traces-dir ./my-traces --agent-id recon -- node agent.js
-`.trim());
+`.trim()
+  );
 }
 async function runCommand(argv) {
   if (argv.includes("--help") || argv.includes("-h")) {
@@ -1842,7 +2443,9 @@ async function runCommand(argv) {
   }
   const parsed = parseRunArgs(argv);
   if (parsed.command.length === 0) {
-    console.error("Error: No command specified. Use -- to separate agentflow flags from the command.");
+    console.error(
+      "Error: No command specified. Use -- to separate agentflow flags from the command."
+    );
     console.error("Example: agentflow run -- python -m myagent process");
     process.exit(1);
   }
@@ -1866,15 +2469,17 @@ async function runCommand(argv) {
   try {
     const result = await runTraced(config);
     console.log("");
-    console.log(`\u2705 Command completed (exit code ${result.exitCode}, ${result.duration.toFixed(1)}s)`);
+    console.log(
+      `\u2705 Command completed (exit code ${result.exitCode}, ${result.duration.toFixed(1)}s)`
+    );
     if (result.tracePaths.length > 0) {
       console.log("\u{1F4DD} Traces saved:");
       const orchPath = result.tracePaths[0];
-      const orchName = (0, import_path.basename)(orchPath, ".json").split("-")[0] ?? "orchestrator";
+      const orchName = (0, import_path3.basename)(orchPath, ".json").split("-")[0] ?? "orchestrator";
       console.log(`   ${orchName.padEnd(14)} \u2192 ${orchPath}`);
       for (let i = 1; i < result.tracePaths.length; i++) {
         const tPath = result.tracePaths[i];
-        const name = (0, import_path.basename)(tPath, ".json").replace(/-\d{4}-.*$/, "");
+        const name = (0, import_path3.basename)(tPath, ".json").replace(/-\d{4}-.*$/, "");
         const isLast = i === result.tracePaths.length - 1;
         const prefix = isLast ? "\u2514\u2500" : "\u251C\u2500";
         console.log(`   ${prefix} ${name.padEnd(12)} \u2192 ${tPath} (state changed)`);
@@ -1891,7 +2496,7 @@ async function runCommand(argv) {
 }
 async function main() {
   const argv = process.argv.slice(2);
-  const knownCommands = ["run", "live", "watch"];
+  const knownCommands = ["run", "live", "watch", "trace"];
   if (argv.length === 0 || !knownCommands.includes(argv[0]) && (argv.includes("--help") || argv.includes("-h"))) {
     printHelp();
     process.exit(0);
@@ -1907,6 +2512,9 @@ async function main() {
     case "watch":
       startWatch(argv);
       break;
+    case "trace":
+      await handleTrace(argv);
+      break;
     default:
       if (!subcommand?.startsWith("-")) {
         startLive(["live", ...argv]);