@kage-core/kage-graph-mcp 1.1.8 → 1.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kage-core/kage-graph-mcp",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "description": "Local-first repo memory, code graph, and recall MCP server for coding agents",
   "main": "dist/index.js",
   "files": [

package/viewer/app.js

@@ -7,6 +7,8 @@
     edges: [],
     episodesById: new Map(),
     entityById: new Map(),
+    edgeById: new Map(),
+    degreeById: new Map(),
     positions: new Map(),
     visibleEntityIds: new Set(),
     visibleEdgeIds: new Set(),
@@ -27,8 +29,12 @@
       panning: null,
       hoverNode: null,
       raf: null,
+      drawRaf: null,
       running: false,
-      lastSignature: ""
+      lastSignature: "",
+      tick: 0,
+      idleFrames: 0,
+      adjacency: new Map()
     },
     pan: null
   };
@@ -104,7 +110,7 @@
   };
 
   els.graphFile.addEventListener("change", handleFile);
-  els.searchInput.addEventListener("input", render);
+  els.searchInput.addEventListener("input", scheduleRender);
   els.viewMode.addEventListener("change", render);
   els.typeFilter.addEventListener("change", render);
   els.relationFilter.addEventListener("change", render);
@@ -183,6 +189,10 @@
     state.entityById = new Map(entities.map(function (entity) {
       return [entity.id, entity];
     }));
+    state.edgeById = new Map(edges.map(function (edge) {
+      return [edge.id, edge];
+    }));
+    state.degreeById = buildDegreeMap(edges);
     state.episodesById = new Map(episodes.map(function (episode) {
       return [episode.id, episode];
     }));
@@ -195,6 +205,15 @@
     render();
   }
 
+  function buildDegreeMap(edges) {
+    var degrees = new Map();
+    edges.forEach(function (edge) {
+      degrees.set(edge.from, (degrees.get(edge.from) || 0) + 1);
+      degrees.set(edge.to, (degrees.get(edge.to) || 0) + 1);
+    });
+    return degrees;
+  }
+
   function loadFromUrlParams() {
     var params = new URLSearchParams(window.location.search);
     var graphPaths = []
@@ -214,7 +233,7 @@
     if (reviewPath) jobs.push(fetchText(reviewPath).then(function (text) { state.reviewText = text; }).catch(function () { state.reviewText = ""; }));
     if (pendingPath) jobs.push(loadPending(pendingPath).then(function (packets) { state.pendingPackets = packets; }));
     if (!graphPaths.length && !jobs.length) {
-      setAutoLoad("manual mode", false);
+      loadHostedDemo();
       return;
     }
     setAutoLoad("loading project graph", false);
@@ -239,6 +258,21 @@
     });
   }
 
+  function loadHostedDemo() {
+    setAutoLoad("loading hosted demo graph", false);
+    Promise.all([
+      fetchJson("./demo/graph.json"),
+      fetchJson("./demo/metrics.json").catch(function () { return null; })
+    ]).then(function (items) {
+      var graph = items[0];
+      state.metrics = items[1];
+      loadNormalizedGraph(normalizeGraph(graph), "hosted demo graph");
+      setAutoLoad("hosted demo graph loaded", true);
+    }).catch(function () {
+      setAutoLoad("manual mode", false);
+    });
+  }
+
   function inferMemoryRoot(path) {
     var marker = "/.agent_memory/";
     var index = path.indexOf(marker);
@@ -471,6 +505,7 @@
     if (!state.graph) return;
 
     var query = parseSearchQuery(els.searchInput.value);
+    state.renderQuery = query;
     var mode = els.viewMode.value;
     var type = els.typeFilter.value;
     var relation = els.relationFilter.value;
@@ -509,6 +544,7 @@
       type: type,
       relation: relation,
       scope: els.scopeFilter.value,
+      mode: mode,
       maxNodes: Number(els.maxNodes.value || 90),
       showDependencies: els.showDependencies.checked
     });
@@ -528,6 +564,14 @@
     renderProof();
   }
 
