agentflow-dashboard 0.4.1 → 0.6.0

package/dist/index.cjs

@@ -37,13 +37,13 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/server.ts
-var import_express = __toESM(require("express"), 1);
 var fs3 = __toESM(require("fs"), 1);
-var import_http = require("http");
+var import_node_http = require("http");
 var path3 = __toESM(require("path"), 1);
-var import_url = require("url");
-var import_ws = require("ws");
+var import_node_url = require("url");
 var import_agentflow_core3 = require("agentflow-core");
+var import_express = __toESM(require("express"), 1);
+var import_ws = require("ws");
 
 // src/stats.ts
 var import_agentflow_core = require("agentflow-core");
@@ -221,12 +221,162 @@ var AgentStats = class {
 };
 
 // src/watcher.ts
-var import_agentflow_core2 = require("agentflow-core");
-var import_chokidar = __toESM(require("chokidar"), 1);
-var import_events = require("events");
+var import_node_events = require("events");
 var fs = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
-var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
+var import_agentflow_core2 = require("agentflow-core");
+var import_chokidar = __toESM(require("chokidar"), 1);
+
+// src/parsers/log-utils.ts
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function parseValue(value) {
+  if (value.match(/^\d+$/)) return parseInt(value, 10);
+  if (value.match(/^\d+\.\d+$/)) return parseFloat(value);
+  if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+  if (value.startsWith('"') && value.endsWith('"')) return value.slice(1, -1);
+  return value;
+}
+function parseTimestamp(value) {
+  if (!value) return null;
+  if (typeof value === "number") return value;
+  try {
+    return new Date(value).getTime();
+  } catch {
+    return null;
+  }
+}
+function extractTimestamp(line) {
+  const clean = stripAnsi(line);
+  const isoMatch = clean.match(/(\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}[.\d]*Z?)/);
+  if (isoMatch) return new Date(isoMatch[1]).getTime();
+  return null;
+}
+function extractLogLevel(line) {
+  const clean = stripAnsi(line);
+  const levelMatch = clean.match(/\b(debug|info|warn|warning|error|fatal|trace)\b/i);
+  return levelMatch ? levelMatch[1].trim().toLowerCase() : null;
+}
+function extractAction(line) {
+  const clean = stripAnsi(line);
+  const actionMatch = clean.match(/\]\s+(\S+)/);
+  if (actionMatch) return actionMatch[1].trim();
+  const afterLevel = clean.replace(/^.*?(debug|info|warn|warning|error|fatal|trace)\s*\]?\s*/i, "");
+  return afterLevel.split(/\s+/)[0] || "";
+}
+function extractKeyValuePairs(line) {
+  const pairs = {};
+  const clean = stripAnsi(line);
+  const kvRegex = /(\w+)=('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|\S+)/g;
+  let match;
+  while ((match = kvRegex.exec(clean)) !== null) {
+    if (match[1] === "Z" || match[1] === "m") continue;
+    pairs[match[1]] = parseValue(match[2]);
+  }
+  return pairs;
+}
+function detectComponent(action, kvPairs) {
+  if (action.includes(".")) return action.split(".")[0];
+  if (kvPairs.component) return String(kvPairs.component);
+  if (kvPairs.service) return String(kvPairs.service);
+  if (kvPairs.module) return String(kvPairs.module);
+  if (kvPairs.worker) return String(kvPairs.worker);
+  return action || "unknown";
+}
+function detectOperation(action, kvPairs) {
+  if (action.includes(".")) return action.split(".").slice(1).join(".");
+  if (kvPairs.operation) return String(kvPairs.operation);
+  if (kvPairs.method) return String(kvPairs.method);
+  if (kvPairs.action) return String(kvPairs.action);
+  return action || "activity";
+}
+function detectActivityPattern(line) {
+  let timestamp = extractTimestamp(line);
+  let level = extractLogLevel(line);
+  let action = extractAction(line);
+  let kvPairs = extractKeyValuePairs(line);
+  if (!timestamp) {
+    const jsonMatch = line.match(/\{.*\}/);
+    if (jsonMatch) {
+      try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        timestamp = parseTimestamp(parsed.timestamp || parsed.time || parsed.ts) || Date.now();
+        level = parsed.level || parsed.severity || "info";
+        action = parsed.action || parsed.event || parsed.message || "";
+        kvPairs = parsed;
+      } catch {
+      }
+    }
+  }
+  if (!timestamp) {
+    const kvMatches = line.match(/(\w+)=([^\s]+)/g);
+    if (kvMatches && kvMatches.length >= 2) {
+      const pairs = {};
+      for (const m of kvMatches) {
+        const [key, value] = m.split("=", 2);
+        pairs[key] = parseValue(value);
+      }
+      timestamp = parseTimestamp(pairs.timestamp || pairs.time) || Date.now();
+      level = String(pairs.level || "info");
+      action = String(pairs.action || pairs.event || "");
+      kvPairs = pairs;
+    }
+  }
+  if (!timestamp) {
+    const logMatch = line.match(
+      /^(\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}[.\d]*Z?)\s+(\w+)?\s*:?\s*(.+)/
+    );
+    if (logMatch) {
+      timestamp = new Date(logMatch[1]).getTime();
+      level = logMatch[2] || "info";
+      action = logMatch[3] || "";
+    }
+  }
+  if (!timestamp) return null;
+  return {
+    timestamp,
+    level: (level == null ? void 0 : level.toLowerCase()) || "info",
+    action,
+    component: detectComponent(action, kvPairs),
+    operation: detectOperation(action, kvPairs),
+    ...kvPairs
+  };
+}
+function extractSessionIdentifier(activity) {
+  return String(
+    activity.session_id || activity.run_id || activity.request_id || activity.trace_id || activity.sweep_id || activity.transaction_id || "default"
+  );
+}
+function detectTrigger(activity) {
+  if (activity.trigger) return String(activity.trigger);
+  if (activity.method && activity.url) return "api-call";
+  if (typeof activity.operation === "string" && activity.operation.includes("start"))
+    return "startup";
+  if (typeof activity.operation === "string" && activity.operation.includes("invoke"))
+    return "invocation";
+  return "event";
+}
+function getUniversalNodeStatus(activity) {
+  if (activity.level === "error" || activity.level === "fatal") return "failed";
+  if (activity.level === "warn" || activity.level === "warning") return "warning";
+  const op = String(activity.operation || "");
+  if (op.match(/start|begin|init/i)) return "running";
+  if (op.match(/complete|finish|end|done/i)) return "completed";
+  return "completed";
+}
+function openClawSessionIdToAgent(sessionId) {
+  if (sessionId.startsWith("janitor-")) return "vault-janitor";
+  if (sessionId.startsWith("curator-")) return "vault-curator";
+  if (sessionId.startsWith("distiller-")) return "vault-distiller";
+  if (sessionId.startsWith("main-")) return "main";
+  const firstSegment = sessionId.split("-")[0];
+  if (firstSegment) return firstSegment;
+  return "openclaw";
+}
+
+// src/watcher.ts
+var TraceWatcher = class _TraceWatcher extends import_node_events.EventEmitter {
   watchers = [];
   traces = /* @__PURE__ */ new Map();
   tracesDir;
@@ -265,7 +415,9 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
         console.error(`Error scanning directory ${dir}:`, error);
       }
     }
