agentflow-core 0.6.3 → 0.8.0

package/dist/index.cjs

@@ -21,12 +21,28 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   auditProcesses: () => auditProcesses,
+  buildAgentSummaryPrompt: () => buildAgentSummaryPrompt,
+  buildAnomalyExplanationPrompt: () => buildAnomalyExplanationPrompt,
+  buildFailureAnalysisPrompt: () => buildFailureAnalysisPrompt,
+  buildFixSuggestionPrompt: () => buildFixSuggestionPrompt,
+  checkConformance: () => checkConformance,
   checkGuards: () => checkGuards,
+  createEventEmitter: () => createEventEmitter,
+  createExecutionEvent: () => createExecutionEvent,
   createGraphBuilder: () => createGraphBuilder,
+  createInsightEngine: () => createInsightEngine,
+  createJsonEventWriter: () => createJsonEventWriter,
+  createKnowledgeStore: () => createKnowledgeStore,
+  createPatternEvent: () => createPatternEvent,
+  createPolicySource: () => createPolicySource,
+  createSomaEventWriter: () => createSomaEventWriter,
   createTraceStore: () => createTraceStore,
+  discoverProcess: () => discoverProcess,
   discoverProcessConfig: () => discoverProcessConfig,
+  findVariants: () => findVariants,
   findWaitingOn: () => findWaitingOn,
   formatAuditReport: () => formatAuditReport,
+  getBottlenecks: () => getBottlenecks,
   getChildren: () => getChildren,
   getCriticalPath: () => getCriticalPath,
   getDepth: () => getDepth,