+  function scheduleRender() {
+    if (state.renderRaf) return;
+    state.renderRaf = window.requestAnimationFrame(function () {
+      state.renderRaf = null;
+      render();
+    });
+  }
+
   function refineVisibleGraph(entityIds, edgeIds, options) {
     var entities = new Set(entityIds);
     var edges = new Set(edgeIds);
@@ -552,7 +596,9 @@
         return entityImportance(state.entityById.get(b)) - entityImportance(state.entityById.get(a)) ||
           displayName(state.entityById.get(a)).localeCompare(displayName(state.entityById.get(b)));
       });
-      entities = new Set(ranked.slice(0, options.maxNodes));
+      entities = options.mode === "combined"
+        ? balancedSignalEntities(ranked, options.maxNodes)
+        : new Set(ranked.slice(0, options.maxNodes));
       if (state.selected && state.selected.kind === "entity") entities.add(state.selected.id);
       edges = edgesWithVisibleEndpoints(edges, entities);
     }
@@ -568,6 +614,33 @@
     return { entities: entities, edges: edgesWithVisibleEndpoints(edges, entities) };
   }
 
+  function balancedSignalEntities(rankedIds, maxNodes) {
+    var result = new Set();
+    var memoryIds = rankedIds.filter(function (id) {
+      var entity = state.entityById.get(id);
+      return entity && entity.graph_kind === "memory" && ["memory", "repo", "memory_type", "command"].indexOf(entity.type) !== -1;
+    });
+    var codeIds = rankedIds.filter(function (id) {
+      var entity = state.entityById.get(id);
+      return entity && entity.graph_kind === "code";
+    });
+    var otherMemoryIds = rankedIds.filter(function (id) {
+      var entity = state.entityById.get(id);
+      return entity && entity.graph_kind === "memory" && !memoryIds.includes(id);
+    });
+
+    var memoryBudget = clamp(Math.round(maxNodes * 0.34), 18, Math.min(44, maxNodes));
+    memoryIds.slice(0, memoryBudget).forEach(function (id) { result.add(id); });
+    otherMemoryIds.slice(0, Math.max(0, Math.round(memoryBudget * 0.35))).forEach(function (id) { result.add(id); });
+    codeIds.forEach(function (id) {
+      if (result.size < maxNodes) result.add(id);
+    });
+    rankedIds.forEach(function (id) {
+      if (result.size < maxNodes) result.add(id);
+    });
+    return result;
+  }
+
   function focusSelection(entityIds, edgeIds, selection) {
     var entities = new Set();
     var edges = new Set();
@@ -599,7 +672,7 @@
 
   function edgesWithVisibleEndpoints(edgeIds, entityIds) {
     return new Set(Array.from(edgeIds).filter(function (id) {
-      var edge = state.edges.find(function (candidate) { return candidate.id === id; });
+      var edge = state.edgeById.get(id);
       return edge && entityIds.has(edge.from) && entityIds.has(edge.to);
     }));
   }
@@ -656,6 +729,22 @@
     state.sim.edges = state.edges.filter(function (edge) {
       return state.visibleEdgeIds.has(edge.id) && state.sim.nodeById.has(edge.from) && state.sim.nodeById.has(edge.to);
     });
+    state.sim.adjacency = buildAdjacency(state.sim.edges);
+    if (forceReset) {
+      state.sim.tick = 0;
+      state.sim.idleFrames = 0;
+    }
+  }
+
+  function buildAdjacency(edges) {
+    var adjacency = new Map();
+    edges.forEach(function (edge) {
+      if (!adjacency.has(edge.from)) adjacency.set(edge.from, new Set());
+      if (!adjacency.has(edge.to)) adjacency.set(edge.to, new Set());
+      adjacency.get(edge.from).add(edge.to);
+      adjacency.get(edge.to).add(edge.from);
+    });
+    return adjacency;
   }
 
   function seededPosition(index, total) {
@@ -673,16 +762,28 @@
     state.sim.raf = window.requestAnimationFrame(simulationTick);
   }
 
+  function stopSimulation() {
+    state.sim.running = false;
+    if (state.sim.raf) window.cancelAnimationFrame(state.sim.raf);
+    state.sim.raf = null;
+  }
+
   function simulationTick() {
     if (!state.sim.running) return;
-    stepSimulation();
+    var maxVelocity = stepSimulation();
     drawCanvasGraph();
+    state.sim.tick += 1;
+    state.sim.idleFrames = maxVelocity < 0.035 ? state.sim.idleFrames + 1 : 0;
+    if (!state.sim.dragNode && (state.sim.idleFrames > 24 || state.sim.tick > 220)) {
+      stopSimulation();
+      return;
+    }
     state.sim.raf = window.requestAnimationFrame(simulationTick);
   }
 
   function stepSimulation() {
     var nodes = state.sim.nodes;
-    if (!nodes.length) return;
+    if (!nodes.length) return 0;
     var nodeMap = state.sim.nodeById;
     var count = nodes.length;
     var repulsion = count > 120 ? 3600 : count > 70 ? 2500 : 1700;
@@ -736,11 +837,16 @@
       }
     });
 