-    console.log(`Scanned ${totalDirectories} directories (recursive), loaded ${this.traces.size} items from ${totalFiles} files`);
+    console.log(
+      `Scanned ${totalDirectories} directories (recursive), loaded ${this.traces.size} items from ${totalFiles} files`
+    );
   }
   /** Recursively scan directory for supported file types */
   scanDirectoryRecursive(dir, depth = 0) {
@@ -307,7 +459,14 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
     "models.json",
     "config.json"
   ]);
-  static SKIP_SUFFIXES = ["-state.json", "-config.json", "-watch-state.json", ".tmp", ".bak", ".backup"];
+  static SKIP_SUFFIXES = [
+    "-state.json",
+    "-config.json",
+    "-watch-state.json",
+    ".tmp",
+    ".bak",
+    ".backup"
+  ];
   /** Load a .json trace, .jsonl session file, or .log file. */
   loadFile(filePath) {
     const filename = path.basename(filePath);
@@ -358,16 +517,16 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
     const lines = content.split("\n").filter((line) => line.trim());
     const activities = /* @__PURE__ */ new Map();
     for (const line of lines) {
-      const activity = this.detectActivityPattern(line);
+      const activity = detectActivityPattern(line);
       if (!activity) continue;
-      const sessionId = this.extractSessionIdentifier(activity);
+      const sessionId = extractSessionIdentifier(activity);
       if (!activities.has(sessionId)) {
         activities.set(sessionId, {
           id: sessionId,
           rootNodeId: "",
           agentId: this.detectAgentIdentifier(activity, filename, filePath),
           name: this.generateActivityName(activity, sessionId),
-          trigger: this.detectTrigger(activity),
+          trigger: detectTrigger(activity),
           startTime: activity.timestamp,
           endTime: activity.timestamp,
           status: "completed",
@@ -390,7 +549,9 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
       (session) => Object.keys(session.nodes).length > 0
     );
     for (const trace of traces) {
-      const sortedNodes = Object.values(trace.nodes).sort((a, b) => a.startTime - b.startTime);
+      const sortedNodes = Object.values(trace.nodes).sort(
+        (a, b) => a.startTime - b.startTime
+      );
       trace.sessionEvents = sortedNodes.map((node) => ({
         type: node.status === "failed" ? "tool_result" : "system",
         timestamp: node.startTime,
@@ -408,7 +569,7 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
         id: "",
         rootNodeId: "root",
         nodes: {
-          "root": {
+          root: {
             id: "root",
             type: "log-file",
             name: filename,
@@ -431,125 +592,7 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
     }
     return traces;
   }
-  /** Detect activity patterns in log lines using universal heuristics */
-  detectActivityPattern(line) {
-    let timestamp = this.extractTimestamp(line);
-    let level = this.extractLogLevel(line);
-    let action = this.extractAction(line);
-    let kvPairs = this.extractKeyValuePairs(line);
-    if (!timestamp) {
-      const jsonMatch = line.match(/\{.*\}/);
-      if (jsonMatch) {
-        try {
-          const parsed = JSON.parse(jsonMatch[0]);
-          timestamp = this.parseTimestamp(parsed.timestamp || parsed.time || parsed.ts) || Date.now();
-          level = parsed.level || parsed.severity || "info";
-          action = parsed.action || parsed.event || parsed.message || "";
-          kvPairs = parsed;
-        } catch {
-        }
-      }
-    }
-    if (!timestamp) {
-      const kvMatches = line.match(/(\w+)=([^\s]+)/g);
-      if (kvMatches && kvMatches.length >= 2) {
-        const pairs = {};
-        kvMatches.forEach((match) => {
-          const [key, value] = match.split("=", 2);
-          pairs[key] = this.parseValue(value);
-        });
-        timestamp = this.parseTimestamp(pairs.timestamp || pairs.time) || Date.now();
-        level = pairs.level || "info";
-        action = pairs.action || pairs.event || "";
-        kvPairs = pairs;
-      }
-    }
-    if (!timestamp) {
-      const logMatch = line.match(/^(\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}[.\d]*Z?)\s+(\w+)?\s*:?\s*(.+)/);
-      if (logMatch) {
-        timestamp = new Date(logMatch[1]).getTime();
-        level = logMatch[2] || "info";
-        action = logMatch[3] || "";
-      }
-    }
-    if (!timestamp) return null;
-    return {
-      timestamp,
-      level: (level == null ? void 0 : level.toLowerCase()) || "info",
-      action,
-      component: this.detectComponent(action, kvPairs),
-      operation: this.detectOperation(action, kvPairs),
-      ...kvPairs
-    };
-  }
-  /** Strip ANSI escape codes from a string. */
-  stripAnsi(str) {
-    return str.replace(/\x1b\[[0-9;]*m/g, "");
-  }
-  extractTimestamp(line) {
-    const clean = this.stripAnsi(line);
-    const isoMatch = clean.match(/(\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}[.\d]*Z?)/);
-    if (isoMatch) return new Date(isoMatch[1]).getTime();
-    return null;
-  }
-  extractLogLevel(line) {
-    const clean = this.stripAnsi(line);
-    const levelMatch = clean.match(/\b(debug|info|warn|warning|error|fatal|trace)\b/i);
-    return levelMatch ? levelMatch[1].trim().toLowerCase() : null;
-  }
-  extractAction(line) {
-    const clean = this.stripAnsi(line);
-    const actionMatch = clean.match(/\]\s+(\S+)/);
-    if (actionMatch) return actionMatch[1].trim();
-    const afterLevel = clean.replace(/^.*?(debug|info|warn|warning|error|fatal|trace)\s*\]?\s*/i, "");
-    return afterLevel.split(/\s+/)[0] || "";
-  }
-  extractKeyValuePairs(line) {
-    const pairs = {};
-    const clean = this.stripAnsi(line);
-    const kvRegex = /(\w+)=('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|\S+)/g;
-    let match;
-    while ((match = kvRegex.exec(clean)) !== null) {
-      if (match[1] === "Z" || match[1] === "m") continue;
-      pairs[match[1]] = this.parseValue(match[2]);
-    }
-    return pairs;
-  }
-  parseValue(value) {
-    if (value.match(/^\d+$/)) return parseInt(value);
-    if (value.match(/^\d+\.\d+$/)) return parseFloat(value);
-    if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
-    if (value.startsWith('"') && value.endsWith('"')) return value.slice(1, -1);
-    return value;
-  }
-  parseTimestamp(value) {
-    if (!value) return null;
-    if (typeof value === "number") return value;
-    try {
-      return new Date(value).getTime();
-    } catch {
-      return null;
-    }
-  }
-  detectComponent(action, kvPairs) {
-    if (action.includes(".")) return action.split(".")[0];
-    if (kvPairs.component) return kvPairs.component;
-    if (kvPairs.service) return kvPairs.service;
-    if (kvPairs.module) return kvPairs.module;
-    if (kvPairs.worker) return kvPairs.worker;
-    return action || "unknown";
-  }
-  detectOperation(action, kvPairs) {
-    if (action.includes(".")) return action.split(".").slice(1).join(".");
-    if (kvPairs.operation) return kvPairs.operation;
-    if (kvPairs.method) return kvPairs.method;
-    if (kvPairs.action) return kvPairs.action;
-    return action || "activity";
-  }
-  extractSessionIdentifier(activity) {
-    return activity.session_id || activity.run_id || activity.request_id || activity.trace_id || activity.sweep_id || activity.transaction_id || "default";
-  }
-  detectAgentIdentifier(activity, filename, filePath) {
+  detectAgentIdentifier(activity, _filename, filePath) {
     if (activity.agent_id) {
       const agentId = activity.agent_id;
       if (agentId.startsWith("vault-")) return agentId;
@@ -593,14 +636,6 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
     const operation = activity.operation !== "activity" ? `: ${activity.operation}` : "";
     return `${component}${operation} (${sessionId})`;
   }
-  detectTrigger(activity) {
-    var _a, _b;
-    if (activity.trigger) return activity.trigger;
-    if (activity.method && activity.url) return "api-call";
-    if ((_a = activity.operation) == null ? void 0 : _a.includes("start")) return "startup";
-    if ((_b = activity.operation) == null ? void 0 : _b.includes("invoke")) return "invocation";
-    return "event";
-  }
   addActivityNode(session, activity) {
     const nodeId = `${activity.component}-${activity.operation}`;
     if (session.nodes[nodeId]) {
@@ -618,7 +653,7 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
       id: nodeId,
       type: activity.component,
       name: `${activity.component}: ${activity.operation}`,
-      status: this.getUniversalNodeStatus(activity),
+      status: getUniversalNodeStatus(activity),
       startTime: activity.timestamp,
       endTime: activity.timestamp,
       children: [],
@@ -629,17 +664,9 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
       session.rootNodeId = nodeId;
     }
   }
-  getUniversalNodeStatus(activity) {
-    var _a, _b;
-    if (activity.level === "error" || activity.level === "fatal") return "failed";
-    if (activity.level === "warn" || activity.level === "warning") return "warning";
-    if ((_a = activity.operation) == null ? void 0 : _a.match(/start|begin|init/i)) return "running";
-    if ((_b = activity.operation) == null ? void 0 : _b.match(/complete|finish|end|done/i)) return "completed";
-    return "completed";
-  }
   /** Parse OpenClaw tslog-format log files with session run results. */
   loadOpenClawLogFile(content, filename, filePath, stats) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     const lines = content.split("\n").filter((l) => l.trim());
     const sessions = /* @__PURE__ */ new Map();
     for (const line of lines) {
@@ -651,13 +678,13 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
             if ((inner == null ? void 0 : inner.payloads) && ((_a = inner == null ? void 0 : inner.meta) == null ? void 0 : _a.agentMeta)) {
               const agentMeta = inner.meta.agentMeta;
               const sessionId = agentMeta.sessionId || "unknown";
-              const agentName = this.openClawSessionIdToAgent(sessionId);
+              const agentName = openClawSessionIdToAgent(sessionId);
               const timestamp = parsed.time ? new Date(parsed.time).getTime() : ((_b = parsed._meta) == null ? void 0 : _b.date) ? new Date(parsed._meta.date).getTime() : stats.mtime.getTime();
               const texts = (inner.payloads || []).map((p) => p.text || "").filter(Boolean);
               if (!sessions.has(sessionId)) {
                 sessions.set(sessionId, { entries: [] });
               }
-              sessions.get(sessionId).entries.push({
+              (_c = sessions.get(sessionId)) == null ? void 0 : _c.entries.push({
                 text: texts.join("\n"),
                 timestamp,
                 sessionId,
@@ -672,16 +699,16 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
           } catch {
           }
         }
-        if (parsed.payloads && ((_c = parsed.meta) == null ? void 0 : _c.agentMeta)) {
+        if (parsed.payloads && ((_d = parsed.meta) == null ? void 0 : _d.agentMeta)) {
           const agentMeta = parsed.meta.agentMeta;
           const sessionId = agentMeta.sessionId || "unknown";
-          const agentName = this.openClawSessionIdToAgent(sessionId);
-          const timestamp = parsed.time ? new Date(parsed.time).getTime() : ((_d = parsed._meta) == null ? void 0 : _d.date) ? new Date(parsed._meta.date).getTime() : stats.mtime.getTime();
+          const agentName = openClawSessionIdToAgent(sessionId);
+          const timestamp = parsed.time ? new Date(parsed.time).getTime() : ((_e = parsed._meta) == null ? void 0 : _e.date) ? new Date(parsed._meta.date).getTime() : stats.mtime.getTime();
           const texts = (parsed.payloads || []).map((p) => p.text || "").filter(Boolean);
           if (!sessions.has(sessionId)) {
             sessions.set(sessionId, { entries: [] });
           }
-          sessions.get(sessionId).entries.push({
+          (_f = sessions.get(sessionId)) == null ? void 0 : _f.entries.push({
             text: texts.join("\n"),
             timestamp,
             sessionId,
@@ -760,7 +787,11 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
         content: e.text,
         model: e.model,
         provider: e.provider,
-        tokens: { input: e.usage.input || 0, output: e.usage.output || 0, total: e.usage.total || 0 },
+        tokens: {
+          input: e.usage.input || 0,
+          output: e.usage.output || 0,
+          total: e.usage.total || 0
+        },
         duration: e.durationMs,
         id: `entry-${idx}`
       }));
@@ -781,7 +812,12 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
         sourceType: "session",
         sourceDir: path.dirname(filePath),
         sessionEvents,
-        tokenUsage: { input: totalInput, output: totalOutput, total: totalTokens || totalInput + totalOutput, cost: 0 },
+        tokenUsage: {
+          input: totalInput,
+          output: totalOutput,
+          total: totalTokens || totalInput + totalOutput,
+          cost: 0
+        },
         metadata: {
           provider: firstEntry.provider,
           model: firstEntry.model,
@@ -795,16 +831,6 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
     }
     return traceIndex > 0;
   }
-  /** Map OpenClaw sessionId prefix to agent name. */
-  openClawSessionIdToAgent(sessionId) {
-    if (sessionId.startsWith("janitor-")) return "vault-janitor";
-    if (sessionId.startsWith("curator-")) return "vault-curator";
-    if (sessionId.startsWith("distiller-")) return "vault-distiller";
-    if (sessionId.startsWith("main-")) return "main";
-    const firstSegment = sessionId.split("-")[0];
-    if (firstSegment) return firstSegment;
-    return "openclaw";
-  }
   loadTraceFile(filePath) {
     try {
       const content = fs.readFileSync(filePath, "utf8");
@@ -943,9 +969,6 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
       } else {
         agentId = parentDir;
       }
-      if (filePath.includes(".openclaw/") && !agentId.startsWith("openclaw-")) {
-        agentId = `openclaw-${agentId}`;
-      }
       if (filePath.includes(".alfred/") || filePath.includes("alfred")) {
         if (!agentId.startsWith("alfred-")) {
           agentId = `alfred-${agentId}`;
@@ -962,10 +985,12 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
           if (ts > lastTimestamp) lastTimestamp = ts;
         }
       }
-      const firstMessage = rawEvents.find((e) => {
-        var _a2;
-        return e.type === "message" && ((_a2 = e.message) == null ? void 0 : _a2.role) === "user";
-      });
+      const firstMessage = rawEvents.find(
+        (e) => {
+          var _a2;
+          return e.type === "message" && ((_a2 = e.message) == null ? void 0 : _a2.role) === "user";
+        }
+      );
       const userPrompt = ((_d = (_c = (_b = firstMessage == null ? void 0 : firstMessage.message) == null ? void 0 : _b.content) == null ? void 0 : _c[0]) == null ? void 0 : _d.text) || "";
       const cronMatch = userPrompt.match(/\[cron:(\S+)\s+([^\]]+)\]/);
       const triggerName = cronMatch ? cronMatch[2] : "";
@@ -1039,7 +1064,7 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
           nodes.set(spawnId, {
             id: spawnId,
             type: "subagent",
-            name: "Subagent: " + (((_f = evt.data) == null ? void 0 : _f.sessionId) || "").slice(0, 12),
+            name: `Subagent: ${(((_f = evt.data) == null ? void 0 : _f.sessionId) || "").slice(0, 12)}`,
             startTime: evtTs,
             endTime: evtTs,
             status: "completed",
@@ -1163,7 +1188,7 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
               id: evt.id,
               parentId: toolCallId
             });
-            for (const [nodeId, node] of nodes) {
+            for (const [_nodeId, node] of nodes) {
               if (node.type === "tool" && ((_k = node.metadata) == null ? void 0 : _k.toolCallId) === toolCallId) {
                 node.endTime = evtTs;
                 node.status = hasError ? "failed" : "completed";
@@ -1331,7 +1356,7 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
       if (filePath.startsWith(dir)) {
         const dirParts = dir.split(path.sep).filter(Boolean);
         const dirSuffix = dirParts.slice(-2).join("/");
-        return path.relative(dir, filePath).replace(/\\/g, "/") + "@" + dirSuffix;
+        return `${path.relative(dir, filePath).replace(/\\/g, "/")}@${dirSuffix}`;
       }
     }
     return filePath;
@@ -1400,7 +1425,9 @@ var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
       });
       this.watchers.push(watcher);
     }
-    console.log(`Watching ${this.allWatchDirs.length} directories recursively for JSON/JSONL/LOG/TRACE files`);
+    console.log(
+      `Watching ${this.allWatchDirs.length} directories recursively for JSON/JSONL/LOG/TRACE files`
+    );
   }
   getAllTraces() {
     return Array.from(this.traces.values()).sort((a, b) => {
@@ -1501,7 +1528,8 @@ function printBanner(config, traceCount, stats) {
 
   Tabs: \u{1F3AF} Graph \xB7 \u23F1\uFE0F  Timeline \xB7 \u{1F4CA} Metrics \xB7 \u{1F6E0}\uFE0F  Process Health \xB7 \u26A0\uFE0F  Errors
 
-  Traces:     ${config.tracesDir}${((_a = config.dataDirs) == null ? void 0 : _a.length) ? "\n  Data dirs:  " + config.dataDirs.join("\n              ") : ""}
+  Traces:     ${config.tracesDir}${((_a = config.dataDirs) == null ? void 0 : _a.length) ? `
+  Data dirs:  ${config.dataDirs.join("\n              ")}` : ""}
   Loaded:     ${traceCount} traces \xB7 ${stats.totalAgents} agents \xB7 ${stats.totalExecutions} executions
   Success:    ${stats.globalSuccessRate.toFixed(1)}%${stats.activeAgents > 0 ? ` \xB7 ${stats.activeAgents} active now` : ""}
   CORS:       ${config.enableCors ? "enabled" : "disabled"}
@@ -1523,7 +1551,7 @@ async function startDashboard() {
     switch (args[i]) {
       case "--port":
       case "-p":
-        config.port = parseInt(args[++i]) || 3e3;
+        config.port = parseInt(args[++i], 10) || 3e3;
         break;
       case "--traces":
       case "-t":
@@ -1605,7 +1633,7 @@ Tabs:
 
 // src/server.ts
 var import_meta = {};
-var __filename = (0, import_url.fileURLToPath)(import_meta.url);
+var __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
 var __dirname = path3.dirname(__filename);
 function serializeTrace(trace) {
   if (!trace) return trace;
@@ -1627,23 +1655,41 @@ var DashboardServer = class {
       dataDirs: config.dataDirs
     });
     this.stats = new AgentStats();
+    this.knowledgeStore = (0, import_agentflow_core3.createKnowledgeStore)({
+      baseDir: path3.join(config.tracesDir, "..", ".agentflow", "knowledge")
+    });
     this.setupExpress();
     this.setupWebSocket();
     this.setupTraceWatcher();
+    let knowledgeCount = 0;
     for (const trace of this.watcher.getAllTraces()) {
       this.stats.processTrace(trace);
+      if (this.isGraphTrace(trace)) {
+        try {
+          const graph = (0, import_agentflow_core3.loadGraph)(serializeTrace(trace));
+          const event = (0, import_agentflow_core3.createExecutionEvent)(graph);
+          this.knowledgeStore.append(event);
+          knowledgeCount++;
+        } catch {
+        }
+      }
     }
     console.log(`Processed ${this.watcher.getTraceCount()} existing traces for stats`);
+    console.log(`Persisted ${knowledgeCount} graph traces to knowledge store`);
   }
   app = (0, import_express.default)();
-  server = (0, import_http.createServer)(this.app);
+  server = (0, import_node_http.createServer)(this.app);
   wss = new import_ws.WebSocketServer({ server: this.server });
   watcher;
   stats;
-  processHealthCache = { result: null, ts: 0 };
+  processHealthCache = {
+    result: null,
+    ts: 0
+  };
+  knowledgeStore;
   setupExpress() {
     if (this.config.enableCors) {
-      this.app.use((req, res, next) => {
+      this.app.use((_req, res, next) => {
         res.header("Access-Control-Allow-Origin", "*");
         res.header(
           "Access-Control-Allow-Headers",
@@ -1656,11 +1702,11 @@ var DashboardServer = class {
     if (fs3.existsSync(publicDir)) {
       this.app.use(import_express.default.static(publicDir));
     }
-    this.app.get("/api/traces", (req, res) => {
+    this.app.get("/api/traces", (_req, res) => {
       try {
         const traces = this.watcher.getAllTraces().map(serializeTrace);
         res.json(traces);
-      } catch (error) {
+      } catch (_error) {
         res.status(500).json({ error: "Failed to load traces" });
       }
     });
@@ -1671,7 +1717,7 @@ var DashboardServer = class {
           return res.status(404).json({ error: "Trace not found" });
         }
         res.json(serializeTrace(trace));
-      } catch (error) {
+      } catch (_error) {
         res.status(500).json({ error: "Failed to load trace" });
       }
     });
@@ -1686,118 +1732,163 @@ var DashboardServer = class {
           tokenUsage: trace.tokenUsage || null,
           sourceType: trace.sourceType || "trace"
         });
-      } catch (error) {
+      } catch (_error) {
         res.status(500).json({ error: "Failed to load trace events" });
       }
     });
-    this.app.get("/api/agents", (req, res) => {
+    this.app.get("/api/agents", (_req, res) => {
       try {
         const agents = this.stats.getAgentsList();
         res.json(agents);
-      } catch (error) {
+      } catch (_error) {
         res.status(500).json({ error: "Failed to load agents" });
       }
     });
-    this.app.get("/api/stats", (req, res) => {
+    this.app.get("/api/stats", (_req, res) => {
       try {
         const globalStats = this.stats.getGlobalStats();
         res.json(globalStats);
-      } catch (error) {
+      } catch (_error) {
         res.status(500).json({ error: "Failed to load statistics" });
       }
     });
-    this.app.get("/api/agents/:agentId/process-graph", (req, res) => {
+    this.app.get("/api/agents/:agentId/timeline", (req, res) => {
       try {
         const agentId = req.params.agentId;
-        const traces = this.watcher.getTracesByAgent(agentId).map(serializeTrace);
-        if (traces.length === 0) {
+        const limit = Math.min(parseInt(req.query.limit, 10) || 50, 200);
+        const rawTraces = this.watcher.getTracesByAgent(agentId);
+        if (rawTraces.length === 0) {
           return res.status(404).json({ error: "No traces for agent" });
         }
-        const activityCounts = /* @__PURE__ */ new Map();
-        const transitionCounts = /* @__PURE__ */ new Map();
-        const activityDurations = /* @__PURE__ */ new Map();
-        const activityStatuses = /* @__PURE__ */ new Map();
-        let totalTraces = 0;
-        for (const trace of traces) {
-          totalTraces++;
+        const traces = rawTraces.sort((a, b) => (b.startTime || 0) - (a.startTime || 0)).slice(0, limit).reverse();
+        const executions = traces.map((t) => {
+          const serialized = serializeTrace(t);
+          const nodes = serialized.nodes || {};
+          const events = serialized.sessionEvents || [];
           const activities = [];
-          if (trace.sessionEvents && trace.sessionEvents.length > 0) {
-            for (const evt of trace.sessionEvents) {
-              const name = evt.toolName || evt.name || evt.type;
-              if (!name) continue;
+          if (events.length > 0) {
+            for (let i = 0; i < events.length; i++) {
+              const evt = events[i];
+              if (evt.type === "system" || evt.type === "model_change") continue;
+              const dur = evt.duration || 0;
+              const startTs = dur > 0 ? evt.timestamp - dur : evt.timestamp;
+              const nextTs = i + 1 < events.length ? events[i + 1].timestamp : evt.timestamp;
+              const endTs = dur > 0 ? evt.timestamp : Math.max(nextTs, startTs + 500);
               activities.push({
-                name,
+                id: evt.id || `evt-${i}`,
+                name: evt.toolName || evt.name || evt.type,
                 type: evt.type,
                 status: evt.toolError ? "failed" : "completed",
-                duration: evt.duration || 0
+                startTime: startTs,
+                endTime: endTs,
+                parentId: evt.parentId
               });
             }
           } else {
-            const nodes2 = trace.nodes || {};
-            const sorted = Object.values(nodes2).sort((a, b) => (a.startTime || 0) - (b.startTime || 0));
+            const sorted = Object.values(nodes).sort(
+              (a, b) => (a.startTime || 0) - (b.startTime || 0)
+            );
             for (const node of sorted) {
               activities.push({
+                id: node.id,
                 name: node.name || node.type || node.id,
                 type: node.type || "unknown",
                 status: node.status || "completed",
-                duration: (node.endTime || node.startTime || 0) - (node.startTime || 0)
+                startTime: node.startTime || t.startTime,
+                endTime: node.endTime || node.startTime || t.startTime,
+                parentId: node.parentId
               });
             }
           }
-          const seq = ["[START]", ...activities.map((a) => a.name), "[END]"];
-          for (let i = 0; i < seq.length; i++) {
-            const act = seq[i];
-            activityCounts.set(act, (activityCounts.get(act) || 0) + 1);
-            if (i < seq.length - 1) {
-              const key = act + " \u2192 " + seq[i + 1];
-              transitionCounts.set(key, (transitionCounts.get(key) || 0) + 1);
-            }
-          }
-          for (const act of activities) {
-            if (act.duration > 0) {
-              const durs = activityDurations.get(act.name) || [];
-              durs.push(act.duration);
-              activityDurations.set(act.name, durs);
-            }
-            const st = activityStatuses.get(act.name) || { ok: 0, fail: 0 };
-            if (act.status === "failed") st.fail++;
-            else st.ok++;
-            activityStatuses.set(act.name, st);
-          }
-        }
-        const nodes = Array.from(activityCounts.entries()).map(([name, count]) => {
-          const durs = activityDurations.get(name) || [];
-          const st = activityStatuses.get(name) || { ok: 0, fail: 0 };
-          const avgDuration = durs.length > 0 ? durs.reduce((a, b) => a + b, 0) / durs.length : 0;
           return {
-            id: name,
-            label: name,
-            count,
-            frequency: count / totalTraces,
-            avgDuration,
-            failRate: st.ok + st.fail > 0 ? st.fail / (st.ok + st.fail) : 0,
-            isVirtual: name === "[START]" || name === "[END]"
+            id: serialized.id || serialized.filename,
+            filename: serialized.filename,
+            name: serialized.name || serialized.filename,
+            agentId: serialized.agentId,
+            trigger: serialized.trigger,
+            status: serialized.status || "completed",
+            sourceType: serialized.sourceType,
+            startTime: serialized.startTime,
+            endTime: serialized.endTime || serialized.startTime,
+            tokenUsage: serialized.tokenUsage,
+            activities
           };
         });
-        const edges = Array.from(transitionCounts.entries()).map(([key, count]) => {
-          const [source, target] = key.split(" \u2192 ");
-          return { source, target, count, frequency: count / totalTraces };
-        });
-        const maxEdgeCount = Math.max(...edges.map((e) => e.count), 1);
-        const maxNodeCount = Math.max(...nodes.filter((n) => !n.isVirtual).map((n) => n.count), 1);
-        res.json({
-          agentId,
-          totalTraces,
-          nodes,
-          edges,
-          maxEdgeCount,
-          maxNodeCount
-        });
+        const allTimes = executions.flatMap((e) => [e.startTime, e.endTime]);
+        const minTime = Math.min(...allTimes);
+        const maxTime = Math.max(...allTimes);
+        res.json({ agentId, totalExecutions: rawTraces.length, executions, minTime, maxTime });
+      } catch (error) {
+        console.error("Agent timeline error:", error);
+        res.status(500).json({ error: "Failed to build agent timeline" });
+      }
+    });
+    this.app.get("/api/agents/:agentId/process-graph", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const allTraces = this.watcher.getTracesByAgent(agentId);
+        if (allTraces.length === 0) {
+          return res.status(404).json({ error: "No traces for agent" });
+        }
+        const graphs = this.getGraphTraces(agentId);
+        if (graphs.length > 0) {
+          return res.json(this.buildProcessGraphFromCore(agentId, graphs));
+        }
+        return res.json(this.buildProcessGraphLegacy(agentId, allTraces));
       } catch (error) {
         console.error("Process graph error:", error);
         res.status(500).json({ error: "Failed to build process graph" });
       }
     });
+    this.app.get("/api/agents/:agentId/variants", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const graphs = this.getGraphTraces(agentId);
+        if (graphs.length === 0) {
+          return res.json({ agentId, totalTraces: 0, variants: [] });
+        }
+        const variants = (0, import_agentflow_core3.findVariants)(graphs).map((v) => ({
+          pathSignature: v.pathSignature,
+          count: v.count,
+          percentage: v.percentage
+        }));
+        res.json({ agentId, totalTraces: graphs.length, variants });
+      } catch (error) {
+        console.error("Variants error:", error);
+        res.status(500).json({ error: "Failed to compute variants" });
+      }
+    });
+    this.app.get("/api/agents/:agentId/bottlenecks", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const graphs = this.getGraphTraces(agentId);
+        if (graphs.length === 0) {
+          return res.json({ agentId, bottlenecks: [] });
+        }
+        const bottlenecks = (0, import_agentflow_core3.getBottlenecks)(graphs).map((b) => ({
+          nodeName: b.nodeName,
+          nodeType: b.nodeType,
+          occurrences: b.occurrences,
+          durations: b.durations
+        }));
+        res.json({ agentId, bottlenecks });
+      } catch (error) {
+        console.error("Bottlenecks error:", error);
+        res.status(500).json({ error: "Failed to compute bottlenecks" });
+      }
+    });
+    this.app.get("/api/agents/:agentId/profile", (req, res) => {
+      try {
+        const profile = this.knowledgeStore.getAgentProfile(req.params.agentId);
+        if (!profile) {
+          return res.status(404).json({ error: "No profile for agent" });
+        }
+        res.json(profile);
+      } catch (error) {
+        console.error("Profile error:", error);
+        res.status(500).json({ error: "Failed to load agent profile" });
+      }
+    });
     this.app.get("/api/stats/:agentId", (req, res) => {
       try {
         const agentStats = this.stats.getAgentStats(req.params.agentId);
@@ -1805,11 +1896,11 @@ var DashboardServer = class {
           return res.status(404).json({ error: "Agent not found" });
         }
         res.json(agentStats);
-      } catch (error) {
+      } catch (_error) {
         res.status(500).json({ error: "Failed to load agent statistics" });
       }
     });
-    this.app.get("/api/process-health", (req, res) => {
+    this.app.get("/api/process-health", (_req, res) => {
       try {
         const now = Date.now();
         if (this.processHealthCache.result && now - this.processHealthCache.ts < 1e4) {
@@ -1854,9 +1945,11 @@ var DashboardServer = class {
           orphans: uniqueProcesses.filter((p) => {
             var _a;
             const alfredKnownPids = /* @__PURE__ */ new Set();
-            if (((_a = alfredResult.pidFile) == null ? void 0 : _a.pid) && !alfredResult.pidFile.stale) alfredKnownPids.add(alfredResult.pidFile.pid);
+            if (((_a = alfredResult.pidFile) == null ? void 0 : _a.pid) && !alfredResult.pidFile.stale)
+              alfredKnownPids.add(alfredResult.pidFile.pid);
             if (alfredResult.workers) {
-              if (alfredResult.workers.orchestratorPid) alfredKnownPids.add(alfredResult.workers.orchestratorPid);
+              if (alfredResult.workers.orchestratorPid)
+                alfredKnownPids.add(alfredResult.workers.orchestratorPid);
               for (const w of alfredResult.workers.workers) {
                 if (w.pid) alfredKnownPids.add(w.pid);
               }
@@ -1875,11 +1968,22 @@ var DashboardServer = class {
         result.problems = [...alfredResult.problems || [], ...openclawProblems];
         this.processHealthCache = { result, ts: now };
         res.json(result);
-      } catch (error) {
+      } catch (_error) {
         res.status(500).json({ error: "Failed to audit processes" });
       }
     });
-    this.app.get("*", (req, res) => {
+    this.app.get("/health", (_req, res) => {
+      res.json({
+        status: "ok",
+        uptime: process.uptime(),
+        traceCount: this.watcher.getTraceCount(),
+        agentCount: this.watcher.getAgentIds().length
+      });
+    });
+    this.app.get("/ready", (_req, res) => {
+      res.json({ status: "ready" });
+    });
+    this.app.get("*", (_req, res) => {
       const indexPath = path3.join(__dirname, "../public/index.html");
       if (fs3.existsSync(indexPath)) {
         res.sendFile(indexPath);
@@ -1908,6 +2012,189 @@ var DashboardServer = class {
       });
     });
   }
+  /**
+   * Filter an agent's traces to valid ExecutionGraphs and convert via loadGraph().
+   * Returns only traces with proper nodes (Map or non-empty object), skipping session-only traces.
+   */
+  getGraphTraces(agentId) {
+    const traces = this.watcher.getTracesByAgent(agentId).map(serializeTrace);
+    const graphs = [];
+    for (const trace of traces) {
+      try {
+        if (trace.sourceType === "session" || trace.sourceType === "log") continue;
+        if (!trace.rootNodeId && !trace.rootId) continue;
+        const nodes = trace.nodes;
+        if (!nodes || typeof nodes === "object" && Object.keys(nodes).length === 0) continue;
+        const nodeValues = Object.values(nodes);
+        if (nodeValues.some((n) => n.type === "log-file" || n.type === "log-entry")) continue;
+        graphs.push((0, import_agentflow_core3.loadGraph)(trace));
+      } catch {
+      }
+    }
+    return graphs;
+  }
+  /**
+   * Build process graph response using core APIs (discoverProcess + getBottlenecks).
+   * Maps core output to the frontend's expected shape with virtual START/END nodes.
+   */
+  buildProcessGraphFromCore(agentId, graphs) {
+    const model = (0, import_agentflow_core3.discoverProcess)(graphs);
+    const bottleneckList = (0, import_agentflow_core3.getBottlenecks)(graphs);
+    const bottleneckMap = /* @__PURE__ */ new Map();
+    for (const b of bottleneckList) {
+      const key = `${b.nodeType}:${b.nodeName}`;
+      bottleneckMap.set(key, {
+        avgDuration: b.durations.median,
+        failRate: 0,
+        // Not directly available from bottleneck data
+        p95: b.durations.p95
+      });
+      bottleneckMap.set(b.nodeName, {
+        avgDuration: b.durations.median,
+        failRate: 0,
+        p95: b.durations.p95
+      });
+    }
+    const nodes = [];
+    const stepCounts = /* @__PURE__ */ new Map();
+    for (const t of model.transitions) {
+      stepCounts.set(t.from, (stepCounts.get(t.from) ?? 0) + t.count);
+    }
+    for (const step of model.steps) {
+      const count = stepCounts.get(step) ?? model.totalGraphs;
+      const bn = bottleneckMap.get(step);
+      const colonIdx = step.indexOf(":");
+      const label = colonIdx >= 0 ? step.slice(colonIdx + 1) : step;
+      nodes.push({
+        id: step,
+        label,
+        count,
+        frequency: count / model.totalGraphs,
+        avgDuration: (bn == null ? void 0 : bn.avgDuration) ?? 0,
+        failRate: (bn == null ? void 0 : bn.failRate) ?? 0,
+        p95Duration: (bn == null ? void 0 : bn.p95) ?? 0,
+        isVirtual: false
+      });
+    }
+    const rootSteps = new Set(model.steps);
+    const childSteps = new Set(model.transitions.map((t) => t.to));
+    const leafSteps = new Set(model.steps);
+    for (const t of model.transitions) {
+    }
+    nodes.push({ id: "[START]", label: "[START]", count: model.totalGraphs, frequency: 1, avgDuration: 0, failRate: 0, p95Duration: 0, isVirtual: true });
+    nodes.push({ id: "[END]", label: "[END]", count: model.totalGraphs, frequency: 1, avgDuration: 0, failRate: 0, p95Duration: 0, isVirtual: true });
+    const edges = model.transitions.map((t) => ({
+      source: t.from,
+      target: t.to,
+      count: t.count,
+      frequency: t.count / model.totalGraphs
+    }));
+    const targetSteps = new Set(model.transitions.map((t) => t.to));
+    for (const step of model.steps) {
+      if (!targetSteps.has(step)) {
+        edges.push({ source: "[START]", target: step, count: model.totalGraphs, frequency: 1 });
+      }
+    }
+    const sourceSteps = new Set(model.transitions.map((t) => t.from));
+    for (const step of model.steps) {
+      if (!sourceSteps.has(step)) {
+        edges.push({ source: step, target: "[END]", count: model.totalGraphs, frequency: 1 });
+      }
+    }
+    const maxEdgeCount = Math.max(...edges.map((e) => e.count), 1);
+    const maxNodeCount = Math.max(...nodes.filter((n) => !n.isVirtual).map((n) => n.count), 1);
+    return { agentId, totalTraces: model.totalGraphs, nodes, edges, maxEdgeCount, maxNodeCount };
+  }
+  /**
+   * Legacy process graph computation for session-based traces.
+   * Preserved for backward compatibility with JSONL/LOG traces.
+   */
+  buildProcessGraphLegacy(agentId, allTraces) {
+    const traces = allTraces.map(serializeTrace);
+    const activityCounts = /* @__PURE__ */ new Map();
+    const transitionCounts = /* @__PURE__ */ new Map();
+    const activityDurations = /* @__PURE__ */ new Map();
+    const activityStatuses = /* @__PURE__ */ new Map();
+    let totalTraces = 0;
+    for (const trace of traces) {
+      totalTraces++;
+      const activities = [];
+      if (trace.sessionEvents && trace.sessionEvents.length > 0) {
+        for (const evt of trace.sessionEvents) {
+          const name = evt.toolName || evt.name || evt.type;
+          if (!name) continue;
+          activities.push({
+            name,
+            type: evt.type,
+            status: evt.toolError ? "failed" : "completed",
+            duration: evt.duration || 0
+          });
+        }
+      } else {
+        const nodes2 = trace.nodes || {};
+        const sorted = Object.values(nodes2).sort(
+          (a, b) => (a.startTime || 0) - (b.startTime || 0)
+        );
+        for (const node of sorted) {
+          activities.push({
+            name: node.name || node.type || node.id,
+            type: node.type || "unknown",
+            status: node.status || "completed",
+            duration: (node.endTime || node.startTime || 0) - (node.startTime || 0)
+          });
+        }
+      }
+      const seq = ["[START]", ...activities.map((a) => a.name), "[END]"];
+      for (let i = 0; i < seq.length; i++) {
+        const act = seq[i];
+        activityCounts.set(act, (activityCounts.get(act) || 0) + 1);
+        if (i < seq.length - 1) {
+          const key = `${act} \u2192 ${seq[i + 1]}`;
+          transitionCounts.set(key, (transitionCounts.get(key) || 0) + 1);
+        }
+      }
+      for (const act of activities) {
+        if (act.duration > 0) {
+          const durs = activityDurations.get(act.name) || [];
+          durs.push(act.duration);
+          activityDurations.set(act.name, durs);
+        }
+        const st = activityStatuses.get(act.name) || { ok: 0, fail: 0 };
+        if (act.status === "failed") st.fail++;
+        else st.ok++;
+        activityStatuses.set(act.name, st);
+      }
+    }
+    const nodes = Array.from(activityCounts.entries()).map(([name, count]) => {
+      const durs = activityDurations.get(name) || [];
+      const st = activityStatuses.get(name) || { ok: 0, fail: 0 };
+      const avgDuration = durs.length > 0 ? durs.reduce((a, b) => a + b, 0) / durs.length : 0;
+      return {
+        id: name,
+        label: name,
+        count,
+        frequency: count / totalTraces,
+        avgDuration,
+        failRate: st.ok + st.fail > 0 ? st.fail / (st.ok + st.fail) : 0,
+        p95Duration: 0,
+        isVirtual: name === "[START]" || name === "[END]"
+      };
+    });
+    const edges = Array.from(transitionCounts.entries()).map(([key, count]) => {
+      const [source, target] = key.split(" \u2192 ");
+      return { source, target, count, frequency: count / totalTraces };
+    });
+    const maxEdgeCount = Math.max(...edges.map((e) => e.count), 1);
+    const maxNodeCount = Math.max(...nodes.filter((n) => !n.isVirtual).map((n) => n.count), 1);
+    return { agentId, totalTraces, nodes, edges, maxEdgeCount, maxNodeCount };
+  }
+  /** Check if a trace is a proper ExecutionGraph (not a synthetic session-based trace). */
+  isGraphTrace(trace) {
+    if (trace.sourceType === "session" || trace.sourceType === "log") return false;
+    if (!trace.rootNodeId && !trace.rootId) return false;
+    const nodes = trace.nodes instanceof Map ? Object.fromEntries(trace.nodes) : trace.nodes;
+    return nodes && typeof nodes === "object" && Object.keys(nodes).length > 0;
+  }
   setupTraceWatcher() {
     this.watcher.on("trace-added", (trace) => {
       this.stats.processTrace(trace);
@@ -1915,6 +2202,14 @@ var DashboardServer = class {
         type: "trace-added",
         data: serializeTrace(trace)
       });
+      if (this.isGraphTrace(trace)) {
+        try {
+          const graph = (0, import_agentflow_core3.loadGraph)(serializeTrace(trace));
+          const event = (0, import_agentflow_core3.createExecutionEvent)(graph);
+          this.knowledgeStore.append(event);
+        } catch {
+        }
+      }
     });
     this.watcher.on("trace-updated", (trace) => {
       this.stats.processTrace(trace);