agentflow-core 0.2.2 → 0.3.0

package/dist/{chunk-WOJEID7V.js → chunk-NPH34CAL.js}

@@ -879,9 +879,19 @@ function processJsonlFile(file) {
     return [];
   }
 }
+var K = "\x1B[K";
+function writeLine(lines, text) {
+  lines.push(text + K);
+}
+function flushLines(lines) {
+  process.stdout.write("\x1B[H");
+  process.stdout.write(lines.join("\n") + "\n");
+  process.stdout.write("\x1B[J");
+}
 var prevFileCount = 0;
 var newExecCount = 0;
 var sessionStart = Date.now();
+var firstRender = true;
 function render(config) {
   const files = scanFiles(config.dirs, config.recursive);
   if (files.length > prevFileCount && prevFileCount > 0) {
@@ -897,26 +907,58 @@ function render(config) {
       if (r.traceData) allTraces.push(r.traceData);
     }
   }
-  const agents = {};
+  const byFile = /* @__PURE__ */ new Map();
   for (const r of allRecords) {
-    if (!agents[r.id]) {
-      agents[r.id] = { name: r.id, total: 0, ok: 0, fail: 0, running: 0, lastTs: 0, source: r.source, detail: "" };
-    }
-    const ag = agents[r.id];
-    ag.total++;
-    if (r.status === "ok") ag.ok++;
-    else if (r.status === "error") ag.fail++;
-    else if (r.status === "running") ag.running++;
-    if (r.lastActive > ag.lastTs) {
-      ag.lastTs = r.lastActive;
-      ag.detail = r.detail;
-      ag.source = r.source;
+    const arr = byFile.get(r.file) ?? [];
+    arr.push(r);
+    byFile.set(r.file, arr);
+  }
+  const groups = [];
+  for (const [file, records] of byFile) {
+    if (records.length === 1) {
+      const r = records[0];
+      groups.push({
+        name: r.id,
+        source: r.source,
+        status: r.status,
+        lastTs: r.lastActive,
+        detail: r.detail,
+        children: [],
+        ok: r.status === "ok" ? 1 : 0,
+        fail: r.status === "error" ? 1 : 0,
+        running: r.status === "running" ? 1 : 0,
+        total: 1
+      });
+    } else {
+      const groupName = nameFromFile(file);
+      let lastTs = 0;
+      let ok = 0, fail = 0, running = 0;
+      for (const r of records) {
+        if (r.lastActive > lastTs) lastTs = r.lastActive;
+        if (r.status === "ok") ok++;
+        else if (r.status === "error") fail++;
+        else if (r.status === "running") running++;
+      }
+      const status = fail > 0 ? "error" : running > 0 ? "running" : ok > 0 ? "ok" : "unknown";
+      groups.push({
+        name: groupName,
+        source: records[0].source,
+        status,
+        lastTs,
+        detail: `${records.length} agents`,
+        children: records.sort((a, b) => b.lastActive - a.lastActive),
+        ok,
+        fail,
+        running,
+        total: records.length
+      });
     }
   }
-  const agentList = Object.values(agents).sort((a, b) => b.lastTs - a.lastTs);
-  const totExec = agentList.reduce((s, a) => s + a.total, 0);
-  const totFail = agentList.reduce((s, a) => s + a.fail, 0);
-  const totRunning = agentList.reduce((s, a) => s + a.running, 0);
+  groups.sort((a, b) => b.lastTs - a.lastTs);
+  const totExec = allRecords.length;
+  const totFail = allRecords.filter((r) => r.status === "error").length;
+  const totRunning = allRecords.filter((r) => r.status === "running").length;
+  const uniqueAgents = new Set(allRecords.map((r) => r.id)).size;
   const sysRate = totExec > 0 ? ((totExec - totFail) / totExec * 100).toFixed(1) : "100.0";
   const now = Date.now();
   const buckets = new Array(12).fill(0);
@@ -953,7 +995,21 @@ function render(config) {
   const upMin = Math.floor(upSec / 60);
   const upStr = upMin > 0 ? `${upMin}m ${upSec % 60}s` : `${upSec}s`;
   const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
-  const sourceTag = (s) => {
+  function statusIcon(s, recent) {
+    if (s === "error") return `${C.red}\u25CF${C.reset}`;
+    if (s === "running") return `${C.green}\u25CF${C.reset}`;
+    if (s === "ok" && recent) return `${C.green}\u25CF${C.reset}`;
+    if (s === "ok") return `${C.dim}\u25CB${C.reset}`;
+    return `${C.dim}\u25CB${C.reset}`;
+  }
+  function statusText(g) {
+    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}`;
+    return `${C.dim}idle${C.reset}`;
+  }
+  function sourceTag(s) {
     switch (s) {
       case "trace":
         return `${C.cyan}trace${C.reset}`;
@@ -966,93 +1022,115 @@ function render(config) {
       case "state":
         return `${C.dim}state${C.reset}`;
     }
-  };
-  process.stdout.write("\x1B[2J\x1B[H");
-  console.log(`${C.bold}${C.cyan}\u2554${"\u2550".repeat(70)}\u2557${C.reset}`);
-  console.log(`${C.bold}${C.cyan}\u2551${C.reset}  ${C.bold}${C.white}AGENTFLOW LIVE${C.reset}                               ${C.green}\u25CF LIVE${C.reset}  ${C.dim}${time}${C.reset}  ${C.bold}${C.cyan}\u2551${C.reset}`);
+  }
+  function timeStr(ts) {
+    if (ts <= 0) return "n/a";
+    return new Date(ts).toLocaleTimeString();
+  }
+  function truncate(s, max) {
+    return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+  }
+  if (firstRender) {
+    process.stdout.write("\x1B[2J");
+    firstRender = false;
+  }
+  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}`);
   const metaLine = `Refresh: ${config.refreshMs / 1e3}s \xB7 Up: ${upStr} \xB7 Files: ${files.length}`;
   const pad1 = Math.max(0, 64 - metaLine.length);
-  console.log(`${C.bold}${C.cyan}\u2551${C.reset}  ${C.dim}${metaLine}${C.reset}${" ".repeat(pad1)}${C.bold}${C.cyan}\u2551${C.reset}`);
-  console.log(`${C.bold}${C.cyan}\u255A${"\u2550".repeat(70)}\u255D${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;
-  console.log("");
-  console.log(`  ${C.bold}Agents${C.reset} ${sc}${agentList.length}${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}`);
-  console.log("");
-  console.log(`  ${C.bold}Activity (1h)${C.reset}  ${spark}  ${C.dim}\u2190 now${C.reset}`);
-  console.log("");
-  console.log(`  ${C.bold}${C.under}Agent                     Type     Status   Last Active  Detail${C.reset}`);
-  for (const ag of agentList.slice(0, 30)) {
-    const lastTime = ag.lastTs > 0 ? new Date(ag.lastTs).toLocaleTimeString() : "n/a";
-    const isRecent = Date.now() - ag.lastTs < 3e5;
-    let statusIcon;
-    let statusText;
-    if (ag.fail > 0 && ag.ok === 0 && ag.running === 0) {
-      statusIcon = `${C.red}\u25CF${C.reset}`;
-      statusText = `${C.red}error${C.reset}`;
-    } else if (ag.running > 0) {
-      statusIcon = `${C.green}\u25CF${C.reset}`;
-      statusText = `${C.green}running${C.reset}`;
-    } else if (ag.fail > 0) {
-      statusIcon = `${C.yellow}\u25CF${C.reset}`;
-      statusText = `${C.yellow}${ag.ok}ok/${ag.fail}err${C.reset}`;
-    } else if (ag.ok > 0) {
-      statusIcon = isRecent ? `${C.green}\u25CF${C.reset}` : `${C.dim}\u25CB${C.reset}`;
-      statusText = ag.total > 1 ? `${C.green}${ag.ok}/${ag.total}${C.reset}` : `${C.green}ok${C.reset}`;
+  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, "");
+  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}`);
+  let lineCount = 0;
+  for (const g of groups) {
+    if (lineCount > 35) break;
+    const isRecent = Date.now() - g.lastTs < 3e5;
+    const icon = statusIcon(g.status, isRecent);
+    const active = isRecent ? `${C.green}${timeStr(g.lastTs)}${C.reset}` : `${C.dim}${timeStr(g.lastTs)}${C.reset}`;
+    if (g.children.length === 0) {
+      const name = truncate(g.name, 26).padEnd(26);
+      const st = statusText(g);
+      const det = truncate(g.detail, 30);
+      writeLine(L, `  ${icon} ${name}  ${st.padEnd(20)}  ${active.padEnd(20)}  ${C.dim}${det}${C.reset}`);
+      lineCount++;
     } else {
-      statusIcon = `${C.dim}\u25CB${C.reset}`;
-      statusText = `${C.dim}idle${C.reset}`;
+      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}`);
+      lineCount++;
+      const kids = g.children.slice(0, 12);
+      for (let i = 0; i < kids.length; i++) {
+        if (lineCount > 35) break;
+        const child = kids[i];
+        const isLast = i === kids.length - 1;
+        const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
+        const cIcon = statusIcon(child.status, Date.now() - child.lastActive < 3e5);
+        const cName = truncate(child.id, 22).padEnd(22);
+        const cActive = `${C.dim}${timeStr(child.lastActive)}${C.reset}`;
+        const cDet = truncate(child.detail, 25);
+        writeLine(L, `     ${C.dim}${connector}${C.reset} ${cIcon} ${cName}  ${cActive.padEnd(20)}  ${C.dim}${cDet}${C.reset}`);
+        lineCount++;
+      }
+      if (g.children.length > 12) {
+        writeLine(L, `     ${C.dim}   ... +${g.children.length - 12} more${C.reset}`);
+        lineCount++;
+      }
     }
-    const name = ag.name.length > 23 ? ag.name.slice(0, 22) + "\u2026" : ag.name.padEnd(23);
-    const src = sourceTag(ag.source).padEnd(16);
-    const active = isRecent ? `${C.green}${lastTime}${C.reset}` : `${C.dim}${lastTime}${C.reset}`;
-    const detail = ag.detail.length > 30 ? ag.detail.slice(0, 29) + "\u2026" : ag.detail;
-    console.log(`  ${statusIcon} ${name}  ${src}  ${statusText.padEnd(18)}  ${active.padEnd(20)}  ${C.dim}${detail}${C.reset}`);
   }
   if (distributedTraces.length > 0) {
-    console.log("");
-    console.log(`  ${C.bold}${C.under}Distributed Traces${C.reset}`);
+    writeLine(L, "");
+    writeLine(L, `  ${C.bold}${C.under}Distributed Traces${C.reset}`);
     for (const dt of distributedTraces.slice(0, 3)) {
       const traceTime = new Date(dt.startTime).toLocaleTimeString();
-      const statusIcon = dt.status === "completed" ? `${C.green}\u2713${C.reset}` : dt.status === "failed" ? `${C.red}\u2717${C.reset}` : `${C.yellow}\u23F3${C.reset}`;
+      const 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);
-      console.log(`  ${statusIcon}  ${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 g = tree[i];
-        const depth = getDistDepth(dt, g.spanId);
+        const tg = tree[i];
+        const depth = getDistDepth(dt, tg.spanId);
         const indent = "     " + "\u2502  ".repeat(Math.max(0, depth - 1));
         const isLast = i === tree.length - 1 || getDistDepth(dt, tree[i + 1]?.spanId) <= depth;
         const conn = depth === 0 ? "  " : isLast ? "\u2514\u2500 " : "\u251C\u2500 ";
-        const gs = g.status === "completed" ? `${C.green}\u2713${C.reset}` : g.status === "failed" ? `${C.red}\u2717${C.reset}` : `${C.yellow}\u23F3${C.reset}`;
-        const gd = g.endTime ? `${g.endTime - g.startTime}ms` : "running";
-        console.log(`${indent}${conn}${gs} ${C.bold}${g.agentId}${C.reset} ${C.dim}[${g.trigger}] ${gd}${C.reset}`);
+        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}`);
       }
     }
   }
-  const recentRecords = allRecords.filter((r) => r.lastActive > 0).sort((a, b) => b.lastActive - a.lastActive).slice(0, 8);
+  const recentRecords = allRecords.filter((r) => r.lastActive > 0).sort((a, b) => b.lastActive - a.lastActive).slice(0, 6);
   if (recentRecords.length > 0) {
-    console.log("");
-    console.log(`  ${C.bold}${C.under}Recent Activity${C.reset}`);
+    writeLine(L, "");
+    writeLine(L, `  ${C.bold}${C.under}Recent Activity${C.reset}`);
     for (const r of recentRecords) {
       const icon = r.status === "ok" ? `${C.green}\u2713${C.reset}` : r.status === "error" ? `${C.red}\u2717${C.reset}` : r.status === "running" ? `${C.green}\u25B6${C.reset}` : `${C.dim}\u25CB${C.reset}`;
       const t = new Date(r.lastActive).toLocaleTimeString();
-      const agent = r.id.length > 26 ? r.id.slice(0, 25) + "\u2026" : r.id.padEnd(26);
+      const agent = truncate(r.id, 26).padEnd(26);
       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 detail = r.detail.length > 25 ? r.detail.slice(0, 24) + "\u2026" : r.detail;
-      console.log(`  ${icon}  ${agent} ${C.dim}${t}  ${ageStr.padStart(8)}${C.reset}  ${C.dim}${detail}${C.reset}`);
+      const det = truncate(r.detail, 25);
+      writeLine(L, `  ${icon}  ${agent} ${C.dim}${t}  ${ageStr.padStart(8)}${C.reset}  ${C.dim}${det}${C.reset}`);
     }
   }
   if (files.length === 0) {
-    console.log("");
-    console.log(`  ${C.dim}No JSON/JSONL files found. Waiting for data in:${C.reset}`);
-    for (const d of config.dirs) console.log(`  ${C.dim}  ${d}${C.reset}`);
+    writeLine(L, "");
+    writeLine(L, `  ${C.dim}No JSON/JSONL files found. Waiting for data in:${C.reset}`);
+    for (const d of config.dirs) writeLine(L, `  ${C.dim}  ${d}${C.reset}`);
   }
-  console.log("");
+  writeLine(L, "");
   const dirLabel = config.dirs.length === 1 ? config.dirs[0] : `${config.dirs.length} directories`;
-  console.log(`  ${C.dim}Watching: ${dirLabel}${C.reset}`);
-  console.log(`  ${C.dim}Press Ctrl+C to exit${C.reset}`);
+  writeLine(L, `  ${C.dim}Watching: ${dirLabel}${C.reset}`);
+  writeLine(L, `  ${C.dim}Press Ctrl+C to exit${C.reset}`);
+  flushLines(L);
 }
 function getDistDepth(dt, spanId) {
   if (!spanId) return 0;
@@ -1091,6 +1169,522 @@ function startLive(argv) {
   });
 }
 
+// src/watch.ts
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve3, join as join3 } from "path";
+import { hostname } from "os";
+
+// src/watch-state.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync } from "fs";
+function parseDuration(input) {
+  const match = input.match(/^(\d+(?:\.\d+)?)\s*(s|m|h|d)$/i);
+  if (!match) {
+    const n = parseInt(input, 10);
+    return isNaN(n) ? 0 : n * 1e3;
+  }
+  const value = parseFloat(match[1]);
+  switch (match[2].toLowerCase()) {
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 6e4;
+    case "h":
+      return value * 36e5;
+    case "d":
+      return value * 864e5;
+    default:
+      return value * 1e3;
+  }
+}
+function emptyState() {
+  return { version: 1, agents: {}, lastPollTime: 0 };
+}
+function loadWatchState(filePath) {
+  if (!existsSync3(filePath)) return emptyState();
+  try {
+    const raw = JSON.parse(readFileSync2(filePath, "utf8"));
+    if (raw.version !== 1 || typeof raw.agents !== "object") return emptyState();
+    return raw;
+  } catch {
+    return emptyState();
+  }
+}
+function saveWatchState(filePath, state) {
+  const tmp = filePath + ".tmp";
+  try {
+    writeFileSync2(tmp, JSON.stringify(state, null, 2), "utf8");
+    renameSync(tmp, filePath);
+  } catch {
+    try {
+      writeFileSync2(filePath, JSON.stringify(state, null, 2), "utf8");
+    } catch {
+    }
+  }
+}
+function estimateInterval(history) {
+  if (history.length < 3) return 0;
+  const sorted = [...history].sort((a, b) => a - b);
+  const deltas = [];
+  for (let i = 1; i < sorted.length; i++) {
+    const d = sorted[i] - sorted[i - 1];
+    if (d > 0) deltas.push(d);
+  }
+  if (deltas.length === 0) return 0;
+  deltas.sort((a, b) => a - b);
+  return deltas[Math.floor(deltas.length / 2)];
+}
+function detectTransitions(previous, currentRecords, config, now) {
+  const alerts = [];
+  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 byAgent = /* @__PURE__ */ new Map();
+  for (const r of currentRecords) {
+    const existing = byAgent.get(r.id);
+    if (!existing || r.lastActive > existing.lastActive) {
+      byAgent.set(r.id, r);
+    }
+  }
+  for (const [agentId, record] of byAgent) {
+    const prev = previous.agents[agentId];
+    const prevStatus = prev?.lastStatus ?? "unknown";
+    const currStatus = record.status;
+    if (hasError && currStatus === "error" && prevStatus !== "error") {
+      if (canAlert(prev, "error", config.cooldownMs, now)) {
+        alerts.push(makePayload(agentId, "error", prevStatus, currStatus, record, config.dirs));
+      }
+    }
+    if (hasRecovery && currStatus === "ok" && prevStatus === "error") {
+      alerts.push(makePayload(agentId, "recovery", prevStatus, currStatus, record, config.dirs));
+    }
+    const newConsec = currStatus === "error" ? (prev?.consecutiveErrors ?? 0) + 1 : 0;
+    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
+          ));
+        }
+      }
+    }
+    for (const cond of staleConditions) {
+      const sinceActive = now - record.lastActive;
+      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
+          ));
+        }
+      }
+    }
+    if (staleConditions.length === 0) {
+      const history = prev?.mtimeHistory ?? [];
+      const expectedInterval = estimateInterval(history);
+      if (expectedInterval > 0) {
+        const sinceActive = now - record.lastActive;
+        if (sinceActive > expectedInterval * 3) {
+          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
+            ));
+          }
+        }
+      }
+    }
+  }
+  return alerts;
+}
+function updateWatchState(state, records, alerts, now) {
+  const agents = { ...state.agents };
+  const alertsByAgent = /* @__PURE__ */ new Map();
+  for (const a of alerts) alertsByAgent.set(a.agentId, a);
+  const byAgent = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const existing = byAgent.get(r.id);
+    if (!existing || r.lastActive > existing.lastActive) {
+      byAgent.set(r.id, r);
+    }
+  }
+  for (const [agentId, record] of byAgent) {
+    const prev = agents[agentId];
+    const history = prev?.mtimeHistory ?? [];
+    const newHistory = [...history];
+    if (newHistory.length === 0 || newHistory[newHistory.length - 1] !== record.lastActive) {
+      newHistory.push(record.lastActive);
+    }
+    while (newHistory.length > 10) newHistory.shift();
+    const alert = alertsByAgent.get(agentId);
+    const consecutiveErrors = record.status === "error" ? (prev?.consecutiveErrors ?? 0) + 1 : 0;
+    agents[agentId] = {
+      id: agentId,
+      lastStatus: record.status,
+      lastActive: record.lastActive,
+      lastAlertTime: alert ? now : prev?.lastAlertTime ?? 0,
+      lastAlertReason: alert ? alert.condition : prev?.lastAlertReason ?? "",
+      consecutiveErrors,
+      mtimeHistory: newHistory
+    };
+  }
+  return { version: 1, agents, lastPollTime: now };
+}
+function canAlert(prev, reason, cooldownMs, now) {
+  if (!prev) return true;
+  if (prev.lastAlertReason !== reason) return true;
+  return now - prev.lastAlertTime > cooldownMs;
+}
+function makePayload(agentId, condition, previousStatus, currentStatus, record, dirs) {
+  return {
+    agentId,
+    condition,
+    previousStatus,
+    currentStatus,
+    detail: record.detail,
+    file: record.file,
+    timestamp: Date.now(),
+    dirs
+  };
+}
+
+// src/watch-alerts.ts
+import { request as httpsRequest } from "https";
+import { request as httpRequest } from "http";
+import { exec } from "child_process";
+function formatAlertMessage(payload) {
+  const time = new Date(payload.timestamp).toISOString();
+  const arrow = `${payload.previousStatus} \u2192 ${payload.currentStatus}`;
+  return [
+    `[ALERT] ${payload.condition}: "${payload.agentId}"`,
+    `  Status:  ${arrow}`,
+    payload.detail ? `  Detail:  ${payload.detail}` : null,
+    `  File:    ${payload.file}`,
+    `  Time:    ${time}`
+  ].filter(Boolean).join("\n");
+}
+function formatTelegram(payload) {
+  const icon = payload.condition === "recovery" ? "\u2705" : "\u26A0\uFE0F";
+  const time = new Date(payload.timestamp).toLocaleTimeString();
+  return [
+    `${icon} *AgentFlow Alert*`,
+    `*${payload.condition}*: \`${payload.agentId}\``,
+    `Status: ${payload.previousStatus} \u2192 ${payload.currentStatus}`,
+    payload.detail ? `Detail: ${payload.detail.slice(0, 200)}` : null,
+    `Time: ${time}`
+  ].filter(Boolean).join("\n");
+}
+async function sendAlert(payload, channel) {
+  try {
+    switch (channel.type) {
+      case "stdout":
+        sendStdout(payload);
+        break;
+      case "telegram":
+        await sendTelegram(payload, channel.botToken, channel.chatId);
+        break;
+      case "webhook":
+        await sendWebhook(payload, channel.url);
+        break;
+      case "command":
+        await sendCommand(payload, channel.cmd);
+        break;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[agentflow] Failed to send ${channel.type} alert: ${msg}`);
+  }
+}
+function sendStdout(payload) {
+  console.log(formatAlertMessage(payload));
+}
+function sendTelegram(payload, botToken, chatId) {
+  const body = JSON.stringify({
+    chat_id: chatId,
+    text: formatTelegram(payload),
+    parse_mode: "Markdown"
+  });
+  return new Promise((resolve4, reject) => {
+    const req = httpsRequest(
+      `https://api.telegram.org/bot${botToken}/sendMessage`,
+      { method: "POST", headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
+      (res) => {
+        res.resume();
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) resolve4();
+        else reject(new Error(`Telegram API returned ${res.statusCode}`));
+      }
+    );
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+function sendWebhook(payload, url) {
+  const body = JSON.stringify(payload);
+  const isHttps = url.startsWith("https");
+  const doRequest = isHttps ? httpsRequest : httpRequest;
+  return new Promise((resolve4, reject) => {
+    const req = doRequest(
+      url,
+      { method: "POST", headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
+      (res) => {
+        res.resume();
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) resolve4();
+        else reject(new Error(`Webhook returned ${res.statusCode}`));
+      }
+    );
+    req.on("error", reject);
+    req.setTimeout(1e4, () => {
+      req.destroy(new Error("Webhook timeout"));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+function sendCommand(payload, cmd) {
+  return new Promise((resolve4, reject) => {
+    const env = {
+      ...process.env,
+      AGENTFLOW_ALERT_AGENT: payload.agentId,
+      AGENTFLOW_ALERT_CONDITION: payload.condition,
+      AGENTFLOW_ALERT_STATUS: payload.currentStatus,
+      AGENTFLOW_ALERT_PREVIOUS_STATUS: payload.previousStatus,
+      AGENTFLOW_ALERT_DETAIL: payload.detail,
+      AGENTFLOW_ALERT_FILE: payload.file,
+      AGENTFLOW_ALERT_TIMESTAMP: String(payload.timestamp)
+    };
+    exec(cmd, { env, timeout: 3e4 }, (err) => {
+      if (err) reject(err);
+      else resolve4();
+    });
+  });
+}
+
+// src/watch.ts
+function parseWatchArgs(argv) {
+  const dirs = [];
+  const alertConditions = [];
+  const notifyChannels = [];
+  let recursive = false;
+  let pollIntervalMs = 3e4;
+  let cooldownMs = 30 * 6e4;
+  let stateFilePath = "";
+  const args = argv.slice(0);
+  if (args[0] === "watch") args.shift();
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      printWatchUsage();
+      process.exit(0);
+    } else if (arg === "--alert-on") {
+      i++;
+      const val = args[i] ?? "";
+      if (val === "error") {
+        alertConditions.push({ type: "error" });
+      } else if (val === "recovery") {
+        alertConditions.push({ type: "recovery" });
+      } else if (val.startsWith("stale:")) {
+        const dur = parseDuration(val.slice(6));
+        if (dur > 0) alertConditions.push({ type: "stale", durationMs: dur });
+      } else if (val.startsWith("consecutive-errors:")) {
+        const n = parseInt(val.slice(19), 10);
+        if (n > 0) alertConditions.push({ type: "consecutive-errors", threshold: n });
+      }
+      i++;
+    } else if (arg === "--notify") {
+      i++;
+      const val = args[i] ?? "";
+      if (val === "telegram") {
+        const botToken = process.env["AGENTFLOW_TELEGRAM_BOT_TOKEN"] ?? "";
+        const chatId = process.env["AGENTFLOW_TELEGRAM_CHAT_ID"] ?? "";
+        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");
+        }
+      } else if (val.startsWith("webhook:")) {
+        notifyChannels.push({ type: "webhook", url: val.slice(8) });
+      } else if (val.startsWith("command:")) {
+        notifyChannels.push({ type: "command", cmd: val.slice(8) });
+      }
+      i++;
+    } else if (arg === "--poll") {
+      i++;
+      const v = parseInt(args[i] ?? "", 10);
+      if (!isNaN(v) && v > 0) pollIntervalMs = v * 1e3;
+      i++;
+    } else if (arg === "--cooldown") {
+      i++;
+      const dur = parseDuration(args[i] ?? "30m");
+      if (dur > 0) cooldownMs = dur;
+      i++;
+    } else if (arg === "--state-file") {
+      i++;
+      stateFilePath = args[i] ?? "";
+      i++;
+    } else if (arg === "--recursive" || arg === "-R") {
+      recursive = true;
+      i++;
+    } else if (!arg.startsWith("-")) {
+      dirs.push(resolve3(arg));
+      i++;
+    } else {
+      i++;
+    }
+  }
+  if (dirs.length === 0) dirs.push(resolve3("."));
+  if (alertConditions.length === 0) {
+    alertConditions.push({ type: "error" });
+    alertConditions.push({ type: "recovery" });
+  }
+  notifyChannels.unshift({ type: "stdout" });
+  if (!stateFilePath) {
+    stateFilePath = join3(dirs[0], ".agentflow-watch-state.json");
+  }
+  return {
+    dirs,
+    recursive,
+    pollIntervalMs,
+    alertConditions,
+    notifyChannels,
+    stateFilePath: resolve3(stateFilePath),
+    cooldownMs
+  };
+}
+function printWatchUsage() {
+  console.log(`
+AgentFlow Watch \u2014 headless alert system for agent infrastructure.
+
+Polls directories for JSON/JSONL files, detects failures and stale
+agents, sends alerts. Same auto-detection as \`agentflow live\`.
+
+Usage:
+  agentflow watch [dir...] [options]
+
+Arguments:
+  dir                          One or more directories to watch (default: .)
+
+Alert conditions (--alert-on, repeatable):
+  error                        Agent transitions to error status
+  recovery                     Agent recovers from error to ok
+  stale:DURATION               No file update within duration (e.g. 15m, 1h)
+  consecutive-errors:N         N consecutive error observations
+
+  Default (if none specified): error + recovery
+
+Notification channels (--notify, repeatable):
+  telegram                     Telegram Bot API (needs env vars)
+  webhook:URL                  POST JSON to any URL
+  command:CMD                  Run shell command with alert env vars
+
+  Stdout alerts are always printed regardless of --notify flags.
+
+Options:
+  --poll <secs>                Poll interval in seconds (default: 30)
+  --cooldown <duration>        Alert dedup cooldown (default: 30m)
+  --state-file <path>          Persistence file (default: <dir>/.agentflow-watch-state.json)
+  -R, --recursive              Scan subdirectories (1 level deep)
+  -h, --help                   Show this help message
+
+Environment variables:
+  AGENTFLOW_TELEGRAM_BOT_TOKEN   Telegram bot token (for --notify telegram)
+  AGENTFLOW_TELEGRAM_CHAT_ID     Telegram chat ID (for --notify telegram)
+
+Examples:
+  agentflow watch ./data --alert-on error --alert-on stale:15m
+  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());
+}
+function startWatch(argv) {
+  const config = parseWatchArgs(argv);
+  const valid = config.dirs.filter((d) => existsSync4(d));
+  if (valid.length === 0) {
+    console.error(`No valid directories found: ${config.dirs.join(", ")}`);
+    process.exit(1);
+  }
+  const invalid = config.dirs.filter((d) => !existsSync4(d));
+  if (invalid.length > 0) {
+    console.warn(`Skipping non-existent: ${invalid.join(", ")}`);
+  }
+  let state = loadWatchState(config.stateFilePath);
+  const condLabels = config.alertConditions.map((c) => {
+    if (c.type === "stale") return `stale:${Math.floor(c.durationMs / 6e4)}m`;
+    if (c.type === "consecutive-errors") return `consecutive-errors:${c.threshold}`;
+    return c.type;
+  });
+  const channelLabels = config.notifyChannels.filter((c) => c.type !== "stdout").map((c) => {
+    if (c.type === "webhook") return `webhook:${c.url.slice(0, 40)}...`;
+    if (c.type === "command") return `command:${c.cmd.slice(0, 40)}`;
+    return c.type;
+  });
+  console.log(`
+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(`  Cooldown:     ${Math.floor(config.cooldownMs / 6e4)}m`);
+  console.log(`  State:        ${config.stateFilePath}`);
+  console.log(`  Hostname:     ${hostname()}`);
+  console.log("");
+  let pollCount = 0;
+  async function poll() {
+    const now = Date.now();
+    pollCount++;
+    const files = scanFiles(valid, config.recursive);
+    const records = [];
+    for (const f of files.slice(0, 500)) {
+      const recs = f.ext === ".jsonl" ? processJsonlFile(f) : processJsonFile(f);
+      records.push(...recs);
+    }
+    const alerts = detectTransitions(state, records, config, now);
+    for (const alert of alerts) {
+      for (const channel of config.notifyChannels) {
+        await sendAlert(alert, channel);
+      }
+    }
+    state = updateWatchState(state, records, alerts, now);
+    saveWatchState(config.stateFilePath, state);
+    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 time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      console.log(`[${time}] heartbeat: ${agentCount} agents, ${runningCount} running, ${errorCount} errors, ${files.length} files`);
+    }
+  }
+  poll();
+  setInterval(() => {
+    poll();
+  }, config.pollIntervalMs);
+  function shutdown() {
+    console.log("\nagentflow watch stopped.");
+    saveWatchState(config.stateFilePath, state);
+    process.exit(0);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
 export {
   createGraphBuilder,
   loadGraph,
@@ -1110,5 +1704,6 @@ export {
   groupByTraceId,
   stitchTrace,
   getTraceTree,
-  startLive
+  startLive,
+  startWatch
 };