agentflow-dashboard 0.3.1 → 0.4.1

package/dist/server.cjs

@@ -221,7 +221,7 @@ var import_chokidar = __toESM(require("chokidar"), 1);
 var import_events = require("events");
 var fs = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
-var TraceWatcher = class extends import_events.EventEmitter {
+var TraceWatcher = class _TraceWatcher extends import_events.EventEmitter {
   watchers = [];
   traces = /* @__PURE__ */ new Map();
   tracesDir;
@@ -249,22 +249,65 @@ var TraceWatcher = class extends import_events.EventEmitter {
   }
   loadExistingFiles() {
     let totalFiles = 0;
+    let totalDirectories = 0;
     for (const dir of this.allWatchDirs) {
       if (!fs.existsSync(dir)) continue;
       try {
-        const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl"));
-        totalFiles += files.length;
-        for (const file of files) {
-          this.loadFile(path.join(dir, file));
-        }
+        totalDirectories++;
+        const loadedFiles = this.scanDirectoryRecursive(dir);
+        totalFiles += loadedFiles;
       } catch (error) {
         console.error(`Error scanning directory ${dir}:`, error);
       }
     }
-    console.log(`Scanned ${this.allWatchDirs.length} directories, 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) {
+    if (depth > 10) return 0;
+    let fileCount = 0;
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isFile()) {
+          if (this.isSupportedFile(entry.name)) {
+            if (this.loadFile(fullPath)) {
+              fileCount++;
+            }
+          }
+        } else if (entry.isDirectory()) {
+          fileCount += this.scanDirectoryRecursive(fullPath, depth + 1);
+        }
+      }
+    } catch (error) {
+      console.warn(`Cannot read directory ${dir}:`, error.message);
+    }
+    return fileCount;
+  }
+  /** Check if file type is supported */
+  isSupportedFile(filename) {
+    return filename.endsWith(".json") || filename.endsWith(".jsonl") || filename.endsWith(".log") || filename.endsWith(".trace");
   }
+  /** File names that are config/state, not traces — skip them. */
+  static SKIP_FILES = /* @__PURE__ */ new Set([
+    "workers.json",
+    "package.json",
+    "package-lock.json",
+    "tsconfig.json",
+    "biome.json",
+    "jobs.json",
+    "auth.json",
+    "models.json",
+    "config.json"
+  ]);
+  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);
+    if (_TraceWatcher.SKIP_FILES.has(filename)) return false;
+    if (_TraceWatcher.SKIP_SUFFIXES.some((s) => filename.endsWith(s))) return false;
     if (filePath.endsWith(".jsonl")) {
       return this.loadSessionFile(filePath);
     }
@@ -278,12 +321,23 @@ var TraceWatcher = class extends import_events.EventEmitter {
       const content = fs.readFileSync(filePath, "utf8");
       const filename = path.basename(filePath);
       const stats = fs.statSync(filePath);
+      if (filename.startsWith("openclaw-") || filePath.includes("openclaw")) {
+        const result = this.loadOpenClawLogFile(content, filename, filePath, stats);
+        if (result) return true;
+      }
       const traces = this.parseUniversalLog(content, filename, filePath);
       for (let i = 0; i < traces.length; i++) {
         const trace = traces[i];
+        if (trace.nodes && !(trace.nodes instanceof Map)) {
+          const nodeMap = /* @__PURE__ */ new Map();
+          for (const [key2, value] of Object.entries(trace.nodes)) {
+            nodeMap.set(key2, value);
+          }
+          trace.nodes = nodeMap;
+        }
         trace.filename = filename;
         trace.lastModified = stats.mtime.getTime();
-        trace.sourceType = "trace";
+        trace.sourceType = trace.sourceType || "trace";
         trace.sourceDir = path.dirname(filePath);
         const key = traces.length === 1 ? this.traceKey(filePath) : `${this.traceKey(filePath)}-${i}`;
         this.traces.set(key, trace);
@@ -323,10 +377,26 @@ var TraceWatcher = class extends import_events.EventEmitter {
       if (activity.timestamp > session.endTime) {
         session.endTime = activity.timestamp;
       }
+      if (activity.level === "error" || activity.level === "fatal") {
+        session.status = "failed";
+      }
     }
     const traces = Array.from(activities.values()).filter(
       (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);
+      trace.sessionEvents = sortedNodes.map((node) => ({
+        type: node.status === "failed" ? "tool_result" : "system",
+        timestamp: node.startTime,
+        name: node.name,
+        content: node.metadata.count > 1 ? `${node.name} (${node.metadata.count} occurrences, ${node.metadata.errorCount || 0} errors)` : node.name,
+        duration: node.endTime - node.startTime,
+        toolError: node.status === "failed" ? `${node.metadata.errorCount || 1} error(s)` : void 0,
+        id: node.id
+      }));
+      trace.sourceType = "session";
+    }
     if (traces.length === 0) {
       const stats = fs.statSync(filePath);
       traces.push({
@@ -340,6 +410,7 @@ var TraceWatcher = class extends import_events.EventEmitter {
             status: "completed",
             startTime: stats.mtime.getTime(),
             endTime: stats.mtime.getTime(),
+            children: [],
             metadata: { lineCount: lines.length, path: filePath }
           }
         },
@@ -406,38 +477,37 @@ var TraceWatcher = class extends import_events.EventEmitter {
       ...kvPairs
     };
   }
+  /** Strip ANSI escape codes from a string. */
+  stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+  }
   extractTimestamp(line) {
-    const coloredMatch = line.match(/^\[2m(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z)\[0m/);
-    if (coloredMatch) return new Date(coloredMatch[1]).getTime();
-    const isoMatch = line.match(/(\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}[.\d]*Z?)/);
+    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 coloredMatch = line.match(/\[\[(\d+)m\[\[1m(\w+)\s*\[0m\]/);
-    if (coloredMatch) return coloredMatch[2].toLowerCase();
-    const levelMatch = line.match(/\b(debug|info|warn|warning|error|fatal|trace)\b/i);
-    return levelMatch ? levelMatch[1].toLowerCase() : null;
+    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 coloredMatch = line.match(/\[1m([^\[]+?)\s*\[0m/);
-    if (coloredMatch) return coloredMatch[1].trim();
-    const afterLevel = line.replace(/^.*?(debug|info|warn|warning|error|fatal|trace)\s*:?\s*/i, "");
-    return afterLevel.split(" ")[0] || "";
+    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 coloredRegex = /\[36m(\w+)\[0m=\[35m([^\[]+?)\[0m/g;
+    const clean = this.stripAnsi(line);
+    const kvRegex = /(\w+)=('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|\S+)/g;
     let match;
-    while ((match = coloredRegex.exec(line)) !== null) {
+    while ((match = kvRegex.exec(clean)) !== null) {
+      if (match[1] === "Z" || match[1] === "m") continue;
       pairs[match[1]] = this.parseValue(match[2]);
     }
-    if (Object.keys(pairs).length === 0) {
-      const kvRegex = /(\w+)=([^\s]+)/g;
-      while ((match = kvRegex.exec(line)) !== null) {
-        pairs[match[1]] = this.parseValue(match[2]);
-      }
-    }
     return pairs;
   }
   parseValue(value) {
@@ -461,30 +531,51 @@ var TraceWatcher = class extends import_events.EventEmitter {
     if (kvPairs.component) return kvPairs.component;
     if (kvPairs.service) return kvPairs.service;
     if (kvPairs.module) return kvPairs.module;
-    return "unknown";
+    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.run_id || activity.session_id || activity.request_id || activity.trace_id || activity.sweep_id || activity.transaction_id || "default";
+    return activity.session_id || activity.run_id || activity.request_id || activity.trace_id || activity.sweep_id || activity.transaction_id || "default";
   }
   detectAgentIdentifier(activity, filename, filePath) {
-    if (activity.component !== "unknown") {
-      const pathAgent = this.extractAgentFromPath(filePath);
-      if (pathAgent !== activity.component) {
-        return `${pathAgent}-${activity.component}`;
+    if (activity.agent_id) {
+      const agentId = activity.agent_id;
+      if (agentId.startsWith("vault-")) return agentId;
+      if (agentId === "main" && filePath.includes(".alfred/")) return "alfred-main";
+      return agentId;
+    }
+    const pathAgent = this.extractAgentFromPath(filePath);
+    if (filePath.includes(".alfred/") && !pathAgent.startsWith("alfred-")) {
+      const basename2 = path.basename(filePath, path.extname(filePath));
+      if (basename2.match(/^(janitor|curator|distiller|surveyor|alfred)$/)) {
+        return basename2 === "alfred" ? "alfred" : `alfred-${basename2}`;
       }
-      return activity.component;
     }
-    return this.extractAgentFromPath(filePath);
+    return pathAgent;
   }
   extractAgentFromPath(filePath) {
     const filename = path.basename(filePath, path.extname(filePath));
     const pathParts = filePath.split(path.sep);
+    if (filePath.includes(".openclaw/")) {
+      const agentsIndex = pathParts.lastIndexOf("agents");
+      if (agentsIndex !== -1 && agentsIndex + 1 < pathParts.length) {
+        return `openclaw-${pathParts[agentsIndex + 1]}`;
+      }
+      if (filename.startsWith("openclaw-")) {
+        return "openclaw-gateway";
+      }
+      return "openclaw";
+    }
+    if (filePath.includes(".alfred/") || filename.includes("alfred")) {
+      return "alfred";
+    }
     for (const part of pathParts.reverse()) {
       if (part.match(/agent|worker|service|daemon|bot|ai|llm/i)) {
         return part;
@@ -506,7 +597,18 @@ var TraceWatcher = class extends import_events.EventEmitter {
     return "event";
   }
   addActivityNode(session, activity) {
-    const nodeId = `${activity.component}-${activity.operation}-${activity.timestamp}`;
+    const nodeId = `${activity.component}-${activity.operation}`;
+    if (session.nodes[nodeId]) {
+      const node2 = session.nodes[nodeId];
+      node2.endTime = Math.max(node2.endTime, activity.timestamp);
+      node2.startTime = Math.min(node2.startTime, activity.timestamp);
+      node2.metadata.count = (node2.metadata.count || 1) + 1;
+      if (activity.level === "error" || activity.level === "fatal") {
+        node2.status = "failed";
+        node2.metadata.errorCount = (node2.metadata.errorCount || 0) + 1;
+      }
+      return;
+    }
     const node = {
       id: nodeId,
       type: activity.component,
@@ -514,7 +616,8 @@ var TraceWatcher = class extends import_events.EventEmitter {
       status: this.getUniversalNodeStatus(activity),
       startTime: activity.timestamp,
       endTime: activity.timestamp,
-      metadata: activity
+      children: [],
+      metadata: { ...activity, count: 1 }
     };
     session.nodes[nodeId] = node;
     if (!session.rootNodeId) {
@@ -529,22 +632,275 @@ var TraceWatcher = class extends import_events.EventEmitter {
     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;
+    const lines = content.split("\n").filter((l) => l.trim());
+    const sessions = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed["0"] && typeof parsed["0"] === "string") {
+          try {
+            const inner = typeof parsed["0"] === "string" && parsed["0"].startsWith("{") ? JSON.parse(parsed["0"]) : null;
+            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 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({
+                text: texts.join("\n"),
+                timestamp,
+                sessionId,
+                provider: agentMeta.provider || "",
+                model: agentMeta.model || "",
+                usage: agentMeta.usage || {},
+                durationMs: inner.meta.durationMs || 0,
+                agentName
+              });
+              continue;
+            }
+          } catch {
+          }
+        }
+        if (parsed.payloads && ((_c = parsed.meta) == null ? void 0 : _c.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 texts = (parsed.payloads || []).map((p) => p.text || "").filter(Boolean);
+          if (!sessions.has(sessionId)) {
+            sessions.set(sessionId, { entries: [] });
+          }
+          sessions.get(sessionId).entries.push({
+            text: texts.join("\n"),
+            timestamp,
+            sessionId,
+            provider: agentMeta.provider || "",
+            model: agentMeta.model || "",
+            usage: agentMeta.usage || {},
+            durationMs: parsed.meta.durationMs || 0,
+            agentName
+          });
+        }
+      } catch {
+      }
+    }
+    if (sessions.size === 0) return false;
+    let traceIndex = 0;
+    for (const [sessionId, session] of sessions) {
+      const entries = session.entries;
+      if (entries.length === 0) continue;
+      const firstEntry = entries[0];
+      const lastEntry = entries[entries.length - 1];
+      const agentId = firstEntry.agentName;
+      let totalInput = 0, totalOutput = 0, totalTokens = 0;
+      let totalDuration = 0;
+      for (const entry of entries) {
+        totalInput += entry.usage.input || 0;
+        totalOutput += entry.usage.output || 0;
+        totalTokens += entry.usage.total || 0;
+        totalDuration += entry.durationMs;
+      }
+      const nodes = /* @__PURE__ */ new Map();
+      const rootId = `openclaw-${sessionId.slice(0, 12)}`;
+      for (let j = 0; j < entries.length; j++) {
+        const e = entries[j];
+        const nodeId = `entry-${j}`;
+        nodes.set(nodeId, {
+          id: nodeId,
+          type: "tool",
+          name: `${e.model}: ${e.sessionId}`,
+          startTime: e.timestamp - e.durationMs,
+          endTime: e.timestamp,
+          status: "completed",
+          parentId: rootId,
+          children: [],
+          metadata: {
+            provider: e.provider,
+            model: e.model,
+            durationMs: e.durationMs,
+            usage: e.usage,
+            preview: e.text.slice(0, 200)
+          }
+        });
+      }
+      nodes.set(rootId, {
+        id: rootId,
+        type: "agent",
+        name: sessionId,
+        startTime: firstEntry.timestamp - (firstEntry.durationMs || 0),
+        endTime: lastEntry.timestamp,
+        status: "completed",
+        parentId: void 0,
+        children: Array.from(nodes.keys()).filter((k) => k !== rootId),
+        metadata: {
+          provider: firstEntry.provider,
+          model: firstEntry.model,
+          sessionId,
+          totalTokens,
+          inputTokens: totalInput,
+          outputTokens: totalOutput,
+          durationMs: totalDuration
+        }
+      });
+      const sessionEvents = entries.map((e, idx) => ({
+        type: "assistant",
+        timestamp: e.timestamp,
+        name: e.model,
+        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 },
+        duration: e.durationMs,
+        id: `entry-${idx}`
+      }));
+      const trace = {
+        id: sessionId,
+        nodes,
+        edges: [],
+        events: [],
+        startTime: firstEntry.timestamp - (firstEntry.durationMs || 0),
+        endTime: lastEntry.timestamp,
+        agentId,
+        trigger: "cron",
+        name: sessionId,
+        traceId: sessionId,
+        spanId: sessionId,
+        filename,
+        lastModified: stats.mtime.getTime(),
+        sourceType: "session",
+        sourceDir: path.dirname(filePath),
+        sessionEvents,
+        tokenUsage: { input: totalInput, output: totalOutput, total: totalTokens || totalInput + totalOutput, cost: 0 },
+        metadata: {
+          provider: firstEntry.provider,
+          model: firstEntry.model,
+          durationMs: totalDuration,
+          source: "openclaw-log"
+        }
+      };
+      const key = sessions.size === 1 ? this.traceKey(filePath) : `${this.traceKey(filePath)}-${traceIndex}`;
+      this.traces.set(key, trace);
+      traceIndex++;
+    }
+    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");
-      const graph = (0, import_agentflow_core2.loadGraph)(content);
       const filename = path.basename(filePath);
+      if (filename === "sessions.json") {
+        return this.loadSessionsIndex(filePath, content);
+      }
+      const graph = (0, import_agentflow_core2.loadGraph)(content);
       const stats = fs.statSync(filePath);
       graph.filename = filename;
       graph.lastModified = stats.mtime.getTime();
       graph.sourceType = "trace";
       graph.sourceDir = path.dirname(filePath);
+      if (graph.nodes instanceof Map) {
+        for (const node of graph.nodes.values()) {
+          if (!node.children) node.children = [];
+        }
+      }
       this.traces.set(this.traceKey(filePath), graph);
       return true;
     } catch {
       return false;
     }
   }
+  /** Parse sessions.json index to discover agents and their sessions. */
+  loadSessionsIndex(filePath, content) {
+    try {
+      const data = JSON.parse(content);
+      if (typeof data !== "object" || data === null) return false;
+      const stats = fs.statSync(filePath);
+      const pathParts = filePath.split(path.sep);
+      const agentsIndex = pathParts.lastIndexOf("agents");
+      if (agentsIndex === -1 || agentsIndex + 1 >= pathParts.length) return false;
+      const agentName = pathParts[agentsIndex + 1];
+      const agentId = filePath.includes(".openclaw/") ? `openclaw-${agentName}` : agentName;
+      let loaded = 0;
+      for (const [sessionKey, sessionData] of Object.entries(data)) {
+        if (!sessionData || typeof sessionData !== "object") continue;
+        const session = sessionData;
+        const sessionId = session.sessionId;
+        if (!sessionId) continue;
+        const existingKey = Array.from(this.traces.keys()).find((k) => {
+          const t = this.traces.get(k);
+          return (t == null ? void 0 : t.id) === sessionId || (t == null ? void 0 : t.traceId) === sessionId;
+        });
+        if (existingKey) continue;
+        const updatedAt = session.updatedAt || stats.mtime.getTime();
+        const label = session.label || sessionKey.split(":").pop() || sessionId;
+        const chatType = session.chatType || (sessionKey.includes("cron") ? "cron" : "direct");
+        const trigger = sessionKey.includes("cron") ? "cron" : "message";
+        const rootId = `idx-${sessionId.slice(0, 12)}`;
+        const nodes = /* @__PURE__ */ new Map();
+        nodes.set(rootId, {
+          id: rootId,
+          type: "agent",
+          name: label,
+          startTime: updatedAt,
+          endTime: updatedAt,
+          status: "completed",
+          parentId: void 0,
+          children: [],
+          metadata: {
+            sessionId,
+            sessionKey,
+            chatType,
+            source: "sessions-index"
+          }
+        });
+        const trace = {
+          id: sessionId,
+          nodes,
+          edges: [],
+          events: [],
+          startTime: updatedAt,
+          agentId,
+          trigger,
+          name: label,
+          traceId: sessionId,
+          spanId: sessionId,
+          filename: `${agentName}-${sessionId.slice(0, 8)}.index`,
+          lastModified: updatedAt,
+          sourceType: "session",
+          sourceDir: path.dirname(filePath),
+          sessionEvents: [],
+          tokenUsage: { input: 0, output: 0, total: 0, cost: 0 },
+          metadata: {
+            sessionKey,
+            chatType,
+            source: "sessions-index",
+            agentName
+          }
+        };
+        const key = `${this.traceKey(filePath)}-${sessionId.slice(0, 12)}`;
+        this.traces.set(key, trace);
+        loaded++;
+      }
+      return loaded > 0;
+    } catch {
+      return false;
+    }
+  }
   /** Parse a JSONL session log into a WatchedTrace (best-effort). */
   loadSessionFile(filePath) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
@@ -560,6 +916,10 @@ var TraceWatcher = class extends import_events.EventEmitter {
         }
       }
       if (rawEvents.length === 0) return false;
+      const firstEvent = rawEvents[0];
+      if ((firstEvent == null ? void 0 : firstEvent.jobId) && (firstEvent == null ? void 0 : firstEvent.action) && !(firstEvent == null ? void 0 : firstEvent.type)) {
+        return this.loadCronRunFile(rawEvents, filePath);
+      }
       const sessionEvent = rawEvents.find((e) => e.type === "session");
       const sessionId = (sessionEvent == null ? void 0 : sessionEvent.id) || path.basename(filePath, ".jsonl");
       const sessionTimestamp = (sessionEvent == null ? void 0 : sessionEvent.timestamp) || ((_a = rawEvents[0]) == null ? void 0 : _a.timestamp);
@@ -567,7 +927,25 @@ var TraceWatcher = class extends import_events.EventEmitter {
       if (!startTime) return false;
       const parentDir = path.basename(path.dirname(filePath));
       const grandParentDir = path.basename(path.dirname(path.dirname(filePath)));
-      const agentId = grandParentDir === "agents" ? parentDir : parentDir;
+      const greatGrandParentDir = path.basename(path.dirname(path.dirname(path.dirname(filePath))));
+      let agentId;
+      if (parentDir === "sessions" && greatGrandParentDir === "agents") {
+        agentId = grandParentDir;
+      } else if (grandParentDir === "agents") {
+        agentId = parentDir;
+      } else if (parentDir === "runs" && grandParentDir === "cron") {
+        agentId = "openclaw-cron";
+      } 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}`;
+        }
+      }
       const modelEvent = rawEvents.find((e) => e.type === "model_change");
       const provider = (modelEvent == null ? void 0 : modelEvent.provider) || "";
       const modelId = (modelEvent == null ? void 0 : modelEvent.modelId) || "";
@@ -880,11 +1258,75 @@ var TraceWatcher = class extends import_events.EventEmitter {
       return false;
     }
   }
+  /** Parse cron run JSONL files (ts, jobId, action, status format). */
+  loadCronRunFile(rawEvents, filePath) {
+    var _a, _b, _c;
+    try {
+      const filename = path.basename(filePath);
+      const jobId = ((_a = rawEvents[0]) == null ? void 0 : _a.jobId) || path.basename(filePath, ".jsonl");
+      const fileStat = fs.statSync(filePath);
+      const sessionEvents = [];
+      let lastStatus = "completed";
+      for (const evt of rawEvents) {
+        const ts = evt.ts || Date.now();
+        const action = evt.action || "unknown";
+        const status = evt.status || "ok";
+        if (status !== "ok") lastStatus = "failed";
+        sessionEvents.push({
+          type: action === "finished" ? "assistant" : "system",
+          timestamp: ts,
+          name: `${jobId}: ${action}`,
+          content: evt.summary || evt.error || `${action} (${status})`,
+          id: `cron-${ts}`
+        });
+      }
+      const firstTs = ((_b = rawEvents[0]) == null ? void 0 : _b.ts) || fileStat.mtime.getTime();
+      const lastTs = ((_c = rawEvents[rawEvents.length - 1]) == null ? void 0 : _c.ts) || fileStat.mtime.getTime();
+      const rootId = `cron-${jobId.slice(0, 12)}`;
+      const nodes = /* @__PURE__ */ new Map();
+      nodes.set(rootId, {
+        id: rootId,
+        type: "agent",
+        name: jobId,
+        startTime: firstTs,
+        endTime: lastTs,
+        status: lastStatus,
+        parentId: void 0,
+        children: [],
+        metadata: { jobId, runs: rawEvents.length }
+      });
+      const trace = {
+        id: jobId,
+        nodes,
+        edges: [],
+        events: [],
+        startTime: firstTs,
+        agentId: "openclaw-cron",
+        trigger: "cron",
+        name: jobId,
+        traceId: jobId,
+        spanId: jobId,
+        filename,
+        lastModified: fileStat.mtime.getTime(),
+        sourceType: "session",
+        sourceDir: path.dirname(filePath),
+        sessionEvents,
+        tokenUsage: { input: 0, output: 0, total: 0, cost: 0 },
+        metadata: { jobId, source: "cron-run" }
+      };
+      this.traces.set(this.traceKey(filePath), trace);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   /** Unique key for a file across directories. */
   traceKey(filePath) {
     for (const dir of this.allWatchDirs) {
       if (filePath.startsWith(dir)) {
-        return path.relative(dir, filePath).replace(/\\/g, "/") + "@" + path.basename(dir);
+        const dirParts = dir.split(path.sep).filter(Boolean);
+        const dirSuffix = dirParts.slice(-2).join("/");
+        return path.relative(dir, filePath).replace(/\\/g, "/") + "@" + dirSuffix;
       }
     }
     return filePath;
@@ -892,16 +1334,35 @@ var TraceWatcher = class extends import_events.EventEmitter {
   startWatching() {
     for (const dir of this.allWatchDirs) {
       if (!fs.existsSync(dir)) continue;
-      const watcher = import_chokidar.default.watch(dir, {
-        ignored: /^\./,
+      const patterns = [
+        path.join(dir, "**/*.json"),
+        path.join(dir, "**/*.jsonl"),
+        path.join(dir, "**/*.log"),
+        path.join(dir, "**/*.trace")
+      ];
+      const watcher = import_chokidar.default.watch(patterns, {
+        ignored: [
+          /^\./,
+          // Ignore hidden files
+          /node_modules/,
+          // Ignore node_modules
+          /\.git/,
+          // Ignore git directories
+          /\.vscode/,
+          // Ignore vscode
+          /\.idea/
+          // Ignore idea
+        ],
         persistent: true,
         ignoreInitial: true,
-        depth: 0
-        // don't recurse into subdirectories
+        followSymlinks: false,
+        depth: 10
+        // Allow deep nesting for OpenClaw agents/*/sessions/
       });
       watcher.on("add", (filePath) => {
-        if (filePath.endsWith(".json") || filePath.endsWith(".jsonl") || filePath.endsWith(".log") || filePath.endsWith(".trace")) {
-          console.log(`New file: ${path.basename(filePath)}`);
+        if (this.isSupportedFile(path.basename(filePath))) {
+          const relativePath = path.relative(dir, filePath);
+          console.log(`New file: ${relativePath} (in ${path.basename(dir)})`);
           if (this.loadFile(filePath)) {
             const key = this.traceKey(filePath);
             const trace = this.traces.get(key);
@@ -912,7 +1373,7 @@ var TraceWatcher = class extends import_events.EventEmitter {
         }
       });
       watcher.on("change", (filePath) => {
-        if (filePath.endsWith(".json") || filePath.endsWith(".jsonl") || filePath.endsWith(".log") || filePath.endsWith(".trace")) {
+        if (this.isSupportedFile(path.basename(filePath))) {
           if (this.loadFile(filePath)) {
             const key = this.traceKey(filePath);
             const trace = this.traces.get(key);
@@ -923,7 +1384,7 @@ var TraceWatcher = class extends import_events.EventEmitter {
         }
       });
       watcher.on("unlink", (filePath) => {
-        if (filePath.endsWith(".json") || filePath.endsWith(".jsonl") || filePath.endsWith(".log") || filePath.endsWith(".trace")) {
+        if (this.isSupportedFile(path.basename(filePath))) {
           const key = this.traceKey(filePath);
           this.traces.delete(key);
           this.emit("trace-removed", key);
@@ -934,7 +1395,7 @@ var TraceWatcher = class extends import_events.EventEmitter {
       });
       this.watchers.push(watcher);
     }
-    console.log(`Watching ${this.allWatchDirs.length} directories for JSON/JSONL 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) => {
@@ -996,7 +1457,7 @@ var TraceWatcher = class extends import_events.EventEmitter {
 var fs2 = __toESM(require("fs"), 1);
 var os = __toESM(require("os"), 1);
 var path2 = __toESM(require("path"), 1);
-var VERSION = "0.3.1";
+var VERSION = "0.4.0";
 function getLanAddress() {
   const interfaces = os.networkInterfaces();
   for (const name of Object.keys(interfaces)) {
@@ -1141,6 +1602,18 @@ Tabs:
 var import_meta = {};
 var __filename = (0, import_url.fileURLToPath)(import_meta.url);
 var __dirname = path3.dirname(__filename);
+function serializeTrace(trace) {
+  if (!trace) return trace;
+  const obj = { ...trace };
+  if (obj.nodes instanceof Map) {
+    const nodesObj = {};
+    for (const [key, value] of obj.nodes) {
+      nodesObj[key] = value;
+    }
+    obj.nodes = nodesObj;
+  }
+  return obj;
+}
 var DashboardServer = class {
   constructor(config) {
     this.config = config;
@@ -1152,6 +1625,10 @@ var DashboardServer = class {
     this.setupExpress();
     this.setupWebSocket();
     this.setupTraceWatcher();
+    for (const trace of this.watcher.getAllTraces()) {
+      this.stats.processTrace(trace);
+    }
+    console.log(`Processed ${this.watcher.getTraceCount()} existing traces for stats`);
   }
   app = (0, import_express.default)();
   server = (0, import_http.createServer)(this.app);
@@ -1176,7 +1653,7 @@ var DashboardServer = class {
     }
     this.app.get("/api/traces", (req, res) => {
       try {
-        const traces = this.watcher.getAllTraces();
+        const traces = this.watcher.getAllTraces().map(serializeTrace);
         res.json(traces);
       } catch (error) {
         res.status(500).json({ error: "Failed to load traces" });
@@ -1188,7 +1665,7 @@ var DashboardServer = class {
         if (!trace) {
           return res.status(404).json({ error: "Trace not found" });
         }
-        res.json(trace);
+        res.json(serializeTrace(trace));
       } catch (error) {
         res.status(500).json({ error: "Failed to load trace" });
       }
@@ -1224,6 +1701,98 @@ var DashboardServer = class {
         res.status(500).json({ error: "Failed to load statistics" });
       }
     });
+    this.app.get("/api/agents/:agentId/process-graph", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const traces = this.watcher.getTracesByAgent(agentId).map(serializeTrace);
+        if (traces.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 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,
+            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);
+        res.json({
+          agentId,
+          totalTraces,
+          nodes,
+          edges,
+          maxEdgeCount,
+          maxNodeCount
+        });
+      } catch (error) {
+        console.error("Process graph error:", error);
+        res.status(500).json({ error: "Failed to build process graph" });
+      }
+    });
     this.app.get("/api/stats/:agentId", (req, res) => {
       try {
         const agentStats = this.stats.getAgentStats(req.params.agentId);
@@ -1250,7 +1819,55 @@ var DashboardServer = class {
         if (!processConfig) {
           return res.json(null);
         }
-        const result = (0, import_agentflow_core3.auditProcesses)(processConfig);
+        const alfredResult = (0, import_agentflow_core3.auditProcesses)(processConfig);
+        const openclawConfig = {
+          processName: "openclaw",
+          pidFile: void 0,
+          workersFile: void 0,
+          systemdUnit: null
+        };
+        const openclawResult = (0, import_agentflow_core3.auditProcesses)(openclawConfig);
+        const clawmetryConfig = {
+          processName: "clawmetry",
+          pidFile: void 0,
+          workersFile: void 0,
+          systemdUnit: null
+        };
+        const clawmetryResult = (0, import_agentflow_core3.auditProcesses)(clawmetryConfig);
+        const allOsProcesses = [
+          ...alfredResult.osProcesses,
+          ...openclawResult.osProcesses,
+          ...clawmetryResult.osProcesses
+        ];
+        const uniqueProcesses = allOsProcesses.filter(
+          (proc, index, arr) => arr.findIndex((p) => p.pid === proc.pid) === index
+        );
+        const result = {
+          ...alfredResult,
+          osProcesses: uniqueProcesses,
+          // Recalculate orphans based on all processes
+          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 (alfredResult.workers) {
+              if (alfredResult.workers.orchestratorPid) alfredKnownPids.add(alfredResult.workers.orchestratorPid);
+              for (const w of alfredResult.workers.workers) {
+                if (w.pid) alfredKnownPids.add(w.pid);
+              }
+            }
+            const isOpenClawProcess = p.cmdline.includes("openclaw") || p.cmdline.includes("clawmetry");
+            return !alfredKnownPids.has(p.pid) && !isOpenClawProcess && p.pid !== process.pid && p.pid !== process.ppid;
+          })
+        };
+        const openclawProblems = [];
+        if (openclawResult.osProcesses.length === 0) {
+          openclawProblems.push("No OpenClaw gateway processes detected");
+        }
+        if (clawmetryResult.osProcesses.length === 0) {
+          openclawProblems.push("No clawmetry processes detected");
+        }
+        result.problems = [...alfredResult.problems || [], ...openclawProblems];
         this.processHealthCache = { result, ts: now };
         res.json(result);
       } catch (error) {
@@ -1273,7 +1890,7 @@ var DashboardServer = class {
         JSON.stringify({
           type: "init",
           data: {
-            traces: this.watcher.getAllTraces(),
+            traces: this.watcher.getAllTraces().map(serializeTrace),
             stats: this.stats.getGlobalStats()
           }
         })
@@ -1291,14 +1908,14 @@ var DashboardServer = class {
       this.stats.processTrace(trace);
       this.broadcast({
         type: "trace-added",
-        data: trace
+        data: serializeTrace(trace)
       });
     });
     this.watcher.on("trace-updated", (trace) => {
       this.stats.processTrace(trace);
       this.broadcast({
         type: "trace-updated",
-        data: trace
+        data: serializeTrace(trace)
       });
     });
     this.watcher.on("stats-updated", () => {