+    var maxVelocity = 0;
     nodes.forEach(function (node) {
       if (state.sim.dragNode === node) return;
-      node.x += clamp(node.vx, -8, 8);
-      node.y += clamp(node.vy, -8, 8);
+      var vx = clamp(node.vx, -8, 8);
+      var vy = clamp(node.vy, -8, 8);
+      node.x += vx;
+      node.y += vy;
+      maxVelocity = Math.max(maxVelocity, Math.abs(vx), Math.abs(vy));
     });
+    return maxVelocity;
   }
 
   function drawCanvasGraph() {
@@ -803,7 +909,7 @@
   function drawCanvasEdges(ctx) {
     var nodeMap = state.sim.nodeById;
     var focusId = focusedCanvasNodeId();
-    var query = parseSearchQuery(els.searchInput.value);
+    var query = state.renderQuery || parseSearchQuery(els.searchInput.value);
     var dense = state.sim.nodes.length > 55;
     state.sim.edges.forEach(function (edge) {
       var from = nodeMap.get(edge.from);
@@ -832,15 +938,14 @@
 
   function drawCanvasNodes(ctx) {
     var focusId = focusedCanvasNodeId();
-    var query = parseSearchQuery(els.searchInput.value);
+    var query = state.renderQuery || parseSearchQuery(els.searchInput.value);
     var dense = state.sim.nodes.length > 55;
+    var focusNeighbors = focusId ? state.sim.adjacency.get(focusId) : null;
     state.sim.nodes.forEach(function (node) {
       var entity = node.entity;
       var selected = state.selected && state.selected.kind === "entity" && state.selected.id === node.id;
       var hovered = state.sim.hoverNode && state.sim.hoverNode.id === node.id;
-      var connected = focusId && (node.id === focusId || state.sim.edges.some(function (edge) {
-        return (edge.from === focusId && edge.to === node.id) || (edge.to === focusId && edge.from === node.id);
-      }));
+      var connected = focusId && (node.id === focusId || (focusNeighbors && focusNeighbors.has(node.id)));
       var matches = matchesSearchQuery(entity, query);
       var alpha = !matches ? 0.12 : focusId && !connected ? 0.20 : 1;
       var color = nodeThemeColor(entity);
@@ -1376,9 +1481,7 @@
   }
 
   function degreeOf(id) {
-    return state.edges.reduce(function (sum, edge) {
-      return sum + (edge.from === id || edge.to === id ? 1 : 0);
-    }, 0);
+    return state.degreeById.get(id) || 0;
   }
 
   function entityImportance(entity) {
@@ -1442,6 +1545,9 @@
       state.sim.dragNode.y = world.y;
       state.sim.dragNode.vx = 0;
       state.sim.dragNode.vy = 0;
+      state.sim.tick = 0;
+      state.sim.idleFrames = 0;
+      startSimulation();
     } else if (state.sim.panning) {
       var dx = event.clientX - state.sim.panning.x;
       var dy = event.clientY - state.sim.panning.y;
@@ -1451,7 +1557,7 @@
     }
     state.sim.hoverNode = findCanvasNode(world.x, world.y);
     updateCanvasTooltip(event);
-    drawCanvasGraph();
+    scheduleCanvasDraw();
   }
 
   function endCanvasPointer() {
@@ -1471,7 +1577,7 @@
     state.sim.dragNode = null;
     state.sim.panning = null;
     if (els.tooltip) els.tooltip.classList.remove("visible");
-    drawCanvasGraph();
+    scheduleCanvasDraw();
   }
 
   function handleCanvasWheel(event) {
@@ -1482,7 +1588,15 @@
     state.sim.zoom = clamp(state.sim.zoom * factor, 0.14, 4.5);
     state.sim.panX = event.clientX - rect.left - before.x * state.sim.zoom;
     state.sim.panY = event.clientY - rect.top - before.y * state.sim.zoom;
-    drawCanvasGraph();
+    scheduleCanvasDraw();
+  }
+
+  function scheduleCanvasDraw() {
+    if (state.sim.drawRaf) return;
+    state.sim.drawRaf = window.requestAnimationFrame(function () {
+      state.sim.drawRaf = null;
+      drawCanvasGraph();
+    });
   }
 
   function handleCanvasDoubleClick(event) {

package/viewer/demo/graph.json

@@ -0,0 +1,267 @@
+{
+  "entities": [
+    {
+      "id": "repo:kage",
+      "type": "repo",
+      "name": "Kage",
+      "summary": "Repo memory and source graph for coding agents.",
+      "aliases": ["kage-core/Kage"],
+      "evidence": ["episode:demo-launch"]
+    },
+    {
+      "id": "memory:viewer-balance",
+      "type": "memory",
+      "name": "Viewer balances memory and code",
+      "summary": "Combined mode reserves visible space for memory packets before filling the rest with code graph nodes.",
+      "aliases": ["viewer", "memory graph", "code graph"],
+      "evidence": ["episode:demo-viewer"]
+    },
+    {
+      "id": "memory:kage-context",
+      "type": "memory",
+      "name": "kage_context starts agent sessions",
+      "summary": "Agents should call kage_context at session start to receive repo memory, code graph, metrics, and policy hints.",
+      "aliases": ["codex", "claude code", "mcp"],
+      "evidence": ["episode:demo-context"]
+    },
+    {
+      "id": "memory:repo-local",
+      "type": "memory",
+      "name": "Repo-local memory is git-native",
+      "summary": "Approved repo memory is written as JSON packets under .agent_memory/packets and travels with the repo.",
+      "aliases": ["git", "packets"],
+      "evidence": ["episode:demo-repo-memory"]
+    },
+    {
+      "id": "memory:review-boundary",
+      "type": "memory",
+      "name": "Org/global promotion is reviewed",
+      "summary": "Agents can write repo-local memory, but org/global/public promotion requires explicit human review.",
+      "aliases": ["trust", "review"],
+      "evidence": ["episode:demo-trust"]
+    },
+    {
+      "id": "type:decision",
+      "type": "memory_type",
+      "name": "decision",
+      "summary": "Durable architectural or product choice.",
+      "aliases": [],
+      "evidence": ["episode:demo-viewer"]
+    },
+    {
+      "id": "type:runbook",
+      "type": "memory_type",
+      "name": "runbook",
+      "summary": "How to run, test, debug, or operate the repo.",
+      "aliases": [],
+      "evidence": ["episode:demo-context"]
+    },
+    {
+      "id": "command:kage-viewer",
+      "type": "command",
+      "name": "kage viewer --project .",
+      "summary": "Launches the local auto-loaded Memory Terminal for a repo.",
+      "aliases": ["viewer"],
+      "evidence": ["episode:demo-viewer"]
+    },
+    {
+      "id": "command:kage-refresh",
+      "type": "command",
+      "name": "kage refresh --project .",
+      "summary": "Rebuilds indexes, code graph, memory graph, metrics, and stale memory metadata.",
+      "aliases": ["refresh"],
+      "evidence": ["episode:demo-context"]
+    },
+    {
+      "id": "path:mcp-viewer-app",
+      "type": "path",
+      "name": "mcp/viewer/app.js",
+      "summary": "Static Memory Terminal canvas graph and inspector.",
+      "aliases": ["viewer app"],
+      "evidence": ["episode:demo-viewer"]
+    },
+    {
+      "id": "path:mcp-kernel",
+      "type": "path",
+      "name": "mcp/kernel.ts",
+      "summary": "Memory kernel, validation, indexing, graph, recall, setup, metrics, and PR checks.",
+      "aliases": ["kernel"],
+      "evidence": ["episode:demo-context"]
+    },
+    {
+      "id": "tag:viewer",
+      "type": "tag",
+      "name": "viewer",
+      "summary": "Graph and memory terminal experience.",
+      "aliases": [],
+      "evidence": ["episode:demo-viewer"]
+    },
+    {
+      "id": "tag:repo-memory",
+      "type": "tag",
+      "name": "repo-memory",
+      "summary": "Git-native memory packets shared across agents.",
+      "aliases": [],
+      "evidence": ["episode:demo-repo-memory"]
+    },
+    {
+      "id": "tag:mcp",
+      "type": "tag",
+      "name": "mcp",
+      "summary": "Model Context Protocol integration for coding agents.",
+      "aliases": [],
+      "evidence": ["episode:demo-context"]
+    }
+  ],
+  "edges": [
+    {
+      "id": "edge:repo:viewer",
+      "from": "repo:kage",
+      "to": "memory:viewer-balance",
+      "relation": "contains_memory",
+      "fact": "Kage contains a viewer memory about balancing memory and code graph nodes.",
+      "confidence": 0.95,
+      "evidence": ["episode:demo-viewer"]
+    },
+    {
+      "id": "edge:repo:context",
+      "from": "repo:kage",
+      "to": "memory:kage-context",
+      "relation": "contains_memory",
+      "fact": "Kage contains a session-start memory about kage_context.",
+      "confidence": 0.95,
+      "evidence": ["episode:demo-context"]
+    },
+    {
+      "id": "edge:repo:local",
+      "from": "repo:kage",
+      "to": "memory:repo-local",
+      "relation": "contains_memory",
+      "fact": "Kage contains a memory about git-native repo-local packets.",
+      "confidence": 0.95,
+      "evidence": ["episode:demo-repo-memory"]
+    },
+    {
+      "id": "edge:repo:review",
+      "from": "repo:kage",
+      "to": "memory:review-boundary",
+      "relation": "contains_memory",
+      "fact": "Kage contains a trust-boundary memory for org/global promotion.",
+      "confidence": 0.95,
+      "evidence": ["episode:demo-trust"]
+    },
+    {
+      "id": "edge:viewer:type",
+      "from": "memory:viewer-balance",
+      "to": "type:decision",
+      "relation": "has_type",
+      "fact": "Viewer balance is a product decision.",
+      "confidence": 0.9,
+      "evidence": ["episode:demo-viewer"]
+    },
+    {
+      "id": "edge:context:type",
+      "from": "memory:kage-context",
+      "to": "type:runbook",
+      "relation": "has_type",
+      "fact": "kage_context is operational runbook memory.",
+      "confidence": 0.9,
+      "evidence": ["episode:demo-context"]
+    },
+    {
+      "id": "edge:viewer:path",
+      "from": "memory:viewer-balance",
+      "to": "path:mcp-viewer-app",
+      "relation": "affects_path",
+      "fact": "Viewer balance applies to the static viewer app.",
+      "confidence": 0.92,
+      "evidence": ["episode:demo-viewer"]
+    },
+    {
+      "id": "edge:context:path",
+      "from": "memory:kage-context",
+      "to": "path:mcp-kernel",
+      "relation": "affects_path",
+      "fact": "kage_context is implemented through the memory kernel and MCP server.",
+      "confidence": 0.88,
+      "evidence": ["episode:demo-context"]
+    },
+    {
+      "id": "edge:viewer:command",
+      "from": "memory:viewer-balance",
+      "to": "command:kage-viewer",
+      "relation": "documents_command",
+      "fact": "The viewer memory documents the kage viewer command.",
+      "confidence": 0.9,
+      "evidence": ["episode:demo-viewer"]
+    },
+    {
+      "id": "edge:context:refresh",
+      "from": "memory:kage-context",
+      "to": "command:kage-refresh",
+      "relation": "documents_command",
+      "fact": "Agent context should be refreshed after meaningful changes.",
+      "confidence": 0.86,
+      "evidence": ["episode:demo-context"]
+    },
+    {
+      "id": "edge:viewer:tag",
+      "from": "memory:viewer-balance",
+      "to": "tag:viewer",
+      "relation": "mentions_tag",
+      "fact": "Viewer balance is tagged viewer.",
+      "confidence": 0.9,
+      "evidence": ["episode:demo-viewer"]
+    },
+    {
+      "id": "edge:local:tag",
+      "from": "memory:repo-local",
+      "to": "tag:repo-memory",
+      "relation": "mentions_tag",
+      "fact": "Repo-local memory is tagged repo-memory.",
+      "confidence": 0.9,
+      "evidence": ["episode:demo-repo-memory"]
+    },
+    {
+      "id": "edge:context:tag",
+      "from": "memory:kage-context",
+      "to": "tag:mcp",
+      "relation": "mentions_tag",
+      "fact": "kage_context is exposed through MCP.",
+      "confidence": 0.9,
+      "evidence": ["episode:demo-context"]
+    }
+  ],
+  "episodes": [
+    {
+      "id": "episode:demo-launch",
+      "summary": "Kage demo graph for the hosted Memory Terminal.",
+      "source": "hosted_demo",
+      "created_at": "2026-05-03T00:00:00.000Z"
+    },
+    {
+      "id": "episode:demo-viewer",
+      "summary": "The viewer should show memory and code graph together, not an empty shell.",
+      "source": "hosted_demo",
+      "created_at": "2026-05-03T00:00:00.000Z"
+    },
+    {
+      "id": "episode:demo-context",
+      "summary": "Agents use kage_context and refresh to avoid rediscovery.",
+      "source": "hosted_demo",
+      "created_at": "2026-05-03T00:00:00.000Z"
+    },
+    {
+      "id": "episode:demo-repo-memory",
+      "summary": "Repo-local packets are git-native durable memory.",
+      "source": "hosted_demo",
+      "created_at": "2026-05-03T00:00:00.000Z"
+    },
+    {
+      "id": "episode:demo-trust",
+      "summary": "Org/global sharing is review-gated.",
+      "source": "hosted_demo",
+      "created_at": "2026-05-03T00:00:00.000Z"
+    }
+  ]
+}

package/viewer/demo/metrics.json

@@ -0,0 +1,87 @@
+{
+  "schema_version": 1,
+  "project_dir": "hosted-demo",
+  "repo_key": "kage-core-kage",
+  "generated_at": "2026-05-03T00:00:00.000Z",
+  "code_graph": {
+    "files": 12,
+    "symbols": 1894,
+    "imports": 37,
+    "calls": 2317,
+    "routes": 3,
+    "tests": 64,
+    "packages_and_scripts": 9,
+    "languages": {
+      "typescript": 6,
+      "javascript": 3,
+      "markdown": 3
+    },
+    "parsers": {
+      "typescript": 6,
+      "javascript": 3,
+      "metadata": 3
+    },
+    "source_symbols_by_parser": {
+      "typescript": 1620,
+      "javascript": 274
+    },
+    "indexer_coverage_percent": 100
+  },
+  "memory_graph": {
+    "approved_packets": 22,
+    "pending_packets": 0,
+    "episodes": 5,
+    "entities": 14,
+    "edges": 13,
+    "evidence_backed_edges": 13,
+    "evidence_coverage_percent": 100,
+    "average_quality_score": 97,
+    "duplicate_candidate_pairs": 0
+  },
+  "savings": {
+    "estimated_indexed_source_tokens": 113882,
+    "estimated_memory_tokens": 1800,
+    "estimated_recall_context_tokens": 1800,
+    "estimated_tokens_saved_per_recall": 112082
+  },
+  "harness": {
+    "policy_installed": true,
+    "validation_ok": true,
+    "warnings": 0,
+    "errors": 0,
+    "readiness_score": 100
+  },
+  "pain": {
+    "setup_runbook_coverage_percent": 100,
+    "bug_fix_coverage_percent": 80,
+    "decision_coverage_percent": 100,
+    "code_flow_coverage_percent": 100,
+    "recall_hit_rate_percent": 100,
+    "estimated_rediscovery_avoided": 9,
+    "estimated_tokens_saved": 112082,
+    "time_to_first_use_seconds": 60
+  },
+  "quality": {
+    "totals": {
+      "approved": 22,
+      "pending": 0,
+      "high_signal": 21,
+      "needs_review": 1,
+      "duplicate": 0,
+      "stale": 0,
+      "too_generic": 0
+    },
+    "memory_type_coverage": {
+      "decision": 10,
+      "runbook": 5,
+      "gotcha": 3,
+      "reference": 4
+    },
+    "useful_memory_ratio_percent": 97,
+    "duplicate_burden": 0,
+    "stale_wrong_feedback_rate_percent": 0,
+    "evidence_coverage_percent": 100,
+    "path_grounding_coverage_percent": 100,
+    "approved_to_pending_ratio": 22
+  }
+}