agentflow-dashboard 0.8.3 → 0.9.0

package/dist/chunk-LZXEKWRO.js

@@ -0,0 +1,1220 @@
+// ../../../soma/dist/chunk-ZZ3NNYCV.js
+import {
+  closeSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statfsSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { createHash, randomUUID } from "crypto";
+import { join, basename, dirname } from "path";
+import { withGuards } from "agentflow-core";
+import { getPathSignature } from "agentflow-core";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+var FRONTMATTER_DELIM = "---";
+var WIKILINK_REGEX = /\[\[([^\]]+)\]\]/g;
+function parseEntity(content, defaults) {
+  var _a;
+  const lines = content.split("\n");
+  let frontmatter = {};
+  let bodyStartLine = 0;
+  if (((_a = lines[0]) == null ? void 0 : _a.trim()) === FRONTMATTER_DELIM) {
+    const endIdx = lines.indexOf(FRONTMATTER_DELIM, 1);
+    if (endIdx > 0) {
+      const yamlLines = lines.slice(1, endIdx);
+      frontmatter = parseSimpleYaml(yamlLines.join("\n"));
+      bodyStartLine = endIdx + 1;
+    }
+  }
+  const body = lines.slice(bodyStartLine).join("\n").trim();
+  const fmRelated = Array.isArray(frontmatter.related) ? frontmatter.related : [];
+  const bodyLinks = extractWikilinks(body);
+  const allRelated = [.../* @__PURE__ */ new Set([...fmRelated, ...bodyLinks])];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const resolvedType = frontmatter.type ?? (defaults == null ? void 0 : defaults.type);
+  if (!resolvedType) console.warn(`[Entity] Missing type in frontmatter and defaults, using 'untyped'`);
+  return {
+    ...frontmatter,
+    type: resolvedType ?? "untyped",
+    id: frontmatter.id ?? (defaults == null ? void 0 : defaults.id) ?? "",
+    name: frontmatter.name ?? (defaults == null ? void 0 : defaults.name) ?? "",
+    status: frontmatter.status ?? (defaults == null ? void 0 : defaults.status) ?? "active",
+    created: frontmatter.created ?? (defaults == null ? void 0 : defaults.created) ?? now,
+    updated: frontmatter.updated ?? (defaults == null ? void 0 : defaults.updated) ?? now,
+    tags: Array.isArray(frontmatter.tags) ? frontmatter.tags : [],
+    related: allRelated,
+    body
+  };
+}
+function serializeEntity(entity) {
+  const { body, ...fm } = entity;
+  const yamlLines = [FRONTMATTER_DELIM];
+  for (const [key, value] of Object.entries(fm)) {
+    if (value === void 0 || value === null) continue;
+    if (key === "body") continue;
+    yamlLines.push(serializeYamlField(key, value));
+  }
+  yamlLines.push(FRONTMATTER_DELIM);
+  return `${yamlLines.join("\n")}
+
+${body ?? ""}
+`;
+}
+function extractWikilinks(text) {
+  const links = [];
+  let match;
+  while ((match = WIKILINK_REGEX.exec(text)) !== null) {
+    if (match[1]) links.push(match[1]);
+  }
+  return [...new Set(links)];
+}
+function parseSimpleYaml(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const colonIdx = line.indexOf(":");
+    if (colonIdx <= 0) continue;
+    const key = line.slice(0, colonIdx).trim();
+    let value = line.slice(colonIdx + 1).trim();
+    if (value.startsWith("{") && value.endsWith("}")) {
+      try {
+        result[key] = JSON.parse(value);
+      } catch {
+        result[key] = value.replace(/^["']|["']$/g, "");
+      }
+      continue;
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+      try {
+        result[key] = JSON.parse(value);
+      } catch {
+        result[key] = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+      }
+    } else if (value === "") {
+      const items = [];
+      while (i + 1 < lines.length && lines[i + 1].trimStart().startsWith("- ")) {
+        i++;
+        items.push(lines[i].trimStart().slice(2).trim());
+      }
+      if (items.length > 0) result[key] = items;
+      else result[key] = "";
+    } else if (value === "true" || value === "false") {
+      result[key] = value === "true";
+    } else if (!Number.isNaN(Number(value)) && value !== "") {
+      result[key] = Number(value);
+    } else {
+      result[key] = value.replace(/^["']|["']$/g, "");
+    }
+  }
+  return result;
+}
+function serializeYamlField(key, value) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) return `${key}: []`;
+    if (value.some((v) => typeof v === "object" && v !== null)) {
+      return `${key}: ${JSON.stringify(value)}`;
+    }
+    if (value.length <= 5 && value.every((v) => typeof v === "string" && v.length < 30)) {
+      return `${key}: [${value.map((v) => JSON.stringify(v)).join(", ")}]`;
+    }
+    return `${key}:
+${value.map((v) => `  - ${typeof v === "string" ? v : JSON.stringify(v)}`).join("\n")}`;
+  }
+  if (typeof value === "object" && value !== null) {
+    return `${key}: ${JSON.stringify(value)}`;
+  }
+  if (typeof value === "string" && (value.includes(":") || value.includes("#") || value.includes("\n"))) {
+    return `${key}: "${value.replace(/"/g, '\\"')}"`;
+  }
+  return `${key}: ${value}`;
+}
+var DEFAULT_BASE_DIR = ".soma/vault";
+var VAULT_ID_FILE = "_vault_id.json";
+var MIN_DISK_SPACE_BYTES = 10 * 1024 * 1024;
+var MAX_MUTATION_LOG_BYTES = 10 * 1024 * 1024;
+var LOCK_TIMEOUT_MS = 5e3;
+var LOCK_POLL_MS = 50;
+var idCounter = 0;
+function vaultFingerprint(baseDir) {
+  const idPath = join(baseDir, VAULT_ID_FILE);
+  if (!existsSync(idPath)) return "";
+  try {
+    const content = readFileSync(idPath, "utf-8");
+    return createHash("sha256").update(content).digest("hex");
+  } catch {
+    return "";
+  }
+}
+function vaultEntityCount(baseDir) {
+  const indexPath = join(baseDir, "_index.json");
+  if (!existsSync(indexPath)) return 0;
+  try {
+    const content = readFileSync(indexPath, "utf-8");
+    const index = JSON.parse(content);
+    if (typeof index === "object" && index !== null) {
+      return Object.keys(index).length;
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireLock(lockPath) {
+  const startTime = Date.now();
+  if (existsSync(lockPath)) {
+    try {
+      const content = readFileSync(lockPath, "utf-8");
+      const pid = parseInt(content.trim(), 10);
+      if (!isNaN(pid) && !isProcessAlive(pid)) {
+        try {
+          unlinkSync(lockPath);
+        } catch {
+        }
+      }
+    } catch {
+      try {
+        unlinkSync(lockPath);
+      } catch {
+      }
+    }
+  }
+  while (true) {
+    try {
+      const fd = openSync(lockPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL);
+      writeFileSync(fd, `${process.pid}
+`);
+      closeSync(fd);
+      return;
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST") throw err;
+      try {
+        const content = readFileSync(lockPath, "utf-8");
+        const pid = parseInt(content.trim(), 10);
+        if (!isNaN(pid) && !isProcessAlive(pid)) {
+          try {
+            unlinkSync(lockPath);
+          } catch {
+          }
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() - startTime >= LOCK_TIMEOUT_MS) {
+        throw new Error(`Vault lock timeout: could not acquire ${lockPath} within ${LOCK_TIMEOUT_MS}ms`);
+      }
+      const waitUntil = Date.now() + LOCK_POLL_MS;
+      while (Date.now() < waitUntil) {
+      }
+    }
+  }
+}
+function releaseLock(lockPath) {
+  try {
+    unlinkSync(lockPath);
+  } catch {
+  }
+}
+function checkDiskSpace(dirPath) {
+  try {
+    const stats = statfsSync(dirPath);
+    const available = stats.bavail * stats.bsize;
+    if (available < MIN_DISK_SPACE_BYTES) {
+      throw new Error(
+        `Insufficient disk space: ${Math.round(available / 1024 / 1024)}MB available, minimum ${Math.round(MIN_DISK_SPACE_BYTES / 1024 / 1024)}MB required`
+      );
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Insufficient disk space")) throw err;
+  }
+}
+function cleanupTempFiles(baseDir) {
+  let cleaned = 0;
+  if (!existsSync(baseDir)) return cleaned;
+  try {
+    for (const entry of readdirSync(baseDir)) {
+      if (entry.startsWith("_") || entry.startsWith(".")) continue;
+      const typePath = join(baseDir, entry);
+      try {
+        const stat = statSync(typePath);
+        if (!stat.isDirectory()) continue;
+        for (const file of readdirSync(typePath)) {
+          if (file.includes(".tmp.")) {
+            try {
+              unlinkSync(join(typePath, file));
+              cleaned++;
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  try {
+    for (const file of readdirSync(baseDir)) {
+      if (file.includes(".tmp.")) {
+        try {
+          unlinkSync(join(baseDir, file));
+          cleaned++;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return cleaned;
+}
+function createVault(config) {
+  const baseDir = (config == null ? void 0 : config.baseDir) ?? DEFAULT_BASE_DIR;
+  const indexPath = join(baseDir, "_index.json");
+  const mutationLogPath = join(baseDir, "_mutations.jsonl");
+  const lockPath = join(baseDir, "_vault.lock");
+  let index = /* @__PURE__ */ new Map();
+  function ensureDir(dir) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+  function entityPath(type, id) {
+    return join(baseDir, type, `${id}.md`);
+  }
+  function writeAtomic(filePath, content) {
+    ensureDir(dirname(filePath));
+    const tmpPath = `${filePath}.tmp.${Date.now()}`;
+    try {
+      writeFileSync(tmpPath, content, "utf-8");
+      renameSync(tmpPath, filePath);
+    } catch (err) {
+      try {
+        unlinkSync(tmpPath);
+      } catch (cleanupErr) {
+        console.warn(`[Vault] Failed to clean up temp file ${tmpPath}:`, cleanupErr.message);
+      }
+      throw err;
+    }
+  }
+  function rotateMutationLog() {
+    try {
+      const stat = statSync(mutationLogPath);
+      if (stat.size >= MAX_MUTATION_LOG_BYTES) {
+        const rotatedPath = join(baseDir, `_mutations.${Date.now()}.jsonl`);
+        renameSync(mutationLogPath, rotatedPath);
+      }
+    } catch {
+    }
+  }
+  function logMutation(entry) {
+    ensureDir(baseDir);
+    rotateMutationLog();
+    writeFileSync(mutationLogPath, `${JSON.stringify(entry)}
+`, { flag: "a" });
+  }
+  function generateId(type, name) {
+    const normalized = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    return normalized || `${type}-${Date.now()}-${idCounter++}`;
+  }
+  function updateIndex(entity, filePath) {
+    index.set(entity.id, {
+      id: entity.id,
+      type: entity.type,
+      name: entity.name,
+      status: entity.status,
+      tags: entity.tags,
+      related: entity.related,
+      path: filePath,
+      layer: entity.layer
+    });
+    saveIndex();
+  }
+  function removeFromIndex(id) {
+    index.delete(id);
+    saveIndex();
+  }
+  function saveIndex() {
+    ensureDir(baseDir);
+    const entries = Object.fromEntries(index);
+    writeAtomic(indexPath, JSON.stringify(entries, null, 2));
+  }
+  function loadIndex() {
+    if (existsSync(indexPath)) {
+      try {
+        const data = JSON.parse(readFileSync(indexPath, "utf-8"));
+        index = new Map(Object.entries(data));
+      } catch {
+        rebuildIndex();
+      }
+    }
+  }
+  function validateIndex() {
+    if (index.size === 0) return true;
+    const entries = Array.from(index.values());
+    const sampleSize = Math.max(1, Math.ceil(entries.length * 0.1));
+    const step = Math.max(1, Math.floor(entries.length / sampleSize));
+    let missingCount = 0;
+    let checkedCount = 0;
+    for (let i = 0; i < entries.length && checkedCount < sampleSize; i += step) {
+      checkedCount++;
+      const entry = entries[i];
+      if (!existsSync(entry.path)) {
+        missingCount++;
+      }
+    }
+    if (missingCount > checkedCount / 2) {
+      rebuildIndex();
+      return false;
+    }
+    return true;
+  }
+  function rebuildIndex() {
+    index = /* @__PURE__ */ new Map();
+    if (!existsSync(baseDir)) return;
+    for (const typeDir of readdirSync(baseDir)) {
+      if (typeDir.startsWith("_") || typeDir.startsWith(".")) continue;
+      const typePath = join(baseDir, typeDir);
+      try {
+        const stat = statSync(typePath);
+        if (!stat.isDirectory()) continue;
+        const files = readdirSync(typePath).filter((f) => f.endsWith(".md"));
+        for (const file of files) {
+          const filePath = join(typePath, file);
+          try {
+            const content = readFileSync(filePath, "utf-8");
+            const entity = parseEntity(content, { type: typeDir, id: basename(file, ".md") });
+            if (!entity.id) entity.id = basename(file, ".md");
+            index.set(entity.id, {
+              id: entity.id,
+              type: entity.type,
+              name: entity.name,
+              status: entity.status,
+              tags: entity.tags,
+              related: entity.related,
+              path: filePath,
+              layer: entity.layer
+            });
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    saveIndex();
+  }
+  const cleanedCount = cleanupTempFiles(baseDir);
+  if (cleanedCount > 0) {
+    process.stderr.write(`[soma/vault] cleaned up ${cleanedCount} orphaned temp file(s)
+`);
+  }
+  if (existsSync(lockPath)) {
+    try {
+      const content = readFileSync(lockPath, "utf-8");
+      const pid = parseInt(content.trim(), 10);
+      if (!isNaN(pid) && !isProcessAlive(pid)) {
+        try {
+          unlinkSync(lockPath);
+        } catch {
+        }
+      }
+    } catch {
+      try {
+        unlinkSync(lockPath);
+      } catch {
+      }
+    }
+  }
+  loadIndex();
+  if (index.size === 0 && existsSync(baseDir)) {
+    rebuildIndex();
+  } else if (index.size > 0) {
+    validateIndex();
+  }
+  const vaultIdPath = join(baseDir, VAULT_ID_FILE);
+  if (existsSync(baseDir) && !existsSync(vaultIdPath)) {
+    writeAtomic(vaultIdPath, JSON.stringify({
+      id: randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }, null, 2) + "\n");
+  }
+  let onReadCallback = config == null ? void 0 : config.onRead;
+  function _readRaw(type, id) {
+    const entry = index.get(id);
+    if (entry && existsSync(entry.path)) {
+      try {
+        const content = readFileSync(entry.path, "utf-8");
+        return parseEntity(content, { type, id });
+      } catch {
+        return null;
+      }
+    }
+    const fp = entityPath(type, id);
+    if (!existsSync(fp)) return null;
+    try {
+      const content = readFileSync(fp, "utf-8");
+      return parseEntity(content, { type, id });
+    } catch {
+      return null;
+    }
+  }
+  return {
+    baseDir,
+    setOnRead(callback) {
+      onReadCallback = callback;
+    },
+    create(partial) {
+      ensureDir(baseDir);
+      checkDiskSpace(baseDir);
+      acquireLock(lockPath);
+      try {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const id = partial.id ?? generateId(partial.type, partial.name);
+        const entity = {
+          ...partial,
+          type: partial.type,
+          id,
+          name: partial.name,
+          status: partial.status ?? "active",
+          created: partial.created ?? now,
+          updated: now,
+          tags: partial.tags ?? [],
+          related: partial.related ?? [],
+          body: partial.body ?? ""
+        };
+        const fp = entityPath(entity.type, entity.id);
+        writeAtomic(fp, serializeEntity(entity));
+        updateIndex(entity, fp);
+        logMutation({ ts: Date.now(), op: "create", id: entity.id, type: entity.type });
+        return entity.id;
+      } finally {
+        releaseLock(lockPath);
+      }
+    },
+    read(type, id) {
+      const entity = _readRaw(type, id);
+      if (entity && onReadCallback) {
+        try {
+          onReadCallback(entity);
+        } catch {
+        }
+      }
+      return entity;
+    },
+    update(id, patch) {
+      if ("layer" in patch && patch.layer !== void 0) {
+        const entry = index.get(id);
+        if (entry && entry.layer !== void 0 && patch.layer !== entry.layer) {
+          throw new Error(
+            `Cannot change layer via vault.update() \u2014 layer changes require writeToLayer or the governance API. Current layer: '${entry.layer}', attempted: '${patch.layer}'`
+          );
+        }
+      }
+      ensureDir(baseDir);
+      checkDiskSpace(baseDir);
+      acquireLock(lockPath);
+      try {
+        const entry = index.get(id);
+        if (!entry) return;
+        const existing = _readRaw(entry.type, id);
+        if (!existing) return;
+        const updated = {
+          ...existing,
+          ...patch,
+          updated: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        writeAtomic(entry.path, serializeEntity(updated));
+        updateIndex(updated, entry.path);
+        logMutation({
+          ts: Date.now(),
+          op: "update",
+          id,
+          type: entry.type,
+          fields: Object.keys(patch)
+        });
+      } finally {
+        releaseLock(lockPath);
+      }
+    },
+    remove(id) {
+      acquireLock(lockPath);
+      try {
+        const entry = index.get(id);
+        if (!entry) return;
+        try {
+          rmSync(entry.path);
+        } catch {
+        }
+        removeFromIndex(id);
+        logMutation({ ts: Date.now(), op: "delete", id, type: entry.type });
+      } finally {
+        releaseLock(lockPath);
+      }
+    },
+    list(type, filter) {
+      const limit = (filter == null ? void 0 : filter.limit) ?? 1e3;
+      const results = [];
+      for (const entry of index.values()) {
+        if (entry.type !== type) continue;
+        if (filter) {
+          let match = true;
+          for (const [key, value] of Object.entries(filter)) {
+            if (key === "limit" || key === "offset") continue;
+            if (entry[key] !== value) {
+              match = false;
+              break;
+            }
+          }
+          if (!match) continue;
+        }
+        const entity = _readRaw(type, entry.id);
+        if (entity) results.push(entity);
+        if (results.length >= limit) break;
+      }
+      return results;
+    },
+    listByLayer(layer, filter) {
+      const limit = (filter == null ? void 0 : filter.limit) ?? 1e3;
+      const results = [];
+      for (const entry of index.values()) {
+        if (entry.layer !== layer) continue;
+        const entity = _readRaw(entry.type, entry.id);
+        if (!entity) continue;
+        if (filter) {
+          let match = true;
+          for (const [key, value] of Object.entries(filter)) {
+            if (key === "limit" || key === "offset" || key === "layer") continue;
+            if (entity[key] !== value) {
+              match = false;
+              break;
+            }
+          }
+          if (!match) continue;
+        }
+        results.push(entity);
+        if (results.length >= limit) break;
+      }
+      return results;
+    },
+    findByTag(tag) {
+      const results = [];
+      for (const entry of index.values()) {
+        if (entry.tags.includes(tag)) {
+          const entity = _readRaw(entry.type, entry.id);
+          if (entity) results.push(entity);
+        }
+      }
+      return results;
+    },
+    findLinked(id) {
+      const entry = index.get(id);
+      if (!entry) return [];
+      const results = [];
+      for (const link of entry.related) {
+        const parts = link.split("/");
+        if (parts.length >= 2) {
+          const linkedType = parts[0];
+          const linkedId = parts.slice(1).join("/");
+          const entity = _readRaw(linkedType, linkedId);
+          if (entity) results.push(entity);
+        }
+      }
+      return results;
+    },
+    rebuildIndex
+  };
+}
+var MAX_REASONING_LEN = 200;
+var MAX_OUTPUT_LEN = 100;
+function truncate(s, max) {
+  if (!s) return void 0;
+  return s.length > max ? s.slice(0, max) + "..." : s;
+}
+function enrichActionName(toolName, args) {
+  var _a;
+  if (!args) return toolName;
+  if ((toolName === "exec" || toolName === "bash") && typeof args.command === "string") {
+    const cmd = args.command.trim();
+    const program = (_a = cmd.split(/\s+/)[0]) == null ? void 0 : _a.replace(/^.*\//, "");
+    if (program) return `${toolName}:${program}`;
+  }
+  if ((toolName === "write" || toolName === "read") && typeof args.file_path === "string") {
+    const parts = args.file_path.split("/").filter(Boolean);
+    for (let i = parts.length - 2; i >= 0; i--) {
+      const seg = parts[i];
+      if (seg.startsWith(".") || /^(home|tmp|var|usr|etc|lib)$/.test(seg) || /^[a-z]{1,3}\d*$/.test(seg)) continue;
+      return `${toolName}:${seg}`;
+    }
+  }
+  if (typeof args.action === "string") {
+    return `${toolName}:${args.action}`;
+  }
+  if (typeof args.url === "string") {
+    try {
+      const host = new URL(args.url).hostname.replace("www.", "");
+      return `${toolName}:${host}`;
+    } catch {
+    }
+  }
+  return toolName;
+}
+function extractDecisionsFromSession(events) {
+  const decisions = [];
+  let lastReasoning;
+  let decisionIndex = 0;
+  const toolResultsById = /* @__PURE__ */ new Map();
+  const toolResultsByParentId = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "message") continue;
+    const msg = event.message;
+    if (!msg) continue;
+    if (msg.role === "tool") {
+      for (const c of msg.content) {
+        if (typeof c === "object" && c !== null) {
+          const item = c;
+          const toolId = item.tool_use_id;
+          if (toolId) {
+            toolResultsById.set(toolId, {
+              isError: !!item.is_error,
+              content: String(item.content ?? "").slice(0, MAX_OUTPUT_LEN)
+            });
+          }
+        }
+      }
+    }
+    if (msg.role === "toolResult") {
+      const parentId = event.parentId;
+      let text = "";
+      let isError = false;
+      for (const c of msg.content) {
+        if (typeof c === "object" && c !== null) {
+          const item = c;
+          if (item.type === "text") text = String(item.text ?? "").slice(0, MAX_OUTPUT_LEN);
+          if (item.is_error) isError = true;
+        }
+      }
+      if (event.isError) isError = true;
+      if (parentId) {
+        toolResultsByParentId.set(parentId, { isError, content: text });
+      }
+    }
+  }
+  for (const event of events) {
+    if (event.type !== "message") continue;
+    const msg = event.message;
+    if (!msg || msg.role !== "assistant") continue;
+    const eventId = event.id;
+    for (const c of msg.content) {
+      if (typeof c !== "object" || c === null) continue;
+      const item = c;
+      if (item.type === "thinking" || item.type === "text") {
+        const text = String(item.text ?? "").trim();
+        if (text) lastReasoning = text;
+      }
+      if (item.type === "tool_use" || item.type === "toolCall") {
+        const toolId = item.id ?? item.tool_use_id;
+        const result = toolResultsById.get(toolId) ?? toolResultsByParentId.get(eventId);
+        const toolName = String(item.name ?? "unattributed");
+        if (!item.name) console.warn(`[Decision-Extraction] Tool call missing name, using 'unattributed'`);
+        const args = item.input ?? item.arguments;
+        const action = enrichActionName(toolName, args);
+        decisions.push({
+          action,
+          reasoning: truncate(lastReasoning, MAX_REASONING_LEN),
+          tool: toolName,
+          args,
+          outcome: result ? result.isError ? "failed" : "ok" : "skipped",
+          output: result ? truncate(result.content, MAX_OUTPUT_LEN) : void 0,
+          error: (result == null ? void 0 : result.isError) ? truncate(result.content, MAX_OUTPUT_LEN) : void 0,
+          durationMs: void 0,
+          index: decisionIndex++
+        });
+        lastReasoning = void 0;
+      }
+    }
+  }
+  return decisions;
+}
+function extractDecisionsFromNodes(nodes) {
+  const nodeList = nodes instanceof Map ? [...nodes.values()] : Object.values(nodes);
+  const sorted = nodeList.filter((n) => n.type === "tool" || n.type === "action" || n.type === "decision").sort((a, b) => (a.startTime ?? 0) - (b.startTime ?? 0));
+  return sorted.map((node, index) => {
+    var _a, _b, _c;
+    const dur = node.endTime != null ? node.endTime - node.startTime : void 0;
+    const isFailed = node.status === "failed" || node.status === "error";
+    const isTimeout = node.status === "timeout" || node.status === "hung";
+    return {
+      action: node.name,
+      tool: node.name,
+      args: node.metadata,
+      outcome: isTimeout ? "timeout" : isFailed ? "failed" : node.status === "skipped" ? "skipped" : "ok",
+      output: truncate(String(((_a = node.state) == null ? void 0 : _a.result) ?? ((_b = node.state) == null ? void 0 : _b.summary) ?? ""), MAX_OUTPUT_LEN) || void 0,
+      error: isFailed ? truncate(String(((_c = node.state) == null ? void 0 : _c.error) ?? ""), MAX_OUTPUT_LEN) : void 0,
+      durationMs: dur,
+      index
+    };
+  });
+}
+function extractDecisionsFromLangChain(run) {
+  const decisions = [];
+  let index = 0;
+  function walk(r, parentName) {
+    if (r.run_type === "tool" || r.run_type === "retriever") {
+      decisions.push({
+        action: r.name,
+        reasoning: parentName ? `Called by ${parentName}` : void 0,
+        tool: r.name,
+        args: r.inputs,
+        outcome: r.status === "error" ? "failed" : "ok",
+        output: r.outputs ? truncate(JSON.stringify(r.outputs), MAX_OUTPUT_LEN) : void 0,
+        error: r.error ? truncate(r.error, MAX_OUTPUT_LEN) : void 0,
+        durationMs: r.end_time - r.start_time,
+        index: index++
+      });
+    }
+    for (const child of r.child_runs ?? []) {
+      walk(child, r.name);
+    }
+  }
+  walk(run);
+  return decisions;
+}
+function computePatternSignature(decisions) {
+  if (decisions.length === 0) return "";
+  const actions = decisions.map(
+    (d) => d.action.toLowerCase().replace(/[-_]\d+$/g, "").replace(/\s+/g, "_")
+  );
+  const collapsed = [];
+  let current = actions[0];
+  let count = 1;
+  for (let i = 1; i < actions.length; i++) {
+    if (actions[i] === current) {
+      count++;
+    } else {
+      collapsed.push(count > 1 ? `${current}[${count}]` : current);
+      current = actions[i];
+      count = 1;
+    }
+  }
+  collapsed.push(count > 1 ? `${current}[${count}]` : current);
+  return collapsed.join("\u2192");
+}
+function computeToolPatternSignature(decisions) {
+  if (decisions.length === 0) return "";
+  const actions = decisions.map((d) => {
+    const action = d.action.toLowerCase().replace(/[-_]\d+$/g, "").replace(/\s+/g, "_");
+    const tool = d.tool ? d.tool.toLowerCase().replace(/[-_]\d+$/g, "") : "";
+    return tool && tool !== action ? `${action}:${tool}` : action;
+  });
+  const collapsed = [];
+  let current = actions[0];
+  let count = 1;
+  for (let i = 1; i < actions.length; i++) {
+    if (actions[i] === current) {
+      count++;
+    } else {
+      collapsed.push(count > 1 ? `${current}[${count}]` : current);
+      current = actions[i];
+      count = 1;
+    }
+  }
+  collapsed.push(count > 1 ? `${current}[${count}]` : current);
+  return collapsed.join("\u2192");
+}
+function trackConformanceTrend(history, newEntry) {
+  return [
+    ...history,
+    {
+      agentId: newEntry.agentId,
+      timestamp: Date.now(),
+      score: newEntry.score,
+      runId: newEntry.runId
+    }
+  ];
+}
+function detectDrift(history, options) {
+  const windowSize = (options == null ? void 0 : options.windowSize) ?? 50;
+  const window = history.slice(-windowSize);
+  const n = window.length;
+  if (n < 10) {
+    return { status: "insufficient_data", slope: 0, r2: 0, windowSize, dataPoints: n };
+  }
+  let sumX = 0;
+  let sumY = 0;
+  let sumXY = 0;
+  let sumX2 = 0;
+  for (let i = 0; i < n; i++) {
+    const y = window[i].score;
+    sumX += i;
+    sumY += y;
+    sumXY += i * y;
+    sumX2 += i * i;
+  }
+  const denominator = n * sumX2 - sumX * sumX;
+  const slope = denominator !== 0 ? (n * sumXY - sumX * sumY) / denominator : 0;
+  const intercept = (sumY - slope * sumX) / n;
+  const meanY = sumY / n;
+  let ssRes = 0;
+  let ssTot = 0;
+  for (let i = 0; i < n; i++) {
+    const y = window[i].score;
+    const yHat = intercept + slope * i;
+    ssRes += (y - yHat) ** 2;
+    ssTot += (y - meanY) ** 2;
+  }
+  const r2 = ssTot > 0 ? 1 - ssRes / ssTot : 0;
+  let status = "stable";
+  if (r2 > 0.3) {
+    status = slope < 0 ? "degrading" : "improving";
+  }
+  const currentScore = window[n - 1].score;
+  const agentId = window[n - 1].agentId;
+  const alert = status === "degrading" ? {
+    type: "conformance_trend_degradation",
+    agentId,
+    currentScore,
+    trendSlope: slope,
+    windowSize: n,
+    message: `Agent '${agentId}' conformance declining (slope: ${slope.toFixed(4)}/run, R\xB2: ${r2.toFixed(2)}, current: ${(currentScore * 100).toFixed(0)}%)`
+  } : void 0;
+  return { status, slope, r2, windowSize: n, dataPoints: n, alert };
+}
+async function evaluateAssertions(assertions, nodeId, timestamp) {
+  const now = timestamp ?? Date.now();
+  const violations = [];
+  for (const assertion of assertions) {
+    const timeoutMs = assertion.timeout ?? 5e3;
+    try {
+      const result = await Promise.race([
+        Promise.resolve(assertion.verify()),
+        new Promise((resolve) => setTimeout(() => resolve("timeout"), timeoutMs))
+      ]);
+      if (result === "timeout" || result === false) {
+        const explanation = {
+          rule: assertion.name,
+          threshold: "pass",
+          actual: result === "timeout" ? "timeout" : "fail",
+          source: "assertion"
+        };
+        violations.push({
+          type: "outcome_mismatch",
+          nodeId,
+          message: `Assertion '${assertion.name}' ${result === "timeout" ? "timed out" : "failed"}. Source: assertion.`,
+          timestamp: now,
+          explanation
+        });
+      }
+    } catch {
+      const explanation = {
+        rule: assertion.name,
+        threshold: "pass",
+        actual: "error",
+        source: "assertion"
+      };
+      violations.push({
+        type: "outcome_mismatch",
+        nodeId,
+        message: `Assertion '${assertion.name}' threw an error. Source: assertion.`,
+        timestamp: now,
+        explanation
+      });
+    }
+  }
+  return violations;
+}
+function createGuardedBuilder(builder, config) {
+  const guarded = withGuards(builder, config);
+  const logger = (config == null ? void 0 : config.logger) ?? ((msg) => console.warn(`[SOMA Guard] ${msg}`));
+  const onViolation = (config == null ? void 0 : config.onViolation) ?? "warn";
+  function handleViolations(violations) {
+    for (const violation of violations) {
+      const message = `Guard violation: ${violation.message}`;
+      switch (onViolation) {
+        case "warn":
+          logger(message);
+          break;
+        case "error":
+          logger(message);
+          break;
+        case "abort":
+          throw new Error(`AgentFlow guard violation: ${violation.message}`);
+      }
+    }
+  }
+  return {
+    ...guarded,
+    async endNodeWithAssertions(nodeId, status, assertions) {
+      guarded.endNode(nodeId, status);
+      const assertionViolations = await evaluateAssertions(assertions, nodeId);
+      handleViolations(assertionViolations);
+    }
+  };
+}
+function extractTokenCost(node) {
+  var _a, _b;
+  const semantic = (_a = node.metadata) == null ? void 0 : _a.semantic;
+  if ((semantic == null ? void 0 : semantic.tokenCost) != null && typeof semantic.tokenCost === "number") {
+    return semantic.tokenCost;
+  }
+  if (((_b = node.state) == null ? void 0 : _b.tokenCost) != null) {
+    return node.state.tokenCost;
+  }
+  return null;
+}
+function median(sorted) {
+  if (sorted.length === 0) return 0;
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+function getEfficiency(graphs) {
+  const allNodeCosts = [];
+  const runs = [];
+  let totalNodesWithCost = 0;
+  let totalNodes = 0;
+  for (const graph of graphs) {
+    let graphTokenCost = 0;
+    let completedNodes = 0;
+    for (const node of graph.nodes.values()) {
+      totalNodes++;
+      const cost = extractTokenCost(node);
+      if (cost !== null) totalNodesWithCost++;
+      const duration = node.startTime && node.endTime != null ? node.endTime - node.startTime : null;
+      allNodeCosts.push({
+        nodeId: node.id,
+        name: node.name,
+        type: node.type,
+        tokenCost: cost,
+        durationMs: duration
+      });
+      if (node.status === "completed") completedNodes++;
+      if (cost !== null) graphTokenCost += cost;
+    }
+    const costPerNode = completedNodes > 0 ? graphTokenCost / completedNodes : 0;
+    runs.push({
+      graphId: graph.id,
+      agentId: graph.agentId,
+      totalTokenCost: graphTokenCost,
+      completedNodes,
+      costPerNode
+    });
+  }
+  const costPerNodeValues = runs.map((r) => r.costPerNode).filter((v) => v > 0).sort((a, b) => a - b);
+  const mean = costPerNodeValues.length > 0 ? costPerNodeValues.reduce((a, b) => a + b, 0) / costPerNodeValues.length : 0;
+  const aggregate = {
+    mean,
+    median: median(costPerNodeValues),
+    p95: percentile(costPerNodeValues, 95)
+  };
+  const flags = [];
+  const medianCostPerNode = aggregate.median;
+  for (let gi = 0; gi < graphs.length; gi++) {
+    const graph = graphs[gi];
+    const run = runs[gi];
+    const nameCounts = /* @__PURE__ */ new Map();
+    const nameCost = /* @__PURE__ */ new Map();
+    for (const node of graph.nodes.values()) {
+      nameCounts.set(node.name, (nameCounts.get(node.name) ?? 0) + 1);
+      const cost = extractTokenCost(node);
+      if (cost !== null) {
+        nameCost.set(node.name, (nameCost.get(node.name) ?? 0) + cost);
+      }
+    }
+    if (medianCostPerNode > 0 && run.costPerNode > 3 * medianCostPerNode) {
+      for (const [name, count] of nameCounts) {
+        if (count > 1) {
+          flags.push({
+            pattern: "wasteful_retry",
+            nodeName: name,
+            retryCount: count,
+            tokenCost: nameCost.get(name) ?? 0,
+            message: `Node "${name}" appears ${count} times with cost-per-node ${run.costPerNode.toFixed(1)} (>3x median ${medianCostPerNode.toFixed(1)})`
+          });
+        }
+      }
+    }
+  }
+  const dataCoverage = totalNodes > 0 ? totalNodesWithCost / totalNodes : 0;
+  return { runs, aggregate, flags, nodeCosts: allNodeCosts, dataCoverage };
+}
+function getModelAwareSignature(graph, dimensions) {
+  var _a, _b;
+  const parts = [];
+  if (dimensions.includes("path")) {
+    parts.push(getPathSignature(graph));
+  }
+  if (dimensions.includes("modelId")) {
+    const models = /* @__PURE__ */ new Set();
+    for (const node of graph.nodes.values()) {
+      const semantic = (_a = node.metadata) == null ? void 0 : _a.semantic;
+      const modelId = (semantic == null ? void 0 : semantic.modelId) ?? ((_b = node.state) == null ? void 0 : _b.modelId);
+      models.add(modelId ?? "unattributed");
+    }
+    parts.push(`model:${[...models].sort().join("+")}`);
+  }
+  if (dimensions.includes("status")) {
+    parts.push(`status:${graph.status}`);
+  }
+  return parts.join("|");
+}
+function findVariantsWithModel(graphs, options) {
+  if (graphs.length === 0) return [];
+  const dimensions = (options == null ? void 0 : options.dimensions) ?? ["path"];
+  const groups = /* @__PURE__ */ new Map();
+  for (const graph of graphs) {
+    const sig = getModelAwareSignature(graph, dimensions);
+    const group = groups.get(sig) ?? [];
+    group.push(graph);
+    groups.set(sig, group);
+  }
+  const total = graphs.length;
+  const variants = [];
+  for (const [pathSignature, groupGraphs] of groups) {
+    variants.push({
+      pathSignature,
+      count: groupGraphs.length,
+      percentage: groupGraphs.length / total * 100,
+      graphIds: groupGraphs.map((g) => g.id),
+      exampleGraph: groupGraphs[0]
+    });
+  }
+  variants.sort((a, b) => {
+    const freqDiff = b.count - a.count;
+    if (freqDiff !== 0) return freqDiff;
+    return a.pathSignature.localeCompare(b.pathSignature);
+  });
+  return variants;
+}
+function getDecisionReplayData(options) {
+  const { trace, vault: vaultDir = ".soma/vault" } = options;
+  if (!trace) {
+    return { error: "Missing trace file path" };
+  }
+  const searchPaths = [trace, `${vaultDir}/../traces/${trace}`];
+  let content = null;
+  let isJsonl = false;
+  for (const p of searchPaths) {
+    if (existsSync2(p)) {
+      content = readFileSync2(p, "utf-8");
+      isJsonl = p.endsWith(".jsonl");
+      break;
+    }
+  }
+  if (!content) {
+    return { error: `Trace not found: ${trace}` };
+  }
+  let decisions;
+  if (isJsonl) {
+    const events = content.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
+    decisions = extractDecisionsFromSession(events);
+  } else {
+    try {
+      const parsed = JSON.parse(content);
+      const nodes = parsed.nodes ?? parsed;
+      decisions = extractDecisionsFromNodes(
+        nodes
+      );
+    } catch {
+      return { error: `Failed to parse trace file: ${trace}` };
+    }
+  }
+  const okCount = decisions.filter((d) => d.outcome === "ok").length;
+  const failedCount = decisions.filter((d) => d.outcome === "failed").length;
+  return {
+    decisions,
+    total: decisions.length,
+    pattern: computePatternSignature(decisions),
+    okCount,
+    failedCount,
+    skippedCount: decisions.length - okCount - failedCount
+  };
+}
+function getAgentBriefingData(options) {
+  const { agent: agentId, vault: vaultDir = ".soma/vault" } = options;
+  if (!agentId) {
+    return { error: "Missing agent ID" };
+  }
+  const vault = createVault({ baseDir: vaultDir });
+  const agents = vault.list("agent");
+  const agent = agents.find((a) => a.name === agentId || a.agentId === agentId);
+  if (!agent) {
+    return {
+      error: `Agent not found: ${agentId}`,
+      available: agents.map((a) => a.name)
+    };
+  }
+  const data = agent;
+  const totalExecutions = data.totalExecutions ?? 0;
+  const failureRate = data.failureRate ?? 0;
+  const failureCount = data.failureCount ?? 0;
+  const status = failureRate > 0.5 ? "CRITICAL" : failureRate > 0.1 ? "DEGRADED" : "HEALTHY";
+  const entityTypes = ["decision", "insight", "constraint", "contradiction", "policy", "content"];
+  const intelligence = [];
+  for (const etype of entityTypes) {
+    for (const e of vault.list(etype)) {
+      const eData = e;
+      const body = e.body + " " + (eData.claim ?? "") + " " + e.related.join(" ");
+      if (body.includes(agentId) || body.includes(agent.name)) {
+        intelligence.push({
+          type: etype,
+          name: e.name,
+          claim: String(eData.claim ?? "").slice(0, 100)
+        });
+      }
+    }
+  }
+  const peers = agents.map((a) => ({
+    name: a.name,
+    failureRate: a.failureRate ?? 0,
+    totalExecutions: a.totalExecutions ?? 0
+  })).filter((a) => a.totalExecutions > 0).sort((a, b) => a.failureRate - b.failureRate);
+  return {
+    agentId,
+    status,
+    failureRate,
+    failureCount,
+    totalExecutions,
+    intelligence,
+    peers
+  };
+}
+
+export {
+  parseEntity,
+  serializeEntity,
+  extractWikilinks,
+  vaultFingerprint,
+  vaultEntityCount,
+  createVault,
+  extractDecisionsFromSession,
+  extractDecisionsFromNodes,
+  extractDecisionsFromLangChain,
+  computePatternSignature,
+  computeToolPatternSignature,
+  trackConformanceTrend,
+  detectDrift,
+  evaluateAssertions,
+  createGuardedBuilder,
+  getEfficiency,
+  findVariantsWithModel,
+  getDecisionReplayData,
+  getAgentBriefingData
+};