@@ -35,6 +51,7 @@ __export(index_exports, {
   getHungNodes: () => getHungNodes,
   getNode: () => getNode,
   getParent: () => getParent,
+  getPathSignature: () => getPathSignature,
   getStats: () => getStats,
   getSubtree: () => getSubtree,
   getTraceTree: () => getTraceTree,
@@ -51,8 +68,321 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/process-mining.ts
+function getPathSignature(graph) {
+  const root = graph.nodes.get(graph.rootNodeId);
+  if (!root) return "";
+  const parts = [];
+  function walk(node) {
+    parts.push(`${node.type}:${node.name}`);
+    const childNodes = [];
+    for (const childId of node.children) {
+      const child = graph.nodes.get(childId);
+      if (child) childNodes.push(child);
+    }
+    childNodes.sort((a, b) => {
+      const keyA = `${a.type}:${a.name}`;
+      const keyB = `${b.type}:${b.name}`;
+      return keyA.localeCompare(keyB);
+    });
+    for (const child of childNodes) {
+      walk(child);
+    }
+  }
+  walk(root);
+  return parts.join("\u2192");
+}
+function stepKey(node) {
+  return `${node.type}:${node.name}`;
+}
+function discoverProcess(graphs) {
+  if (graphs.length === 0) {
+    throw new Error("discoverProcess requires at least one graph");
+  }
+  const steps = /* @__PURE__ */ new Set();
+  const transitionCounts = /* @__PURE__ */ new Map();
+  const outgoingCounts = /* @__PURE__ */ new Map();
+  for (const graph of graphs) {
+    for (const node of graph.nodes.values()) {
+      const parentKey = stepKey(node);
+      steps.add(parentKey);
+      for (const childId of node.children) {
+        const child = graph.nodes.get(childId);
+        if (!child) continue;
+        const childKey = stepKey(child);
+        const tKey = `${parentKey}\0${childKey}`;
+        transitionCounts.set(tKey, (transitionCounts.get(tKey) ?? 0) + 1);
+        outgoingCounts.set(parentKey, (outgoingCounts.get(parentKey) ?? 0) + 1);
+      }
+    }
+  }
+  const transitions = [];
+  for (const [tKey, count] of transitionCounts) {
+    const [from, to] = tKey.split("\0");
+    const outgoing = outgoingCounts.get(from) ?? count;
+    transitions.push({
+      from,
+      to,
+      count,
+      probability: count / outgoing
+    });
+  }
+  transitions.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+  return {
+    steps: [...steps].sort(),
+    transitions,
+    totalGraphs: graphs.length,
+    agentId: graphs[0].agentId
+  };
+}
+function findVariants(graphs) {
+  if (graphs.length === 0) return [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const graph of graphs) {
+    const sig = getPathSignature(graph);
+    const group = groups.get(sig) ?? [];
+    group.push(graph);
+    groups.set(sig, group);
+  }
+  const total = graphs.length;
+  const variants = [];
+  for (const [pathSignature, groupGraphs] of groups) {
+    variants.push({
+      pathSignature,
+      count: groupGraphs.length,
+      percentage: groupGraphs.length / total * 100,
+      graphIds: groupGraphs.map((g) => g.id),
+      exampleGraph: groupGraphs[0]
+    });
+  }
+  variants.sort((a, b) => {
+    const freqDiff = b.count - a.count;
+    if (freqDiff !== 0) return freqDiff;
+    return a.pathSignature.localeCompare(b.pathSignature);
+  });
+  return variants;
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  if (sorted.length === 1) return sorted[0];
+  const index = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) return sorted[lower];
+  const weight = index - lower;
+  return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+}
+function getBottlenecks(graphs) {
+  if (graphs.length === 0) return [];
+  const now = Date.now();
+  const stats = /* @__PURE__ */ new Map();
+  for (const graph of graphs) {
+    for (const node of graph.nodes.values()) {
+      const key = `${node.type}:${node.name}`;
+      const entry = stats.get(key) ?? { durations: [], nodeType: node.type, nodeName: node.name };
+      const end = node.endTime ?? now;
+      entry.durations.push(end - node.startTime);
+      stats.set(key, entry);
+    }
+  }
+  const total = graphs.length;
+  const bottlenecks = [];
+  for (const [, entry] of stats) {
+    const sorted = [...entry.durations].sort((a, b) => a - b);
+    bottlenecks.push({
+      nodeName: entry.nodeName,
+      nodeType: entry.nodeType,
+      occurrences: sorted.length,
+      durations: {
+        median: percentile(sorted, 50),
+        p95: percentile(sorted, 95),
+        p99: percentile(sorted, 99),
+        min: sorted[0],
+        max: sorted[sorted.length - 1]
+      },
+      percentOfGraphs: sorted.length / total * 100
+    });
+  }
+  bottlenecks.sort((a, b) => b.durations.p95 - a.durations.p95);
+  return bottlenecks;
+}
+function extractGraphTransitions(graph) {
+  const transitions = /* @__PURE__ */ new Set();
+  for (const node of graph.nodes.values()) {
+    const parentKey = stepKey(node);
+    for (const childId of node.children) {
+      const child = graph.nodes.get(childId);
+      if (!child) continue;
+      transitions.add(`${parentKey}\0${stepKey(child)}`);
+    }
+  }
+  return transitions;
+}
+function checkConformance(graph, model) {
+  const graphTransitions = extractGraphTransitions(graph);
+  const deviations = [];
+  const modelLookup = /* @__PURE__ */ new Map();
+  for (const t of model.transitions) {
+    modelLookup.set(`${t.from}\0${t.to}`, t);
+  }
+  let totalChecks = 0;
+  let deviationCount = 0;
+  for (const tKey of graphTransitions) {
+    totalChecks++;
+    const [from, to] = tKey.split("\0");
+    const modelTransition = modelLookup.get(tKey);
+    if (!modelTransition) {
+      deviationCount++;
+      deviations.push({
+        type: "unexpected-transition",
+        from,
+        to,
+        message: `Unexpected transition ${from} \u2192 ${to} (not in process model)`
+      });
+    } else if (modelTransition.probability < 0.1) {
+      deviationCount++;
+      deviations.push({
+        type: "low-frequency-path",
+        from,
+        to,
+        message: `Low-frequency path ${from} \u2192 ${to} (model probability: ${(modelTransition.probability * 100).toFixed(1)}%)`,
+        modelProbability: modelTransition.probability
+      });
+    }
+  }
+  const graphSteps = /* @__PURE__ */ new Set();
+  for (const node of graph.nodes.values()) {
+    graphSteps.add(stepKey(node));
+  }
+  for (const t of model.transitions) {
+    if (t.probability > 0.5) {
+      const tKey = `${t.from}\0${t.to}`;
+      if (graphSteps.has(t.from) && !graphTransitions.has(tKey)) {
+        totalChecks++;
+        deviationCount++;
+        deviations.push({
+          type: "missing-transition",
+          from: t.from,
+          to: t.to,
+          message: `Missing expected transition ${t.from} \u2192 ${t.to} (model probability: ${(t.probability * 100).toFixed(1)}%)`,
+          modelProbability: t.probability
+        });
+      }
+    }
+  }
+  const conformanceScore = totalChecks === 0 ? 1 : (totalChecks - deviationCount) / totalChecks;
+  return {
+    conformanceScore,
+    isConforming: deviations.length === 0,
+    deviations
+  };
+}
+
+// src/event-emitter.ts
+var SCHEMA_VERSION = 1;
+function createExecutionEvent(graph, options) {
+  const duration = graph.endTime !== null ? graph.endTime - graph.startTime : Date.now() - graph.startTime;
+  let failurePoint;
+  if (graph.status === "failed") {
+    let candidate;
+    for (const node of graph.nodes.values()) {
+      if (node.status === "failed" || node.status === "timeout") {
+        const errorMeta = node.metadata.error;
+        const fp = {
+          nodeId: node.id,
+          nodeName: node.name,
+          nodeType: node.type,
+          error: typeof errorMeta === "string" ? errorMeta : void 0
+        };
+        if (node.id !== graph.rootNodeId) {
+          failurePoint = fp;
+          break;
+        }
+        if (!candidate) candidate = fp;
+      }
+    }
+    if (!failurePoint) failurePoint = candidate;
+  }
+  return {
+    eventType: graph.status === "failed" ? "execution.failed" : "execution.completed",
+    graphId: graph.id,
+    agentId: graph.agentId,
+    timestamp: Date.now(),
+    schemaVersion: SCHEMA_VERSION,
+    status: graph.status,
+    duration,
+    nodeCount: graph.nodes.size,
+    pathSignature: getPathSignature(graph),
+    ...failurePoint ? { failurePoint } : {},
+    ...options?.processContext ? { processContext: options.processContext } : {},
+    ...options?.semantic ? { semantic: options.semantic } : {},
+    violations: options?.violations ?? []
+  };
+}
+function createPatternEvent(agentId, model, variants, bottlenecks) {
+  return {
+    eventType: "pattern.discovered",
+    agentId,
+    timestamp: Date.now(),
+    schemaVersion: SCHEMA_VERSION,
+    pattern: {
+      totalGraphs: model.totalGraphs,
+      variantCount: variants.length,
+      topVariants: variants.slice(0, 5).map((v) => ({
+        pathSignature: v.pathSignature,
+        count: v.count,
+        percentage: v.percentage
+      })),
+      topBottlenecks: bottlenecks.slice(0, 5).map((b) => ({
+        nodeName: b.nodeName,
+        nodeType: b.nodeType,
+        p95: b.durations.p95
+      })),
+      processModel: model
+    }
+  };
+}
+function createEventEmitter(config) {
+  const writers = config?.writers ?? [];
+  const knowledgeStore = config?.knowledgeStore;
+  const onError = config?.onError ?? (() => {
+  });
+  const subscribers = /* @__PURE__ */ new Set();
+  return {
+    async emit(event) {
+      if (knowledgeStore) {
+        try {
+          knowledgeStore.append(event);
+        } catch (err) {
+          onError(err);
+        }
+      }
+      for (const writer of writers) {
+        try {
+          await writer.writeEvent(event);
+        } catch (err) {
+          onError(err);
+        }
+      }
+      for (const listener of subscribers) {
+        try {
+          listener(event);
+        } catch (err) {
+          onError(err);
+        }
+      }
+    },
+    subscribe(listener) {
+      subscribers.add(listener);
+      return () => {
+        subscribers.delete(listener);
+      };
+    }
+  };
+}
+
 // src/graph-builder.ts
-var import_crypto = require("crypto");
+var import_node_crypto = require("crypto");
 function deepFreeze(obj) {
   if (obj === null || typeof obj !== "object") return obj;
   if (obj instanceof Map) {
@@ -83,8 +413,8 @@ function createGraphBuilder(config) {
   const generateId = config?.idGenerator ?? createCounterIdGenerator();
   const agentId = config?.agentId ?? "unknown";
   const trigger = config?.trigger ?? "manual";
-  const spanId = (0, import_crypto.randomUUID)();
-  const traceId = config?.traceId ?? (typeof process !== "undefined" ? process.env?.AGENTFLOW_TRACE_ID : void 0) ?? (0, import_crypto.randomUUID)();
+  const spanId = (0, import_node_crypto.randomUUID)();
+  const traceId = config?.traceId ?? (typeof process !== "undefined" ? process.env?.AGENTFLOW_TRACE_ID : void 0) ?? (0, import_node_crypto.randomUUID)();
   const parentSpanId = config?.parentSpanId ?? (typeof process !== "undefined" ? process.env?.AGENTFLOW_PARENT_SPAN_ID : void 0) ?? null;
   const graphId = generateId();
   const startTime = Date.now();
@@ -277,6 +607,336 @@ function createGraphBuilder(config) {
   return builder;
 }
 
+// src/prompt-builder.ts
+var ROLE = "You are analyzing execution data for an AI agent system. Provide clear, actionable analysis based on the data below.";
+function fmtDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function fmtTime(ts) {
+  return new Date(ts).toISOString();
+}
+function durationStats(durations) {
+  if (durations.length === 0) return { avg: 0, p50: 0, p95: 0, min: 0, max: 0 };
+  const sorted = [...durations].sort((a, b) => a - b);
+  const sum = sorted.reduce((a, b) => a + b, 0);
+  return {
+    avg: Math.round(sum / sorted.length),
+    p50: sorted[Math.floor(sorted.length * 0.5)] ?? 0,
+    p95: sorted[Math.floor(sorted.length * 0.95)] ?? 0,
+    min: sorted[0] ?? 0,
+    max: sorted[sorted.length - 1] ?? 0
+  };
+}
+function buildFailureAnalysisPrompt(events, profile) {
+  const stats = durationStats(profile.recentDurations);
+  const failureDetails = events.map((e, i) => {
+    const lines = [
+      `Failure ${i + 1}:`,
+      `  Time: ${fmtTime(e.timestamp)}`,
+      `  Duration: ${fmtDuration(e.duration)}`,
+      `  Path: ${e.pathSignature}`
+    ];
+    if (e.failurePoint) {
+      lines.push(`  Failed at: ${e.failurePoint.nodeName} (${e.failurePoint.nodeType})`);
+      if (e.failurePoint.error) lines.push(`  Error: ${e.failurePoint.error}`);
+    }
+    if (e.violations.length > 0) {
+      lines.push(`  Violations: ${e.violations.map((v) => v.message).join("; ")}`);
+    }
+    return lines.join("\n");
+  }).join("\n\n");
+  return `${ROLE}
+
+## Agent Profile
+- Agent: ${profile.agentId}
+- Total runs: ${profile.totalRuns}
+- Failure rate: ${(profile.failureRate * 100).toFixed(1)}% (${profile.failureCount} failures / ${profile.totalRuns} total)
+- Avg duration: ${fmtDuration(stats.avg)} (p50: ${fmtDuration(stats.p50)}, p95: ${fmtDuration(stats.p95)})
+- Known bottlenecks: ${profile.knownBottlenecks.length > 0 ? profile.knownBottlenecks.join(", ") : "none"}
+- Last conformance score: ${profile.lastConformanceScore ?? "N/A"}
+
+## Recent Failures (${events.length})
+
+${failureDetails}
+
+## Question
+Analyze these failures. What patterns do you see? What is the most likely root cause? Are these related or independent failures?`;
+}
+function buildAnomalyExplanationPrompt(event, profile) {
+  const stats = durationStats(profile.recentDurations);
+  const eventDetails = [
+    `Time: ${fmtTime(event.timestamp)}`,
+    `Status: ${event.status}`,
+    `Duration: ${fmtDuration(event.duration)}`,
+    `Path: ${event.pathSignature}`,
+    `Node count: ${event.nodeCount}`
+  ];
+  if (event.processContext) {
+    eventDetails.push(`Conformance score: ${event.processContext.conformanceScore}`);
+    eventDetails.push(`Is anomaly: ${event.processContext.isAnomaly}`);
+    eventDetails.push(`Variant: ${event.processContext.variant}`);
+  }
+  if (event.failurePoint) {
+    eventDetails.push(`Failed at: ${event.failurePoint.nodeName} (${event.failurePoint.nodeType})`);
+    if (event.failurePoint.error) eventDetails.push(`Error: ${event.failurePoint.error}`);
+  }
+  if (event.violations.length > 0) {
+    eventDetails.push(`Violations: ${event.violations.map((v) => v.message).join("; ")}`);
+  }
+  return `${ROLE}
+
+## Agent Baseline (from profile)
+- Agent: ${profile.agentId}
+- Total runs: ${profile.totalRuns}
+- Typical failure rate: ${(profile.failureRate * 100).toFixed(1)}%
+- Typical duration: avg ${fmtDuration(stats.avg)}, p50 ${fmtDuration(stats.p50)}, p95 ${fmtDuration(stats.p95)}
+- Last conformance score: ${profile.lastConformanceScore ?? "N/A"}
+- Known bottlenecks: ${profile.knownBottlenecks.length > 0 ? profile.knownBottlenecks.join(", ") : "none"}
+
+## Anomalous Execution
+${eventDetails.join("\n")}
+
+## Question
+This execution has been flagged as anomalous. Explain what is unusual about it compared to the agent's typical behavior. What might have caused this deviation?`;
+}
+function buildAgentSummaryPrompt(profile, recentEvents, patterns) {
+  const stats = durationStats(profile.recentDurations);
+  const recentOutcomes = recentEvents.slice(0, 10).map((e) => `  ${fmtTime(e.timestamp)} \u2014 ${e.eventType} (${fmtDuration(e.duration)})`).join("\n");
+  const patternSummary = patterns.length > 0 ? patterns.slice(0, 3).map((p) => {
+    const lines = [
+      `  Variants: ${p.pattern.variantCount} across ${p.pattern.totalGraphs} executions`,
+      `  Top variant: ${p.pattern.topVariants[0]?.pathSignature ?? "N/A"} (${p.pattern.topVariants[0]?.percentage.toFixed(0) ?? 0}%)`
+    ];
+    if (p.pattern.topBottlenecks.length > 0) {
+      const topB = p.pattern.topBottlenecks[0];
+      if (topB)
+        lines.push(`  Top bottleneck: ${topB.nodeName} (p95: ${fmtDuration(topB.p95)})`);
+    }
+    return lines.join("\n");
+  }).join("\n\n") : "  No patterns discovered yet.";
+  const dataNote = recentEvents.length === 0 && patterns.length === 0 ? "\nNote: Limited data available. Summary is based only on the profile statistics.\n" : "";
+  return `${ROLE}
+
+## Agent Profile
+- Agent: ${profile.agentId}
+- Total runs: ${profile.totalRuns}
+- Success rate: ${((1 - profile.failureRate) * 100).toFixed(1)}% (${profile.successCount} successes, ${profile.failureCount} failures)
+- Duration: avg ${fmtDuration(stats.avg)}, p50 ${fmtDuration(stats.p50)}, p95 ${fmtDuration(stats.p95)}, range ${fmtDuration(stats.min)}\u2013${fmtDuration(stats.max)}
+- Known bottlenecks: ${profile.knownBottlenecks.length > 0 ? profile.knownBottlenecks.join(", ") : "none"}
+- Last conformance score: ${profile.lastConformanceScore ?? "N/A"}
+- Last pattern analysis: ${profile.lastPatternTimestamp ? fmtTime(profile.lastPatternTimestamp) : "never"}
+${dataNote}
+## Recent Executions (last ${recentEvents.slice(0, 10).length})
+${recentOutcomes || "  No recent events."}
+
+## Pattern Analysis
+${patternSummary}
+
+## Question
+Provide a health summary for this agent. What are the key observations? Is the agent healthy, degrading, or in trouble? What should the operator pay attention to?`;
+}
+function buildFixSuggestionPrompt(events, profile, patterns) {
+  const failureGroups = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const key = e.failurePoint?.error ?? e.pathSignature;
+    const group = failureGroups.get(key) ?? [];
+    group.push(e);
+    failureGroups.set(key, group);
+  }
+  const failureGroupSummary = [...failureGroups.entries()].map(([key, group]) => {
+    const latest = group[0];
+    return `  "${key}" \u2014 ${group.length} occurrence(s), latest at ${latest ? fmtTime(latest.timestamp) : "unknown"}`;
+  }).join("\n");
+  const bottleneckDetails = patterns.flatMap((p) => p.pattern.topBottlenecks).map((b) => `  ${b.nodeName} (${b.nodeType}) \u2014 p95: ${fmtDuration(b.p95)}`);
+  const uniqueBottlenecks = [...new Set(bottleneckDetails)].join("\n");
+  const conformanceIssues = events.filter((e) => e.processContext && e.processContext.conformanceScore < 0.8).map(
+    (e) => `  ${fmtTime(e.timestamp)}: conformance ${e.processContext?.conformanceScore}, variant "${e.processContext?.variant}"`
+  ).join("\n");
+  return `${ROLE}
+
+## Agent Profile
+- Agent: ${profile.agentId}
+- Failure rate: ${(profile.failureRate * 100).toFixed(1)}%
+- Known bottlenecks: ${profile.knownBottlenecks.length > 0 ? profile.knownBottlenecks.join(", ") : "none"}
+
+## Failure Patterns (${events.length} failures)
+${failureGroupSummary || "  No failures recorded."}
+
+## Bottlenecks
+${uniqueBottlenecks || "  No bottlenecks detected."}
+
+## Conformance Issues
+${conformanceIssues || "  No conformance issues."}
+
+## Question
+Based on the failure patterns, bottlenecks, and conformance issues above, provide specific, actionable recommendations to improve this agent's reliability and performance. Prioritize by impact.`;
+}
+
+// src/insight-engine.ts
+var DEFAULT_CACHE_TTL_MS = 36e5;
+var SCHEMA_VERSION2 = 1;
+function simpleHash(input) {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    const char = input.charCodeAt(i);
+    hash = (hash << 5) - hash + char | 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+function createInsightEngine(store, analysisFn, config) {
+  const cacheTtlMs = config?.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+  function checkCache(agentId, insightType, dataHash) {
+    const recent = store.getRecentInsights(agentId, { type: insightType, limit: 1 });
+    if (recent.length === 0) return null;
+    const cached = recent[0];
+    if (!cached || cached.dataHash !== dataHash) return null;
+    const age = Date.now() - cached.timestamp;
+    if (age >= cacheTtlMs) return null;
+    return cached;
+  }
+  function storeAndReturn(agentId, insightType, prompt, response, dataHash) {
+    const event = {
+      eventType: "insight.generated",
+      agentId,
+      timestamp: Date.now(),
+      schemaVersion: SCHEMA_VERSION2,
+      insightType,
+      prompt,
+      response,
+      dataHash
+    };
+    store.appendInsight(event);
+    return {
+      agentId,
+      insightType,
+      content: response,
+      cached: false,
+      timestamp: event.timestamp
+    };
+  }
+  function shortCircuit(agentId, insightType, content, cached, timestamp) {
+    return { agentId, insightType, content, cached, timestamp: timestamp ?? Date.now() };
+  }
+  return {
+    async explainFailures(agentId) {
+      const profile = store.getAgentProfile(agentId);
+      if (!profile) {
+        return shortCircuit(
+          agentId,
+          "failure-analysis",
+          "No data available for this agent.",
+          false
+        );
+      }
+      const events = store.getRecentEvents(agentId, { limit: 50 });
+      const failures = events.filter((e) => e.eventType === "execution.failed");
+      if (failures.length === 0) {
+        return shortCircuit(
+          agentId,
+          "failure-analysis",
+          "No recent failures found for this agent.",
+          false
+        );
+      }
+      const dataHash = simpleHash(JSON.stringify({ failures, profile }));
+      const cached = checkCache(agentId, "failure-analysis", dataHash);
+      if (cached) {
+        return shortCircuit(agentId, "failure-analysis", cached.response, true, cached.timestamp);
+      }
+      const prompt = buildFailureAnalysisPrompt(failures, profile);
+      try {
+        const response = await analysisFn(prompt);
+        return storeAndReturn(agentId, "failure-analysis", prompt, response, dataHash);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return shortCircuit(agentId, "failure-analysis", `Analysis failed: ${message}`, false);
+      }
+    },
+    async explainAnomaly(agentId, event) {
+      const profile = store.getAgentProfile(agentId);
+      if (!profile) {
+        return shortCircuit(
+          agentId,
+          "anomaly-explanation",
+          "No data available for this agent.",
+          false
+        );
+      }
+      const dataHash = simpleHash(JSON.stringify({ event, profile }));
+      const cached = checkCache(agentId, "anomaly-explanation", dataHash);
+      if (cached) {
+        return shortCircuit(
+          agentId,
+          "anomaly-explanation",
+          cached.response,
+          true,
+          cached.timestamp
+        );
+      }
+      const prompt = buildAnomalyExplanationPrompt(event, profile);
+      try {
+        const response = await analysisFn(prompt);
+        return storeAndReturn(agentId, "anomaly-explanation", prompt, response, dataHash);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return shortCircuit(agentId, "anomaly-explanation", `Analysis failed: ${message}`, false);
+      }
+    },
+    async summarizeAgent(agentId) {
+      const profile = store.getAgentProfile(agentId);
+      if (!profile) {
+        return shortCircuit(agentId, "agent-summary", "No data available for this agent.", false);
+      }
+      const recentEvents = store.getRecentEvents(agentId, { limit: 20 });
+      const patterns = store.getPatternHistory(agentId, { limit: 5 });
+      const dataHash = simpleHash(JSON.stringify({ profile, recentEvents, patterns }));
+      const cached = checkCache(agentId, "agent-summary", dataHash);
+      if (cached) {
+        return shortCircuit(agentId, "agent-summary", cached.response, true, cached.timestamp);
+      }
+      const prompt = buildAgentSummaryPrompt(profile, recentEvents, patterns);
+      try {
+        const response = await analysisFn(prompt);
+        return storeAndReturn(agentId, "agent-summary", prompt, response, dataHash);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return shortCircuit(agentId, "agent-summary", `Analysis failed: ${message}`, false);
+      }
+    },
+    async suggestFixes(agentId) {
+      const profile = store.getAgentProfile(agentId);
+      if (!profile) {
+        return shortCircuit(agentId, "fix-suggestion", "No data available for this agent.", false);
+      }
+      const events = store.getRecentEvents(agentId, { limit: 50 });
+      const failures = events.filter((e) => e.eventType === "execution.failed");
+      const patterns = store.getPatternHistory(agentId, { limit: 5 });
+      if (failures.length === 0 && profile.knownBottlenecks.length === 0) {
+        return shortCircuit(
+          agentId,
+          "fix-suggestion",
+          "Agent is healthy \u2014 no failures or bottlenecks detected.",
+          false
+        );
+      }
+      const dataHash = simpleHash(JSON.stringify({ failures, profile, patterns }));
+      const cached = checkCache(agentId, "fix-suggestion", dataHash);
+      if (cached) {
+        return shortCircuit(agentId, "fix-suggestion", cached.response, true, cached.timestamp);
+      }
+      const prompt = buildFixSuggestionPrompt(failures, profile, patterns);
+      try {
+        const response = await analysisFn(prompt);
+        return storeAndReturn(agentId, "fix-suggestion", prompt, response, dataHash);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return shortCircuit(agentId, "fix-suggestion", `Analysis failed: ${message}`, false);
+      }
+    }
+  };
+}
+
 // src/graph-query.ts
 function getNode(graph, nodeId) {
   return graph.nodes.get(nodeId);
@@ -429,7 +1089,7 @@ function groupByTraceId(graphs) {
 }
 function stitchTrace(graphs) {
   if (graphs.length === 0) throw new Error("No graphs to stitch");
-  const traceId = graphs[0].traceId ?? "";
+  const traceId = graphs[0]?.traceId ?? "";
   const graphsBySpan = /* @__PURE__ */ new Map();
   const childMap = /* @__PURE__ */ new Map();
   let rootGraph = null;
@@ -540,6 +1200,9 @@ function checkGuards(graph, config) {
     });
   }
   violations.push(...detectReasoningLoops(graph, maxReasoningSteps, now));
+  if (config?.policySource) {
+    violations.push(...checkPolicyViolations(graph, config.policySource, config.policyThresholds, now));
+  }
   return violations;
 }
 function detectReasoningLoops(graph, maxSteps, timestamp) {
@@ -574,6 +1237,40 @@ function detectReasoningLoops(graph, maxSteps, timestamp) {
   walk(graph.rootNodeId, 0, null);
   return violations;
 }
+function checkPolicyViolations(graph, policySource, thresholds, timestamp) {
+  const violations = [];
+  const maxFailureRate = thresholds?.maxFailureRate ?? 0.5;
+  const minConformance = thresholds?.minConformance ?? 0.7;
+  const failureRate = policySource.recentFailureRate(graph.agentId);
+  if (failureRate > maxFailureRate) {
+    violations.push({
+      type: "high-failure-rate",
+      nodeId: graph.rootNodeId,
+      message: `Agent ${graph.agentId} has a recent failure rate of ${(failureRate * 100).toFixed(0)}% (threshold: ${(maxFailureRate * 100).toFixed(0)}%)`,
+      timestamp
+    });
+  }
+  const conformanceScore = policySource.lastConformanceScore(graph.agentId);
+  if (conformanceScore !== null && conformanceScore < minConformance) {
+    violations.push({
+      type: "conformance-drift",
+      nodeId: graph.rootNodeId,
+      message: `Agent ${graph.agentId} conformance score ${(conformanceScore * 100).toFixed(0)}% is below threshold ${(minConformance * 100).toFixed(0)}%`,
+      timestamp
+    });
+  }
+  for (const node of graph.nodes.values()) {
+    if (node.status === "running" && policySource.isKnownBottleneck(node.name)) {
+      violations.push({
+        type: "known-bottleneck",
+        nodeId: node.id,
+        message: `Node ${node.name} (${node.type}) is a known bottleneck`,
+        timestamp
+      });
+    }
+  }
+  return violations;
+}
 function withGuards(builder, config) {
   const logger = config?.logger ?? ((msg) => console.warn(`[AgentFlow Guard] ${msg}`));
   const onViolation = config?.onViolation ?? "warn";
@@ -638,9 +1335,510 @@ function withGuards(builder, config) {
   };
 }
 
-// src/live.ts
+// src/json-event-writer.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function createJsonEventWriter(config) {
+  const { outputDir } = config;
+  function ensureDir() {
+    (0, import_node_fs.mkdirSync)(outputDir, { recursive: true });
+  }
+  function eventFileName(event) {
+    const typePart = event.eventType.replace(/\./g, "-");
+    const agentId = "agentId" in event ? event.agentId : "unknown";
+    return `${typePart}-${agentId}-${event.timestamp}.json`;
+  }
+  return {
+    async write(_graph) {
+    },
+    async writeEvent(event) {
+      ensureDir();
+      const fileName = eventFileName(event);
+      const filePath = (0, import_node_path.join)(outputDir, fileName);
+      (0, import_node_fs.writeFileSync)(filePath, JSON.stringify(event, null, 2), "utf-8");
+    }
+  };
+}
+
+// src/knowledge-store.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
+var DEFAULT_BASE_DIR = ".agentflow/knowledge";
+var MAX_RECENT_DURATIONS = 100;
+var writeCounter = 0;
+function toDateDir(epochMs) {
+  return new Date(epochMs).toISOString().slice(0, 10);
+}
+function readJson(filePath) {
+  try {
+    return JSON.parse((0, import_node_fs2.readFileSync)(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJsonAtomic(filePath, data) {
+  const tmpPath = `${filePath}.tmp.${Date.now()}`;
+  (0, import_node_fs2.writeFileSync)(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+  (0, import_node_fs2.renameSync)(tmpPath, filePath);
+}
+function emptyProfile(agentId) {
+  return {
+    agentId,
+    totalRuns: 0,
+    successCount: 0,
+    failureCount: 0,
+    failureRate: 0,
+    recentDurations: [],
+    lastConformanceScore: null,
+    knownBottlenecks: [],
+    lastPatternTimestamp: null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function mergeExecutionEvent(profile, event) {
+  const totalRuns = profile.totalRuns + 1;
+  const isFailure = event.eventType === "execution.failed";
+  const successCount = profile.successCount + (isFailure ? 0 : 1);
+  const failureCount = profile.failureCount + (isFailure ? 1 : 0);
+  const durations = [...profile.recentDurations, event.duration];
+  if (durations.length > MAX_RECENT_DURATIONS) {
+    durations.shift();
+  }
+  const conformanceScore = event.processContext?.conformanceScore ?? profile.lastConformanceScore;
+  return {
+    agentId: profile.agentId,
+    totalRuns,
+    successCount,
+    failureCount,
+    failureRate: failureCount / totalRuns,
+    recentDurations: durations,
+    lastConformanceScore: conformanceScore,
+    knownBottlenecks: profile.knownBottlenecks,
+    lastPatternTimestamp: profile.lastPatternTimestamp,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function mergePatternEvent(profile, event) {
+  const existingBottlenecks = new Set(profile.knownBottlenecks);
+  for (const b of event.pattern.topBottlenecks) {
+    existingBottlenecks.add(b.nodeName);
+  }
+  return {
+    ...profile,
+    knownBottlenecks: [...existingBottlenecks],
+    lastPatternTimestamp: event.timestamp,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createKnowledgeStore(config) {
+  const baseDir = config?.baseDir ?? DEFAULT_BASE_DIR;
+  const eventsDir = (0, import_node_path2.join)(baseDir, "events");
+  const patternsDir = (0, import_node_path2.join)(baseDir, "patterns");
+  const profilesDir = (0, import_node_path2.join)(baseDir, "profiles");
+  const insightsDir = (0, import_node_path2.join)(baseDir, "insights");
+  function ensureDir(dir) {
+    (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  }
+  function profilePath(agentId) {
+    return (0, import_node_path2.join)(profilesDir, `${agentId}.json`);
+  }
+  function appendExecutionEvent(event) {
+    const dateDir = (0, import_node_path2.join)(eventsDir, event.agentId, toDateDir(event.timestamp));
+    ensureDir(dateDir);
+    const typePart = event.eventType.replace(/\./g, "-");
+    const seq = String(writeCounter++).padStart(4, "0");
+    const fileName = `${typePart}-${event.timestamp}-${seq}.json`;
+    (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(dateDir, fileName), JSON.stringify(event, null, 2), "utf-8");
+    ensureDir(profilesDir);
+    const existing = readJson(profilePath(event.agentId)) ?? emptyProfile(event.agentId);
+    const updated = mergeExecutionEvent(existing, event);
+    writeJsonAtomic(profilePath(event.agentId), updated);
+  }
+  function appendPatternEvent(event) {
+    const agentPatternDir = (0, import_node_path2.join)(patternsDir, event.agentId);
+    ensureDir(agentPatternDir);
+    const seq = String(writeCounter++).padStart(4, "0");
+    const fileName = `${event.timestamp}-${seq}.json`;
+    (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(agentPatternDir, fileName), JSON.stringify(event, null, 2), "utf-8");
+    ensureDir(profilesDir);
+    const existing = readJson(profilePath(event.agentId)) ?? emptyProfile(event.agentId);
+    const updated = mergePatternEvent(existing, event);
+    writeJsonAtomic(profilePath(event.agentId), updated);
+  }
+  return {
+    baseDir,
+    append(event) {
+      if (event.eventType === "pattern.discovered" || event.eventType === "pattern.updated") {
+        appendPatternEvent(event);
+      } else {
+        appendExecutionEvent(event);
+      }
+    },
+    getRecentEvents(agentId, options) {
+      const limit = options?.limit ?? 50;
+      const since = options?.since ?? 0;
+      const agentDir = (0, import_node_path2.join)(eventsDir, agentId);
+      if (!(0, import_node_fs2.existsSync)(agentDir)) return [];
+      const events = [];
+      const dateDirs = (0, import_node_fs2.readdirSync)(agentDir).sort().reverse();
+      for (const dateDir of dateDirs) {
+        const fullDateDir = (0, import_node_path2.join)(agentDir, dateDir);
+        let files;
+        try {
+          files = (0, import_node_fs2.readdirSync)(fullDateDir).filter((f) => f.endsWith(".json"));
+        } catch {
+          continue;
+        }
+        for (const file of files) {
+          const event = readJson((0, import_node_path2.join)(fullDateDir, file));
+          if (event && event.timestamp > since) {
+            events.push(event);
+          }
+        }
+        if (events.length >= limit * 2) break;
+      }
+      events.sort((a, b) => b.timestamp - a.timestamp);
+      return events.slice(0, limit);
+    },
+    getAgentProfile(agentId) {
+      return readJson(profilePath(agentId));
+    },
+    getPatternHistory(agentId, options) {
+      const limit = options?.limit ?? 20;
+      const agentPatternDir = (0, import_node_path2.join)(patternsDir, agentId);
+      if (!(0, import_node_fs2.existsSync)(agentPatternDir)) return [];
+      const files = (0, import_node_fs2.readdirSync)(agentPatternDir).filter((f) => f.endsWith(".json")).sort().reverse();
+      const events = [];
+      for (const file of files.slice(0, limit)) {
+        const event = readJson((0, import_node_path2.join)(agentPatternDir, file));
+        if (event) events.push(event);
+      }
+      return events;
+    },
+    compact(options) {
+      let removed = 0;
+      if ((0, import_node_fs2.existsSync)(eventsDir)) {
+        for (const agentId of (0, import_node_fs2.readdirSync)(eventsDir)) {
+          const agentDir = (0, import_node_path2.join)(eventsDir, agentId);
+          let dateDirs;
+          try {
+            dateDirs = (0, import_node_fs2.readdirSync)(agentDir);
+          } catch {
+            continue;
+          }
+          for (const dateDir of dateDirs) {
+            const fullDateDir = (0, import_node_path2.join)(agentDir, dateDir);
+            let files;
+            try {
+              files = (0, import_node_fs2.readdirSync)(fullDateDir).filter((f) => f.endsWith(".json"));
+            } catch {
+              continue;
+            }
+            for (const file of files) {
+              const parts = file.replace(".json", "").split("-");
+              const tsPart = parts[parts.length - 2];
+              const ts = tsPart ? Number.parseInt(tsPart, 10) : 0;
+              if (!Number.isNaN(ts) && ts < options.olderThan) {
+                try {
+                  (0, import_node_fs2.rmSync)((0, import_node_path2.join)(fullDateDir, file));
+                  removed++;
+                } catch {
+                }
+              }
+            }
+            try {
+              if ((0, import_node_fs2.readdirSync)(fullDateDir).length === 0) {
+                (0, import_node_fs2.rmSync)(fullDateDir, { recursive: true });
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      if ((0, import_node_fs2.existsSync)(patternsDir)) {
+        for (const agentId of (0, import_node_fs2.readdirSync)(patternsDir)) {
+          const agentPatternDir = (0, import_node_path2.join)(patternsDir, agentId);
+          let files;
+          try {
+            files = (0, import_node_fs2.readdirSync)(agentPatternDir).filter((f) => f.endsWith(".json"));
+          } catch {
+            continue;
+          }
+          for (const file of files) {
+            const ts = Number.parseInt(file.split("-")[0], 10);
+            if (!Number.isNaN(ts) && ts < options.olderThan) {
+              try {
+                (0, import_node_fs2.rmSync)((0, import_node_path2.join)(agentPatternDir, file));
+                removed++;
+              } catch {
+              }
+            }
+          }
+        }
+      }
+      if ((0, import_node_fs2.existsSync)(insightsDir)) {
+        for (const agentId of (0, import_node_fs2.readdirSync)(insightsDir)) {
+          const agentInsightDir = (0, import_node_path2.join)(insightsDir, agentId);
+          let files;
+          try {
+            files = (0, import_node_fs2.readdirSync)(agentInsightDir).filter((f) => f.endsWith(".json"));
+          } catch {
+            continue;
+          }
+          for (const file of files) {
+            const parts = file.replace(".json", "").split("-");
+            const tsPart = parts[parts.length - 2];
+            const ts = tsPart ? Number.parseInt(tsPart, 10) : 0;
+            if (!Number.isNaN(ts) && ts < options.olderThan) {
+              try {
+                (0, import_node_fs2.rmSync)((0, import_node_path2.join)(agentInsightDir, file));
+                removed++;
+              } catch {
+              }
+            }
+          }
+        }
+      }
+      return { removed };
+    },
+    appendInsight(event) {
+      const agentInsightDir = (0, import_node_path2.join)(insightsDir, event.agentId);
+      ensureDir(agentInsightDir);
+      const seq = String(writeCounter++).padStart(4, "0");
+      const fileName = `${event.insightType}-${event.timestamp}-${seq}.json`;
+      (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(agentInsightDir, fileName), JSON.stringify(event, null, 2), "utf-8");
+    },
+    getRecentInsights(agentId, options) {
+      const limit = options?.limit ?? 10;
+      const typeFilter = options?.type;
+      const agentInsightDir = (0, import_node_path2.join)(insightsDir, agentId);
+      if (!(0, import_node_fs2.existsSync)(agentInsightDir)) return [];
+      const files = (0, import_node_fs2.readdirSync)(agentInsightDir).filter((f) => f.endsWith(".json"));
+      const events = [];
+      for (const file of files) {
+        const event = readJson((0, import_node_path2.join)(agentInsightDir, file));
+        if (event) {
+          if (typeFilter && event.insightType !== typeFilter) continue;
+          events.push(event);
+        }
+      }
+      events.sort((a, b) => b.timestamp - a.timestamp);
+      return events.slice(0, limit);
+    },
+    // EventWriter interface
+    async write(_graph) {
+    },
+    async writeEvent(event) {
+      this.append(event);
+    }
+  };
+}
+
+// src/policy-source.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+function createPolicySource(store) {
+  return {
+    recentFailureRate(agentId) {
+      const profile = store.getAgentProfile(agentId);
+      return profile?.failureRate ?? 0;
+    },
+    isKnownBottleneck(nodeName) {
+      const profilesDir = (0, import_node_path3.join)(store.baseDir, "profiles");
+      let agentIds;
+      try {
+        agentIds = (0, import_node_fs3.readdirSync)(profilesDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+      } catch {
+        return false;
+      }
+      for (const agentId of agentIds) {
+        const profile = store.getAgentProfile(agentId);
+        if (profile && profile.knownBottlenecks.includes(nodeName)) {
+          return true;
+        }
+      }
+      return false;
+    },
+    lastConformanceScore(agentId) {
+      const profile = store.getAgentProfile(agentId);
+      return profile?.lastConformanceScore ?? null;
+    },
+    getAgentProfile(agentId) {
+      return store.getAgentProfile(agentId);
+    }
+  };
+}
+
+// src/soma-event-writer.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+function compactIso(epochMs) {
+  return new Date(epochMs).toISOString().slice(0, 19).replace(/:/g, "");
+}
+function isoDate(epochMs) {
+  return new Date(epochMs).toISOString().slice(0, 10);
+}
+function renderFrontmatter(fields) {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      lines.push(`${key}: [${value.map((v) => `'${v}'`).join(", ")}]`);
+    } else if (typeof value === "string") {
+      lines.push(`${key}: '${value}'`);
+    } else {
+      lines.push(`${key}: ${String(value)}`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms.toFixed(0)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${(ms / 6e4).toFixed(1)}min`;
+}
+function executionEventToMarkdown(event) {
+  const isCompleted = event.eventType === "execution.completed";
+  const subtype = isCompleted ? "completed" : "failed";
+  const tags = [
+    "agentflow/execution",
+    `agent/${event.agentId}`,
+    `status/${subtype}`
+  ];
+  if (event.processContext?.isAnomaly) {
+    tags.push("agentflow/anomaly");
+  }
+  const frontmatter = {
+    type: "execution",
+    subtype,
+    name: `Execution: ${event.agentId} \u2014 ${subtype}`,
+    source: "agentflow",
+    created: isoDate(event.timestamp),
+    alfred_tags: tags,
+    agentflow_graph_id: event.graphId,
+    duration_ms: event.duration,
+    node_count: event.nodeCount
+  };
+  if (event.processContext) {
+    frontmatter.conformance_score = event.processContext.conformanceScore;
+    frontmatter.is_anomaly = event.processContext.isAnomaly;
+  }
+  const body = [];
+  body.push(`# Execution: ${event.agentId} \u2014 ${subtype}
+`);
+  body.push(`**Duration:** ${formatDuration(event.duration)}  `);
+  body.push(`**Nodes:** ${event.nodeCount}  `);
+  body.push(`**Status:** ${event.status}
+`);
+  if (event.pathSignature) {
+    body.push(`## Path
+`);
+    body.push(`\`${event.pathSignature}\`
+`);
+  }
+  if (!isCompleted && event.failurePoint) {
+    const fp = event.failurePoint;
+    body.push(`## Failure Point
+`);
+    body.push(`**Node:** ${fp.nodeType}:${fp.nodeName} (\`${fp.nodeId}\`)  `);
+    if (fp.error) {
+      body.push(`**Error:** ${fp.error}
+`);
+    }
+  }
+  if (event.processContext) {
+    body.push(`## Process Context
+`);
+    body.push(`**Conformance:** ${(event.processContext.conformanceScore * 100).toFixed(0)}%  `);
+    body.push(`**Anomaly:** ${event.processContext.isAnomaly ? "yes" : "no"}
+`);
+  }
+  body.push(`## Related
+`);
+  body.push(`- [[agent/${event.agentId}]]`);
+  return `${renderFrontmatter(frontmatter)}
+
+${body.join("\n")}`;
+}
+function patternEventToMarkdown(event) {
+  const { pattern } = event;
+  const tags = [
+    "agentflow/pattern",
+    `agent/${event.agentId}`
+  ];
+  const frontmatter = {
+    type: "synthesis",
+    subtype: "pattern-discovery",
+    name: `Pattern: ${event.agentId} \u2014 ${pattern.variantCount} variants across ${pattern.totalGraphs} runs`,
+    source: "agentflow",
+    created: isoDate(event.timestamp),
+    alfred_tags: tags,
+    variant_count: pattern.variantCount,
+    total_graphs: pattern.totalGraphs
+  };
+  const body = [];
+  body.push(`# Pattern: ${event.agentId}
+`);
+  body.push(`**Variants:** ${pattern.variantCount}  `);
+  body.push(`**Total Runs:** ${pattern.totalGraphs}
+`);
+  if (pattern.topVariants.length > 0) {
+    body.push(`## Top Variants
+`);
+    body.push(`| Path | Count | % |`);
+    body.push(`|------|-------|---|`);
+    for (const v of pattern.topVariants) {
+      const sig = v.pathSignature.length > 60 ? `${v.pathSignature.slice(0, 57)}...` : v.pathSignature;
+      body.push(`| \`${sig}\` | ${v.count} | ${v.percentage.toFixed(1)}% |`);
+    }
+    body.push("");
+  }
+  if (pattern.topBottlenecks.length > 0) {
+    body.push(`## Top Bottlenecks
+`);
+    body.push(`| Node | Type | p95 |`);
+    body.push(`|------|------|-----|`);
+    for (const b of pattern.topBottlenecks) {
+      body.push(`| ${b.nodeName} | ${b.nodeType} | ${formatDuration(b.p95)} |`);
+    }
+    body.push("");
+  }
+  body.push(`## Related
+`);
+  body.push(`- [[agent/${event.agentId}]]`);
+  return `${renderFrontmatter(frontmatter)}
+
+${body.join("\n")}`;
+}
+function createSomaEventWriter(config) {
+  const { inboxDir } = config;
+  function ensureDir() {
+    (0, import_node_fs4.mkdirSync)(inboxDir, { recursive: true });
+  }
+  function eventFileName(event) {
+    const agentId = event.agentId;
+    const ts = compactIso(event.timestamp);
+    if (event.eventType === "pattern.discovered" || event.eventType === "pattern.updated") {
+      return `synthesis-${agentId}-${ts}.md`;
+    }
+    return `execution-${agentId}-${ts}.md`;
+  }
+  return {
+    async write(_graph) {
+    },
+    async writeEvent(event) {
+      ensureDir();
+      const markdown = event.eventType === "pattern.discovered" || event.eventType === "pattern.updated" ? patternEventToMarkdown(event) : executionEventToMarkdown(event);
+      const fileName = eventFileName(event);
+      (0, import_node_fs4.writeFileSync)((0, import_node_path4.join)(inboxDir, fileName), markdown, "utf-8");
+    }
+  };
+}
+
+// src/live.ts
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
 
 // src/loader.ts
 function toNodesMap(raw) {
@@ -696,8 +1894,8 @@ function graphToJson(graph) {
 
 // src/process-audit.ts
 var import_node_child_process = require("child_process");
-var import_node_fs = require("fs");
-var import_node_path = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
 function isPidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -708,7 +1906,7 @@ function isPidAlive(pid) {
 }
 function pidMatchesName(pid, name) {
   try {
-    const cmdline = (0, import_node_fs.readFileSync)(`/proc/${pid}/cmdline`, "utf8");
+    const cmdline = (0, import_node_fs5.readFileSync)(`/proc/${pid}/cmdline`, "utf8");
     return cmdline.includes(name);
   } catch {
     return false;
@@ -716,8 +1914,8 @@ function pidMatchesName(pid, name) {
 }
 function readPidFile(path) {
   try {
-    const pid = parseInt((0, import_node_fs.readFileSync)(path, "utf8").trim(), 10);
-    return isNaN(pid) ? null : pid;
+    const pid = parseInt((0, import_node_fs5.readFileSync)(path, "utf8").trim(), 10);
+    return Number.isNaN(pid) ? null : pid;
   } catch {
     return null;
   }
@@ -731,8 +1929,8 @@ function auditPidFile(config) {
       pid: null,
       alive: false,
       matchesProcess: false,
-      stale: !(0, import_node_fs.existsSync)(config.pidFile),
-      reason: (0, import_node_fs.existsSync)(config.pidFile) ? "PID file exists but content is invalid" : "No PID file found"
+      stale: !(0, import_node_fs5.existsSync)(config.pidFile),
+      reason: (0, import_node_fs5.existsSync)(config.pidFile) ? "PID file exists but content is invalid" : "No PID file found"
     };
   }
   const alive = isPidAlive(pid);
@@ -761,11 +1959,11 @@ function auditSystemd(config) {
       const [k, ...v] = line.split("=");
       if (k) props[k.trim()] = v.join("=").trim();
     }
-    const activeState = props["ActiveState"] ?? "unknown";
-    const subState = props["SubState"] ?? "unknown";
-    const mainPid = parseInt(props["MainPID"] ?? "0", 10);
-    const restarts = parseInt(props["NRestarts"] ?? "0", 10);
-    const result = props["Result"] ?? "unknown";
+    const activeState = props.ActiveState ?? "unknown";
+    const subState = props.SubState ?? "unknown";
+    const mainPid = parseInt(props.MainPID ?? "0", 10);
+    const restarts = parseInt(props.NRestarts ?? "0", 10);
+    const result = props.Result ?? "unknown";
     return {
       unit,
       activeState,
@@ -781,9 +1979,9 @@ function auditSystemd(config) {
   }
 }
 function auditWorkers(config) {
-  if (!config.workersFile || !(0, import_node_fs.existsSync)(config.workersFile)) return null;
+  if (!config.workersFile || !(0, import_node_fs5.existsSync)(config.workersFile)) return null;
   try {
-    const data = JSON.parse((0, import_node_fs.readFileSync)(config.workersFile, "utf8"));
+    const data = JSON.parse((0, import_node_fs5.readFileSync)(config.workersFile, "utf8"));
     const orchPid = data.pid ?? null;
     const orchAlive = orchPid ? isPidAlive(orchPid) : false;
     const workers = [];
@@ -811,17 +2009,17 @@ function auditWorkers(config) {
 }
 function readCmdline(pid) {
   try {
-    return (0, import_node_fs.readFileSync)(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ").trim();
+    return (0, import_node_fs5.readFileSync)(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ").trim();
   } catch {
     return "";
   }
 }
 function getOsProcesses(processName) {
   try {
-    const raw = (0, import_node_child_process.execSync)(
-      `ps -eo pid,pcpu,pmem,etime,lstart,args --no-headers`,
-      { encoding: "utf8", timeout: 5e3 }
-    );
+    const raw = (0, import_node_child_process.execSync)(`ps -eo pid,pcpu,pmem,etime,lstart,args --no-headers`, {
+      encoding: "utf8",
+      timeout: 5e3
+    });
     const results = [];
     for (const line of raw.split("\n")) {
       if (!line.includes(processName)) continue;
@@ -829,7 +2027,7 @@ function getOsProcesses(processName) {
       const trimmed = line.trim();
       const parts = trimmed.split(/\s+/);
       const pid = parseInt(parts[0] ?? "0", 10);
-      if (isNaN(pid) || pid <= 0) continue;
+      if (Number.isNaN(pid) || pid <= 0) continue;
       const cpu = parts[1] ?? "0";
       const mem = parts[2] ?? "0";
       const elapsed = parts[3] ?? "";
@@ -848,30 +2046,30 @@ function discoverProcessConfig(dirs) {
   let workersFile;
   let processName = "";
   for (const dir of dirs) {
-    if (!(0, import_node_fs.existsSync)(dir)) continue;
+    if (!(0, import_node_fs5.existsSync)(dir)) continue;
     let entries;
     try {
-      entries = (0, import_node_fs.readdirSync)(dir);
+      entries = (0, import_node_fs5.readdirSync)(dir);
     } catch {
       continue;
     }
     for (const f of entries) {
-      const fp = (0, import_node_path.join)(dir, f);
+      const fp = (0, import_node_path5.join)(dir, f);
       try {
-        if (!(0, import_node_fs.statSync)(fp).isFile()) continue;
+        if (!(0, import_node_fs5.statSync)(fp).isFile()) continue;
       } catch {
         continue;
       }
       if (f.endsWith(".pid") && !pidFile) {
         pidFile = fp;
         if (!processName) {
-          processName = (0, import_node_path.basename)(f, ".pid");
+          processName = (0, import_node_path5.basename)(f, ".pid");
         }
       }
       if ((f === "workers.json" || f.endsWith("-workers.json")) && !workersFile) {
         workersFile = fp;
         if (!processName && f !== "workers.json") {
-          processName = (0, import_node_path.basename)(f, "-workers.json");
+          processName = (0, import_node_path5.basename)(f, "-workers.json");
         }
       }
     }
@@ -906,16 +2104,45 @@ function auditProcesses(config) {
     }
   }
   if (systemd?.mainPid) knownPids.add(systemd.mainPid);
+  const childPids = /* @__PURE__ */ new Set();
+  for (const knownPid of knownPids) {
+    try {
+      const childrenRaw = (0, import_node_fs5.readFileSync)(
+        `/proc/${knownPid}/task/${knownPid}/children`,
+        "utf8"
+      ).trim();
+      if (childrenRaw) {
+        for (const c of childrenRaw.split(/\s+/)) {
+          const cp = parseInt(c, 10);
+          if (!Number.isNaN(cp)) childPids.add(cp);
+        }
+      }
+    } catch {
+    }
+  }
+  for (const p of osProcesses) {
+    if (knownPids.has(p.pid)) continue;
+    try {
+      const statusContent = (0, import_node_fs5.readFileSync)(`/proc/${p.pid}/status`, "utf8");
+      const ppidMatch = statusContent.match(/^PPid:\s+(\d+)/m);
+      if (ppidMatch) {
+        const ppid = parseInt(ppidMatch[1] ?? "0", 10);
+        if (knownPids.has(ppid)) childPids.add(p.pid);
+      }
+    } catch {
+    }
+  }
   const selfPid = process.pid;
   const selfPpid = process.ppid;
   const orphans = osProcesses.filter(
-    (p) => !knownPids.has(p.pid) && p.pid !== selfPid && p.pid !== selfPpid
+    (p) => !knownPids.has(p.pid) && !childPids.has(p.pid) && p.pid !== selfPid && p.pid !== selfPpid
   );
   const problems = [];
   if (pidFile?.stale) problems.push(`Stale PID file: ${pidFile.reason}`);
   if (systemd?.crashLooping) problems.push("Systemd unit is crash-looping (auto-restart)");
   if (systemd?.failed) problems.push("Systemd unit has failed");
-  if (systemd && systemd.restarts > 10) problems.push(`High systemd restart count: ${systemd.restarts}`);
+  if (systemd && systemd.restarts > 10)
+    problems.push(`High systemd restart count: ${systemd.restarts}`);
   if (pidFile?.pid && systemd?.mainPid && pidFile.pid !== systemd.mainPid) {
     problems.push(`PID mismatch: file says ${pidFile.pid}, systemd says ${systemd.mainPid}`);
   }
@@ -924,15 +2151,24 @@ function auditProcesses(config) {
       if (w.stale) problems.push(`Worker "${w.name}" (pid ${w.pid}) declares running but is dead`);
     }
   }
-  if (orphans.length > 0) problems.push(`${orphans.length} orphan process(es) not tracked by PID file or workers registry`);
+  if (orphans.length > 0)
+    problems.push(
+      `${orphans.length} orphan process(es) not tracked by PID file or workers registry`
+    );
   return { pidFile, systemd, workers, osProcesses, orphans, problems };
 }
 function formatAuditReport(result) {
   const lines = [];
   lines.push("");
-  lines.push("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
-  lines.push("\u2551            \u{1F50D}  P R O C E S S   A U D I T                      \u2551");
-  lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  lines.push(
+    "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"
+  );
+  lines.push(
+    "\u2551            \u{1F50D}  P R O C E S S   A U D I T                      \u2551"
+  );
+  lines.push(
+    "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+  );
   if (result.pidFile) {
     const pf = result.pidFile;
     const icon = pf.pid && pf.alive && pf.matchesProcess ? "\u2705" : pf.stale ? "\u26A0\uFE0F " : "\u2139\uFE0F ";
@@ -950,25 +2186,33 @@ function formatAuditReport(result) {
   }
   if (result.workers) {
     const w = result.workers;
-    lines.push(`
-  Workers (orchestrator pid ${w.orchestratorPid ?? "unknown"} ${w.orchestratorAlive ? "\u2705" : "\u274C"})`);
+    lines.push(
+      `
+  Workers (orchestrator pid ${w.orchestratorPid ?? "unknown"} ${w.orchestratorAlive ? "\u2705" : "\u274C"})`
+    );
     for (const worker of w.workers) {
       const icon = worker.declaredStatus === "running" && worker.alive ? "\u{1F7E2}" : worker.stale ? "\u{1F534} STALE" : "\u26AA";
-      lines.push(`  ${icon}  ${worker.name.padEnd(14)} pid=${String(worker.pid ?? "-").padEnd(8)} status=${worker.declaredStatus}`);
+      lines.push(
+        `  ${icon}  ${worker.name.padEnd(14)} pid=${String(worker.pid ?? "-").padEnd(8)} status=${worker.declaredStatus}`
+      );
     }
   }
   if (result.osProcesses.length > 0) {
     lines.push(`
   OS Processes (${result.osProcesses.length} total)`);
     for (const p of result.osProcesses) {
-      lines.push(`    PID ${String(p.pid).padEnd(8)} CPU=${p.cpu.padEnd(6)} MEM=${p.mem.padEnd(6)} Up=${p.elapsed.padEnd(10)} ${p.command.substring(0, 50)}`);
+      lines.push(
+        `    PID ${String(p.pid).padEnd(8)} CPU=${p.cpu.padEnd(6)} MEM=${p.mem.padEnd(6)} Up=${p.elapsed.padEnd(10)} ${p.command.substring(0, 50)}`
+      );
     }
   }
   if (result.orphans.length > 0) {
     lines.push(`
   \u26A0\uFE0F  ${result.orphans.length} ORPHAN PROCESS(ES):`);
     for (const p of result.orphans) {
-      lines.push(`     PID ${String(p.pid).padEnd(8)} CPU=${p.cpu.padEnd(6)} MEM=${p.mem.padEnd(6)} Up=${p.elapsed}`);
+      lines.push(
+        `     PID ${String(p.pid).padEnd(8)} CPU=${p.cpu.padEnd(6)} MEM=${p.mem.padEnd(6)} Up=${p.elapsed}`
+      );
       lines.push(`       Started: ${p.started}`);
       lines.push(`       Command: ${p.cmdline || p.command}`);
     }
@@ -1013,19 +2257,19 @@ function parseArgs(argv) {
     } else if (arg === "--refresh" || arg === "-r") {
       i++;
       const v = parseInt(args[i] ?? "", 10);
-      if (!isNaN(v) && v > 0) config.refreshMs = v * 1e3;
+      if (!Number.isNaN(v) && v > 0) config.refreshMs = v * 1e3;
       i++;
     } else if (arg === "--recursive" || arg === "-R") {
       config.recursive = true;
       i++;
     } else if (!arg.startsWith("-")) {
-      config.dirs.push((0, import_node_path2.resolve)(arg));
+      config.dirs.push((0, import_node_path6.resolve)(arg));
       i++;
     } else {
       i++;
     }
   }
-  if (config.dirs.length === 0) config.dirs.push((0, import_node_path2.resolve)("."));
+  if (config.dirs.length === 0) config.dirs.push((0, import_node_path6.resolve)("."));
   return config;
 }
 function printUsage() {
@@ -1061,7 +2305,7 @@ function scanFiles(dirs, recursive) {
   const seen = /* @__PURE__ */ new Set();
   function scanDir(d, topLevel) {
     try {
-      const dirStat = (0, import_node_fs2.statSync)(d);
+      const dirStat = (0, import_node_fs6.statSync)(d);
       const dirMtime = dirStat.mtime.getTime();
       const cachedMtime = dirMtimeCache.get(d);
       if (cachedMtime === dirMtime) {
@@ -1077,13 +2321,13 @@ function scanFiles(dirs, recursive) {
         }
       }
       const dirResults = [];
-      for (const f of (0, import_node_fs2.readdirSync)(d)) {
+      for (const f of (0, import_node_fs6.readdirSync)(d)) {
         if (f.startsWith(".")) continue;
-        const fp = (0, import_node_path2.join)(d, f);
+        const fp = (0, import_node_path6.join)(d, f);
         if (seen.has(fp)) continue;
         let stat;
         try {
-          stat = (0, import_node_fs2.statSync)(fp);
+          stat = (0, import_node_fs6.statSync)(fp);
         } catch {
           continue;
         }
@@ -1094,12 +2338,22 @@ function scanFiles(dirs, recursive) {
         if (!stat.isFile()) continue;
         if (f.endsWith(".json")) {
           seen.add(fp);
-          const entry = { filename: f, path: fp, mtime: stat.mtime.getTime(), ext: ".json" };
+          const entry = {
+            filename: f,
+            path: fp,
+            mtime: stat.mtime.getTime(),
+            ext: ".json"
+          };
           results.push(entry);
           dirResults.push(entry);
         } else if (f.endsWith(".jsonl")) {
           seen.add(fp);
-          const entry = { filename: f, path: fp, mtime: stat.mtime.getTime(), ext: ".jsonl" };
+          const entry = {
+            filename: f,
+            path: fp,
+            mtime: stat.mtime.getTime(),
+            ext: ".jsonl"
+          };
           results.push(entry);
           dirResults.push(entry);
         }
@@ -1115,13 +2369,13 @@ function scanFiles(dirs, recursive) {
 }
 function safeReadJson(fp) {
   try {
-    return JSON.parse((0, import_node_fs2.readFileSync)(fp, "utf8"));
+    return JSON.parse((0, import_node_fs6.readFileSync)(fp, "utf8"));
   } catch {
     return null;
   }
 }
 function nameFromFile(filename) {
-  return (0, import_node_path2.basename)(filename).replace(/\.(json|jsonl)$/, "").replace(/-state$/, "");
+  return (0, import_node_path6.basename)(filename).replace(/\.(json|jsonl)$/, "").replace(/-state$/, "");
 }
 function normalizeStatus(val) {
   if (typeof val !== "string") return "unknown";
@@ -1161,7 +2415,7 @@ function findTimestamp(obj) {
     if (typeof val === "number") return val > 1e12 ? val : val * 1e3;
     if (typeof val === "string") {
       const d = Date.parse(val);
-      if (!isNaN(d)) return d;
+      if (!Number.isNaN(d)) return d;
     }
   }
   return 0;
@@ -1193,7 +2447,7 @@ function extractDetail(obj) {
   }
   return parts.join(" | ") || "";
 }
-function tryLoadTrace(fp, raw) {
+function tryLoadTrace(_fp, raw) {
   if (typeof raw !== "object" || raw === null) return null;
   const obj = raw;
   if (!("nodes" in obj)) return null;
@@ -1299,7 +2553,7 @@ function processJsonFile(file) {
 }
 function processJsonlFile(file) {
   try {
-    const content = (0, import_node_fs2.readFileSync)(file.path, "utf8").trim();
+    const content = (0, import_node_fs6.readFileSync)(file.path, "utf8").trim();
     if (!content) return [];
     const lines = content.split("\n");
     const lineCount = lines.length;
@@ -1444,13 +2698,14 @@ function writeLine(lines, text) {
 }
 function flushLines(lines) {
   process.stdout.write("\x1B[H");
-  process.stdout.write(lines.join("\n") + "\n");
+  process.stdout.write(`${lines.join("\n")}
+`);
   process.stdout.write("\x1B[J");
 }
 var prevFileCount = 0;
 var newExecCount = 0;
 var sessionStart = Date.now();
-var firstRender = true;
+var liveRunning = false;
 var cachedAuditConfig = null;
 var cachedAuditResult = null;
 var lastAuditTime = 0;
@@ -1538,7 +2793,7 @@ function render(config) {
       const status = fail > 0 ? "error" : running > 0 ? "running" : ok > 0 ? "ok" : "unknown";
       groups.push({
         name: groupName,
-        source: records[0].source,
+        source: records[0]?.source ?? "trace",
         status,
         lastTs,
         detail: `${records.length} agents`,
@@ -1584,8 +2839,10 @@ function render(config) {
         cachedAuditResult = auditResult;
         lastAuditTime = now;
       } catch (err) {
-        process.stderr.write(`[agentflow] process audit error: ${err instanceof Error ? err.message : err}
-`);
+        process.stderr.write(
+          `[agentflow] process audit error: ${err instanceof Error ? err.message : err}
+`
+        );
       }
     }
   } else {
@@ -1642,14 +2899,10 @@ function render(config) {
     return new Date(ts).toLocaleTimeString();
   }
   function truncate(s, max) {
-    return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+    return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
   }
   const termWidth = process.stdout.columns || 120;
   const detailWidth = Math.max(20, termWidth - 60);
-  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(
@@ -1687,7 +2940,8 @@ function render(config) {
     if (ar.systemd) {
       const si = ar.systemd.activeState === "active" ? `${C.green}\u25CF${C.reset}` : ar.systemd.crashLooping ? `${C.yellow}\u25CF${C.reset}` : ar.systemd.failed ? `${C.red}\u25CF${C.reset}` : `${C.dim}\u25CB${C.reset}`;
       sysdLabel = `  ${C.bold}Systemd${C.reset} ${si} ${ar.systemd.activeState}`;
-      if (ar.systemd.restarts > 0) sysdLabel += ` ${C.dim}(${ar.systemd.restarts} restarts)${C.reset}`;
+      if (ar.systemd.restarts > 0)
+        sysdLabel += ` ${C.dim}(${ar.systemd.restarts} restarts)${C.reset}`;
     }
     let pidLabel = "";
     if (ar.pidFile?.pid) {
@@ -1696,7 +2950,10 @@ function render(config) {
     }
     writeLine(L, "");
     writeLine(L, `  ${C.bold}${C.under}Process Health${C.reset}`);
-    writeLine(L, `  ${healthIcon} ${healthLabel}${pidLabel}${sysdLabel}    ${C.bold}Procs${C.reset} ${C.dim}${ar.osProcesses.length}${C.reset}    ${ar.orphans.length > 0 ? `${C.red}Orphans ${ar.orphans.length}${C.reset}` : `${C.dim}Orphans 0${C.reset}`}`);
+    writeLine(
+      L,
+      `  ${healthIcon} ${healthLabel}${pidLabel}${sysdLabel}    ${C.bold}Procs${C.reset} ${C.dim}${ar.osProcesses.length}${C.reset}    ${ar.orphans.length > 0 ? `${C.red}Orphans ${ar.orphans.length}${C.reset}` : `${C.dim}Orphans 0${C.reset}`}`
+    );
     if (workerParts.length > 0) {
       writeLine(L, `  ${C.dim}Workers${C.reset}  ${workerParts.join("  ")}`);
     }
@@ -1708,7 +2965,10 @@ function render(config) {
     if (ar.orphans.length > 0) {
       for (const o of ar.orphans.slice(0, 5)) {
         const cmd = (o.cmdline || o.command).substring(0, detailWidth);
-        writeLine(L, `    ${C.red}?${C.reset} ${C.dim}pid=${o.pid} cpu=${o.cpu} mem=${o.mem} up=${o.elapsed}${C.reset}  ${C.dim}${cmd}${C.reset}`);
+        writeLine(
+          L,
+          `    ${C.red}?${C.reset} ${C.dim}pid=${o.pid} cpu=${o.cpu} mem=${o.mem} up=${o.elapsed}${C.reset}  ${C.dim}${cmd}${C.reset}`
+        );
       }
       if (ar.orphans.length > 5) {
         writeLine(L, `    ${C.dim}... +${ar.orphans.length - 5} more orphans${C.reset}`);
@@ -1782,7 +3042,7 @@ function render(config) {
       for (let i = 0; i < Math.min(tree.length, 6); i++) {
         const tg = tree[i];
         const depth = getDistDepth(dt, tg.spanId);
-        const indent = "     " + "\u2502  ".repeat(Math.max(0, depth - 1));
+        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 = tg.status === "completed" ? `${C.green}\u2713${C.reset}` : tg.status === "failed" ? `${C.red}\u2717${C.reset}` : `${C.yellow}\u23F3${C.reset}`;
@@ -1803,7 +3063,7 @@ function render(config) {
       const t = new Date(r.lastActive).toLocaleTimeString();
       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 ageStr = age < 60 ? `${age}s ago` : age < 3600 ? `${Math.floor(age / 60)}m ago` : `${Math.floor(age / 3600)}h ago`;
       const det = truncate(r.detail, detailWidth);
       writeLine(
         L,
@@ -1833,22 +3093,25 @@ function getDistDepth(dt, spanId, visited) {
 }
 function startLive(argv) {
   const config = parseArgs(argv);
-  const valid = config.dirs.filter((d) => (0, import_node_fs2.existsSync)(d));
+  const valid = config.dirs.filter((d) => (0, import_node_fs6.existsSync)(d));
   if (valid.length === 0) {
     console.error(`No valid directories found: ${config.dirs.join(", ")}`);
     console.error("Specify directories containing JSON/JSONL files: agentflow live <dir> [dir...]");
     process.exit(1);
   }
-  const invalid = config.dirs.filter((d) => !(0, import_node_fs2.existsSync)(d));
+  const invalid = config.dirs.filter((d) => !(0, import_node_fs6.existsSync)(d));
   if (invalid.length > 0) {
     console.warn(`Skipping non-existent: ${invalid.join(", ")}`);
   }
   config.dirs = valid;
+  process.stdout.write("\x1B[?1049h");
+  process.stdout.write("\x1B[?25l");
+  liveRunning = true;
   render(config);
   let debounce = null;
   for (const dir of config.dirs) {
     try {
-      (0, import_node_fs2.watch)(dir, { recursive: config.recursive }, () => {
+      (0, import_node_fs6.watch)(dir, { recursive: config.recursive }, () => {
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => render(config), 500);
       });
@@ -1856,28 +3119,40 @@ function startLive(argv) {
     }
   }
   setInterval(() => render(config), config.refreshMs);
+  const cleanup = () => {
+    if (liveRunning) {
+      liveRunning = false;
+      process.stdout.write("\x1B[?25h");
+      process.stdout.write("\x1B[?1049l");
+    }
+  };
   process.on("SIGINT", () => {
-    console.log("\n" + C.dim + "Monitor stopped." + C.reset);
+    cleanup();
+    console.log(`${C.dim}Monitor stopped.${C.reset}`);
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
     process.exit(0);
   });
 }
 
 // src/runner.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs3 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path7 = require("path");
 function globToRegex(pattern) {
   const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
   return new RegExp(`^${escaped}$`);
 }
 function snapshotDir(dir, patterns) {
   const result = /* @__PURE__ */ new Map();
-  if (!(0, import_node_fs3.existsSync)(dir)) return result;
-  for (const entry of (0, import_node_fs3.readdirSync)(dir)) {
+  if (!(0, import_node_fs7.existsSync)(dir)) return result;
+  for (const entry of (0, import_node_fs7.readdirSync)(dir)) {
     if (!patterns.some((re) => re.test(entry))) continue;
-    const full = (0, import_node_path3.join)(dir, entry);
+    const full = (0, import_node_path7.join)(dir, entry);
     try {
-      const stat = (0, import_node_fs3.statSync)(full);
+      const stat = (0, import_node_fs7.statSync)(full);
       if (stat.isFile()) {
         result.set(full, stat.mtimeMs);
       }
@@ -1887,11 +3162,11 @@ function snapshotDir(dir, patterns) {
   return result;
 }
 function agentIdFromFilename(filePath) {
-  const base = (0, import_node_path3.basename)(filePath, ".json");
+  const base = (0, import_node_path7.basename)(filePath, ".json");
   const cleaned = base.replace(/-state$/, "");
   return `alfred-${cleaned}`;
 }
-function deriveAgentId(command) {
+function deriveAgentId(_command) {
   return "orchestrator";
 }
 function fileTimestamp() {
@@ -1909,7 +3184,7 @@ async function runTraced(config) {
   if (command.length === 0) {
     throw new Error("runTraced: command must not be empty");
   }
-  const resolvedTracesDir = (0, import_node_path3.resolve)(tracesDir);
+  const resolvedTracesDir = (0, import_node_path7.resolve)(tracesDir);
   const patterns = watchPatterns.map(globToRegex);
   const orchestrator = createGraphBuilder({ agentId, trigger });
   const { traceId, spanId } = orchestrator.traceContext;
@@ -1992,23 +3267,27 @@ async function runTraced(config) {
     childBuilder.endNode(childRootId);
     allGraphs.push(childBuilder.build());
   }
-  if (!(0, import_node_fs3.existsSync)(resolvedTracesDir)) {
-    (0, import_node_fs3.mkdirSync)(resolvedTracesDir, { recursive: true });
+  if (!(0, import_node_fs7.existsSync)(resolvedTracesDir)) {
+    (0, import_node_fs7.mkdirSync)(resolvedTracesDir, { recursive: true });
   }
   const ts = fileTimestamp();
   const tracePaths = [];
   for (const graph of allGraphs) {
     const filename = `${graph.agentId}-${ts}.json`;
-    const outPath = (0, import_node_path3.join)(resolvedTracesDir, filename);
-    const resolvedOut = (0, import_node_path3.resolve)(outPath);
-    if (!resolvedOut.startsWith(resolvedTracesDir + "/") && resolvedOut !== resolvedTracesDir) {
-      throw new Error(`Path traversal detected: agentId "${graph.agentId}" escapes traces directory`);
+    const outPath = (0, import_node_path7.join)(resolvedTracesDir, filename);
+    const resolvedOut = (0, import_node_path7.resolve)(outPath);
+    if (!resolvedOut.startsWith(`${resolvedTracesDir}/`) && resolvedOut !== resolvedTracesDir) {
+      throw new Error(
+        `Path traversal detected: agentId "${graph.agentId}" escapes traces directory`
+      );
     }
-    (0, import_node_fs3.writeFileSync)(outPath, JSON.stringify(graphToJson(graph), null, 2), "utf-8");
+    (0, import_node_fs7.writeFileSync)(outPath, JSON.stringify(graphToJson(graph), null, 2), "utf-8");
     tracePaths.push(outPath);
   }
   if (tracePaths.length > 0) {
-    console.log(`\u{1F50D} Run "agentflow trace show ${orchestratorGraph.id} --traces-dir ${resolvedTracesDir}" to inspect`);
+    console.log(
+      `\u{1F50D} Run "agentflow trace show ${orchestratorGraph.id} --traces-dir ${resolvedTracesDir}" to inspect`
+    );
   }
   return {
     exitCode,
@@ -2022,7 +3301,7 @@ async function runTraced(config) {
 
 // src/trace-store.ts
 var import_promises = require("fs/promises");
-var import_path = require("path");
+var import_node_path8 = require("path");
 function createTraceStore(dir) {
   async function ensureDir() {
     await (0, import_promises.mkdir)(dir, { recursive: true });
@@ -2039,7 +3318,7 @@ function createTraceStore(dir) {
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
       try {
-        const content = await (0, import_promises.readFile)((0, import_path.join)(dir, file), "utf-8");
+        const content = await (0, import_promises.readFile)((0, import_node_path8.join)(dir, file), "utf-8");
         const graph = loadGraph(content);
         graphs.push(graph);
       } catch {
@@ -2051,10 +3330,10 @@ function createTraceStore(dir) {
     async save(graph) {
       await ensureDir();
       const json = graphToJson(graph);
-      const filePath = (0, import_path.join)(dir, `${graph.id}.json`);
-      const resolvedBase = (0, import_path.resolve)(dir);
-      const resolvedPath = (0, import_path.resolve)(filePath);
-      if (!resolvedPath.startsWith(resolvedBase + "/") && resolvedPath !== resolvedBase) {
+      const filePath = (0, import_node_path8.join)(dir, `${graph.id}.json`);
+      const resolvedBase = (0, import_node_path8.resolve)(dir);
+      const resolvedPath = (0, import_node_path8.resolve)(filePath);
+      if (!resolvedPath.startsWith(`${resolvedBase}/`) && resolvedPath !== resolvedBase) {
         throw new Error(`Path traversal detected: "${graph.id}" escapes base directory`);
       }
       await (0, import_promises.writeFile)(filePath, JSON.stringify(json, null, 2), "utf-8");
@@ -2062,7 +3341,7 @@ function createTraceStore(dir) {
     },
     async get(graphId) {
       await ensureDir();
-      const filePath = (0, import_path.join)(dir, `${graphId}.json`);
+      const filePath = (0, import_node_path8.join)(dir, `${graphId}.json`);
       try {
         const content = await (0, import_promises.readFile)(filePath, "utf-8");
         return loadGraph(content);
@@ -2132,7 +3411,7 @@ var STATUS_ICONS = {
   hung: "\u231B",
   timeout: "\u231B"
 };
-function formatDuration(ms) {
+function formatDuration2(ms) {
   if (ms < 1e3) return `${ms}ms`;
   if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
   if (ms < 36e5) return `${(ms / 6e4).toFixed(1)}m`;
@@ -2140,7 +3419,7 @@ function formatDuration(ms) {
 }
 function nodeDuration(node, graphEndTime) {
   const end = node.endTime ?? graphEndTime;
-  return formatDuration(end - node.startTime);
+  return formatDuration2(end - node.startTime);
 }
 function getGenAiInfo(node) {
   const parts = [];
@@ -2184,7 +3463,8 @@ function toAsciiTree(graph) {
     const children = getChildren(graph, nodeId);
     const childPrefix = isRoot ? "" : prefix + (isLast ? "   " : "\u2502  ");
     for (let i = 0; i < children.length; i++) {
-      renderNode(children[i].id, childPrefix, i === children.length - 1, false);
+      const childId = children[i]?.id;
+      if (childId) renderNode(childId, childPrefix, i === children.length - 1, false);
     }
   }
   renderNode(graph.rootNodeId, "", true, true);
@@ -2203,7 +3483,7 @@ function toTimeline(graph) {
   const tickCount = Math.min(5, Math.max(2, Math.floor(barWidth / 10)));
   for (let i = 0; i <= tickCount; i++) {
     const t = totalDuration * i / tickCount;
-    scaleLabels.push(formatDuration(t));
+    scaleLabels.push(formatDuration2(t));
   }
   let header = "";
   for (let i = 0; i < scaleLabels.length; i++) {
@@ -2255,9 +3535,9 @@ function toTimeline(graph) {
 }
 
 // src/watch.ts
-var import_node_fs5 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_os = require("os");
-var import_node_path4 = require("path");
+var import_node_path9 = require("path");
 
 // src/watch-alerts.ts
 var import_node_child_process3 = require("child_process");
@@ -2378,15 +3658,15 @@ function sendCommand(payload, cmd) {
 }
 
 // src/watch-state.ts
-var import_node_fs4 = require("fs");
+var import_node_fs8 = require("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;
+    return Number.isNaN(n) ? 0 : n * 1e3;
   }
   const value = parseFloat(match[1]);
-  switch (match[2].toLowerCase()) {
+  switch (match[2]?.toLowerCase()) {
     case "s":
       return value * 1e3;
     case "m":
@@ -2403,9 +3683,9 @@ function emptyState() {
   return { version: 1, agents: {}, lastPollTime: 0 };
 }
 function loadWatchState(filePath) {
-  if (!(0, import_node_fs4.existsSync)(filePath)) return emptyState();
+  if (!(0, import_node_fs8.existsSync)(filePath)) return emptyState();
   try {
-    const raw = JSON.parse((0, import_node_fs4.readFileSync)(filePath, "utf8"));
+    const raw = JSON.parse((0, import_node_fs8.readFileSync)(filePath, "utf8"));
     if (raw.version !== 1 || typeof raw.agents !== "object") return emptyState();
     return raw;
   } catch {
@@ -2413,13 +3693,13 @@ function loadWatchState(filePath) {
   }
 }
 function saveWatchState(filePath, state) {
-  const tmp = filePath + ".tmp";
+  const tmp = `${filePath}.tmp`;
   try {
-    (0, import_node_fs4.writeFileSync)(tmp, JSON.stringify(state, null, 2), "utf8");
-    (0, import_node_fs4.renameSync)(tmp, filePath);
+    (0, import_node_fs8.writeFileSync)(tmp, JSON.stringify(state, null, 2), "utf8");
+    (0, import_node_fs8.renameSync)(tmp, filePath);
   } catch {
     try {
-      (0, import_node_fs4.writeFileSync)(filePath, JSON.stringify(state, null, 2), "utf8");
+      (0, import_node_fs8.writeFileSync)(filePath, JSON.stringify(state, null, 2), "utf8");
     } catch {
     }
   }
@@ -2614,8 +3894,8 @@ function parseWatchArgs(argv) {
       i++;
       const val = args[i] ?? "";
       if (val === "telegram") {
-        const botToken = process.env["AGENTFLOW_TELEGRAM_BOT_TOKEN"] ?? "";
-        const chatId = process.env["AGENTFLOW_TELEGRAM_CHAT_ID"] ?? "";
+        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 {
@@ -2632,7 +3912,7 @@ function parseWatchArgs(argv) {
     } else if (arg === "--poll") {
       i++;
       const v = parseInt(args[i] ?? "", 10);
-      if (!isNaN(v) && v > 0) pollIntervalMs = v * 1e3;
+      if (!Number.isNaN(v) && v > 0) pollIntervalMs = v * 1e3;
       i++;
     } else if (arg === "--cooldown") {
       i++;
@@ -2647,20 +3927,20 @@ function parseWatchArgs(argv) {
       recursive = true;
       i++;
     } else if (!arg.startsWith("-")) {
-      dirs.push((0, import_node_path4.resolve)(arg));
+      dirs.push((0, import_node_path9.resolve)(arg));
       i++;
     } else {
       i++;
     }
   }
-  if (dirs.length === 0) dirs.push((0, import_node_path4.resolve)("."));
+  if (dirs.length === 0) dirs.push((0, import_node_path9.resolve)("."));
   if (alertConditions.length === 0) {
     alertConditions.push({ type: "error" });
     alertConditions.push({ type: "recovery" });
   }
   notifyChannels.unshift({ type: "stdout" });
   if (!stateFilePath) {
-    stateFilePath = (0, import_node_path4.join)(dirs[0], ".agentflow-watch-state.json");
+    stateFilePath = (0, import_node_path9.join)(dirs[0], ".agentflow-watch-state.json");
   }
   return {
     dirs,
@@ -2668,7 +3948,7 @@ function parseWatchArgs(argv) {
     pollIntervalMs,
     alertConditions,
     notifyChannels,
-    stateFilePath: (0, import_node_path4.resolve)(stateFilePath),
+    stateFilePath: (0, import_node_path9.resolve)(stateFilePath),
     cooldownMs
   };
 }
@@ -2722,12 +4002,12 @@ Examples:
 }
 function startWatch(argv) {
   const config = parseWatchArgs(argv);
-  const valid = config.dirs.filter((d) => (0, import_node_fs5.existsSync)(d));
+  const valid = config.dirs.filter((d) => (0, import_node_fs9.existsSync)(d));
   if (valid.length === 0) {
     console.error(`No valid directories found: ${config.dirs.join(", ")}`);
     process.exit(1);
   }
-  const invalid = config.dirs.filter((d) => !(0, import_node_fs5.existsSync)(d));
+  const invalid = config.dirs.filter((d) => !(0, import_node_fs9.existsSync)(d));
   if (invalid.length > 0) {
     console.warn(`Skipping non-existent: ${invalid.join(", ")}`);
   }
@@ -2748,7 +4028,7 @@ agentflow watch started`);
   console.log(`  Poll:         ${config.pollIntervalMs / 1e3}s`);
   console.log(`  Alert on:     ${condLabels.join(", ")}`);
   console.log(
-    `  Notify:       stdout${channelLabels.length > 0 ? ", " + channelLabels.join(", ") : ""}`
+    `  Notify:       stdout${channelLabels.length > 0 ? `, ${channelLabels.join(", ")}` : ""}`
   );
   console.log(`  Cooldown:     ${Math.floor(config.cooldownMs / 6e4)}m`);
   console.log(`  State:        ${config.stateFilePath}`);
@@ -2807,12 +4087,28 @@ agentflow watch started`);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   auditProcesses,
+  buildAgentSummaryPrompt,
+  buildAnomalyExplanationPrompt,
+  buildFailureAnalysisPrompt,
+  buildFixSuggestionPrompt,
+  checkConformance,
   checkGuards,
+  createEventEmitter,
+  createExecutionEvent,
   createGraphBuilder,
+  createInsightEngine,
+  createJsonEventWriter,
+  createKnowledgeStore,
+  createPatternEvent,
+  createPolicySource,
+  createSomaEventWriter,
   createTraceStore,
+  discoverProcess,
   discoverProcessConfig,
+  findVariants,
   findWaitingOn,
   formatAuditReport,
+  getBottlenecks,
   getChildren,
   getCriticalPath,
   getDepth,
@@ -2821,6 +4117,7 @@ agentflow watch started`);
   getHungNodes,
   getNode,
   getParent,
+  getPathSignature,
   getStats,
   getSubtree,
   getTraceTree,