agentflow-core 0.8.0 → 0.8.1

package/dist/index.cjs

@@ -37,11 +37,13 @@ __export(index_exports, {
   createPolicySource: () => createPolicySource,
   createSomaEventWriter: () => createSomaEventWriter,
   createTraceStore: () => createTraceStore,
+  discoverAllProcessConfigs: () => discoverAllProcessConfigs,
   discoverProcess: () => discoverProcess,
   discoverProcessConfig: () => discoverProcessConfig,
   findVariants: () => findVariants,
   findWaitingOn: () => findWaitingOn,
   formatAuditReport: () => formatAuditReport,
+  formatReceipt: () => formatReceipt,
   getBottlenecks: () => getBottlenecks,
   getChildren: () => getChildren,
   getCriticalPath: () => getCriticalPath,
@@ -63,6 +65,7 @@ __export(index_exports, {
   startWatch: () => startWatch,
   stitchTrace: () => stitchTrace,
   toAsciiTree: () => toAsciiTree,
+  toReceipt: () => toReceipt,
   toTimeline: () => toTimeline,
   withGuards: () => withGuards
 });
@@ -132,7 +135,7 @@ function discoverProcess(graphs) {
     steps: [...steps].sort(),
     transitions,
     totalGraphs: graphs.length,
-    agentId: graphs[0].agentId
+    agentId: graphs[0]?.agentId ?? ""
   };
 }
 function findVariants(graphs) {
@@ -164,13 +167,13 @@ function findVariants(graphs) {
 }
 function percentile(sorted, p) {
   if (sorted.length === 0) return 0;
-  if (sorted.length === 1) return sorted[0];
+  if (sorted.length === 1) return sorted[0] ?? 0;
   const index = p / 100 * (sorted.length - 1);
   const lower = Math.floor(index);
   const upper = Math.ceil(index);
-  if (lower === upper) return sorted[lower];
+  if (lower === upper) return sorted[lower] ?? 0;
   const weight = index - lower;
-  return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+  return (sorted[lower] ?? 0) * (1 - weight) + (sorted[upper] ?? 0) * weight;
 }
 function getBottlenecks(graphs) {
   if (graphs.length === 0) return [];
@@ -197,8 +200,8 @@ function getBottlenecks(graphs) {
         median: percentile(sorted, 50),
         p95: percentile(sorted, 95),
         p99: percentile(sorted, 99),
-        min: sorted[0],
-        max: sorted[sorted.length - 1]
+        min: sorted[0] ?? 0,
+        max: sorted[sorted.length - 1] ?? 0
       },
       percentOfGraphs: sorted.length / total * 100
     });
@@ -607,435 +610,105 @@ 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`;
+// src/graph-query.ts
+function getNode(graph, nodeId) {
+  return graph.nodes.get(nodeId);
 }
-function fmtTime(ts) {
-  return new Date(ts).toISOString();
+function getChildren(graph, nodeId) {
+  const node = graph.nodes.get(nodeId);
+  if (!node) return [];
+  const result = [];
+  for (const childId of node.children) {
+    const child = graph.nodes.get(childId);
+    if (child) result.push(child);
+  }
+  return result;
 }
-function 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 getParent(graph, nodeId) {
+  const node = graph.nodes.get(nodeId);
+  if (!node || node.parentId === null) return void 0;
+  return graph.nodes.get(node.parentId);
 }
-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 getFailures(graph) {
+  const failureStatuses = /* @__PURE__ */ new Set(["failed", "hung", "timeout"]);
+  return [...graph.nodes.values()].filter((node) => failureStatuses.has(node.status));
 }
-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}`);
+function getHungNodes(graph) {
+  return [...graph.nodes.values()].filter(
+    (node) => node.status === "running" && node.endTime === null
+  );
+}
+function getCriticalPath(graph) {
+  const root = graph.nodes.get(graph.rootNodeId);
+  if (!root) return [];
+  function nodeDuration3(node) {
+    const end = node.endTime ?? Date.now();
+    return end - node.startTime;
   }
-  if (event.violations.length > 0) {
-    eventDetails.push(`Violations: ${event.violations.map((v) => v.message).join("; ")}`);
+  function dfs(node) {
+    if (node.children.length === 0) {
+      return { duration: nodeDuration3(node), path: [node] };
+    }
+    let bestChild = { duration: -1, path: [] };
+    for (const childId of node.children) {
+      const child = graph.nodes.get(childId);
+      if (!child) continue;
+      const result = dfs(child);
+      if (result.duration > bestChild.duration) {
+        bestChild = result;
+      }
+    }
+    return {
+      duration: nodeDuration3(node) + bestChild.duration,
+      path: [node, ...bestChild.path]
+    };
   }
-  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?`;
+  return dfs(root).path;
 }
-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)})`);
+function findWaitingOn(graph, nodeId) {
+  const results = [];
+  for (const edge of graph.edges) {
+    if (edge.from === nodeId && edge.type === "waited_on") {
+      const node = graph.nodes.get(edge.to);
+      if (node) results.push(node);
     }
-    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?`;
+  }
+  return results;
 }
-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);
+function getSubtree(graph, nodeId) {
+  const startNode = graph.nodes.get(nodeId);
+  if (!startNode) return [];
+  const result = [];
+  const queue = [...startNode.children];
+  while (queue.length > 0) {
+    const currentId = queue.shift();
+    if (currentId === void 0) break;
+    const current = graph.nodes.get(currentId);
+    if (!current) continue;
+    result.push(current);
+    queue.push(...current.children);
   }
-  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.`;
+  return result;
 }
-
-// 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;
+function getDuration(graph) {
+  const end = graph.endTime ?? Date.now();
+  return end - graph.startTime;
+}
+function getDepth(graph) {
+  const root = graph.nodes.get(graph.rootNodeId);
+  if (!root) return -1;
+  function dfs(node, depth) {
+    if (node.children.length === 0) return depth;
+    let maxDepth = depth;
+    for (const childId of node.children) {
+      const child = graph.nodes.get(childId);
+      if (!child) continue;
+      const childDepth = dfs(child, depth + 1);
+      if (childDepth > maxDepth) maxDepth = childDepth;
+    }
+    return maxDepth;
   }
-  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);
-}
-function getChildren(graph, nodeId) {
-  const node = graph.nodes.get(nodeId);
-  if (!node) return [];
-  const result = [];
-  for (const childId of node.children) {
-    const child = graph.nodes.get(childId);
-    if (child) result.push(child);
-  }
-  return result;
-}
-function getParent(graph, nodeId) {
-  const node = graph.nodes.get(nodeId);
-  if (!node || node.parentId === null) return void 0;
-  return graph.nodes.get(node.parentId);
-}
-function getFailures(graph) {
-  const failureStatuses = /* @__PURE__ */ new Set(["failed", "hung", "timeout"]);
-  return [...graph.nodes.values()].filter((node) => failureStatuses.has(node.status));
-}
-function getHungNodes(graph) {
-  return [...graph.nodes.values()].filter(
-    (node) => node.status === "running" && node.endTime === null
-  );
-}
-function getCriticalPath(graph) {
-  const root = graph.nodes.get(graph.rootNodeId);
-  if (!root) return [];
-  function nodeDuration2(node) {
-    const end = node.endTime ?? Date.now();
-    return end - node.startTime;
-  }
-  function dfs(node) {
-    if (node.children.length === 0) {
-      return { duration: nodeDuration2(node), path: [node] };
-    }
-    let bestChild = { duration: -1, path: [] };
-    for (const childId of node.children) {
-      const child = graph.nodes.get(childId);
-      if (!child) continue;
-      const result = dfs(child);
-      if (result.duration > bestChild.duration) {
-        bestChild = result;
-      }
-    }
-    return {
-      duration: nodeDuration2(node) + bestChild.duration,
-      path: [node, ...bestChild.path]
-    };
-  }
-  return dfs(root).path;
-}
-function findWaitingOn(graph, nodeId) {
-  const results = [];
-  for (const edge of graph.edges) {
-    if (edge.from === nodeId && edge.type === "waited_on") {
-      const node = graph.nodes.get(edge.to);
-      if (node) results.push(node);
-    }
-  }
-  return results;
-}
-function getSubtree(graph, nodeId) {
-  const startNode = graph.nodes.get(nodeId);
-  if (!startNode) return [];
-  const result = [];
-  const queue = [...startNode.children];
-  while (queue.length > 0) {
-    const currentId = queue.shift();
-    if (currentId === void 0) break;
-    const current = graph.nodes.get(currentId);
-    if (!current) continue;
-    result.push(current);
-    queue.push(...current.children);
-  }
-  return result;
-}
-function getDuration(graph) {
-  const end = graph.endTime ?? Date.now();
-  return end - graph.startTime;
-}
-function getDepth(graph) {
-  const root = graph.nodes.get(graph.rootNodeId);
-  if (!root) return -1;
-  function dfs(node, depth) {
-    if (node.children.length === 0) return depth;
-    let maxDepth = depth;
-    for (const childId of node.children) {
-      const child = graph.nodes.get(childId);
-      if (!child) continue;
-      const childDepth = dfs(child, depth + 1);
-      if (childDepth > maxDepth) maxDepth = childDepth;
-    }
-    return maxDepth;
-  }
-  return dfs(root, 0);
+  return dfs(root, 0);
 }
 function getStats(graph) {
   const byStatus = {
@@ -1141,6 +814,10 @@ function getTraceTree(trace) {
 }
 
 // src/guards.ts
+function explainMessage(explanation) {
+  const sourceLabel = explanation.source === "static" ? "static config" : explanation.source === "soma-policy" ? `soma-policy${explanation.evidence ? ` (${explanation.evidence})` : ""}` : explanation.source === "assertion" ? "assertion" : "adaptive";
+  return `This run was stopped because ${explanation.rule} reached ${explanation.actual}, which exceeds the limit of ${explanation.threshold}. Source: ${sourceLabel}.`;
+}
 var DEFAULT_TIMEOUTS = {
   tool: 3e4,
   // 30s
@@ -1167,22 +844,36 @@ function checkGuards(graph, config) {
       const timeoutThreshold = timeouts[node.type];
       const elapsed = now - node.startTime;
       if (elapsed > timeoutThreshold) {
+        const explanation = {
+          rule: "timeout",
+          threshold: timeoutThreshold,
+          actual: elapsed,
+          source: "static"
+        };
         violations.push({
           type: "timeout",
           nodeId: node.id,
-          message: `Node ${node.id} (${node.type}: ${node.name}) has been running for ${elapsed}ms, exceeding timeout of ${timeoutThreshold}ms`,
-          timestamp: now
+          message: explainMessage(explanation),
+          timestamp: now,
+          explanation
         });
       }
     }
   }
   const depth = getDepth(graph);
   if (depth > maxDepth) {
+    const explanation = {
+      rule: "max-depth",
+      threshold: maxDepth,
+      actual: depth,
+      source: "static"
+    };
     violations.push({
       type: "spawn-explosion",
       nodeId: graph.rootNodeId,
-      message: `Graph depth ${depth} exceeds maximum depth of ${maxDepth}`,
-      timestamp: now
+      message: explainMessage(explanation),
+      timestamp: now,
+      explanation
     });
   }
   let agentCount = 0;
@@ -1192,16 +883,25 @@ function checkGuards(graph, config) {
     }
   }
   if (agentCount > maxAgentSpawns) {
+    const explanation = {
+      rule: "max-agent-spawns",
+      threshold: maxAgentSpawns,
+      actual: agentCount,
+      source: "static"
+    };
     violations.push({
       type: "spawn-explosion",
       nodeId: graph.rootNodeId,
-      message: `Total agent/subagent count ${agentCount} exceeds maximum of ${maxAgentSpawns}`,
-      timestamp: now
+      message: explainMessage(explanation),
+      timestamp: now,
+      explanation
     });
   }
   violations.push(...detectReasoningLoops(graph, maxReasoningSteps, now));
   if (config?.policySource) {
-    violations.push(...checkPolicyViolations(graph, config.policySource, config.policyThresholds, now));
+    violations.push(
+      ...checkPolicyViolations(graph, config.policySource, config.policyThresholds, now)
+    );
   }
   return violations;
 }
@@ -1222,11 +922,18 @@ function detectReasoningLoops(graph, maxSteps, timestamp) {
     }
     if (newCount > maxSteps && !reported.has(newType)) {
       reported.add(newType);
+      const explanation = {
+        rule: "max-reasoning-steps",
+        threshold: maxSteps,
+        actual: newCount,
+        source: "static"
+      };
       violations.push({
         type: "reasoning-loop",
         nodeId: node.id,
-        message: `Detected ${newCount} consecutive ${newType} nodes along path to ${node.name}`,
-        timestamp
+        message: explainMessage(explanation),
+        timestamp,
+        explanation
       });
     }
     const children = getChildren(graph, nodeId);
@@ -1243,29 +950,50 @@ function checkPolicyViolations(graph, policySource, thresholds, timestamp) {
   const minConformance = thresholds?.minConformance ?? 0.7;
   const failureRate = policySource.recentFailureRate(graph.agentId);
   if (failureRate > maxFailureRate) {
+    const explanation = {
+      rule: "max-failure-rate",
+      threshold: maxFailureRate,
+      actual: failureRate,
+      source: "soma-policy"
+    };
     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
+      message: explainMessage(explanation),
+      timestamp,
+      explanation
     });
   }
   const conformanceScore = policySource.lastConformanceScore(graph.agentId);
   if (conformanceScore !== null && conformanceScore < minConformance) {
+    const explanation = {
+      rule: "min-conformance",
+      threshold: minConformance,
+      actual: conformanceScore,
+      source: "soma-policy"
+    };
     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
+      message: explainMessage(explanation),
+      timestamp,
+      explanation
     });
   }
   for (const node of graph.nodes.values()) {
     if (node.status === "running" && policySource.isKnownBottleneck(node.name)) {
+      const explanation = {
+        rule: "known-bottleneck",
+        threshold: "flagged",
+        actual: "running",
+        source: "soma-policy"
+      };
       violations.push({
         type: "known-bottleneck",
         nodeId: node.id,
-        message: `Node ${node.name} (${node.type}) is a known bottleneck`,
-        timestamp
+        message: explainMessage(explanation),
+        timestamp,
+        explanation
       });
     }
   }
