agentflow-dashboard 0.8.4 → 0.9.0

package/dist/dist-H4QMTTY3.js

@@ -0,0 +1,3223 @@
+import {
+  computePatternSignature,
+  computeToolPatternSignature,
+  createGuardedBuilder,
+  createVault,
+  detectDrift,
+  evaluateAssertions,
+  extractDecisionsFromLangChain,
+  extractDecisionsFromNodes,
+  extractDecisionsFromSession,
+  extractWikilinks,
+  findVariantsWithModel,
+  getAgentBriefingData,
+  getDecisionReplayData,
+  getEfficiency,
+  parseEntity,
+  serializeEntity,
+  trackConformanceTrend,
+  vaultEntityCount,
+  vaultFingerprint
+} from "./chunk-LZXEKWRO.js";
+import "./chunk-3RG5ZIWI.js";
+
+// ../../../soma/dist/index.js
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { mkdirSync } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { join, basename, extname } from "path";
+import { createHash } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { createHash as createHash2 } from "crypto";
+import { dirname as dirname3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { dirname as dirname4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6 } from "fs";
+import { dirname as dirname5 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync } from "fs";
+import { join as join2, extname as extname2, basename as basename2 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+var KNOWLEDGE_LAYERS = ["archive", "working", "emerging", "canon"];
+var LAYER_SEMANTIC_WEIGHTS = {
+  archive: "historical",
+  working: "contextual",
+  emerging: "advisory",
+  canon: "mandatory"
+};
+var ENTITY_STATUSES = {
+  agent: ["active", "inactive", "deprecated"],
+  execution: ["completed", "failed", "running", "pending"],
+  archetype: ["active", "proposed", "deprecated"],
+  insight: ["active", "superseded", "rejected"],
+  policy: ["active", "draft", "deprecated", "enforcing"],
+  decision: ["active", "superseded", "reversed", "flagged"],
+  assumption: ["active", "validated", "invalidated"],
+  constraint: ["active", "resolved", "deprecated"],
+  contradiction: ["active", "resolved"],
+  synthesis: ["active", "superseded"],
+  content: ["active", "superseded"]
+};
+function resolveAgentId(entity) {
+  return entity.agentId ?? entity.agent_id;
+}
+var WORKER_WRITE_PERMISSIONS = {
+  harvester: ["archive"],
+  reconciler: ["archive"],
+  synthesizer: ["emerging"],
+  cartographer: ["emerging"],
+  governance: ["canon"],
+  "team-context": ["working"],
+  "policy-bridge": []
+  // read-only
+};
+var LAYER_REQUIRED_FIELDS = {
+  archive: ["layer", "source_worker"],
+  working: ["layer", "source_worker", "team_id", "decay_at"],
+  emerging: ["layer", "source_worker", "confidence_score", "evidence_links", "decay_at"],
+  canon: ["layer", "source_worker", "ratified_by", "ratified_at", "origin_l3_id"]
+};
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length || a.length === 0) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  return denominator === 0 ? 0 : dotProduct / denominator;
+}
+function createJsonVectorStore(filePath) {
+  let vectors = /* @__PURE__ */ new Map();
+  let dirty = false;
+  function load() {
+    if (existsSync(filePath)) {
+      try {
+        const data = JSON.parse(readFileSync(filePath, "utf-8"));
+        vectors = new Map(data.map((v) => [v.id, v]));
+      } catch {
+        vectors = /* @__PURE__ */ new Map();
+      }
+    }
+  }
+  function save() {
+    if (!dirty) return;
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(filePath, JSON.stringify([...vectors.values()]), "utf-8");
+    dirty = false;
+  }
+  function matchesFilter(metadata, filter) {
+    for (const [key, value] of Object.entries(filter)) {
+      const actual = metadata[key];
+      if (Array.isArray(value)) {
+        if (!value.includes(actual)) return false;
+      } else if (typeof value === "object" && value !== null) {
+        const range = value;
+        const num = typeof actual === "number" ? actual : Number.NaN;
+        if (range.min !== void 0 && num < range.min) return false;
+        if (range.max !== void 0 && num > range.max) return false;
+      } else {
+        if (actual !== value) return false;
+      }
+    }
+    return true;
+  }
+  load();
+  return {
+    async upsert(id, vector, metadata) {
+      vectors.set(id, { id, vector, metadata });
+      dirty = true;
+      save();
+    },
+    async delete(id) {
+      vectors.delete(id);
+      dirty = true;
+      save();
+    },
+    async search(queryVector, options) {
+      const limit = (options == null ? void 0 : options.limit) ?? 10;
+      const filter = options == null ? void 0 : options.filter;
+      const scored = [];
+      for (const stored of vectors.values()) {
+        if (filter && !matchesFilter(stored.metadata, filter)) continue;
+        const score = cosineSimilarity(queryVector, stored.vector);
+        scored.push({ id: stored.id, score, metadata: stored.metadata });
+      }
+      scored.sort((a, b) => b.score - a.score);
+      return scored.slice(0, limit);
+    },
+    async count() {
+      return vectors.size;
+    }
+  };
+}
+function createLanceVectorStore(_dirPath) {
+  throw new Error(
+    "LanceDB vector store not yet implemented. Install @lancedb/lancedb and check back. For now, use createJsonVectorStore() as the default."
+  );
+}
+function createMilvusVectorStore(_url) {
+  throw new Error(
+    "Milvus vector store not yet implemented. For now, use createJsonVectorStore() as the default."
+  );
+}
+var _layersConfig = {};
+function setLayersConfig(config) {
+  _layersConfig = config;
+}
+function isLayerEnabled(layer) {
+  var _a;
+  if (layer === "working") return ((_a = _layersConfig.working) == null ? void 0 : _a.enabled) ?? false;
+  return true;
+}
+function validateLayerFields(entity) {
+  const errors = [];
+  const layer = entity.layer;
+  if (!layer) return [];
+  if (layer === "working" && !isLayerEnabled("working")) return [];
+  const requiredFields = LAYER_REQUIRED_FIELDS[layer];
+  if (!requiredFields) {
+    errors.push({ field: "layer", message: `Unknown layer: ${layer}` });
+    return errors;
+  }
+  for (const field of requiredFields) {
+    const value = entity[field];
+    if (value === void 0 || value === null) {
+      errors.push({ field, message: `Missing required field '${field}' for layer '${layer}'` });
+    }
+  }
+  if (layer === "working" && entity.team_id !== void 0 && entity.team_id === "") {
+    errors.push({ field: "team_id", message: "team_id must be a non-empty string for L2 entries" });
+  }
+  if (layer === "emerging" && entity.confidence_score !== void 0) {
+    if (entity.confidence_score < 0 || entity.confidence_score > 1) {
+      errors.push({ field: "confidence_score", message: "confidence_score must be between 0.0 and 1.0" });
+    }
+  }
+  if (layer === "emerging" && entity.evidence_links !== void 0 && !Array.isArray(entity.evidence_links)) {
+    errors.push({ field: "evidence_links", message: "evidence_links must be an array" });
+  }
+  if ((layer === "archive" || layer === "canon") && entity.decay_at) {
+    errors.push({ field: "decay_at", message: `L${layer === "archive" ? "1" : "4"} entries must not have decay_at` });
+  }
+  return errors;
+}
+var LayerPermissionError = class extends Error {
+  constructor(worker, layer, permittedLayers) {
+    super(`Worker '${worker}' is not authorized to write to layer '${layer}'. Permitted layers: [${permittedLayers.join(", ")}]`);
+    this.worker = worker;
+    this.layer = layer;
+    this.permittedLayers = permittedLayers;
+    this.name = "LayerPermissionError";
+  }
+};
+function enforceWritePermission(worker, layer) {
+  const permitted = WORKER_WRITE_PERMISSIONS[worker];
+  if (!permitted) {
+    throw new LayerPermissionError(worker, layer, []);
+  }
+  if (!permitted.includes(layer)) {
+    throw new LayerPermissionError(worker, layer, permitted);
+  }
+}
+function canWrite(worker, layer) {
+  const permitted = WORKER_WRITE_PERMISSIONS[worker];
+  return permitted !== void 0 && permitted.includes(layer);
+}
+function queryByLayer(vault, layer, filter) {
+  return vault.listByLayer(layer, filter);
+}
+function writeToLayer(vault, worker, layer, entity) {
+  if (!isLayerEnabled(layer)) {
+    throw new Error(`Layer '${layer}' is disabled. Set layers.working.enabled=true to enable.`);
+  }
+  enforceWritePermission(worker, layer);
+  const layered = {
+    ...entity,
+    layer,
+    source_worker: worker
+  };
+  const errors = validateLayerFields(layered);
+  if (errors.length > 0) {
+    const messages = errors.map((e) => `${e.field}: ${e.message}`).join("; ");
+    throw new Error(`Layer validation failed for '${layer}': ${messages}`);
+  }
+  return vault.create(layered);
+}
+function getNodes(graph) {
+  if (graph.nodes instanceof Map) {
+    return [...graph.nodes.values()];
+  }
+  return Object.values(graph.nodes);
+}
+function getNode(graph, id) {
+  if (graph.nodes instanceof Map) {
+    return graph.nodes.get(id);
+  }
+  return graph.nodes[id];
+}
+function isExecutionGraph(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const o = obj;
+  return "nodes" in o && (o.nodes instanceof Map || typeof o.nodes === "object" && o.nodes !== null) && ("edges" in o && Array.isArray(o.edges)) && ("agentId" in o && typeof o.agentId === "string");
+}
+function extractDecisionsFromGraph(graph) {
+  var _a;
+  const decisions = [];
+  const nodes = getNodes(graph);
+  const nonRootNodes = nodes.filter((n) => n.parentId !== null);
+  const hasExplicitDecisionEvents = (_a = graph.events) == null ? void 0 : _a.some((e) => e.eventType === "decision" || e.eventType === "subagent_spawn");
+  if (nonRootNodes.length === 0 && !hasExplicitDecisionEvents) return decisions;
+  for (const node of nodes) {
+    if (node.type === "tool") {
+      decisions.push({
+        decision_type: "tool_choice",
+        choice: node.name,
+        outcome: node.status,
+        decision_context: {
+          ...node.metadata,
+          ...node.state ?? {},
+          duration: node.endTime != null && node.startTime ? node.endTime - node.startTime : void 0
+        },
+        agent_id: graph.agentId,
+        graph_id: graph.id,
+        node_id: node.id
+      });
+    }
+  }
+  for (const edge of graph.edges) {
+    if (edge.type === "branched") {
+      const targetNode = getNode(graph, edge.to);
+      const sourceNode = getNode(graph, edge.from);
+      if (!targetNode || !sourceNode) continue;
+      const siblings = nodes.filter(
+        (n) => n.parentId === sourceNode.id && n.id !== targetNode.id
+      );
+      decisions.push({
+        decision_type: "branch",
+        choice: targetNode.name,
+        alternatives: siblings.map((s) => s.name),
+        outcome: targetNode.status,
+        decision_context: {
+          source_node: sourceNode.name,
+          ...targetNode.metadata
+        },
+        agent_id: graph.agentId,
+        graph_id: graph.id,
+        node_id: targetNode.id
+      });
+    }
+  }
+  const retryEdges = graph.edges.filter((e) => e.type === "retried");
+  if (retryEdges.length > 0) {
+    const retryGroups = /* @__PURE__ */ new Map();
+    for (const edge of retryEdges) {
+      const group = retryGroups.get(edge.to) ?? [];
+      group.push(edge);
+      retryGroups.set(edge.to, group);
+    }
+    for (const [targetId, edges] of retryGroups) {
+      const targetNode = getNode(graph, targetId);
+      if (!targetNode) continue;
+      decisions.push({
+        decision_type: "retry",
+        choice: targetNode.name,
+        outcome: targetNode.status,
+        decision_context: {
+          retry_count: edges.length,
+          ...targetNode.metadata
+        },
+        agent_id: graph.agentId,
+        graph_id: graph.id,
+        node_id: targetNode.id
+      });
+    }
+  }
+  for (const node of nodes) {
+    if (node.type === "subagent") {
+      decisions.push({
+        decision_type: "delegation",
+        choice: node.name,
+        outcome: node.status,
+        decision_context: {
+          parent_agent: graph.agentId,
+          ...node.metadata
+        },
+        agent_id: graph.agentId,
+        graph_id: graph.id,
+        node_id: node.id
+      });
+    }
+  }
+  if (graph.events) {
+    for (const event of graph.events) {
+      if (event.eventType === "subagent_spawn") {
+        const alreadyCaptured = decisions.some(
+          (d) => d.decision_type === "delegation" && d.node_id === event.nodeId
+        );
+        if (!alreadyCaptured) {
+          decisions.push({
+            decision_type: "delegation",
+            choice: String(event.data.name ?? event.data.agentId ?? `unattributed:node-${event.nodeId}`),
+            outcome: "spawned",
+            decision_context: { ...event.data },
+            agent_id: graph.agentId,
+            graph_id: graph.id,
+            node_id: event.nodeId
+          });
+        }
+      }
+    }
+  }
+  const failedNodes = nodes.filter((n) => n.status === "failed");
+  for (const failedNode of failedNodes) {
+    const path = [];
+    let current = failedNode;
+    while (current) {
+      path.unshift(current.name);
+      current = current.parentId ? getNode(graph, current.parentId) : void 0;
+    }
+    decisions.push({
+      decision_type: "failure",
+      choice: failedNode.name,
+      outcome: "failed",
+      decision_context: {
+        error: failedNode.metadata.error ?? failedNode.metadata.errorMessage,
+        error_stack: failedNode.metadata.errorStack,
+        failure_path: path,
+        ...failedNode.metadata
+      },
+      agent_id: graph.agentId,
+      graph_id: graph.id,
+      node_id: failedNode.id
+    });
+  }
+  if (graph.events) {
+    for (const event of graph.events) {
+      if (event.eventType === "custom" && event.data.action === "state_update") {
+        const matchingDecision = decisions.find((d) => d.node_id === event.nodeId);
+        if (matchingDecision) {
+          const { action, ...stateData } = event.data;
+          Object.assign(matchingDecision.decision_context, stateData);
+        }
+      }
+    }
+  }
+  if (graph.events) {
+    for (const event of graph.events) {
+      if (event.eventType === "decision") {
+        decisions.push({
+          decision_type: event.data.decision_type ?? "tool_choice",
+          choice: String(event.data.choice ?? "unattributed"),
+          alternatives: Array.isArray(event.data.alternatives) ? event.data.alternatives.map(String) : void 0,
+          rationale: event.data.rationale ? String(event.data.rationale) : void 0,
+          outcome: String(event.data.outcome ?? "unattributed"),
+          decision_context: { ...event.data },
+          agent_id: graph.agentId,
+          graph_id: graph.id,
+          node_id: event.nodeId
+        });
+      }
+    }
+  }
+  return decisions;
+}
+function decisionsToEntities(decisions) {
+  return decisions.map((d) => ({
+    type: "decision",
+    name: `${d.decision_type}: ${d.choice} (${d.agent_id})`,
+    status: "active",
+    decision_type: d.decision_type,
+    choice: d.choice,
+    alternatives: d.alternatives,
+    rationale: d.rationale ?? "",
+    outcome: d.outcome,
+    decision_context: d.decision_context,
+    graph_id: d.graph_id,
+    agent_id: d.agent_id,
+    claim: `Agent ${d.agent_id} ${d.decision_type === "tool_choice" ? "used tool" : d.decision_type === "branch" ? "chose branch" : d.decision_type === "retry" ? "retried" : d.decision_type === "delegation" ? "delegated to" : "failed at"} "${d.choice}"`,
+    confidence: "medium",
+    evidence: [],
+    sourceIds: [d.graph_id],
+    tags: ["graph-inferred", d.decision_type],
+    related: [`execution/${d.graph_id}`],
+    body: buildDecisionBody(d)
+  }));
+}
+function buildDecisionBody(d) {
+  var _a;
+  const lines = [`## ${d.decision_type}: ${d.choice}
+`];
+  lines.push(`Agent **${d.agent_id}** made a ${d.decision_type} decision.`);
+  lines.push(`- **Choice:** ${d.choice}`);
+  if ((_a = d.alternatives) == null ? void 0 : _a.length) lines.push(`- **Alternatives:** ${d.alternatives.join(", ")}`);
+  if (d.rationale) lines.push(`- **Rationale:** ${d.rationale}`);
+  lines.push(`- **Outcome:** ${d.outcome}`);
+  if (d.decision_context.error) lines.push(`- **Error:** ${d.decision_context.error}`);
+  return lines.join("\n");
+}
+var DEFAULT_MAX_LENGTH = 2e3;
+var DEFAULT_MIN_LENGTH = 50;
+var DEFAULT_DENYLIST = ["process", "sleep", "poll", "clear", "remove"];
+function extractContentFromSession(events, config) {
+  if (!config.enabled) return [];
+  const maxLen = config.maxContentLength ?? DEFAULT_MAX_LENGTH;
+  const minLen = config.minContentLength ?? DEFAULT_MIN_LENGTH;
+  const denylist = new Set(config.toolDenylist ?? DEFAULT_DENYLIST);
+  const allowlist = config.toolAllowlist ? new Set(config.toolAllowlist) : null;
+  const extractToolResults = config.extractToolResults ?? true;
+  const extractReasoning = config.extractReasoning ?? true;
+  const extractOutputs = config.extractOutputs ?? true;
+  const artifacts = [];
+  let lastToolName = "";
+  for (const evt of events) {
+    const evtType = evt.type;
+    if (evtType === "message") {
+      const msg = evt.message;
+      if (!msg) continue;
+      const role = msg.role;
+      const content = msg.content;
+      const blocks = Array.isArray(content) ? content : [];
+      if (role === "assistant") {
+        for (const block of blocks) {
+          const blockType = block.type;
+          if (blockType === "thinking" && extractReasoning) {
+            const text = String(block.thinking ?? block.text ?? "");
+            if (text.length >= minLen) {
+              artifacts.push({
+                contentType: "agent_reasoning",
+                body: text.slice(0, maxLen),
+                tags: ["content", "reasoning"]
+              });
+            }
+          }
+          if (blockType === "toolCall" || blockType === "tool_use") {
+            lastToolName = String(block.name ?? "");
+          }
+          if (extractOutputs && (blockType === "toolCall" || blockType === "tool_use")) {
+            const toolName = String(block.name ?? "");
+            const input = block.input ?? block.arguments ?? {};
+            const inputStr = JSON.stringify(input);
+            if (toolName === "write" || toolName === "writeFile" || inputStr.includes("writeFileSync") || inputStr.includes("clemo-second-brain") || inputStr.includes("/inbox/")) {
+              const filePath = input.path ?? input.filePath ?? input.file_path ?? extractPathFromArgs(inputStr);
+              if (filePath) {
+                artifacts.push({
+                  contentType: "generated_output",
+                  sourceTool: toolName,
+                  body: `Output written to: ${filePath}`,
+                  filePath,
+                  tags: ["content", "generated-output", toolName]
+                });
+              }
+            }
+          }
+        }
+      }
+      if (role === "toolResult" && extractToolResults) {
+        const toolName = lastToolName || "unknown";
+        if (allowlist && !allowlist.has(toolName)) continue;
+        if (!allowlist && denylist.has(toolName)) continue;
+        const text = blocksToText(blocks);
+        if (text.length >= minLen) {
+          artifacts.push({
+            contentType: "tool_result",
+            sourceTool: toolName,
+            body: text.slice(0, maxLen),
+            tags: ["content", "tool-result", toolName]
+          });
+        }
+      }
+    }
+    if (evtType === "tool_use" || evtType === "toolCall") {
+      lastToolName = String(evt.name ?? evt.toolName ?? "");
+    }
+    if (evtType === "tool_result" || evtType === "toolResult") {
+      if (!extractToolResults) continue;
+      const toolName = lastToolName || "unknown";
+      if (allowlist && !allowlist.has(toolName)) continue;
+      if (!allowlist && denylist.has(toolName)) continue;
+      const text = String(evt.content ?? evt.output ?? evt.text ?? "");
+      if (text.length >= minLen) {
+        artifacts.push({
+          contentType: "tool_result",
+          sourceTool: toolName,
+          body: text.slice(0, maxLen),
+          tags: ["content", "tool-result", toolName]
+        });
+      }
+    }
+  }
+  return artifacts;
+}
+function blocksToText(blocks) {
+  return blocks.map((b) => String(b.text ?? b.content ?? "")).filter(Boolean).join("\n");
+}
+function extractPathFromArgs(argsStr) {
+  const match = argsStr.match(/"(?:path|filePath|file_path|destination)"\s*:\s*"([^"]+)"/);
+  if (match == null ? void 0 : match[1]) return match[1];
+  const pathMatch = argsStr.match(/\/home\/[^"'\s]+\.\w+/);
+  return (pathMatch == null ? void 0 : pathMatch[0]) ?? null;
+}
+var DEFAULT_STATE_FILE = ".soma/harvester-state.json";
+var jsonParser = (content) => {
+  const data = JSON.parse(content);
+  const events = Array.isArray(data) ? data : [data];
+  return { events };
+};
+var jsonlParser = (content) => {
+  const events = content.trim().split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  return { events };
+};
+var markdownParser = (content, fileName) => {
+  return {
+    entities: [{
+      type: "note",
+      name: basename(fileName, ".md"),
+      body: content,
+      tags: ["inbox"]
+    }]
+  };
+};
+var DEFAULT_PARSERS = {
+  ".json": jsonParser,
+  ".jsonl": jsonlParser,
+  ".md": markdownParser
+};
+function createHarvester(vault, config) {
+  void (config == null ? void 0 : config.concurrency);
+  const stateFile = (config == null ? void 0 : config.stateFile) ?? DEFAULT_STATE_FILE;
+  const parsers = { ...DEFAULT_PARSERS, ...config == null ? void 0 : config.parsers };
+  const contentConfig = (config == null ? void 0 : config.contentExtraction) ?? { enabled: false };
+  let state = { processedEventIds: /* @__PURE__ */ new Set(), lastProcessedTimestamp: 0 };
+  try {
+    if (existsSync2(stateFile)) {
+      const raw = JSON.parse(readFileSync2(stateFile, "utf-8"));
+      const currentCount = vaultEntityCount(vault.baseDir);
+      if (raw.entityCount == null && raw.vaultFingerprint) {
+        console.log("[Harvester] Migrating state from vaultFingerprint to entityCount");
+        state = { processedEventIds: /* @__PURE__ */ new Set(), lastProcessedTimestamp: 0, entityCount: currentCount };
+      } else if (raw.entityCount != null && currentCount < raw.entityCount) {
+        console.log(`[Harvester] Vault entity count decreased (${raw.entityCount} \u2192 ${currentCount}) \u2014 resetting state`);
+        state = { processedEventIds: /* @__PURE__ */ new Set(), lastProcessedTimestamp: 0, entityCount: currentCount };
+      } else {
+        state = {
+          processedEventIds: new Set(raw.processedEventIds ?? []),
+          lastProcessedTimestamp: raw.lastProcessedTimestamp ?? 0,
+          entityCount: currentCount
+        };
+      }
+    }
+  } catch {
+  }
+  function saveState() {
+    const dir = join(stateFile, "..");
+    if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+    const raw = {
+      processedEventIds: [...state.processedEventIds].slice(-1e4),
+      // Keep last 10K
+      lastProcessedTimestamp: state.lastProcessedTimestamp,
+      entityCount: state.entityCount ?? vaultEntityCount(vault.baseDir)
+    };
+    writeFileSync2(stateFile, JSON.stringify(raw, null, 2), "utf-8");
+  }
+  function eventId(event) {
+    return `${event.agentId}-${event.timestamp}`;
+  }
+  function normalizeId(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  }
+  function ensureAgentEntity(agentId) {
+    const id = normalizeId(agentId);
+    const existing = vault.read("agent", id);
+    if (!existing) {
+      writeToLayer(vault, "harvester", "archive", {
+        type: "agent",
+        id,
+        name: agentId,
+        agentId,
+        status: "active",
+        tags: ["agent-layer"]
+      });
+    }
+  }
+  function isDuplicateTrace(traceId) {
+    if (state.processedEventIds.has(traceId)) return true;
+    const existing = vault.list("execution", { limit: 5e3 });
+    return existing.some((e) => e.trace_id === traceId);
+  }
+  function createExecutionEntity(event, decisions) {
+    var _a;
+    const agentNormId = normalizeId(event.agentId);
+    const execId = `exec-${event.agentId}-${event.timestamp}`;
+    const traceId = `${event.agentId}-${event.timestamp}`;
+    if (isDuplicateTrace(traceId)) {
+      console.log(`[Harvester] Duplicate trace skipped: ${traceId}`);
+      return;
+    }
+    const eventData = event;
+    const metadata = eventData.metadata;
+    const aicp = metadata == null ? void 0 : metadata.aicp;
+    let allDecisions = decisions ? [...decisions] : [];
+    if (aicp == null ? void 0 : aicp.consulted) {
+      allDecisions.push({
+        action: "aicp-preflight",
+        outcome: aicp.proceed ? "ok" : "failed",
+        reasoning: `AICP: ${aicp.warnings ?? 0} warnings, ${aicp.recommendations ?? 0} recommendations`,
+        index: allDecisions.length
+      });
+    }
+    const decisionPattern = allDecisions.length > 0 ? computePatternSignature(allDecisions) : void 0;
+    writeToLayer(vault, "harvester", "archive", {
+      type: "execution",
+      id: normalizeId(execId),
+      name: `${event.agentId} execution at ${new Date(event.timestamp).toISOString()}`,
+      agentId: event.agentId,
+      agent_id: event.agentId,
+      trace_id: traceId,
+      source_system: "agentflow",
+      status: event.status === "completed" ? "completed" : event.status === "failed" ? "failed" : "running",
+      duration: event.duration,
+      nodeCount: event.nodeCount,
+      variant: event.pathSignature,
+      conformanceScore: (_a = event.processContext) == null ? void 0 : _a.conformanceScore,
+      trigger: "event",
+      decisions: allDecisions.length > 0 ? allDecisions : void 0,
+      decisionPattern,
+      tags: ["agent-layer", event.agentId],
+      related: [`agent/${agentNormId}`],
+      body: `Execution of ${event.agentId}. Duration: ${event.duration}ms. Nodes: ${event.nodeCount}. Status: ${event.status}.`
+    });
+    const agent = vault.read("agent", agentNormId);
+    if (agent) {
+      const execRef = `execution/${normalizeId(execId)}`;
+      if (!agent.related.includes(execRef)) {
+        const updatedRelated = [...agent.related, execRef].slice(-50);
+        vault.update(agentNormId, { related: updatedRelated });
+      }
+    }
+  }
+  function updateAgentProfile(event) {
+    const id = normalizeId(event.agentId);
+    const agent = vault.read("agent", id);
+    if (!agent) return;
+    const totalExec = (agent.totalExecutions ?? 0) + 1;
+    const failCount = agent.failureCount ?? 0;
+    const newFails = event.eventType === "execution.failed" ? failCount + 1 : failCount;
+    vault.update(id, {
+      totalExecutions: totalExec,
+      failureCount: newFails,
+      failureRate: totalExec > 0 ? newFails / totalExec : 0
+    });
+  }
+  return {
+    /**
+     * Ingest execution and pattern events from AgentFlow.
+     * Returns the number of events ingested (skipping already-processed).
+     */
+    async ingest(events) {
+      let ingested = 0;
+      for (const event of events) {
+        const eid = eventId(event);
+        if (state.processedEventIds.has(eid)) continue;
+        ensureAgentEntity(event.agentId);
+        if (event.eventType === "execution.completed" || event.eventType === "execution.failed") {
+          createExecutionEntity(event);
+          updateAgentProfile(event);
+        }
+        if (event.eventType === "pattern.discovered" || event.eventType === "pattern.updated") {
+        }
+        state.processedEventIds.add(eid);
+        state.lastProcessedTimestamp = Math.max(state.lastProcessedTimestamp, event.timestamp);
+        ingested++;
+      }
+      if (ingested > 0) saveState();
+      return ingested;
+    },
+    /**
+     * Process files from an inbox directory.
+     * Each file is parsed, entities created, then moved to processed/.
+     */
+    async processInbox(inboxDir) {
+      var _a, _b;
+      if (!existsSync2(inboxDir)) return 0;
+      const processedDir = join(inboxDir, "..", "processed");
+      const errorsDir = join(inboxDir, "..", "errors");
+      if (!existsSync2(processedDir)) mkdirSync2(processedDir, { recursive: true });
+      if (!existsSync2(errorsDir)) mkdirSync2(errorsDir, { recursive: true });
+      const supportedExts = Object.keys(parsers);
+      const files = readdirSync(inboxDir).filter((f) => supportedExts.includes(extname(f)));
+      let processed = 0;
+      for (const file of files) {
+        const filePath = join(inboxDir, file);
+        try {
+          const content = readFileSync2(filePath, "utf-8");
+          const ext = extname(file);
+          const parser = parsers[ext];
+          if (!parser) continue;
+          const result = parser(content, file);
+          if ((_a = result.events) == null ? void 0 : _a.length) {
+            for (const event of result.events) {
+              if (isExecutionGraph(event)) {
+                await this.ingestGraph(event);
+              }
+            }
+            await this.ingest(result.events.filter((e) => !isExecutionGraph(e)));
+            if (contentConfig.enabled) {
+              const rawEvents = ext === ".jsonl" ? content.trim().split("\n").filter(Boolean).map((l) => {
+                try {
+                  return JSON.parse(l);
+                } catch {
+                  return null;
+                }
+              }).filter(Boolean) : result.events;
+              const contentArtifacts = extractContentFromSession(rawEvents, contentConfig);
+              const firstEvt = result.events[0];
+              const execId = (firstEvt == null ? void 0 : firstEvt.agentId) ? `exec-${firstEvt.agentId}-${firstEvt.timestamp}` : null;
+              for (let ci = 0; ci < contentArtifacts.length; ci++) {
+                const artifact = contentArtifacts[ci];
+                const contentId = `content-${file.replace(/\.\w+$/, "")}-${ci}`;
+                try {
+                  const agentIdStr = (firstEvt == null ? void 0 : firstEvt.agentId) ? String(firstEvt.agentId) : void 0;
+                  writeToLayer(vault, "harvester", "archive", {
+                    type: "content",
+                    id: normalizeId(contentId),
+                    name: `${artifact.contentType}: ${(artifact.sourceTool ?? artifact.contentType).slice(0, 40)}`,
+                    status: "active",
+                    content_type: artifact.contentType,
+                    source_tool: artifact.sourceTool,
+                    source_execution: execId ? normalizeId(execId) : void 0,
+                    agent_id: agentIdStr,
+                    agentId: agentIdStr,
+                    file_path: artifact.filePath,
+                    tags: agentIdStr ? [...artifact.tags, agentIdStr] : artifact.tags,
+                    related: execId ? [`execution/${normalizeId(execId)}`] : [],
+                    body: artifact.body
+                  });
+                } catch {
+                }
+              }
+            }
+          }
+          if ((_b = result.entities) == null ? void 0 : _b.length) {
+            for (const entity of result.entities) {
+              writeToLayer(vault, "harvester", "archive", entity);
+            }
+          }
+          renameSync(filePath, join(processedDir, file));
+          processed++;
+        } catch (err) {
+          try {
+            renameSync(filePath, join(errorsDir, file));
+          } catch (moveErr) {
+            console.warn(`[Harvester] Failed to move ${file} to errors dir:`, moveErr.message);
+          }
+          console.error(`Harvester error processing ${file}:`, err);
+        }
+      }
+      return processed;
+    },
+    /**
+     * Ingest a full ExecutionGraph, extracting decisions and writing them
+     * to L1 with stable trace_id (decision-graphId-nodeId).
+     * Returns the number of decision entities created.
+     */
+    async ingestGraph(graph) {
+      const graphNodes = graph.nodes;
+      const normalizedDecisions = extractDecisionsFromNodes(graphNodes);
+      const pattern = normalizedDecisions.length > 0 ? computePatternSignature(normalizedDecisions) : void 0;
+      if (graph.agentId && normalizedDecisions.length > 0) {
+        const execTraceId = `exec-${graph.agentId}-${Date.now()}`;
+        if (!isDuplicateTrace(execTraceId)) {
+          try {
+            writeToLayer(vault, "harvester", "archive", {
+              type: "execution",
+              id: normalizeId(execTraceId),
+              name: `${graph.agentId} execution`,
+              agentId: graph.agentId,
+              agent_id: graph.agentId,
+              trace_id: execTraceId,
+              source_system: "agentflow-graph",
+              status: graph.status ?? "completed",
+              decisions: normalizedDecisions,
+              decisionPattern: pattern,
+              tags: ["agent-layer", graph.agentId],
+              related: [],
+              body: ""
+            });
+            state.processedEventIds.add(execTraceId);
+          } catch {
+          }
+        }
+      }
+      const decisions = extractDecisionsFromGraph(graph);
+      if (decisions.length === 0) return normalizedDecisions.length > 0 ? 1 : 0;
+      const entities = decisionsToEntities(decisions);
+      let created = 0;
+      for (const entity of entities) {
+        const traceId = `decision-${entity.graph_id}-${entity.name.replace(/[^a-z0-9]+/gi, "-").toLowerCase()}`;
+        if (isDuplicateTrace(traceId)) continue;
+        try {
+          writeToLayer(vault, "harvester", "archive", {
+            ...entity,
+            trace_id: traceId,
+            source_system: "agentflow-graph"
+          });
+          state.processedEventIds.add(traceId);
+          created++;
+        } catch {
+        }
+      }
+      if (created > 0) saveState();
+      return created;
+    },
+    /** Get current state for debugging. */
+    getState() {
+      return {
+        processedCount: state.processedEventIds.size,
+        lastTimestamp: state.lastProcessedTimestamp
+      };
+    }
+  };
+}
+var DEFAULT_SCORE_THRESHOLD = 0.4;
+var DEFAULT_DEDUP_THRESHOLD = 0.7;
+var SCORING_KEYWORDS = [
+  { category: "decision", keywords: ["decided", "chose", "selected", "opted", "picked", "agreed", "concluded"], weight: 0.15 },
+  { category: "assumption", keywords: ["assumed", "expected", "believed", "thought", "predicted", "hypothesized"], weight: 0.15 },
+  { category: "constraint", keywords: ["must", "cannot", "required", "blocked", "limited", "restricted", "prevented"], weight: 0.15 },
+  { category: "contradiction", keywords: ["contradicts", "conflicts", "inconsistent", "disagrees", "but", "however", "although"], weight: 0.15 }
+];
+function overlapCoefficient(a, b) {
+  const setA = new Set(a.toLowerCase().split(/\s+/));
+  const setB = new Set(b.toLowerCase().split(/\s+/));
+  let intersection = 0;
+  for (const word of setA) if (setB.has(word)) intersection++;
+  const minSize = Math.min(setA.size, setB.size);
+  return minSize > 0 ? intersection / minSize : 0;
+}
+function isDuplicateInVault(vault, type, title, threshold = 0.7) {
+  const existing = vault.list(type);
+  return existing.some((e) => overlapCoefficient(e.name, title) >= threshold);
+}
+function md5(content) {
+  return createHash("md5").update(content).digest("hex");
+}
+function createSynthesizer(vault, analysisFn, config) {
+  const scoreThreshold = (config == null ? void 0 : config.scoreThreshold) ?? DEFAULT_SCORE_THRESHOLD;
+  const dedupThreshold = (config == null ? void 0 : config.dedupThreshold) ?? DEFAULT_DEDUP_THRESHOLD;
+  const stateFile = (config == null ? void 0 : config.stateFile) ?? ".soma/synthesizer-state.json";
+  let hashes = /* @__PURE__ */ new Map();
+  let lastAnalysisHash = "";
+  let savedEntityCount = 0;
+  try {
+    if (existsSync3(stateFile)) {
+      const raw = JSON.parse(readFileSync3(stateFile, "utf-8"));
+      const currentCount = vaultEntityCount(vault.baseDir);
+      if (raw.entityCount == null && raw.vaultFingerprint) {
+        console.log("[Synthesizer] Migrating state from vaultFingerprint to entityCount");
+        hashes = /* @__PURE__ */ new Map();
+        lastAnalysisHash = "";
+      } else if (raw.entityCount != null && currentCount < raw.entityCount) {
+        console.log(`[Synthesizer] Vault entity count decreased (${raw.entityCount} \u2192 ${currentCount}) \u2014 resetting state`);
+        hashes = /* @__PURE__ */ new Map();
+        lastAnalysisHash = "";
+      } else {
+        hashes = new Map(Object.entries(raw.hashes ?? {}));
+        lastAnalysisHash = raw.lastAnalysisHash ?? "";
+      }
+      savedEntityCount = currentCount;
+    }
+  } catch {
+  }
+  function saveState() {
+    const dir = dirname2(stateFile);
+    if (!existsSync3(dir)) mkdirSync3(dir, { recursive: true });
+    writeFileSync3(stateFile, JSON.stringify({
+      hashes: Object.fromEntries(hashes),
+      lastAnalysisHash,
+      entityCount: savedEntityCount ?? vaultEntityCount(vault.baseDir)
+    }), "utf-8");
+  }
+  function scoreCandidate(entity) {
+    let score = 0;
+    const text = `${entity.name} ${entity.body}`.toLowerCase();
+    score += Math.min(text.length / 3e3, 0.3);
+    for (const { keywords, weight } of SCORING_KEYWORDS) {
+      if (keywords.some((kw) => text.includes(kw))) score += weight;
+    }
+    if (text.includes("## outcome") || text.includes("## result")) score += 0.1;
+    if (text.includes("## context") || text.includes("## background")) score += 0.1;
+    return score;
+  }
+  function deduplicateSpecs(specs) {
+    const merged = [];
+    for (const spec of specs) {
+      let found = false;
+      for (const existing of merged) {
+        if (existing.type === spec.type && overlapCoefficient(existing.title, spec.title) >= dedupThreshold) {
+          existing.sourceCount += spec.sourceCount;
+          existing.evidence = [.../* @__PURE__ */ new Set([...existing.evidence, ...spec.evidence])];
+          existing.sourceIds = [.../* @__PURE__ */ new Set([...existing.sourceIds, ...spec.sourceIds])];
+          if (existing.sourceCount >= 3 && existing.confidence === "low") existing.confidence = "medium";
+          if (existing.sourceCount >= 2 && existing.confidence === "medium") existing.confidence = "high";
+          found = true;
+          break;
+        }
+      }
+      if (!found) merged.push({ ...spec });
+    }
+    const existingLearnings = [
+      ...vault.list("assumption"),
+      ...vault.list("decision"),
+      ...vault.list("constraint"),
+      ...vault.list("contradiction"),
+      ...vault.list("synthesis")
+    ];
+    return merged.filter((spec) => {
+      return !existingLearnings.some(
+        (existing) => overlapCoefficient(existing.name, spec.title) >= 0.8
+      );
+    });
+  }
+  return {
+    /**
+     * Run the full synthesis pipeline.
+     * Returns the number of learning records created.
+     */
+    async synthesize() {
+      const allEntities = [
+        ...vault.list("execution"),
+        ...vault.list("insight"),
+        ...vault.list("agent"),
+        ...vault.list("decision")
+      ].filter((e) => !e.tags.includes("synthesized") && !e.decayed_from);
+      const candidates = allEntities.filter((e) => {
+        const hash = md5(e.body);
+        if (hashes.get(e.id) === hash) return false;
+        hashes.set(e.id, hash);
+        return true;
+      }).filter((e) => scoreCandidate(e) >= scoreThreshold);
+      if (candidates.length === 0) {
+        saveState();
+        return 0;
+      }
+      const allSpecs = [];
+      for (const candidate of candidates) {
+        try {
+          const prompt = buildExtractionPrompt(candidate);
+          const response = await analysisFn(prompt);
+          const specs = parseExtractionResponse(response, candidate);
+          allSpecs.push(...specs);
+        } catch {
+        }
+      }
+      if (allSpecs.length === 0) {
+        saveState();
+        return 0;
+      }
+      const deduplicated = deduplicateSpecs(allSpecs);
+      let created = 0;
+      for (const spec of deduplicated) {
+        try {
+          const entityType = spec.type;
+          writeToLayer(vault, "synthesizer", "emerging", {
+            type: entityType,
+            name: spec.title,
+            status: "active",
+            claim: spec.claim,
+            confidence: spec.confidence,
+            confidence_score: spec.confidence === "high" ? 0.9 : spec.confidence === "medium" ? 0.6 : 0.3,
+            evidence: spec.evidence,
+            evidence_links: spec.sourceIds,
+            sourceIds: spec.sourceIds,
+            decay_at: new Date(Date.now() + 90 * 24 * 60 * 60 * 1e3).toISOString(),
+            tags: ["synthesized", spec.type],
+            related: spec.sourceIds.map((id) => `execution/${id}`),
+            body: `## ${spec.title}
+
+${spec.claim}
+
+### Evidence
+${spec.evidence.map((e) => `- ${e}`).join("\n")}`
+          });
+          created++;
+        } catch {
+        }
+      }
+      for (const spec of deduplicated) {
+        if (spec.confidence === "high" && (spec.type === "constraint" || spec.type === "decision")) {
+          try {
+            const policyPrompt = `Based on this ${spec.type}: "${spec.claim}", suggest a guard policy. Return JSON: { "scope": "...", "conditions": "...", "enforcement": "warn|error|abort", "thresholds": {} }`;
+            const policyResponse = await analysisFn(policyPrompt);
+            const policyData = JSON.parse(policyResponse);
+            if (!policyData.scope) console.warn(`[Synthesizer] Policy for '${spec.title}' missing scope`);
+            writeToLayer(vault, "synthesizer", "emerging", {
+              type: "policy",
+              name: `Policy: ${spec.title}`,
+              status: "draft",
+              scope: policyData.scope ?? "unattributed",
+              conditions: policyData.conditions ?? spec.claim,
+              enforcement: policyData.enforcement ?? "warn",
+              thresholds: policyData.thresholds,
+              confidence_score: 0.7,
+              evidence_links: spec.sourceIds,
+              decay_at: new Date(Date.now() + 90 * 24 * 60 * 60 * 1e3).toISOString(),
+              tags: ["synthesized", "auto-policy"],
+              related: [`${spec.type}/${spec.title}`],
+              body: `Auto-generated policy from ${spec.type}: ${spec.claim}`
+            });
+          } catch {
+          }
+        }
+      }
+      saveState();
+      return created;
+    },
+    /** Score a single entity (for testing/debugging). */
+    scoreCandidate,
+    /**
+     * Analyze agent-level statistics via LLM.
+     * Unlike synthesize() which scores individual entity bodies,
+     * this builds a rich prompt from aggregate agent data and
+     * asks the LLM to extract insights, patterns, and policy suggestions.
+     * Returns the number of learnings created.
+     */
+    async analyzeAgents() {
+      const agents = vault.list("agent");
+      if (agents.length === 0) return 0;
+      const agentSummaries = [];
+      for (const agent of agents) {
+        const data = agent;
+        const total = data.totalExecutions ?? 0;
+        if (total === 0) continue;
+        const failRate = data.failureRate ?? 0;
+        const failCount = Math.round(total * failRate);
+        agentSummaries.push(`- ${agent.name}: ${total} runs, ${failCount} failures (${(failRate * 100).toFixed(1)}%)`);
+      }
+      const statsString = agentSummaries.join("\n");
+      const currentHash = md5(statsString);
+      if (currentHash === lastAnalysisHash) {
+        console.log("[Soma Synthesizer] Agent stats unchanged \u2014 skipping analysis");
+        return 0;
+      }
+      const existingTypes = ["insight", "decision", "assumption", "constraint", "contradiction", "synthesis"];
+      const existingTitles = [];
+      for (const type of existingTypes) {
+        for (const e of vault.list(type)) {
+          if (e.tags.includes("synthesized")) existingTitles.push(`[${e.type}] ${e.name}`);
+        }
+      }
+      for (const p of vault.list("policy")) {
+        existingTitles.push(`[policy] ${p.name}`);
+      }
+      const existingKnowledgeSection = existingTitles.length > 0 ? `
+The following insights and policies ALREADY EXIST in the knowledge vault.
+Do NOT repeat or rephrase these. Only return genuinely NEW findings:
+${existingTitles.map((t) => `- ${t}`).join("\n")}
+` : "";
+      const prompt = `You are analyzing AI agent execution statistics from an organizational knowledge vault.
+
+Here are all agents and their performance:
+
+${statsString}
+${existingKnowledgeSection}
+Based on this data, extract NEW insights, decisions, constraints, and contradictions that are NOT already covered above.
+
+For each finding, return a JSON array:
+[
+  {
+    "type": "insight|decision|constraint|contradiction",
+    "title": "Short descriptive title",
+    "claim": "What was found or should be done",
+    "confidence": "low|medium|high",
+    "evidence": ["supporting data point 1", "supporting data point 2"],
+    "agentIds": ["agent-name-1"]
+  }
+]
+
+Focus on:
+- Agents with high failure rates \u2014 what policies should be enforced?
+- Patterns across agents \u2014 do similar agents fail similarly?
+- Reliability trends \u2014 which agents are healthy vs. problematic?
+- Suggested guard thresholds based on the data
+
+Return [] if all meaningful insights are already covered above.`;
+      try {
+        const response = await analysisFn(prompt);
+        if (!response) {
+          console.warn("[Soma Synthesizer] LLM returned empty response for agent analysis");
+          return 0;
+        }
+        const match = response.match(/\[[\s\S]*\]/);
+        if (!match) {
+          console.warn("[Soma Synthesizer] No JSON array found in LLM response (" + response.length + " chars)");
+          return 0;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(match[0]);
+        } catch {
+          let fixable = match[0];
+          const lastBrace = fixable.lastIndexOf("}");
+          if (lastBrace > 0) {
+            fixable = fixable.slice(0, lastBrace + 1) + "]";
+            try {
+              parsed = JSON.parse(fixable);
+            } catch {
+              console.warn("[Soma Synthesizer] Could not parse LLM JSON response (even after repair)");
+              return 0;
+            }
+          } else {
+            console.warn("[Soma Synthesizer] Could not parse LLM JSON response");
+            return 0;
+          }
+        }
+        if (!Array.isArray(parsed)) return 0;
+        console.log(`[Soma Synthesizer] Extracted ${parsed.length} insights from LLM`);
+        let created = 0;
+        let superseded = 0;
+        let skippedDupes = 0;
+        const confidenceRank = { high: 3, medium: 2, low: 1 };
+        for (const rawItem of parsed) {
+          const item = rawItem;
+          const entityType = String(item.type ?? "insight");
+          const title = String(item.title ?? "Untitled");
+          const claim = String(item.claim ?? "");
+          const confidence = String(item.confidence ?? "medium");
+          const evidence = Array.isArray(item.evidence) ? item.evidence.map(String) : [];
+          const agentIds = Array.isArray(item.agentIds) ? item.agentIds.map(String) : [];
+          const existingMatch = vault.list(entityType).find(
+            (e) => overlapCoefficient(e.name, title) >= dedupThreshold
+          );
+          if (existingMatch) {
+            const existingConf = existingMatch.confidence ?? "low";
+            const existingEvidence = existingMatch.evidence;
+            const existingEvidenceArr = Array.isArray(existingEvidence) ? existingEvidence.map(String) : [];
+            const newEvidenceItems = evidence.filter((ev) => !existingEvidenceArr.includes(ev));
+            if ((confidenceRank[confidence] ?? 0) > (confidenceRank[existingConf] ?? 0) || newEvidenceItems.length > 0) {
+              const mergedEvidence = [.../* @__PURE__ */ new Set([...existingEvidenceArr, ...evidence])];
+              const bestConfidence = (confidenceRank[confidence] ?? 0) >= (confidenceRank[existingConf] ?? 0) ? confidence : existingConf;
+              vault.update(existingMatch.id, {
+                claim,
+                confidence: bestConfidence,
+                evidence: mergedEvidence,
+                body: `## ${existingMatch.name}
+
+${claim}
+
+### Evidence
+${mergedEvidence.map((e) => `- ${e}`).join("\n")}`
+              });
+              superseded++;
+            } else {
+              skippedDupes++;
+            }
+            continue;
+          }
+          try {
+            writeToLayer(vault, "synthesizer", "emerging", {
+              type: entityType,
+              name: title,
+              status: "active",
+              claim,
+              confidence,
+              confidence_score: confidence === "high" ? 0.9 : confidence === "medium" ? 0.6 : 0.3,
+              evidence,
+              evidence_links: agentIds,
+              sourceIds: agentIds,
+              decay_at: new Date(Date.now() + 90 * 24 * 60 * 60 * 1e3).toISOString(),
+              tags: ["synthesized", entityType, "agent-analysis"],
+              related: agentIds.map((id) => `agent/${id}`),
+              body: `## ${title}
+
+${claim}
+
+### Evidence
+${evidence.map((e) => `- ${e}`).join("\n")}`
+            });
+            created++;
+          } catch {
+          }
+        }
+        if (skippedDupes > 0 || superseded > 0) {
+          console.log(`[Soma Synthesizer] ${skippedDupes} skipped, ${superseded} superseded, ${created} new`);
+        }
+        lastAnalysisHash = currentHash;
+        for (const rawItem2 of parsed) {
+          const item2 = rawItem2;
+          if (item2.confidence === "high" && (item2.type === "constraint" || item2.type === "decision")) {
+            const policyTitle = `Policy: ${item2.title}`;
+            if (isDuplicateInVault(vault, "policy", policyTitle, dedupThreshold)) {
+              continue;
+            }
+            try {
+              const policyPrompt = `Based on this ${item2.type}: "${item2.claim}", suggest a guard policy for an AI agent system. Return JSON: { "scope": "...", "conditions": "...", "enforcement": "warn|error|abort", "thresholds": {} }`;
+              const policyResponse = await analysisFn(policyPrompt);
+              const policyMatch = policyResponse.match(/\{[\s\S]*\}/);
+              if (policyMatch) {
+                const policyData = JSON.parse(policyMatch[0]);
+                if (!policyData.scope) console.warn(`[Synthesizer] Policy '${policyTitle}' missing scope`);
+                writeToLayer(vault, "synthesizer", "emerging", {
+                  type: "policy",
+                  name: policyTitle,
+                  status: "draft",
+                  scope: policyData.scope ?? "unattributed",
+                  conditions: policyData.conditions ?? item2.claim,
+                  enforcement: policyData.enforcement ?? "warn",
+                  thresholds: policyData.thresholds,
+                  confidence_score: 0.7,
+                  evidence_links: item2.agentIds ?? [],
+                  decay_at: new Date(Date.now() + 90 * 24 * 60 * 60 * 1e3).toISOString(),
+                  tags: ["synthesized", "auto-policy", "agent-analysis"],
+                  related: (item2.agentIds ?? []).map((id) => `agent/${id}`),
+                  body: `Auto-generated policy from ${item2.type}: ${item2.claim}`
+                });
+              }
+            } catch {
+            }
+          }
+        }
+        saveState();
+        return created;
+      } catch (err) {
+        console.error("[Soma Synthesizer] analyzeAgents error:", err instanceof Error ? err.message : String(err));
+        return 0;
+      }
+    },
+    /**
+     * Synthesize L1 entries into L3 proposals.
+     * Detects recurring patterns across multiple agent traces and
+     * generates L3 (Emerging Knowledge) proposals with confidence scores
+     * and evidence links to source L1 entries.
+     *
+     * Enforces write restriction: only L3 writes allowed.
+     */
+    async synthesizeL3() {
+      enforceWritePermission("synthesizer", "emerging");
+      const l1Entries = queryByLayer(vault, "archive");
+      if (l1Entries.length < 3) return 0;
+      const byAgent = /* @__PURE__ */ new Map();
+      for (const entry of l1Entries) {
+        if (!entry.agent_id) {
+          console.warn(`[Synthesizer] Skipping entry ${entry.id} from agent grouping: missing agent_id`);
+          continue;
+        }
+        if (!byAgent.has(entry.agent_id)) byAgent.set(entry.agent_id, []);
+        byAgent.get(entry.agent_id).push(entry);
+      }
+      const patternCandidates = [];
+      const l1Array = l1Entries.filter((e) => !e.superseded_by);
+      for (let i = 0; i < l1Array.length; i++) {
+        const entry = l1Array[i];
+        const matches = [entry.id];
+        const agents = new Set(entry.agent_id ? [entry.agent_id] : []);
+        for (let j = i + 1; j < l1Array.length; j++) {
+          const other = l1Array[j];
+          const similarity = overlapCoefficient(entry.body, other.body);
+          if (similarity >= 0.5) {
+            matches.push(other.id);
+            if (other.agent_id) agents.add(other.agent_id);
+          }
+        }
+        if (matches.length >= 3) {
+          patternCandidates.push({
+            content: entry.body,
+            evidenceIds: matches,
+            agentCount: agents.size,
+            sourceAgents: [...agents]
+          });
+        }
+      }
+      if (patternCandidates.length === 0) {
+        saveState();
+        return 0;
+      }
+      let created = 0;
+      const decayAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1e3).toISOString();
+      for (const candidate of patternCandidates.slice(0, 20)) {
+        try {
+          const prompt = `You are analyzing recurring patterns found across ${candidate.agentCount} agents and ${candidate.evidenceIds.length} traces.
+
+Pattern content sample:
+${candidate.content.slice(0, 2e3)}
+
+Synthesize this into a concise organizational knowledge proposal. Return JSON:
+{ "title": "Short title", "claim": "What was discovered", "confidence": 0.0-1.0 }
+
+Set confidence based on: number of supporting traces (${candidate.evidenceIds.length}), cross-agent corroboration (${candidate.agentCount} agents).`;
+          const response = await analysisFn(prompt);
+          const match = response.match(/\{[\s\S]*\}/);
+          if (!match) continue;
+          const data = JSON.parse(match[0]);
+          const confidenceScore = Math.max(0, Math.min(1, Number(data.confidence) || 0.5));
+          const existingL3 = queryByLayer(vault, "emerging");
+          const isDuplicate = existingL3.some(
+            (e) => overlapCoefficient(e.name, String(data.title)) >= dedupThreshold
+          );
+          if (isDuplicate) continue;
+          writeToLayer(vault, "synthesizer", "emerging", {
+            type: "insight",
+            name: String(data.title),
+            status: "pending",
+            confidence_score: confidenceScore,
+            evidence_links: candidate.evidenceIds,
+            source_agents: candidate.sourceAgents,
+            decay_at: decayAt,
+            tags: ["synthesized", "l3-proposal"],
+            related: candidate.evidenceIds.map((id) => `execution/${id}`),
+            body: `## ${data.title}
+
+${data.claim}
+
+### Evidence
+Based on ${candidate.evidenceIds.length} traces across ${candidate.agentCount} agents.`
+          });
+          created++;
+        } catch {
+        }
+      }
+      saveState();
+      return created;
+    },
+    /**
+     * Synthesize decision entities into L3 proposals via pattern clustering.
+     * Groups decisions by decision_type and agent, detects recurring patterns,
+     * and generates L3 proposals with confidence scoring.
+     *
+     * Returns the number of L3 proposals created.
+     */
+    async synthesizeDecisions() {
+      enforceWritePermission("synthesizer", "emerging");
+      const decisions = vault.list("decision");
+      if (decisions.length < 2) return 0;
+      const byType = /* @__PURE__ */ new Map();
+      for (const d of decisions) {
+        const dtype = d.decision_type ?? "untyped:decision";
+        if (!d.decision_type) console.warn(`[Synthesizer] Decision ${d.id} missing decision_type, using 'untyped:decision'`);
+        if (!byType.has(dtype)) byType.set(dtype, []);
+        byType.get(dtype).push(d);
+      }
+      let created = 0;
+      const decayAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1e3).toISOString();
+      for (const [decisionType, group] of byType) {
+        if (group.length < 2) continue;
+        const clusters = [];
+        const used = /* @__PURE__ */ new Set();
+        for (let i = 0; i < group.length; i++) {
+          const entry = group[i];
+          if (used.has(entry.id)) continue;
+          const cluster = [entry];
+          used.add(entry.id);
+          for (let j = i + 1; j < group.length; j++) {
+            const other = group[j];
+            if (used.has(other.id)) continue;
+            if (overlapCoefficient(entry.body, other.body) >= 0.4) {
+              cluster.push(other);
+              used.add(other.id);
+            }
+          }
+          if (cluster.length >= 2) {
+            clusters.push(cluster);
+          }
+        }
+        for (const cluster of clusters.slice(0, 10)) {
+          const agents = [...new Set(cluster.map((e) => e.agent_id).filter(Boolean))];
+          const evidenceIds = cluster.map((e) => e.id);
+          const confidenceScore = Math.min(0.9, 0.3 + cluster.length * 0.1 + agents.length * 0.1);
+          const title = `${decisionType} pattern: ${cluster[0].name.slice(0, 60)}`;
+          const existingL3 = queryByLayer(vault, "emerging");
+          const isDuplicate = existingL3.some(
+            (e) => overlapCoefficient(e.name, title) >= dedupThreshold
+          );
+          if (isDuplicate) continue;
+          try {
+            writeToLayer(vault, "synthesizer", "emerging", {
+              type: "insight",
+              name: title,
+              status: "pending",
+              confidence_score: confidenceScore,
+              evidence_links: evidenceIds,
+              source_agents: agents.map(String),
+              decay_at: decayAt,
+              decision_type: decisionType,
+              tags: ["synthesized", "l3-proposal", "decision-pattern"],
+              related: evidenceIds.map((id) => `decision/${id}`),
+              body: `## Decision Pattern: ${decisionType}
+
+Recurring ${decisionType} pattern detected across ${agents.length} agent(s) and ${cluster.length} decisions.
+
+### Evidence
+${evidenceIds.map((id) => `- [[decision/${id}]]`).join("\n")}`
+            });
+            created++;
+          } catch {
+          }
+        }
+      }
+      saveState();
+      return created;
+    },
+    /**
+     * Detect decision divergence between agents with similar patterns.
+     * Compares decision chains across agents to find where failing agents
+     * make different choices than successful ones.
+     */
+    synthesizeDecisionDivergence() {
+      const executions = vault.list("execution");
+      const agents = vault.list("agent");
+      const agentDecisions = /* @__PURE__ */ new Map();
+      for (const exec of executions) {
+        const data = exec;
+        const agentId = resolveAgentId(data);
+        const decisions = data.decisions;
+        const pattern = data.decisionPattern;
+        if (!agentId || !decisions || decisions.length === 0) continue;
+        if (!agentDecisions.has(agentId)) {
+          const agent = agents.find((a) => a.name === agentId || a.agentId === agentId);
+          const failureRate = (agent == null ? void 0 : agent.failureRate) ?? 0;
+          agentDecisions.set(agentId, { patterns: [], successRate: 1 - failureRate, decisions: [] });
+        }
+        const entry = agentDecisions.get(agentId);
+        if (pattern) entry.patterns.push(pattern);
+        entry.decisions.push(decisions);
+      }
+      const agentsWithData = [...agentDecisions.entries()].filter(([, v]) => v.decisions.length >= 3);
+      if (agentsWithData.length < 2) return 0;
+      let created = 0;
+      for (let i = 0; i < agentsWithData.length; i++) {
+        for (let j = i + 1; j < agentsWithData.length; j++) {
+          const [agentA, dataA] = agentsWithData[i];
+          const [agentB, dataB] = agentsWithData[j];
+          const gap = Math.abs(dataA.successRate - dataB.successRate);
+          if (gap < 0.2) continue;
+          const [winner, winnerData] = dataA.successRate > dataB.successRate ? [agentA, dataA] : [agentB, dataB];
+          const [loser, loserData] = dataA.successRate > dataB.successRate ? [agentB, dataB] : [agentA, dataA];
+          const winnerActions = /* @__PURE__ */ new Map();
+          const loserActions = /* @__PURE__ */ new Map();
+          for (const chain of winnerData.decisions) {
+            for (const d of chain) {
+              const cur = winnerActions.get(d.action) ?? { total: 0, ok: 0 };
+              cur.total++;
+              if (d.outcome === "ok") cur.ok++;
+              winnerActions.set(d.action, cur);
+            }
+          }
+          for (const chain of loserData.decisions) {
+            for (const d of chain) {
+              const cur = loserActions.get(d.action) ?? { total: 0, ok: 0 };
+              cur.total++;
+              if (d.outcome === "ok") cur.ok++;
+              loserActions.set(d.action, cur);
+            }
+          }
+          const winnerActionSet = new Set(winnerActions.keys());
+          const loserActionSet = new Set(loserActions.keys());
+          let intersection = 0;
+          for (const a of winnerActionSet) {
+            if (loserActionSet.has(a)) intersection++;
+          }
+          const actionOverlap = intersection / Math.min(winnerActionSet.size, loserActionSet.size);
+          if (actionOverlap < 0.3) continue;
+          const winnerOnly = [...winnerActions.keys()].filter((a) => !loserActions.has(a));
+          const loserOnly = [...loserActions.keys()].filter((a) => !winnerActions.has(a));
+          if (winnerOnly.length === 0 && loserOnly.length === 0) continue;
+          const insightName = `Decision divergence: ${loser} vs ${winner}`;
+          const existingL3 = queryByLayer(vault, "emerging");
+          if (existingL3.some((e) => overlapCoefficient(e.name, insightName) >= dedupThreshold)) continue;
+          const fmtRate = (stats) => `${(stats.ok / Math.max(1, stats.total) * 100).toFixed(0)}%`;
+          const claim = `${winner} (${(winnerData.successRate * 100).toFixed(0)}% overall) and ${loser} (${(loserData.successRate * 100).toFixed(0)}% overall) show different decision patterns. ` + (winnerOnly.length > 0 ? `${winner} uses: ${winnerOnly.slice(0, 3).map((a) => `${a} (${fmtRate(winnerActions.get(a))} success)`).join(", ")}. ` : "") + (loserOnly.length > 0 ? `${loser} uses instead: ${loserOnly.slice(0, 3).map((a) => `${a} (${fmtRate(loserActions.get(a))} success)`).join(", ")}.` : "");
+          const hasAicpPreflight = [...winnerData.decisions, ...loserData.decisions].some((chain) => chain.some((d) => d.action === "aicp-preflight"));
+          const via = hasAicpPreflight ? "aicp-preflight" : void 0;
+          const tags = ["synthesized", "divergence", "actionable"];
+          if (via) tags.push("aicp-mediated");
+          try {
+            writeToLayer(vault, "synthesizer", "emerging", {
+              type: "insight",
+              name: insightName,
+              status: "active",
+              tags,
+              claim,
+              via,
+              confidence_score: Math.min(0.9, 0.5 + gap),
+              evidence_links: [winner, loser],
+              source_agents: [winner, loser],
+              body: `## Decision Divergence
+
+${claim}
+
+### ${winner} actions
+${[...winnerActions.entries()].map(([a, s]) => `- ${a} (${s.total}x, ${fmtRate(s)} success)`).join("\n")}
+
+### ${loser} actions
+${[...loserActions.entries()].map(([a, s]) => `- ${a} (${s.total}x, ${fmtRate(s)} success)`).join("\n")}`
+            });
+            created++;
+          } catch {
+          }
+        }
+      }
+      return created;
+    }
+  };
+}
+function buildExtractionPrompt(entity) {
+  return `You are analyzing a knowledge record to extract learnings.
+
+Record type: ${entity.type}
+Record name: ${entity.name}
+Content (first 4000 chars):
+${entity.body.slice(0, 4e3)}
+
+Extract any assumptions, decisions, constraints, or contradictions from this record.
+Return a JSON array of objects with: { "type": "assumption|decision|constraint|contradiction", "title": "...", "claim": "...", "confidence": "low|medium|high", "evidence": ["..."] }
+
+Return [] if no learnings found.`;
+}
+function parseExtractionResponse(response, source) {
+  try {
+    const match = response.match(/\[[\s\S]*\]/);
+    if (!match) return [];
+    const parsed = JSON.parse(match[0]);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.map((item) => ({
+      type: String(item.type ?? "assumption"),
+      title: String(item.title ?? "Untitled"),
+      claim: String(item.claim ?? ""),
+      confidence: item.confidence ?? "low",
+      evidence: Array.isArray(item.evidence) ? item.evidence.map(String) : [],
+      sourceIds: [source.id],
+      sourceCount: 1
+    }));
+  } catch {
+    return [];
+  }
+}
+var DEFAULT_MIN_CLUSTER_SIZE = 3;
+var DEFAULT_SIMILARITY_THRESHOLD = 0.5;
+function createCartographer(vault, vectorStore, embedFn, config) {
+  const minClusterSize = (config == null ? void 0 : config.minClusterSize) ?? DEFAULT_MIN_CLUSTER_SIZE;
+  const similarityThreshold = (config == null ? void 0 : config.similarityThreshold) ?? DEFAULT_SIMILARITY_THRESHOLD;
+  const stateFile = (config == null ? void 0 : config.stateFile) ?? ".soma/cartographer-state.json";
+  let state = { embeddedIds: /* @__PURE__ */ new Set(), entityHashes: /* @__PURE__ */ new Map(), clusterAssignments: {} };
+  try {
+    if (existsSync4(stateFile)) {
+      const raw = JSON.parse(readFileSync4(stateFile, "utf-8"));
+      const currentCount = vaultEntityCount(vault.baseDir);
+      if (raw.entityCount == null && raw.vaultFingerprint) {
+        console.log("[Cartographer] Migrating state from vaultFingerprint to entityCount");
+        state = { embeddedIds: /* @__PURE__ */ new Set(), entityHashes: /* @__PURE__ */ new Map(), clusterAssignments: {}, entityCount: currentCount };
+      } else if (raw.entityCount != null && currentCount < raw.entityCount) {
+        console.log(`[Cartographer] Vault entity count decreased (${raw.entityCount} \u2192 ${currentCount}) \u2014 resetting state`);
+        state = { embeddedIds: /* @__PURE__ */ new Set(), entityHashes: /* @__PURE__ */ new Map(), clusterAssignments: {}, entityCount: currentCount };
+      } else {
+        state = {
+          embeddedIds: new Set(raw.embeddedIds ?? []),
+          entityHashes: new Map(Object.entries(raw.entityHashes ?? {})),
+          clusterAssignments: raw.clusterAssignments ?? {},
+          entityCount: currentCount
+        };
+      }
+    }
+  } catch (err) {
+    console.warn("[Cartographer] Failed to load state, starting fresh:", err.message);
+  }
+  function saveState() {
+    const dir = dirname3(stateFile);
+    if (!existsSync4(dir)) mkdirSync4(dir, { recursive: true });
+    writeFileSync4(stateFile, JSON.stringify({
+      embeddedIds: [...state.embeddedIds],
+      entityHashes: Object.fromEntries(state.entityHashes),
+      clusterAssignments: state.clusterAssignments,
+      entityCount: state.entityCount ?? vaultEntityCount(vault.baseDir)
+    }), "utf-8");
+  }
+  function contentHash(text) {
+    return createHash2("md5").update(text).digest("hex");
+  }
+  function entityToText(entity) {
+    return `${entity.type}: ${entity.name}
+${entity.tags.join(", ")}
+${entity.body}`.slice(0, 2e3);
+  }
+  function clusterByLinks(entities) {
+    const adj = /* @__PURE__ */ new Map();
+    for (const e of entities) {
+      if (!adj.has(e.id)) adj.set(e.id, /* @__PURE__ */ new Set());
+      for (const link of e.related) {
+        const linkedId = link.split("/").pop() ?? "";
+        if (!adj.has(linkedId)) adj.set(linkedId, /* @__PURE__ */ new Set());
+        adj.get(e.id).add(linkedId);
+        adj.get(linkedId).add(e.id);
+      }
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const clusters = /* @__PURE__ */ new Map();
+    let clusterId = 0;
+    for (const [nodeId] of adj) {
+      if (visited.has(nodeId)) continue;
+      const community = [];
+      const queue = [nodeId];
+      while (queue.length > 0) {
+        const current = queue.shift();
+        if (visited.has(current)) continue;
+        visited.add(current);
+        community.push(current);
+        for (const neighbor of adj.get(current) ?? []) {
+          if (!visited.has(neighbor)) queue.push(neighbor);
+        }
+      }
+      if (community.length >= minClusterSize) {
+        clusters.set(clusterId++, community);
+      }
+    }
+    return clusters;
+  }
+  return {
+    /**
+     * Embed all new/changed entities into the vector store.
+     * Returns the number of entities embedded.
+     */
+    async embed() {
+      if (!embedFn) return 0;
+      const allTypes = ["agent", "execution", "archetype", "insight", "policy", "decision", "assumption", "constraint", "contradiction", "synthesis"];
+      let embedded = 0;
+      for (const type of allTypes) {
+        const entities = vault.list(type);
+        for (const entity of entities) {
+          const text = entityToText(entity);
+          const hash = contentHash(text);
+          if (state.embeddedIds.has(entity.id) && state.entityHashes.get(entity.id) === hash) continue;
+          try {
+            const vector = await embedFn(text);
+            if (!vector) continue;
+            await vectorStore.upsert(entity.id, vector, {
+              type: entity.type,
+              name: entity.name,
+              status: entity.status,
+              tags: entity.tags
+            });
+            state.embeddedIds.add(entity.id);
+            state.entityHashes.set(entity.id, hash);
+            embedded++;
+          } catch {
+          }
+        }
+      }
+      if (embedded > 0) saveState();
+      return embedded;
+    },
+    /**
+     * Discover clusters and archetypes.
+     * Returns the number of archetypes created.
+     */
+    async discover() {
+      const allEntities = [];
+      for (const type of ["agent", "execution", "archetype", "insight", "policy"]) {
+        allEntities.push(...vault.list(type));
+      }
+      if (allEntities.length < minClusterSize) return 0;
+      const linkClusters = clusterByLinks(allEntities);
+      let archetypesCreated = 0;
+      for (const [, members] of linkClusters) {
+        const memberEntities = members.map((id) => allEntities.find((e) => e.id === id)).filter(Boolean);
+        const types = new Set(memberEntities.map((e) => e.type));
+        const agents = new Set(
+          memberEntities.filter((e) => e.type === "execution" || e.type === "agent").map((e) => e.agentId).filter(Boolean)
+        );
+        if (agents.size >= 2 || types.size >= 3) {
+          const name = `archetype-cluster-${Date.now()}-${archetypesCreated}`;
+          writeToLayer(vault, "cartographer", "emerging", {
+            type: "archetype",
+            name,
+            status: "proposed",
+            pattern: `Cluster of ${members.length} entities across ${agents.size} agents and ${types.size} types`,
+            confidence: Math.min(members.length / 10, 1),
+            confidence_score: Math.min(members.length / 10, 1),
+            evidence_links: members,
+            decay_at: new Date(Date.now() + 90 * 24 * 60 * 60 * 1e3).toISOString(),
+            memberAgents: [...agents],
+            memberExecutions: members.filter((id) => {
+              var _a;
+              return ((_a = memberEntities.find((e) => e.id === id)) == null ? void 0 : _a.type) === "execution";
+            }),
+            bottlenecks: [],
+            suggestedPolicies: [],
+            tags: ["archetype", "auto-discovered"],
+            related: members.map((id) => {
+              const e = memberEntities.find((x) => x.id === id);
+              return e ? `${e.type}/${e.id}` : id;
+            }),
+            body: `Auto-discovered archetype spanning ${agents.size} agents.
+
+Members:
+${members.map((id) => `- [[${id}]]`).join("\n")}`
+          });
+          archetypesCreated++;
+        }
+      }
+      saveState();
+      return archetypesCreated;
+    },
+    /**
+     * Semantic search across all entity types.
+     */
+    async search(query, options) {
+      if (!embedFn) return [];
+      const queryVector = await embedFn(query);
+      if (!queryVector) return [];
+      return vectorStore.search(queryVector, options);
+    },
+    /**
+     * Extract entities and relationships from L1, L3, and L4 entries.
+     * Creates relationship mapping proposals in L3 with evidence_links and confidence_score.
+     * Returns the number of relationship proposals created.
+     */
+    async mapRelationships() {
+      const l1Entries = queryByLayer(vault, "archive");
+      const l3Entries = queryByLayer(vault, "emerging");
+      const l4Entries = queryByLayer(vault, "canon");
+      const allLayered = [...l1Entries, ...l3Entries, ...l4Entries];
+      if (allLayered.length < 2) return 0;
+      let created = 0;
+      const decayAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1e3).toISOString();
+      const CIRCUIT_BREAKER_LIMIT = 100;
+      for (let i = 0; i < allLayered.length && i < 200; i++) {
+        const entry = allLayered[i];
+        for (let j = i + 1; j < allLayered.length && j < 200; j++) {
+          const other = allLayered[j];
+          if (entry.id === other.id) continue;
+          const sharedTags = entry.tags.filter((t) => other.tags.includes(t));
+          if (sharedTags.length === 0) continue;
+          if (entry.related.some((r) => r.includes(other.id))) continue;
+          const confidence = Math.min(sharedTags.length / 5, 0.9);
+          if (confidence < similarityThreshold) continue;
+          try {
+            writeToLayer(vault, "cartographer", "emerging", {
+              type: "synthesis",
+              name: `Relationship: ${entry.name} \u2194 ${other.name}`,
+              status: "pending",
+              confidence_score: confidence,
+              evidence_links: [entry.id, other.id],
+              decay_at: decayAt,
+              tags: ["relationship-proposal", "cartographer"],
+              related: [`${entry.type}/${entry.id}`, `${other.type}/${other.id}`],
+              body: `Proposed relationship between ${entry.name} and ${other.name}.
+Shared tags: ${sharedTags.join(", ")}`
+            });
+            created++;
+          } catch {
+          }
+          if (created >= CIRCUIT_BREAKER_LIMIT) return created;
+        }
+      }
+      return created;
+    },
+    /**
+     * Detect contradictions between L3 entries and L4 canon.
+     * Flags L3 entries that contradict established L4 truth.
+     * Returns the number of contradictions found.
+     */
+    detectContradictions() {
+      const l3Entries = queryByLayer(vault, "emerging");
+      const l4Entries = queryByLayer(vault, "canon");
+      let flagged = 0;
+      for (const l3 of l3Entries) {
+        for (const l4 of l4Entries) {
+          const sharedTags = l3.tags.filter((t) => l4.tags.includes(t) && t !== "synthesized");
+          if (sharedTags.length === 0) continue;
+          const l3Text = l3.body.toLowerCase();
+          const l4Text = l4.body.toLowerCase();
+          const contradictionPairs = [
+            ["should", "should not"],
+            ["enable", "disable"],
+            ["allow", "deny"],
+            ["increase", "decrease"],
+            ["must", "must not"]
+          ];
+          for (const [a, b] of contradictionPairs) {
+            if (l3Text.includes(a) && l4Text.includes(b) || l3Text.includes(b) && l4Text.includes(a)) {
+              vault.update(l3.id, {
+                tags: [.../* @__PURE__ */ new Set([...l3.tags, "contradicts-canon"])],
+                related: [.../* @__PURE__ */ new Set([...l3.related, `${l4.type}/${l4.id}`])]
+              });
+              flagged++;
+              break;
+            }
+          }
+        }
+      }
+      return flagged;
+    },
+    /** Suggest missing relationships within clusters. */
+    async suggestRelationships() {
+      const suggestions = [];
+      const allEntities = vault.list("insight").concat(vault.list("decision"), vault.list("archetype"));
+      for (const entity of allEntities) {
+        if (!embedFn) break;
+        try {
+          const text = entityToText(entity);
+          const vector = await embedFn(text);
+          if (!vector) continue;
+          const similar = await vectorStore.search(vector, { limit: 5 });
+          for (const result of similar) {
+            if (result.id === entity.id) continue;
+            if (result.score < similarityThreshold) continue;
+            if (entity.related.some((r) => r.includes(result.id))) continue;
+            suggestions.push({
+              from: entity.id,
+              to: result.id,
+              type: "related-to",
+              confidence: result.score
+            });
+          }
+        } catch {
+        }
+      }
+      return suggestions;
+    }
+  };
+}
+var DEFAULT_STUB_THRESHOLD = 100;
+function overlapCoefficient2(a, b) {
+  const setA = new Set(a.toLowerCase().split(/\s+/));
+  const setB = new Set(b.toLowerCase().split(/\s+/));
+  let intersection = 0;
+  for (const word of setA) if (setB.has(word)) intersection++;
+  const minSize = Math.min(setA.size, setB.size);
+  return minSize > 0 ? intersection / minSize : 0;
+}
+var TYPE_CORRECTIONS = {
+  agents: "agent",
+  persons: "person",
+  projects: "project",
+  tasks: "task",
+  decisions: "decision",
+  assumptions: "assumption",
+  constraints: "constraint",
+  contradictions: "contradiction",
+  insights: "insight",
+  policies: "policy",
+  executions: "execution",
+  archetypes: "archetype",
+  syntheses: "synthesis"
+};
+var STATUS_CORRECTIONS = {
+  open: "active",
+  closed: "completed",
+  done: "completed",
+  wip: "active",
+  "in-progress": "active",
+  "in progress": "active",
+  finished: "completed",
+  todo: "pending",
+  cancelled: "deprecated",
+  archived: "deprecated"
+};
+function createReconciler(vault, analysisFn, config) {
+  const stubThreshold = (config == null ? void 0 : config.stubThreshold) ?? DEFAULT_STUB_THRESHOLD;
+  const stateFile = (config == null ? void 0 : config.stateFile) ?? ".soma/reconciler-state.json";
+  let hashes = /* @__PURE__ */ new Map();
+  let savedEntityCount = 0;
+  try {
+    if (existsSync5(stateFile)) {
+      const raw = JSON.parse(readFileSync5(stateFile, "utf-8"));
+      const currentCount = vaultEntityCount(vault.baseDir);
+      if (raw.entityCount == null && raw.vaultFingerprint) {
+        console.log("[Reconciler] Migrating state from vaultFingerprint to entityCount");
+        hashes = /* @__PURE__ */ new Map();
+      } else if (raw.entityCount != null && currentCount < raw.entityCount) {
+        console.log(`[Reconciler] Vault entity count decreased (${raw.entityCount} \u2192 ${currentCount}) \u2014 resetting state`);
+        hashes = /* @__PURE__ */ new Map();
+      } else {
+        hashes = new Map(Object.entries(raw.hashes ?? {}));
+      }
+      savedEntityCount = currentCount;
+    }
+  } catch {
+  }
+  function saveState() {
+    const dir = dirname4(stateFile);
+    if (!existsSync5(dir)) mkdirSync5(dir, { recursive: true });
+    writeFileSync5(stateFile, JSON.stringify({
+      hashes: Object.fromEntries(hashes),
+      entityCount: savedEntityCount ?? vaultEntityCount(vault.baseDir)
+    }), "utf-8");
+  }
+  function md52(content) {
+    return createHash3("md5").update(content).digest("hex");
+  }
+  return {
+    /**
+     * Scan vault entities for structural issues.
+     * Returns a list of issues with codes and severities.
+     */
+    scan(options) {
+      const issues = [];
+      const allTypes = ["agent", "execution", "archetype", "insight", "policy", "decision", "assumption", "constraint", "contradiction", "synthesis"];
+      for (const type of allTypes) {
+        const entities = vault.list(type);
+        for (const entity of entities) {
+          const content = `${entity.type}:${entity.name}:${entity.body}`;
+          const hash = md52(content);
+          if (!(options == null ? void 0 : options.fullScan) && hashes.get(entity.id) === hash) continue;
+          hashes.set(entity.id, hash);
+          if (!entity.type) issues.push({ code: "FM001", severity: "error", entityPath: `${type}/${entity.id}`, message: "Missing type field", autoFixable: true });
+          if (!entity.created) issues.push({ code: "FM001", severity: "warning", entityPath: `${type}/${entity.id}`, message: "Missing created field", autoFixable: true });
+          if (!entity.name) issues.push({ code: "FM001", severity: "warning", entityPath: `${type}/${entity.id}`, message: "Missing name field", autoFixable: true });
+          if (TYPE_CORRECTIONS[entity.type]) {
+            issues.push({ code: "FM002", severity: "warning", entityPath: `${type}/${entity.id}`, message: `Invalid type "${entity.type}" (should be "${TYPE_CORRECTIONS[entity.type]}")`, autoFixable: true });
+          }
+          const validStatuses = ENTITY_STATUSES[entity.type];
+          if (validStatuses && !validStatuses.includes(entity.status)) {
+            const corrected = STATUS_CORRECTIONS[entity.status];
+            issues.push({ code: "FM003", severity: "warning", entityPath: `${type}/${entity.id}`, message: `Invalid status "${entity.status}"${corrected ? ` (should be "${corrected}")` : ""}`, autoFixable: !!corrected });
+          }
+          if (entity.tags && !Array.isArray(entity.tags)) {
+            issues.push({ code: "FM004", severity: "warning", entityPath: `${type}/${entity.id}`, message: "tags should be an array", autoFixable: true });
+          }
+          if (entity.related && !Array.isArray(entity.related)) {
+            issues.push({ code: "FM004", severity: "warning", entityPath: `${type}/${entity.id}`, message: "related should be an array", autoFixable: true });
+          }
+          for (const link of entity.related) {
+            const parts = link.split("/");
+            if (parts.length >= 2) {
+              const linkedEntity = vault.read(parts[0], parts.slice(1).join("/"));
+              if (!linkedEntity) {
+                issues.push({ code: "LINK001", severity: "warning", entityPath: `${type}/${entity.id}`, message: `Broken wikilink: [[${link}]]`, autoFixable: false });
+              }
+            }
+          }
+          if (options == null ? void 0 : options.fullScan) {
+            let hasInbound = false;
+            for (const otherType of allTypes) {
+              const others = vault.list(otherType);
+              if (others.some((o) => o.related.some((r) => r.includes(entity.id)))) {
+                hasInbound = true;
+                break;
+              }
+            }
+            if (!hasInbound && entity.type !== "agent") {
+              issues.push({ code: "ORPHAN001", severity: "info", entityPath: `${type}/${entity.id}`, message: "Orphan entity \u2014 no inbound links", autoFixable: false });
+            }
+          }
+          if (entity.body.length < stubThreshold) {
+            issues.push({ code: "STUB001", severity: "info", entityPath: `${type}/${entity.id}`, message: `Stub entity (body: ${entity.body.length} chars, threshold: ${stubThreshold})`, autoFixable: false });
+          }
+        }
+      }
+      saveState();
+      return issues;
+    },
+    /**
+     * Auto-fix deterministic issues (no LLM needed).
+     * Returns the number of fixes applied.
+     */
+    autofix(issues) {
+      let fixed = 0;
+      for (const issue of issues) {
+        if (!issue.autoFixable) continue;
+        const [type, ...idParts] = issue.entityPath.split("/");
+        const id = idParts.join("/");
+        if (!type || !id) continue;
+        const entity = vault.read(type, id);
+        if (!entity) continue;
+        const patch = {};
+        switch (issue.code) {
+          case "FM001": {
+            if (!entity.type) patch.type = type;
+            if (!entity.created) patch.created = (/* @__PURE__ */ new Date()).toISOString();
+            if (!entity.name) patch.name = id;
+            break;
+          }
+          case "FM002": {
+            const corrected = TYPE_CORRECTIONS[entity.type];
+            if (corrected) patch.type = corrected;
+            break;
+          }
+          case "FM003": {
+            const corrected = STATUS_CORRECTIONS[entity.status];
+            if (corrected) patch.status = corrected;
+            break;
+          }
+          case "FM004": {
+            if (entity.tags && !Array.isArray(entity.tags)) patch.tags = [String(entity.tags)];
+            if (entity.related && !Array.isArray(entity.related)) patch.related = [String(entity.related)];
+            break;
+          }
+        }
+        if (Object.keys(patch).length > 0) {
+          vault.update(id, patch);
+          fixed++;
+        }
+      }
+      return fixed;
+    },
+    /**
+     * Reconcile L1 entries: detect near-duplicates, merge overlapping entries,
+     * and resolve conflicts. Only operates on L1 (archive) knowledge entries.
+     *
+     * Execution and agent entities are excluded — they are event logs, not
+     * duplicatable knowledge. Superseded entries are also excluded.
+     *
+     * Returns { reconciled, mergeErrors }.
+     */
+    reconcileL1() {
+      const KNOWLEDGE_TYPES = /* @__PURE__ */ new Set(["insight", "decision", "policy", "constraint", "contradiction", "synthesis", "archetype", "assumption"]);
+      const allL1 = queryByLayer(vault, "archive");
+      const l1Entries = allL1.filter((e) => {
+        if (!KNOWLEDGE_TYPES.has(e.type)) return false;
+        if (e.superseded_by) return false;
+        if (Array.isArray(e.reconciled_from)) return false;
+        return true;
+      });
+      let reconciled = 0;
+      let mergeErrors = 0;
+      const processed = /* @__PURE__ */ new Set();
+      const existingMerges = allL1.map((e) => e.reconciled_from).filter((rf) => Array.isArray(rf));
+      for (let i = 0; i < l1Entries.length; i++) {
+        const entry = l1Entries[i];
+        if (processed.has(entry.id)) continue;
+        const duplicates = [];
+        for (let j = i + 1; j < l1Entries.length; j++) {
+          const other = l1Entries[j];
+          if (processed.has(other.id)) continue;
+          const similarity = overlapCoefficient2(entry.body, other.body);
+          if (similarity >= 0.7) {
+            duplicates.push(other);
+          }
+        }
+        if (duplicates.length === 0) continue;
+        const allEntries = [entry, ...duplicates];
+        const sourceIds = allEntries.map((e) => e.id);
+        const alreadyCovered = existingMerges.some(
+          (rf) => sourceIds.every((id) => rf.includes(id))
+        );
+        if (alreadyCovered) {
+          for (const dup of duplicates) processed.add(dup.id);
+          processed.add(entry.id);
+          continue;
+        }
+        const newestEntry = allEntries.reduce(
+          (a, b) => new Date(b.updated).getTime() > new Date(a.updated).getTime() ? b : a
+        );
+        const allAgentIds = [...new Set(allEntries.map((e) => e.agent_id).filter(Boolean))];
+        try {
+          const mergedId = writeToLayer(vault, "reconciler", "archive", {
+            type: newestEntry.type,
+            name: newestEntry.name,
+            status: newestEntry.status,
+            agent_id: allAgentIds.join(","),
+            trace_id: newestEntry.trace_id,
+            source_system: newestEntry.source_system,
+            reconciled_from: sourceIds,
+            tags: [...new Set(allEntries.flatMap((e) => e.tags))],
+            related: [...new Set(allEntries.flatMap((e) => e.related))],
+            body: newestEntry.body
+          });
+          for (const source of allEntries) {
+            vault.update(source.id, { superseded_by: mergedId });
+            processed.add(source.id);
+          }
+          reconciled++;
+        } catch (err) {
+          console.error("[Reconciler] Merge failed:", err instanceof Error ? err.message : String(err));
+          mergeErrors++;
+        }
+      }
+      return { reconciled, mergeErrors };
+    },
+    /**
+     * Run the full reconciliation pipeline.
+     * Returns { scanned, issues, fixed }.
+     */
+    async run(options) {
+      const issues = this.scan(options);
+      const autoFixable = issues.filter((i) => i.autoFixable);
+      const fixed = this.autofix(autoFixable);
+      if (analysisFn) {
+        const brokenLinks = issues.filter((i) => i.code === "LINK001");
+        for (const _issue of brokenLinks.slice(0, 10)) {
+        }
+        const stubs = issues.filter((i) => i.code === "STUB001");
+        for (const _issue of stubs.slice(0, 5)) {
+        }
+      }
+      return {
+        scanned: issues.length > 0 ? issues.length : 0,
+        issues: issues.length,
+        fixed
+      };
+    }
+  };
+}
+var INTENT_TO_LAYER = {
+  enforce: "canon",
+  advise: "emerging",
+  brief: "working",
+  route: "archive"
+};
+var PolicyBridgeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PolicyBridgeError";
+  }
+};
+function createPolicyBridge(vault) {
+  function tagResults(entries, layer) {
+    return entries.map((entry) => ({
+      entry,
+      source_layer: layer,
+      semantic_weight: LAYER_SEMANTIC_WEIGHTS[layer]
+    }));
+  }
+  function filterByTopic(entries, topic) {
+    if (!topic) return entries;
+    const lower = topic.toLowerCase();
+    return entries.filter(
+      (e) => e.name.toLowerCase().includes(lower) || e.body.toLowerCase().includes(lower) || e.tags.some((t) => t.toLowerCase().includes(lower))
+    );
+  }
+  return {
+    query(intent, options) {
+      const topic = options == null ? void 0 : options.topic;
+      const teamId = options == null ? void 0 : options.team_id;
+      const limit = (options == null ? void 0 : options.limit) ?? 100;
+      if (intent === "all") {
+        const result = {
+          canon: tagResults(filterByTopic(queryByLayer(vault, "canon", { limit }), topic), "canon"),
+          emerging: tagResults(filterByTopic(queryByLayer(vault, "emerging", { limit }), topic), "emerging"),
+          working: tagResults(
+            filterByTopic(queryByLayer(vault, "working", { limit, team_id: teamId }), topic),
+            "working"
+          ),
+          archive: tagResults(filterByTopic(queryByLayer(vault, "archive", { limit }), topic), "archive")
+        };
+        return result;
+      }
+      const layer = INTENT_TO_LAYER[intent];
+      if (!layer) {
+        throw new PolicyBridgeError(`Unknown intent: '${intent}'. Use: enforce, advise, brief, route, or all.`);
+      }
+      if (intent === "brief" && !teamId) {
+        throw new PolicyBridgeError("team_id is required for brief (L2) queries.");
+      }
+      const entries = queryByLayer(vault, layer, { limit, team_id: teamId });
+      return tagResults(filterByTopic(entries, topic), layer);
+    },
+    // Legacy PolicySource for backward compatibility with AgentFlow guards
+    policySource: createSomaPolicySource(vault)
+  };
+}
+function createSomaPolicySource(vault) {
+  return {
+    recentFailureRate(agentId) {
+      const normalized = agentId.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+      const agent = vault.read("agent", normalized);
+      return (agent == null ? void 0 : agent.failureRate) ?? 0;
+    },
+    isKnownBottleneck(nodeName) {
+      const archetypes = vault.list("archetype");
+      return archetypes.some((a) => {
+        const bottlenecks = a.bottlenecks;
+        return Array.isArray(bottlenecks) && bottlenecks.includes(nodeName);
+      });
+    },
+    lastConformanceScore(agentId) {
+      const normalized = agentId.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+      const executions = vault.list("execution", { agentId: normalized, limit: 1 });
+      if (executions.length === 0) return null;
+      return executions[0].conformanceScore ?? null;
+    },
+    getAgentProfile(agentId) {
+      const normalized = agentId.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+      const agent = vault.read("agent", normalized);
+      return (agent == null ? void 0 : agent.profile) ?? null;
+    }
+  };
+}
+var DEFAULT_L2_DECAY_DAYS = 14;
+var DEFAULT_L3_DECAY_DAYS = 90;
+function updateEvidenceReferences(vault, oldId, newId) {
+  for (const layer of ["emerging", "canon"]) {
+    const entries = queryByLayer(vault, layer);
+    for (const entry of entries) {
+      const links = entry.evidence_links;
+      if (!Array.isArray(links) || !links.includes(oldId)) continue;
+      const updatedLinks = links.map((id) => id === oldId ? newId : id);
+      vault.update(entry.id, { evidence_links: updatedLinks });
+    }
+  }
+}
+function checkDanglingReferences(vault) {
+  const dangling = [];
+  for (const layer of ["emerging", "canon"]) {
+    const entries = queryByLayer(vault, layer);
+    for (const entry of entries) {
+      const links = entry.evidence_links;
+      if (!Array.isArray(links)) continue;
+      for (const linkId of links) {
+        let found = false;
+        for (const type of ["execution", "insight", "decision", "policy", "agent", "archetype", "assumption", "constraint", "contradiction", "synthesis"]) {
+          if (vault.read(type, linkId)) {
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          dangling.push({ entryId: entry.id, missingTargetId: linkId });
+        }
+      }
+    }
+  }
+  return dangling;
+}
+function createDecayProcessor(vault, config) {
+  const l2DefaultDays = (config == null ? void 0 : config.l2DefaultDays) ?? DEFAULT_L2_DECAY_DAYS;
+  const l3DefaultDays = (config == null ? void 0 : config.l3DefaultDays) ?? DEFAULT_L3_DECAY_DAYS;
+  const teamDecayDays = (config == null ? void 0 : config.teamDecayDays) ?? {};
+  function computeL2DecayAt(teamId) {
+    const days = teamDecayDays[teamId] ?? l2DefaultDays;
+    return new Date(Date.now() + days * 24 * 60 * 60 * 1e3).toISOString();
+  }
+  function computeL3DecayAt() {
+    return new Date(Date.now() + l3DefaultDays * 24 * 60 * 60 * 1e3).toISOString();
+  }
+  function extendDecayOnAccess(entity) {
+    if (!entity.layer || !entity.decay_at) return;
+    if (entity.layer !== "working" && entity.layer !== "emerging") return;
+    let newDecayAt;
+    if (entity.layer === "working") {
+      const days = (entity.team_id ? teamDecayDays[entity.team_id] : void 0) ?? l2DefaultDays;
+      newDecayAt = new Date(Date.now() + days * 24 * 60 * 60 * 1e3).toISOString();
+    } else {
+      newDecayAt = new Date(Date.now() + l3DefaultDays * 24 * 60 * 60 * 1e3).toISOString();
+    }
+    vault.update(entity.id, { decay_at: newDecayAt });
+  }
+  function processDecay() {
+    const now = Date.now();
+    let l2Decayed = 0;
+    let l3Decayed = 0;
+    const l2Entries = queryByLayer(vault, "working");
+    for (const entry of l2Entries) {
+      if (!entry.decay_at) continue;
+      if (new Date(entry.decay_at).getTime() > now) continue;
+      try {
+        writeToLayer(vault, "reconciler", "archive", {
+          type: entry.type,
+          id: `decayed-${entry.id}`,
+          name: entry.name,
+          status: entry.status,
+          tags: [...entry.tags, "decayed"],
+          related: entry.related,
+          body: entry.body,
+          decayed_from: "working",
+          // Preserve original metadata
+          team_id: entry.team_id,
+          agent_id: entry.agent_id,
+          trace_id: entry.trace_id,
+          source_system: entry.source_system
+        });
+        updateEvidenceReferences(vault, entry.id, `decayed-${entry.id}`);
+        vault.remove(entry.id);
+        l2Decayed++;
+      } catch {
+      }
+    }
+    const l3Entries = queryByLayer(vault, "emerging");
+    for (const entry of l3Entries) {
+      if (!entry.decay_at) continue;
+      if (new Date(entry.decay_at).getTime() > now) continue;
+      if (entry.status === "promoted" || entry.status === "rejected") continue;
+      try {
+        writeToLayer(vault, "reconciler", "archive", {
+          type: entry.type,
+          id: `decayed-${entry.id}`,
+          name: entry.name,
+          status: entry.status,
+          tags: [...entry.tags, "decayed"],
+          related: entry.related,
+          body: entry.body,
+          decayed_from: "emerging",
+          // Preserve original metadata
+          confidence_score: entry.confidence_score,
+          evidence_links: entry.evidence_links,
+          agent_id: entry.agent_id
+        });
+        updateEvidenceReferences(vault, entry.id, `decayed-${entry.id}`);
+        vault.remove(entry.id);
+        l3Decayed++;
+      } catch {
+      }
+    }
+    return { l2Decayed, l3Decayed, total: l2Decayed + l3Decayed };
+  }
+  return {
+    computeL2DecayAt,
+    computeL3DecayAt,
+    extendDecayOnAccess,
+    processDecay,
+    /** Get the configured decay windows. */
+    getConfig() {
+      return { l2DefaultDays, l3DefaultDays, teamDecayDays };
+    }
+  };
+}
+var GovernanceError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GovernanceError";
+  }
+};
+function createGovernanceAPI(vault) {
+  return {
+    list_pending() {
+      const l3Entries = queryByLayer(vault, "emerging");
+      return l3Entries.filter((e) => e.status === "pending").sort((a, b) => (b.confidence_score ?? 0) - (a.confidence_score ?? 0));
+    },
+    promote(entryId, reviewerId) {
+      const l3Entries = queryByLayer(vault, "emerging");
+      const entry = l3Entries.find((e) => e.id === entryId);
+      if (!entry) {
+        const l2Entries = queryByLayer(vault, "working");
+        const l2Entry = l2Entries.find((e) => e.id === entryId);
+        if (l2Entry) {
+          throw new GovernanceError(`L2 entries cannot be promoted. Entry '${entryId}' is in Working Memory (L2).`);
+        }
+        throw new GovernanceError(`Entry '${entryId}' not found in L3 (Emerging Knowledge).`);
+      }
+      if (entry.layer === "working") {
+        throw new GovernanceError(`L2 entries cannot be promoted. Entry '${entryId}' is in Working Memory (L2).`);
+      }
+      if (entry.status === "promoted") {
+        throw new GovernanceError(`Entry '${entryId}' has already been promoted.`);
+      }
+      if (entry.status === "rejected") {
+        throw new GovernanceError(`Entry '${entryId}' has been rejected. Resubmit to promote.`);
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const entryData = entry;
+      const l4Id = writeToLayer(vault, "governance", "canon", {
+        type: entry.type,
+        id: `canon-${entryId}`,
+        name: entry.name,
+        status: "active",
+        ratified_by: reviewerId,
+        ratified_at: now,
+        origin_l3_id: entryId,
+        // Preserve evidence chain from L3
+        evidence_links: entry.evidence_links ?? [],
+        confidence_score: entry.confidence_score,
+        claim: entryData.claim,
+        source_agents: entryData.source_agents,
+        tags: [...entry.tags.filter((t) => t !== "l3-proposal"), "ratified", "canon"],
+        related: entry.related,
+        body: entry.body
+      });
+      vault.update(entryId, { status: "promoted" });
+      return l4Id;
+    },
+    reject(entryId, reviewerId, reason) {
+      const l3Entries = queryByLayer(vault, "emerging");
+      const entry = l3Entries.find((e) => e.id === entryId);
+      if (!entry) {
+        const l2Entries = queryByLayer(vault, "working");
+        const l2Entry = l2Entries.find((e) => e.id === entryId);
+        if (l2Entry) {
+          throw new GovernanceError(`L2 entries cannot be rejected via governance. Entry '${entryId}' is in Working Memory (L2).`);
+        }
+        throw new GovernanceError(`Entry '${entryId}' not found in L3 (Emerging Knowledge).`);
+      }
+      if (entry.status === "promoted") {
+        throw new GovernanceError(`Entry '${entryId}' has already been promoted.`);
+      }
+      if (entry.status === "rejected") {
+        throw new GovernanceError(`Entry '${entryId}' has already been rejected.`);
+      }
+      vault.update(entryId, {
+        status: "rejected",
+        rejected_by: reviewerId,
+        rejected_at: (/* @__PURE__ */ new Date()).toISOString(),
+        rejection_reason: reason
+      });
+    },
+    autoPromote(config) {
+      const enabled = (config == null ? void 0 : config.enabled) ?? false;
+      if (!enabled) return { promoted: [], skipped: 0 };
+      const minConfidence = (config == null ? void 0 : config.minConfidence) ?? 0.9;
+      const minAgentCount = (config == null ? void 0 : config.minAgentCount) ?? 5;
+      const pending = this.list_pending();
+      const promoted = [];
+      let skipped = 0;
+      for (const entry of pending) {
+        const confidence = entry.confidence_score ?? 0;
+        if (confidence < minConfidence) {
+          skipped++;
+          continue;
+        }
+        const evidenceLinks = entry.evidence_links ?? [];
+        const l1Entries = queryByLayer(vault, "archive");
+        const agentIds = /* @__PURE__ */ new Set();
+        for (const linkId of evidenceLinks) {
+          const linked = l1Entries.find((e) => e.id === linkId);
+          if (linked) {
+            const agentId = linked.agent_id ?? linked.agentId;
+            if (agentId) agentIds.add(agentId);
+          }
+        }
+        if (agentIds.size < minAgentCount) {
+          skipped++;
+          continue;
+        }
+        try {
+          const l4Id = this.promote(entry.id, "auto-promote");
+          promoted.push(l4Id);
+          console.log(`[Governance] Auto-promoted '${entry.name}' (confidence: ${confidence}, agents: ${agentIds.size})`);
+        } catch {
+          skipped++;
+        }
+      }
+      return { promoted, skipped };
+    },
+    get_evidence(entryId) {
+      const l3Entries = queryByLayer(vault, "emerging");
+      const entry = l3Entries.find((e) => e.id === entryId);
+      if (!entry) {
+        throw new GovernanceError(`Entry '${entryId}' not found in L3 (Emerging Knowledge).`);
+      }
+      const evidence = [];
+      const evidenceLinks = entry.evidence_links ?? [];
+      for (const linkId of evidenceLinks) {
+        const l1Entries = queryByLayer(vault, "archive");
+        const linked = l1Entries.find((e) => e.id === linkId);
+        if (linked) evidence.push(linked);
+      }
+      return { entry, evidence };
+    }
+  };
+}
+function createSoma(config) {
+  const vaultDir = (config == null ? void 0 : config.vaultDir) ?? ".soma/vault";
+  const inboxDir = (config == null ? void 0 : config.inboxDir) ?? ".soma/inbox";
+  if (config == null ? void 0 : config.layers) setLayersConfig(config.layers);
+  const vault = createVault({ baseDir: vaultDir });
+  const vectorStore = (config == null ? void 0 : config.vectorStore) ?? createJsonVectorStore(`${vaultDir}/../_vectors.json`);
+  const policyBridge = createPolicyBridge(vault);
+  const policySource = policyBridge.policySource;
+  const governance = createGovernanceAPI(vault);
+  const decayProcessor = createDecayProcessor(vault, config == null ? void 0 : config.decay);
+  vault.setOnRead((entity) => decayProcessor.extendDecayOnAccess(entity));
+  const harvester = createHarvester(vault, config == null ? void 0 : config.harvester);
+  const synthesizer = (config == null ? void 0 : config.analysisFn) ? createSynthesizer(vault, config.analysisFn, config == null ? void 0 : config.synthesizer) : void 0;
+  const cartographer = createCartographer(vault, vectorStore, config == null ? void 0 : config.embedFn, config == null ? void 0 : config.cartographer);
+  const reconciler = createReconciler(vault, config == null ? void 0 : config.analysisFn, config == null ? void 0 : config.reconciler);
+  return {
+    vault,
+    vectorStore,
+    policySource,
+    policyBridge,
+    governance,
+    harvester,
+    synthesizer,
+    cartographer,
+    reconciler,
+    decayProcessor,
+    async run() {
+      var _a, _b;
+      const harvested = await harvester.processInbox(inboxDir);
+      const reconcileResult = await reconciler.run();
+      const l1Result = reconciler.reconcileL1();
+      let synthesized = 0;
+      if (synthesizer) {
+        synthesized = await synthesizer.synthesize();
+        synthesized += await synthesizer.synthesizeL3();
+        synthesized += await synthesizer.synthesizeDecisions();
+        synthesized += synthesizer.synthesizeDecisionDivergence();
+      }
+      const autoPromoteResult = governance.autoPromote((_a = config == null ? void 0 : config.governance) == null ? void 0 : _a.autoPromote);
+      const driftStateFile = `${vaultDir}/../conformance-history.json`;
+      let conformanceHistory = [];
+      try {
+        if (existsSync6(driftStateFile)) {
+          conformanceHistory = JSON.parse(readFileSync6(driftStateFile, "utf-8"));
+        }
+      } catch {
+      }
+      const agents = vault.list("agent");
+      let driftTracked = 0;
+      let driftAlerts = 0;
+      for (const agent of agents) {
+        const data = agent;
+        const failureRate = data.failureRate;
+        const totalExecutions = data.totalExecutions;
+        const conformanceScore = data.lastConformanceScore ?? (failureRate != null ? 1 - failureRate : void 0);
+        if (conformanceScore != null && (totalExecutions ?? 0) > 0) {
+          conformanceHistory = trackConformanceTrend(conformanceHistory, {
+            agentId: agent.name,
+            score: conformanceScore,
+            runId: `run-${Date.now()}`
+          });
+          driftTracked++;
+        }
+      }
+      const agentIds = [...new Set(conformanceHistory.map((e) => e.agentId))];
+      for (const agentId of agentIds) {
+        const agentHistory = conformanceHistory.filter((e) => e.agentId === agentId);
+        const driftReport = detectDrift(agentHistory);
+        if (driftReport.status === "degrading" && driftReport.alert) {
+          try {
+            vault.create({
+              type: "insight",
+              name: `Drift alert: ${agentId}`,
+              status: "active",
+              tags: ["drift-alert", "auto-generated"],
+              body: driftReport.alert.message
+            });
+            driftAlerts++;
+          } catch {
+          }
+        }
+      }
+      const trimmedHistory = conformanceHistory.slice(-5e3);
+      try {
+        const dir = dirname5(driftStateFile);
+        if (!existsSync6(dir)) mkdirSync6(dir, { recursive: true });
+        writeFileSync6(driftStateFile, JSON.stringify(trimmedHistory), "utf-8");
+      } catch {
+      }
+      const embedded = await cartographer.embed();
+      const archetypes = await cartographer.discover();
+      await cartographer.mapRelationships();
+      cartographer.detectContradictions();
+      const decayResult = decayProcessor.processDecay();
+      let assertionFailures = 0;
+      if ((config == null ? void 0 : config.assertions) && config.assertions.length > 0) {
+        const violations = await evaluateAssertions(
+          config.assertions,
+          "soma-pipeline"
+        );
+        for (const v of violations) {
+          try {
+            vault.create({
+              type: "insight",
+              name: `Assertion failed: ${((_b = v.explanation) == null ? void 0 : _b.rule) ?? v.message}`,
+              status: "active",
+              tags: ["assertion-failure", "auto-generated"],
+              body: v.message
+            });
+            assertionFailures++;
+          } catch {
+          }
+        }
+      }
+      return {
+        harvested,
+        reconciled: { issues: reconcileResult.issues, fixed: reconcileResult.fixed, mergeErrors: l1Result.mergeErrors },
+        synthesized,
+        autoPromoted: autoPromoteResult.promoted.length,
+        mapped: embedded + archetypes,
+        decayed: decayResult.total,
+        drift: { tracked: driftTracked, alerts: driftAlerts },
+        assertionFailures
+      };
+    },
+    watch(watchDir) {
+      const dir = watchDir ?? inboxDir;
+      const interval = setInterval(async () => {
+        try {
+          const count = await harvester.processInbox(dir);
+          if (count > 0) {
+            console.log(`Soma: Harvested ${count} files from inbox`);
+          }
+        } catch (err) {
+          console.error("Soma watch error:", err);
+        }
+      }, 1e4);
+      return () => clearInterval(interval);
+    }
+  };
+}
+function migrateToLayers(vault) {
+  const allTypes = [
+    "agent",
+    "execution",
+    "archetype",
+    "insight",
+    "policy",
+    "decision",
+    "assumption",
+    "constraint",
+    "contradiction",
+    "synthesis"
+  ];
+  let migrated = 0;
+  let skipped = 0;
+  let errors = 0;
+  for (const type of allTypes) {
+    const entities = vault.list(type, { limit: 1e5 });
+    for (const entity of entities) {
+      if (entity.layer) {
+        skipped++;
+        continue;
+      }
+      try {
+        vault.update(entity.id, {
+          layer: "archive",
+          source_worker: "migration"
+        });
+        migrated++;
+      } catch (err) {
+        console.error(`[Migration] Failed to migrate ${type}/${entity.id}: ${err instanceof Error ? err.message : String(err)}`);
+        errors++;
+      }
+    }
+  }
+  return { migrated, skipped, errors };
+}
+function isLangChainRun(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj;
+  return typeof o.id === "string" && typeof o.name === "string" && typeof o.run_type === "string" && typeof o.start_time === "number" && typeof o.status === "string";
+}
+function mapStatus(status) {
+  if (status === "success") return "completed";
+  if (status === "error") return "failed";
+  if (status === "pending") return "running";
+  return "completed";
+}
+function mapRunType(runType) {
+  switch (runType) {
+    case "chain":
+      return "agent";
+    case "tool":
+      return "tool";
+    case "llm":
+      return "tool";
+    case "retriever":
+      return "tool";
+    case "prompt":
+      return "tool";
+    case "parser":
+      return "tool";
+    default:
+      return "custom";
+  }
+}
+function buildGraph(run, parentId, result) {
+  const nodeId = run.id;
+  const metadata = {};
+  if (run.error) metadata.error = run.error;
+  if (run.inputs) metadata.inputs = run.inputs;
+  if (run.outputs) metadata.outputs = run.outputs;
+  const childIds = [];
+  result.nodes[nodeId] = {
+    id: nodeId,
+    type: mapRunType(run.run_type),
+    name: run.name,
+    startTime: run.start_time,
+    endTime: run.end_time ?? null,
+    status: mapStatus(run.status),
+    parentId,
+    children: childIds,
+    metadata
+  };
+  if (parentId) {
+    result.edges.push({ from: parentId, to: nodeId, type: "called" });
+    const parent = result.nodes[parentId];
+    if (parent) parent.children.push(nodeId);
+  }
+  if (run.child_runs) {
+    for (const child of run.child_runs) {
+      childIds.push(child.id);
+      buildGraph(child, nodeId, result);
+    }
+  }
+}
+function langchainRunToGraphLike(run) {
+  const result = { nodes: {}, edges: [] };
+  buildGraph(run, null, result);
+  return {
+    id: run.id,
+    agentId: run.name,
+    nodes: result.nodes,
+    edges: result.edges,
+    status: mapStatus(run.status),
+    rootNodeId: run.id
+  };
+}
+var langchainAdapter = {
+  canAdapt: isLangChainRun,
+  adapt: langchainRunToGraphLike
+};
+var DEFAULT_FAILURE_RATE_THRESHOLD = 0.2;
+function evaluatePreflight(vault, agentId) {
+  const start = Date.now();
+  const agents = vault.list("agent");
+  const agent = agents.find(
+    (a) => a.name === agentId || a.agentId === agentId
+  );
+  if (!agent) {
+    return {
+      proceed: true,
+      warnings: [],
+      recommendations: [{
+        insight: `Agent '${agentId}' is not registered in the vault. Run the pipeline to create an agent profile.`,
+        sourceAgents: [],
+        confidence: 0
+      }],
+      available: true,
+      _meta: { durationMs: Date.now() - start }
+    };
+  }
+  const data = agent;
+  const failureRate = data.failureRate ?? 0;
+  const totalExecutions = data.totalExecutions ?? 0;
+  const warnings = [];
+  const recommendations = [];
+  let proceed = true;
+  if (failureRate > DEFAULT_FAILURE_RATE_THRESHOLD && totalExecutions >= 5) {
+    warnings.push({
+      rule: "max-failure-rate",
+      threshold: DEFAULT_FAILURE_RATE_THRESHOLD,
+      actual: failureRate,
+      message: `Failure rate ${(failureRate * 100).toFixed(1)}% exceeds threshold ${(DEFAULT_FAILURE_RATE_THRESHOLD * 100).toFixed(0)}%`,
+      source: "agent-profile"
+    });
+  }
+  const l4Entries = queryByLayer(vault, "canon");
+  for (const entry of l4Entries) {
+    const eData = entry;
+    if (eData.enforcement !== "error") continue;
+    const scope = eData.scope ?? "";
+    const body = entry.body + " " + entry.related.join(" ") + " " + scope;
+    if (body.includes(agentId) || body.includes(agent.name) || scope === "*") {
+      warnings.push({
+        rule: entry.name,
+        message: `L4 enforcement policy: ${entry.name}`,
+        source: "L4 canon"
+      });
+      proceed = false;
+    }
+  }
+  const constraints = vault.list("constraint");
+  for (const c of constraints) {
+    if (c.status !== "active") continue;
+    const body = c.body + " " + c.related.join(" ");
+    if (body.includes(agentId) || body.includes(agent.name)) {
+      warnings.push({
+        rule: c.name,
+        message: `Active constraint: ${c.name}`,
+        source: c.layer ? `L${c.layer === "emerging" ? "3" : c.layer === "canon" ? "4" : "?"} ${c.layer}` : "vault"
+      });
+    }
+  }
+  const l3Entries = queryByLayer(vault, "emerging");
+  for (const entry of l3Entries) {
+    if (entry.status !== "pending") continue;
+    const body = entry.body + " " + entry.related.join(" ");
+    if (body.includes(agentId) || body.includes(agent.name)) {
+      warnings.push({
+        rule: entry.name,
+        message: `Pending L3 proposal: ${entry.name}`,
+        source: "L3 emerging"
+      });
+    }
+  }
+  for (const peer of agents) {
+    if (peer.name === agent.name) continue;
+    const peerData = peer;
+    const peerRate = peerData.failureRate ?? 0;
+    const peerExec = peerData.totalExecutions ?? 0;
+    if (peerExec < 5) continue;
+    const gap = failureRate - peerRate;
+    if (gap >= 0.2) {
+      const insights = vault.list("insight");
+      for (const insight of insights) {
+        const sa = insight.source_agents;
+        if (sa && sa.includes(agentId) && sa.includes(peer.name)) {
+          recommendations.push({
+            insight: `${peer.name} has ${((1 - peerRate) * 100).toFixed(0)}% success rate. ${insight.claim ?? insight.name}`,
+            sourceAgents: sa,
+            confidence: insight.confidence_score ?? 0.5
+          });
+        }
+      }
+      if (recommendations.length === 0) {
+        recommendations.push({
+          insight: `Consider approach from ${peer.name} (${((1 - peerRate) * 100).toFixed(0)}% success vs your ${((1 - failureRate) * 100).toFixed(0)}%)`,
+          sourceAgents: [peer.name],
+          confidence: 0.5
+        });
+      }
+    }
+  }
+  return {
+    proceed,
+    warnings,
+    recommendations,
+    available: true,
+    _meta: { durationMs: Date.now() - start }
+  };
+}
+function mapEventType(status) {
+  if (status === "error" || status === "failed") return "execution.failed";
+  return "execution.completed";
+}
+function mapStatus2(status) {
+  if (status === "success") return "completed";
+  if (status === "error" || status === "failed") return "failed";
+  if (status === "running") return "running";
+  return "completed";
+}
+function computePathSignature(nodes) {
+  const nodeList = Object.values(nodes);
+  nodeList.sort((a, b) => (a.startTime ?? 0) - (b.startTime ?? 0));
+  return nodeList.map((n) => `${n.type ?? "?"}:${n.name ?? "?"}`).join("\u2192");
+}
+function traceToEvent(raw) {
+  const agentId = raw.agentId;
+  const status = raw.status;
+  const startTime = raw.startTime;
+  const endTime = raw.endTime;
+  const nodes = raw.nodes ?? {};
+  const graphId = raw.id ?? `${agentId}-${startTime}`;
+  if (!agentId || !startTime) return null;
+  const duration = (endTime ?? startTime) - startTime;
+  const nodeCount = Object.keys(nodes).length;
+  const pathSignature = computePathSignature(nodes);
+  return {
+    eventType: mapEventType(status),
+    graphId,
+    agentId,
+    timestamp: startTime,
+    // Use original timestamp, not Date.now()
+    schemaVersion: 1,
+    status: mapStatus2(status),
+    duration,
+    nodeCount,
+    pathSignature,
+    violations: []
+  };
+}
+function cronRunToEvent(entry, filePath) {
+  if (entry.action !== "finished") return null;
+  const jobId = entry.jobId ?? basename2(filePath, ".jsonl");
+  const agentId = `openclaw:${jobId}`;
+  const startTime = entry.runAtMs ?? entry.ts;
+  const duration = entry.durationMs ?? 0;
+  const status = entry.status;
+  if (!startTime) return null;
+  return {
+    eventType: status === "ok" ? "execution.completed" : "execution.failed",
+    graphId: entry.sessionId ?? `${jobId}-${startTime}`,
+    agentId,
+    timestamp: startTime,
+    schemaVersion: 1,
+    status: status === "ok" ? "completed" : "failed",
+    duration,
+    nodeCount: 1,
+    pathSignature: `cron-job:${jobId}`,
+    violations: []
+  };
+}
+function parseJsonlFile(filePath) {
+  const events = [];
+  try {
+    const content = readFileSync7(filePath, "utf-8");
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        const event = cronRunToEvent(entry, filePath);
+        if (event) events.push(event);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return events;
+}
+function findTraceFiles(dir) {
+  const results = [];
+  if (!existsSync7(dir)) return results;
+  const entries = readdirSync2(dir);
+  for (const entry of entries) {
+    if (entry.startsWith(".") || entry.startsWith("_")) continue;
+    if (entry.includes(".deleted.") || entry.includes(".reset.")) continue;
+    const fullPath = join2(dir, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        results.push(...findTraceFiles(fullPath));
+      } else if (extname2(entry) === ".json" || extname2(entry) === ".jsonl") {
+        results.push(fullPath);
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function scanTraces(dirs) {
+  const events = [];
+  const errors = [];
+  let filesScanned = 0;
+  let filesSkipped = 0;
+  for (const dir of dirs) {
+    const files = findTraceFiles(dir);
+    for (const file of files) {
+      filesScanned++;
+      if (extname2(file) === ".jsonl") {
+        const jsonlEvents = parseJsonlFile(file);
+        events.push(...jsonlEvents);
+        if (jsonlEvents.length === 0) filesSkipped++;
+        continue;
+      }
+      try {
+        const content = readFileSync7(file, "utf-8");
+        const raw = JSON.parse(content);
+        if (raw.eventType && raw.agentId && raw.timestamp) {
+          const event2 = {
+            eventType: mapEventType(String(raw.status ?? raw.eventType)),
+            graphId: String(raw.graphId ?? ""),
+            agentId: String(raw.agentId),
+            timestamp: Number(raw.timestamp),
+            schemaVersion: Number(raw.schemaVersion ?? 1),
+            status: mapStatus2(String(raw.status ?? "completed")),
+            duration: Number(raw.duration ?? 0),
+            nodeCount: Number(raw.nodeCount ?? 1),
+            pathSignature: String(raw.pathSignature ?? ""),
+            violations: Array.isArray(raw.violations) ? raw.violations : []
+          };
+          events.push(event2);
+          continue;
+        }
+        if (!raw.agentId || !raw.nodes) {
+          filesSkipped++;
+          continue;
+        }
+        const event = traceToEvent(raw);
+        if (event) {
+          events.push(event);
+        } else {
+          filesSkipped++;
+        }
+      } catch (err) {
+        filesSkipped++;
+        errors.push(`${file}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  return { events, filesScanned, filesSkipped, errors };
+}
+var PROVIDER_ENV_VARS = {
+  openrouter: "OPENROUTER_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  custom: "SOMA_API_KEY"
+};
+function resolveApiKey(config) {
+  if (config.apiKey) return config.apiKey;
+  if (process.env.SOMA_API_KEY) return process.env.SOMA_API_KEY;
+  const envVar = PROVIDER_ENV_VARS[config.provider];
+  if (envVar && process.env[envVar]) return process.env[envVar];
+  if (envVar) {
+    const dotenvKey = readDotenvKey(envVar);
+    if (dotenvKey) return dotenvKey;
+  }
+  throw new Error(
+    `No API key found for provider "${config.provider}". Set ${envVar ?? "SOMA_API_KEY"} env var or pass --api-key.`
+  );
+}
+function readDotenvKey(varName) {
+  try {
+    const envPath = join3(homedir(), ".env");
+    if (!existsSync8(envPath)) return null;
+    const content = readFileSync8(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      const key = trimmed.slice(0, eqIdx).trim();
+      const value = trimmed.slice(eqIdx + 1).trim();
+      if (key === varName) return value;
+    }
+    return null;
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw new Error(`Failed to read ${join3(homedir(), ".env")}: ${err.message}`);
+  }
+}
+var BASE_URLS = {
+  openrouter: "https://openrouter.ai/api/v1",
+  openai: "https://api.openai.com/v1"
+};
+function createOpenAICompatibleAnalysisFn(baseUrl, model, apiKey, maxTokens) {
+  return async (prompt) => {
+    var _a, _b, _c;
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: maxTokens,
+        temperature: 0.3
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`LLM API error ${response.status}: ${body.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    return ((_c = (_b = (_a = data.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.message) == null ? void 0 : _c.content) ?? "";
+  };
+}
+function createAnthropicAnalysisFn(apiKey, model, maxTokens) {
+  return async (prompt) => {
+    var _a, _b;
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: maxTokens,
+        messages: [{ role: "user", content: prompt }],
+        temperature: 0.3
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Anthropic API error ${response.status}: ${body.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    return ((_b = (_a = data.content) == null ? void 0 : _a.find((c) => c.type === "text")) == null ? void 0 : _b.text) ?? "";
+  };
+}
+function createOpenAICompatibleEmbedFn(baseUrl, model, apiKey) {
+  return async (text) => {
+    var _a, _b;
+    const response = await fetch(`${baseUrl}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        input: text.slice(0, 8e3)
+        // Limit input length
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Embedding API error ${response.status}: ${body.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    const embedding = (_b = (_a = data.data) == null ? void 0 : _a[0]) == null ? void 0 : _b.embedding;
+    if (!embedding) {
+      console.warn("[Embedding] API response missing embedding data, returning null");
+      return null;
+    }
+    return embedding;
+  };
+}
+function createProvider(config) {
+  const apiKey = resolveApiKey(config);
+  const maxTokens = config.maxTokens ?? 4096;
+  let analysisFn;
+  if (config.provider === "anthropic") {
+    analysisFn = createAnthropicAnalysisFn(apiKey, config.model, maxTokens);
+  } else {
+    const baseUrl = config.baseUrl ?? BASE_URLS[config.provider] ?? config.baseUrl;
+    if (!baseUrl) throw new Error(`No base URL for provider "${config.provider}". Set baseUrl in config.`);
+    analysisFn = createOpenAICompatibleAnalysisFn(baseUrl, config.model, apiKey, maxTokens);
+  }
+  let embedFn = null;
+  if (config.embeddingModel) {
+    const embedBaseUrl = config.provider === "anthropic" ? "https://api.openai.com/v1" : config.baseUrl ?? BASE_URLS[config.provider];
+    if (embedBaseUrl) {
+      embedFn = createOpenAICompatibleEmbedFn(embedBaseUrl, config.embeddingModel, apiKey);
+    }
+  }
+  return {
+    analysisFn,
+    embedFn,
+    provider: config.provider,
+    model: config.model
+  };
+}
+export {
+  GovernanceError,
+  KNOWLEDGE_LAYERS,
+  LAYER_REQUIRED_FIELDS,
+  LAYER_SEMANTIC_WEIGHTS,
+  LayerPermissionError,
+  WORKER_WRITE_PERMISSIONS,
+  canWrite,
+  checkDanglingReferences,
+  computePatternSignature,
+  computeToolPatternSignature,
+  cosineSimilarity,
+  createCartographer,
+  createDecayProcessor,
+  createGovernanceAPI,
+  createGuardedBuilder,
+  createHarvester,
+  createJsonVectorStore,
+  createLanceVectorStore,
+  createMilvusVectorStore,
+  createPolicyBridge,
+  createProvider,
+  createReconciler,
+  createSoma,
+  createSomaPolicySource,
+  createSynthesizer,
+  createVault,
+  decisionsToEntities,
+  detectDrift,
+  enforceWritePermission,
+  evaluateAssertions,
+  evaluatePreflight,
+  extractContentFromSession,
+  extractDecisionsFromGraph,
+  extractDecisionsFromLangChain,
+  extractDecisionsFromNodes,
+  extractDecisionsFromSession,
+  extractWikilinks,
+  findVariantsWithModel,
+  getAgentBriefingData,
+  getDecisionReplayData,
+  getEfficiency,
+  isExecutionGraph,
+  isLangChainRun,
+  isLayerEnabled,
+  langchainAdapter,
+  langchainRunToGraphLike,
+  migrateToLayers,
+  parseEntity,
+  queryByLayer,
+  scanTraces,
+  serializeEntity,
+  setLayersConfig,
+  trackConformanceTrend,
+  validateLayerFields,
+  vaultEntityCount,
+  vaultFingerprint,
+  writeToLayer
+};