@@ -1315,22 +1043,352 @@ function withGuards(builder, config) {
       const violations = checkGuards(snapshot, config);
       handleViolations(violations);
     },
-    failNode: (nodeId, error) => {
-      builder.failNode(nodeId, error);
-      const snapshot = builder.getSnapshot();
-      const violations = checkGuards(snapshot, config);
-      handleViolations(violations);
+    failNode: (nodeId, error) => {
+      builder.failNode(nodeId, error);
+      const snapshot = builder.getSnapshot();
+      const violations = checkGuards(snapshot, config);
+      handleViolations(violations);
+    },
+    addEdge: (from, to, type) => builder.addEdge(from, to, type),
+    pushEvent: (event) => builder.pushEvent(event),
+    updateState: (nodeId, state) => builder.updateState(nodeId, state),
+    withParent: (parentId, fn) => builder.withParent(parentId, fn),
+    getSnapshot: () => builder.getSnapshot(),
+    build: () => {
+      const snapshot = builder.getSnapshot();
+      const violations = checkGuards(snapshot, config);
+      handleViolations(violations);
+      return builder.build();
+    }
+  };
+}
+
+// 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);
+      }
     },
-    addEdge: (from, to, type) => builder.addEdge(from, to, type),
-    pushEvent: (event) => builder.pushEvent(event),
-    updateState: (nodeId, state) => builder.updateState(nodeId, state),
-    withParent: (parentId, fn) => builder.withParent(parentId, fn),
-    getSnapshot: () => builder.getSnapshot(),
-    build: () => {
-      const snapshot = builder.getSnapshot();
-      const violations = checkGuards(snapshot, config);
-      handleViolations(violations);
-      return builder.build();
+    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);
+      }
     }
   };
 }
@@ -1440,7 +1498,8 @@ function createKnowledgeStore(config) {
     (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
   }
   function profilePath(agentId) {
-    return (0, import_node_path2.join)(profilesDir, `${agentId}.json`);
+    const safe = agentId.replace(/[/\\]/g, "_").replace(/\.\./g, "_");
+    return (0, import_node_path2.join)(profilesDir, `${safe}.json`);
   }
   function appendExecutionEvent(event) {
     const dateDir = (0, import_node_path2.join)(eventsDir, event.agentId, toDateDir(event.timestamp));
@@ -1565,7 +1624,7 @@ function createKnowledgeStore(config) {
             continue;
           }
           for (const file of files) {
-            const ts = Number.parseInt(file.split("-")[0], 10);
+            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));
@@ -1625,220 +1684,18 @@ function createKnowledgeStore(config) {
       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 {
+    // EventWriter interface
     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");
+      this.append(event);
     }
   };
 }
 
 // src/live.ts
-var import_node_fs6 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
 
 // src/loader.ts
 function toNodesMap(raw) {
@@ -1867,7 +1724,8 @@ function loadGraph(input) {
     events: raw.events ?? [],
     traceId: raw.traceId,
     spanId: raw.spanId,
-    parentSpanId: raw.parentSpanId
+    parentSpanId: raw.parentSpanId,
+    metadata: raw.metadata ?? {}
   };
 }
 function graphToJson(graph) {
@@ -1894,8 +1752,8 @@ function graphToJson(graph) {
 
 // src/process-audit.ts
 var import_node_child_process = require("child_process");
-var import_node_fs5 = require("fs");
-var import_node_path5 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
 function isPidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -1906,7 +1764,7 @@ function isPidAlive(pid) {
 }
 function pidMatchesName(pid, name) {
   try {
-    const cmdline = (0, import_node_fs5.readFileSync)(`/proc/${pid}/cmdline`, "utf8");
+    const cmdline = (0, import_node_fs3.readFileSync)(`/proc/${pid}/cmdline`, "utf8");
     return cmdline.includes(name);
   } catch {
     return false;
@@ -1914,7 +1772,7 @@ function pidMatchesName(pid, name) {
 }
 function readPidFile(path) {
   try {
-    const pid = parseInt((0, import_node_fs5.readFileSync)(path, "utf8").trim(), 10);
+    const pid = parseInt((0, import_node_fs3.readFileSync)(path, "utf8").trim(), 10);
     return Number.isNaN(pid) ? null : pid;
   } catch {
     return null;
@@ -1929,8 +1787,8 @@ function auditPidFile(config) {
       pid: null,
       alive: false,
       matchesProcess: false,
-      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"
+      stale: !(0, import_node_fs3.existsSync)(config.pidFile),
+      reason: (0, import_node_fs3.existsSync)(config.pidFile) ? "PID file exists but content is invalid" : "No PID file found"
     };
   }
   const alive = isPidAlive(pid);
@@ -1950,8 +1808,15 @@ function auditSystemd(config) {
   if (config.systemdUnit === null || config.systemdUnit === void 0) return null;
   const unit = config.systemdUnit;
   try {
-    const raw = (0, import_node_child_process.execSync)(
-      `systemctl --user show ${unit} --property=ActiveState,SubState,MainPID,NRestarts,Result --no-pager 2>/dev/null`,
+    const raw = (0, import_node_child_process.execFileSync)(
+      "systemctl",
+      [
+        "--user",
+        "show",
+        unit,
+        "--property=ActiveState,SubState,MainPID,NRestarts,Result",
+        "--no-pager"
+      ],
       { encoding: "utf8", timeout: 5e3 }
     );
     const props = {};
@@ -1979,9 +1844,9 @@ function auditSystemd(config) {
   }
 }
 function auditWorkers(config) {
-  if (!config.workersFile || !(0, import_node_fs5.existsSync)(config.workersFile)) return null;
+  if (!config.workersFile || !(0, import_node_fs3.existsSync)(config.workersFile)) return null;
   try {
-    const data = JSON.parse((0, import_node_fs5.readFileSync)(config.workersFile, "utf8"));
+    const data = JSON.parse((0, import_node_fs3.readFileSync)(config.workersFile, "utf8"));
     const orchPid = data.pid ?? null;
     const orchAlive = orchPid ? isPidAlive(orchPid) : false;
     const workers = [];
@@ -2009,7 +1874,7 @@ function auditWorkers(config) {
 }
 function readCmdline(pid) {
   try {
-    return (0, import_node_fs5.readFileSync)(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ").trim();
+    return (0, import_node_fs3.readFileSync)(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ").trim();
   } catch {
     return "";
   }
@@ -2042,53 +1907,83 @@ function getOsProcesses(processName) {
   }
 }
 function discoverProcessConfig(dirs) {
-  let pidFile;
-  let workersFile;
-  let processName = "";
+  const configs = discoverAllProcessConfigs(dirs);
+  return configs.length > 0 ? configs[0] ?? null : null;
+}
+function discoverAllProcessConfigs(dirs) {
+  const configs = /* @__PURE__ */ new Map();
   for (const dir of dirs) {
-    if (!(0, import_node_fs5.existsSync)(dir)) continue;
+    if (!(0, import_node_fs3.existsSync)(dir)) continue;
     let entries;
     try {
-      entries = (0, import_node_fs5.readdirSync)(dir);
+      entries = (0, import_node_fs3.readdirSync)(dir);
     } catch {
       continue;
     }
     for (const f of entries) {
-      const fp = (0, import_node_path5.join)(dir, f);
+      const fp = (0, import_node_path3.join)(dir, f);
       try {
-        if (!(0, import_node_fs5.statSync)(fp).isFile()) continue;
+        if (!(0, import_node_fs3.statSync)(fp).isFile()) continue;
       } catch {
         continue;
       }
-      if (f.endsWith(".pid") && !pidFile) {
-        pidFile = fp;
-        if (!processName) {
-          processName = (0, import_node_path5.basename)(f, ".pid");
+      if (f.endsWith(".pid")) {
+        const name = (0, import_node_path3.basename)(f, ".pid");
+        if (!configs.has(name)) {
+          configs.set(name, { processName: name });
         }
+        const cfg = configs.get(name) ?? { processName: name };
+        if (!cfg.pidFile) cfg.pidFile = fp;
       }
-      if ((f === "workers.json" || f.endsWith("-workers.json")) && !workersFile) {
-        workersFile = fp;
-        if (!processName && f !== "workers.json") {
-          processName = (0, import_node_path5.basename)(f, "-workers.json");
+      if (f === "workers.json" || f.endsWith("-workers.json")) {
+        const name = f === "workers.json" ? "" : (0, import_node_path3.basename)(f, "-workers.json");
+        if (name && !configs.has(name)) {
+          configs.set(name, { processName: name });
+        }
+        if (name) {
+          const cfg = configs.get(name) ?? { processName: name };
+          if (!cfg.workersFile) cfg.workersFile = fp;
         }
       }
     }
   }
-  if (!processName && !pidFile && !workersFile) return null;
-  if (!processName) processName = "agent";
-  let systemdUnit;
   try {
-    const unitName = `${processName}.service`;
-    const result = (0, import_node_child_process.execSync)(
-      `systemctl --user show ${unitName} --property=LoadState --no-pager 2>/dev/null`,
-      { encoding: "utf8", timeout: 3e3 }
+    const raw = (0, import_node_child_process.execSync)(
+      "systemctl --user list-units --type=service --all --no-legend --no-pager 2>/dev/null",
+      { encoding: "utf8", timeout: 5e3 }
     );
-    if (result.includes("LoadState=loaded")) {
-      systemdUnit = unitName;
+    for (const line of raw.trim().split("\n")) {
+      if (!line.trim()) continue;
+      const parts = line.trim().split(/\s+/);
+      const unitName = parts[0] ?? "";
+      const loadState = parts[1] ?? "";
+      if (!unitName.endsWith(".service") || loadState !== "loaded") continue;
+      const name = unitName.replace(".service", "");
+      if (/^(dbus|gpg-agent|dirmngr|keyboxd|snapd\.|pk-|launchpadlib-)/.test(name)) continue;
+      if (!configs.has(name)) {
+        configs.set(name, { processName: name });
+      }
+      const cfg = configs.get(name) ?? { processName: name };
+      cfg.systemdUnit = unitName;
     }
   } catch {
   }
-  return { processName, pidFile, workersFile, systemdUnit };
+  for (const cfg of configs.values()) {
+    if (cfg.systemdUnit !== void 0) continue;
+    try {
+      const unitName = `${cfg.processName}.service`;
+      const result = (0, import_node_child_process.execFileSync)(
+        "systemctl",
+        ["--user", "show", unitName, "--property=LoadState", "--no-pager"],
+        { encoding: "utf8", timeout: 3e3 }
+      );
+      if (result.includes("LoadState=loaded")) {
+        cfg.systemdUnit = unitName;
+      }
+    } catch {
+    }
+  }
+  return [...configs.values()];
 }
 function auditProcesses(config) {
   const pidFile = auditPidFile(config);
@@ -2107,7 +2002,7 @@ function auditProcesses(config) {
   const childPids = /* @__PURE__ */ new Set();
   for (const knownPid of knownPids) {
     try {
-      const childrenRaw = (0, import_node_fs5.readFileSync)(
+      const childrenRaw = (0, import_node_fs3.readFileSync)(
         `/proc/${knownPid}/task/${knownPid}/children`,
         "utf8"
       ).trim();
@@ -2123,7 +2018,7 @@ function auditProcesses(config) {
   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 statusContent = (0, import_node_fs3.readFileSync)(`/proc/${p.pid}/status`, "utf8");
       const ppidMatch = statusContent.match(/^PPid:\s+(\d+)/m);
       if (ppidMatch) {
         const ppid = parseInt(ppidMatch[1] ?? "0", 10);
@@ -2250,7 +2145,7 @@ function parseArgs(argv) {
   if (args[0] === "live") args.shift();
   let i = 0;
   while (i < args.length) {
-    const arg = args[i];
+    const arg = args[i] ?? "";
     if (arg === "--help" || arg === "-h") {
       printUsage();
       process.exit(0);
@@ -2263,13 +2158,13 @@ function parseArgs(argv) {
       config.recursive = true;
       i++;
     } else if (!arg.startsWith("-")) {
-      config.dirs.push((0, import_node_path6.resolve)(arg));
+      config.dirs.push((0, import_node_path4.resolve)(arg));
       i++;
     } else {
       i++;
     }
   }
-  if (config.dirs.length === 0) config.dirs.push((0, import_node_path6.resolve)("."));
+  if (config.dirs.length === 0) config.dirs.push((0, import_node_path4.resolve)("."));
   return config;
 }
 function printUsage() {
@@ -2305,7 +2200,7 @@ function scanFiles(dirs, recursive) {
   const seen = /* @__PURE__ */ new Set();
   function scanDir(d, topLevel) {
     try {
-      const dirStat = (0, import_node_fs6.statSync)(d);
+      const dirStat = (0, import_node_fs4.statSync)(d);
       const dirMtime = dirStat.mtime.getTime();
       const cachedMtime = dirMtimeCache.get(d);
       if (cachedMtime === dirMtime) {
@@ -2321,13 +2216,13 @@ function scanFiles(dirs, recursive) {
         }
       }
       const dirResults = [];
-      for (const f of (0, import_node_fs6.readdirSync)(d)) {
+      for (const f of (0, import_node_fs4.readdirSync)(d)) {
         if (f.startsWith(".")) continue;
-        const fp = (0, import_node_path6.join)(d, f);
+        const fp = (0, import_node_path4.join)(d, f);
         if (seen.has(fp)) continue;
         let stat;
         try {
-          stat = (0, import_node_fs6.statSync)(fp);
+          stat = (0, import_node_fs4.statSync)(fp);
         } catch {
           continue;
         }
@@ -2369,13 +2264,13 @@ function scanFiles(dirs, recursive) {
 }
 function safeReadJson(fp) {
   try {
-    return JSON.parse((0, import_node_fs6.readFileSync)(fp, "utf8"));
+    return JSON.parse((0, import_node_fs4.readFileSync)(fp, "utf8"));
   } catch {
     return null;
   }
 }
 function nameFromFile(filename) {
-  return (0, import_node_path6.basename)(filename).replace(/\.(json|jsonl)$/, "").replace(/-state$/, "");
+  return (0, import_node_path4.basename)(filename).replace(/\.(json|jsonl)$/, "").replace(/-state$/, "");
 }
 function normalizeStatus(val) {
   if (typeof val !== "string") return "unknown";
@@ -2553,11 +2448,11 @@ function processJsonFile(file) {
 }
 function processJsonlFile(file) {
   try {
-    const content = (0, import_node_fs6.readFileSync)(file.path, "utf8").trim();
+    const content = (0, import_node_fs4.readFileSync)(file.path, "utf8").trim();
     if (!content) return [];
     const lines = content.split("\n");
     const lineCount = lines.length;
-    const lastObj = JSON.parse(lines[lines.length - 1]);
+    const lastObj = JSON.parse(lines[lines.length - 1] ?? "{}");
     const name = lastObj.jobId ?? lastObj.agentId ?? lastObj.name ?? lastObj.id ?? nameFromFile(file.filename);
     if (lastObj.action !== void 0 || lastObj.jobId !== void 0) {
       const status2 = findStatus(lastObj);
@@ -2653,7 +2548,7 @@ function processJsonlFile(file) {
     }
     const parts = [];
     if (model) {
-      const shortModel = model.includes("/") ? model.split("/").pop() : model;
+      const shortModel = model.includes("/") ? model.split("/").pop() ?? model : model;
       parts.push(shortModel.slice(0, 20));
     }
     if (toolCalls.length > 0) {
@@ -2818,15 +2713,15 @@ function render(config) {
     if (age > 36e5 || age < 0) continue;
     const idx = 11 - Math.floor(age / 3e5);
     if (idx >= 0 && idx < 12) {
-      buckets[idx]++;
-      if (r.status === "error") failBuckets[idx]++;
+      buckets[idx] = (buckets[idx] ?? 0) + 1;
+      if (r.status === "error") failBuckets[idx] = (failBuckets[idx] ?? 0) + 1;
     }
   }
   const maxBucket = Math.max(...buckets, 1);
   const sparkChars = " \u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
   const spark = buckets.map((v, i) => {
     const level = Math.round(v / maxBucket * 8);
-    return (failBuckets[i] > 0 ? C.red : C.green) + sparkChars[level] + C.reset;
+    return ((failBuckets[i] ?? 0) > 0 ? C.red : C.green) + sparkChars[level] + C.reset;
   }).join("");
   let auditResult = null;
   if (now - lastAuditTime > 1e4) {
@@ -3077,7 +2972,7 @@ function render(config) {
     for (const d of config.dirs) writeLine(L, `  ${C.dim}  ${d}${C.reset}`);
   }
   writeLine(L, "");
-  const dirLabel = config.dirs.length === 1 ? config.dirs[0] : `${config.dirs.length} directories`;
+  const dirLabel = config.dirs.length === 1 ? config.dirs[0] ?? "" : `${config.dirs.length} directories`;
   writeLine(L, `  ${C.dim}Watching: ${dirLabel}${C.reset}`);
   writeLine(L, `  ${C.dim}Press Ctrl+C to exit${C.reset}`);
   flushLines(L);
@@ -3093,13 +2988,13 @@ function getDistDepth(dt, spanId, visited) {
 }
 function startLive(argv) {
   const config = parseArgs(argv);
-  const valid = config.dirs.filter((d) => (0, import_node_fs6.existsSync)(d));
+  const valid = config.dirs.filter((d) => (0, import_node_fs4.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_fs6.existsSync)(d));
+  const invalid = config.dirs.filter((d) => !(0, import_node_fs4.existsSync)(d));
   if (invalid.length > 0) {
     console.warn(`Skipping non-existent: ${invalid.join(", ")}`);
   }
@@ -3111,7 +3006,7 @@ function startLive(argv) {
   let debounce = null;
   for (const dir of config.dirs) {
     try {
-      (0, import_node_fs6.watch)(dir, { recursive: config.recursive }, () => {
+      (0, import_node_fs4.watch)(dir, { recursive: config.recursive }, () => {
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => render(config), 500);
       });
@@ -3137,22 +3032,169 @@ function startLive(argv) {
   });
 }
 
+// src/policy-source.ts
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
+function createPolicySource(store) {
+  return {
+    recentFailureRate(agentId) {
+      const profile = store.getAgentProfile(agentId);
+      return profile?.failureRate ?? 0;
+    },
+    isKnownBottleneck(nodeName) {
+      const profilesDir = (0, import_node_path5.join)(store.baseDir, "profiles");
+      let agentIds;
+      try {
+        agentIds = (0, import_node_fs5.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?.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/receipts.ts
+function extractTokenCost(node) {
+  const semantic = node.metadata?.semantic;
+  if (semantic?.tokenCost !== void 0 && semantic.tokenCost !== null) {
+    return semantic.tokenCost;
+  }
+  if (node.state?.tokenCost !== void 0 && node.state.tokenCost !== null) {
+    return node.state.tokenCost;
+  }
+  return null;
+}
+function extractError(node) {
+  if (node.state?.error !== void 0 && node.state.error !== null) {
+    return String(node.state.error);
+  }
+  if (node.metadata?.error !== void 0 && node.metadata.error !== null) {
+    return String(node.metadata.error);
+  }
+  return null;
+}
+function nodeDuration(node) {
+  if (node.endTime === null) return null;
+  return node.endTime - node.startTime;
+}
+function toReceipt(graph) {
+  const nodes = [...graph.nodes.values()];
+  nodes.sort((a, b) => a.startTime - b.startTime);
+  const steps = nodes.map((node) => ({
+    nodeId: node.id,
+    name: node.name,
+    type: node.type,
+    status: node.status,
+    durationMs: nodeDuration(node),
+    tokenCost: extractTokenCost(node),
+    error: extractError(node)
+  }));
+  let succeeded = 0;
+  let failed = 0;
+  const skipped = 0;
+  for (const node of nodes) {
+    if (node.status === "completed") {
+      succeeded++;
+    } else if (node.status === "failed" || node.status === "hung" || node.status === "timeout") {
+      failed++;
+    }
+  }
+  const attempted = nodes.length;
+  let totalTokenCost = null;
+  for (const step of steps) {
+    if (step.tokenCost !== null) {
+      totalTokenCost = (totalTokenCost ?? 0) + step.tokenCost;
+    }
+  }
+  const totalDurationMs = graph.endTime !== null ? graph.endTime - graph.startTime : null;
+  return {
+    runId: graph.id,
+    agentId: graph.agentId,
+    status: graph.status,
+    startTime: graph.startTime,
+    endTime: graph.endTime,
+    totalDurationMs,
+    totalTokenCost,
+    steps,
+    summary: { attempted, succeeded, failed, skipped }
+  };
+}
+function formatReceipt(receipt) {
+  const lines = [];
+  lines.push("=== Run Receipt ===");
+  lines.push(`Run:      ${receipt.runId}`);
+  lines.push(`Agent:    ${receipt.agentId}`);
+  lines.push(`Status:   ${receipt.status}`);
+  lines.push(
+    `Duration: ${receipt.totalDurationMs !== null ? `${receipt.totalDurationMs}ms` : "\u2014"}`
+  );
+  lines.push("");
+  const s = receipt.summary;
+  lines.push(
+    `Summary: ${s.attempted} attempted, ${s.succeeded} succeeded, ${s.failed} failed, ${s.skipped} skipped`
+  );
+  lines.push("");
+  const nameWidth = Math.max(4, ...receipt.steps.map((st) => st.name.length));
+  const typeWidth = Math.max(4, ...receipt.steps.map((st) => st.type.length));
+  const pad = (str, width) => str.padEnd(width);
+  const padNum = (str, width) => str.padStart(width);
+  const idxWidth = Math.max(2, String(receipt.steps.length).length);
+  const statusWidth = 9;
+  const durWidth = 10;
+  const tokWidth = 8;
+  lines.push(
+    ` ${padNum("#", idxWidth)} | ${pad("Step", nameWidth)} | ${pad("Type", typeWidth)} | ${pad("Status", statusWidth)} | ${padNum("Duration", durWidth)} | ${padNum("Tokens", tokWidth)}`
+  );
+  lines.push(
+    `${"-".repeat(idxWidth + 1)}|${"-".repeat(nameWidth + 2)}|${"-".repeat(typeWidth + 2)}|${"-".repeat(statusWidth + 2)}|${"-".repeat(durWidth + 2)}|${"-".repeat(tokWidth + 2)}`
+  );
+  for (let i = 0; i < receipt.steps.length; i++) {
+    const step = receipt.steps[i];
+    const durStr = step.durationMs !== null ? `${step.durationMs}ms` : "\u2014";
+    const tokStr = step.tokenCost !== null ? String(step.tokenCost) : "\u2014";
+    lines.push(
+      ` ${padNum(String(i + 1), idxWidth)} | ${pad(step.name, nameWidth)} | ${pad(step.type, typeWidth)} | ${pad(step.status, statusWidth)} | ${padNum(durStr, durWidth)} | ${padNum(tokStr, tokWidth)}`
+    );
+  }
+  lines.push("");
+  if (receipt.totalTokenCost !== null) {
+    lines.push(`Total token cost: ${receipt.totalTokenCost}`);
+  } else {
+    lines.push("Total token cost: no cost data");
+  }
+  return lines.join("\n");
+}
+
 // src/runner.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs7 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path6 = 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_fs7.existsSync)(dir)) return result;
-  for (const entry of (0, import_node_fs7.readdirSync)(dir)) {
+  if (!(0, import_node_fs6.existsSync)(dir)) return result;
+  for (const entry of (0, import_node_fs6.readdirSync)(dir)) {
     if (!patterns.some((re) => re.test(entry))) continue;
-    const full = (0, import_node_path7.join)(dir, entry);
+    const full = (0, import_node_path6.join)(dir, entry);
     try {
-      const stat = (0, import_node_fs7.statSync)(full);
+      const stat = (0, import_node_fs6.statSync)(full);
       if (stat.isFile()) {
         result.set(full, stat.mtimeMs);
       }
@@ -3162,7 +3204,7 @@ function snapshotDir(dir, patterns) {
   return result;
 }
 function agentIdFromFilename(filePath) {
-  const base = (0, import_node_path7.basename)(filePath, ".json");
+  const base = (0, import_node_path6.basename)(filePath, ".json");
   const cleaned = base.replace(/-state$/, "");
   return `alfred-${cleaned}`;
 }
@@ -3184,7 +3226,7 @@ async function runTraced(config) {
   if (command.length === 0) {
     throw new Error("runTraced: command must not be empty");
   }
-  const resolvedTracesDir = (0, import_node_path7.resolve)(tracesDir);
+  const resolvedTracesDir = (0, import_node_path6.resolve)(tracesDir);
   const patterns = watchPatterns.map(globToRegex);
   const orchestrator = createGraphBuilder({ agentId, trigger });
   const { traceId, spanId } = orchestrator.traceContext;
@@ -3267,21 +3309,21 @@ async function runTraced(config) {
     childBuilder.endNode(childRootId);
     allGraphs.push(childBuilder.build());
   }
-  if (!(0, import_node_fs7.existsSync)(resolvedTracesDir)) {
-    (0, import_node_fs7.mkdirSync)(resolvedTracesDir, { recursive: true });
+  if (!(0, import_node_fs6.existsSync)(resolvedTracesDir)) {
+    (0, import_node_fs6.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_path7.join)(resolvedTracesDir, filename);
-    const resolvedOut = (0, import_node_path7.resolve)(outPath);
+    const outPath = (0, import_node_path6.join)(resolvedTracesDir, filename);
+    const resolvedOut = (0, import_node_path6.resolve)(outPath);
     if (!resolvedOut.startsWith(`${resolvedTracesDir}/`) && resolvedOut !== resolvedTracesDir) {
       throw new Error(
         `Path traversal detected: agentId "${graph.agentId}" escapes traces directory`
       );
     }
-    (0, import_node_fs7.writeFileSync)(outPath, JSON.stringify(graphToJson(graph), null, 2), "utf-8");
+    (0, import_node_fs6.writeFileSync)(outPath, JSON.stringify(graphToJson(graph), null, 2), "utf-8");
     tracePaths.push(outPath);
   }
   if (tracePaths.length > 0) {
@@ -3299,6 +3341,166 @@ async function runTraced(config) {
   };
 }
 
+// src/soma-event-writer.ts
+var import_node_fs7 = require("fs");
+var import_node_path7 = 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_fs7.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_fs7.writeFileSync)((0, import_node_path7.join)(inboxDir, fileName), markdown, "utf-8");
+    }
+  };
+}
+
 // src/trace-store.ts
 var import_promises = require("fs/promises");
 var import_node_path8 = require("path");
@@ -3417,7 +3619,7 @@ function formatDuration2(ms) {
   if (ms < 36e5) return `${(ms / 6e4).toFixed(1)}m`;
   return `${(ms / 36e5).toFixed(1)}h`;
 }
-function nodeDuration(node, graphEndTime) {
+function nodeDuration2(node, graphEndTime) {
   const end = node.endTime ?? graphEndTime;
   return formatDuration2(end - node.startTime);
 }
@@ -3451,7 +3653,7 @@ function toAsciiTree(graph) {
     const node = graph.nodes.get(nodeId);
     if (!node) return;
     const icon = STATUS_ICONS[node.status];
-    const duration = nodeDuration(node, endTime);
+    const duration = nodeDuration2(node, endTime);
     const genAi = getGenAiInfo(node);
     const violation = hasViolation(node, graph) ? " \u26A0" : "";
     const errorInfo = node.status === "failed" && node.metadata.error ? ` \u2014 ${node.metadata.error}` : "";
@@ -3527,7 +3729,7 @@ function toTimeline(graph) {
       }
     }
     const icon = STATUS_ICONS[node.status];
-    const duration = nodeDuration(node, graphEnd);
+    const duration = nodeDuration2(node, graphEnd);
     const violation = hasViolation(node, graph) ? " \u26A0" : "";
     lines.push(`${bar} ${icon} ${node.name} (${duration})${violation}`);
   }
@@ -3665,7 +3867,7 @@ function parseDuration(input) {
     const n = parseInt(input, 10);
     return Number.isNaN(n) ? 0 : n * 1e3;
   }
-  const value = parseFloat(match[1]);
+  const value = parseFloat(match[1] ?? "0");
   switch (match[2]?.toLowerCase()) {
     case "s":
       return value * 1e3;
@@ -3709,12 +3911,12 @@ function estimateInterval(history) {
   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];
+    const d = (sorted[i] ?? 0) - (sorted[i - 1] ?? 0);
     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)];
+  return deltas[Math.floor(deltas.length / 2)] ?? 0;
 }
 function detectTransitions(previous, currentRecords, config, now) {
   const alerts = [];
@@ -3871,7 +4073,7 @@ function parseWatchArgs(argv) {
   if (args[0] === "watch") args.shift();
   let i = 0;
   while (i < args.length) {
-    const arg = args[i];
+    const arg = args[i] ?? "";
     if (arg === "--help" || arg === "-h") {
       printWatchUsage();
       process.exit(0);
@@ -3940,7 +4142,7 @@ function parseWatchArgs(argv) {
   }
   notifyChannels.unshift({ type: "stdout" });
   if (!stateFilePath) {
-    stateFilePath = (0, import_node_path9.join)(dirs[0], ".agentflow-watch-state.json");
+    stateFilePath = (0, import_node_path9.join)(dirs[0] ?? ".", ".agentflow-watch-state.json");
   }
   return {
     dirs,
@@ -4103,11 +4305,13 @@ agentflow watch started`);
   createPolicySource,
   createSomaEventWriter,
   createTraceStore,
+  discoverAllProcessConfigs,
   discoverProcess,
   discoverProcessConfig,
   findVariants,
   findWaitingOn,
   formatAuditReport,
+  formatReceipt,
   getBottlenecks,
   getChildren,
   getCriticalPath,
@@ -4129,6 +4333,7 @@ agentflow watch started`);
   startWatch,
   stitchTrace,
   toAsciiTree,
+  toReceipt,
   toTimeline,
   withGuards
 });