@kage-core/kage-graph-mcp 1.1.25 → 1.1.27

package/package.json

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

package/viewer/app.js

@@ -15,6 +15,16 @@
     selected: null,
     metrics: null,
     inbox: null,
+    reports: {
+      quality: null,
+      benchmark: null,
+      contributors: null,
+      decisions: null,
+      risk: null,
+      moduleHealth: null,
+      graphInsights: null,
+      workspace: null
+    },
     pendingPackets: [],
     reviewText: "",
     viewBox: { x: 0, y: 0, width: 1000, height: 660 },
@@ -138,7 +148,9 @@
     reviewCount: document.getElementById("reviewCount"),
     reviewList: document.getElementById("reviewList"),
     proofStatus: document.getElementById("proofStatus"),
-    proofList: document.getElementById("proofList")
+    proofList: document.getElementById("proofList"),
+    intelligenceStatus: document.getElementById("intelligenceStatus"),
+    intelligenceList: document.getElementById("intelligenceList")
   };
 
   var MEMORY_CODE_RELATIONS = new Set(["explains_symbol", "informs_symbol", "fixes_symbol", "applies_to_route", "verified_by_test", "affects_code_path"]);
@@ -277,15 +289,41 @@
     var inboxPath = params.get("inbox");
     var reviewPath = params.get("review");
     var pendingPath = params.get("pending");
+    var qualityPath = params.get("quality");
+    var benchmarkPath = params.get("benchmark");
+    var contributorsPath = params.get("contributors");
+    var decisionsPath = params.get("decisions");
+    var riskPath = params.get("risk");
+    var moduleHealthPath = params.get("moduleHealth") || params.get("module-health");
+    var graphInsightsPath = params.get("graphInsights") || params.get("graph-insights");
+    var workspacePath = params.get("workspace");
     var inferredRoot = inferMemoryRoot(graphPaths[0] || "");
     if (!inboxPath && inferredRoot) inboxPath = inferredRoot + "/inbox.json";
     if (!reviewPath && inferredRoot) reviewPath = inferredRoot + "/review/memory-review.md";
     if (!pendingPath && inferredRoot) pendingPath = inferredRoot + "/pending";
+    if (inferredRoot) {
+      if (!qualityPath) qualityPath = inferredRoot + "/reports/quality.json";
+      if (!benchmarkPath) benchmarkPath = inferredRoot + "/reports/benchmark.json";
+      if (!contributorsPath) contributorsPath = inferredRoot + "/reports/contributors.json";
+      if (!decisionsPath) decisionsPath = inferredRoot + "/reports/decisions.json";
+      if (!riskPath) riskPath = inferredRoot + "/reports/risk.json";
+      if (!moduleHealthPath) moduleHealthPath = inferredRoot + "/reports/module-health.json";
+      if (!graphInsightsPath) graphInsightsPath = inferredRoot + "/reports/graph-insights.json";
+      if (!workspacePath) workspacePath = inferredRoot + "/reports/workspace.json";
+    }
     var jobs = [];
     if (metricsPath) jobs.push(fetchJson(metricsPath).then(function (metrics) { state.metrics = metrics; }));
     if (inboxPath) jobs.push(fetchJson(inboxPath).then(function (inbox) { state.inbox = inbox; }).catch(function () { state.inbox = null; }));
     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 (qualityPath) jobs.push(fetchJson(qualityPath).then(function (report) { state.reports.quality = report; }).catch(function () { state.reports.quality = null; }));
+    if (benchmarkPath) jobs.push(fetchJson(benchmarkPath).then(function (report) { state.reports.benchmark = report; }).catch(function () { state.reports.benchmark = null; }));
+    if (contributorsPath) jobs.push(fetchJson(contributorsPath).then(function (report) { state.reports.contributors = report; }).catch(function () { state.reports.contributors = null; }));
+    if (decisionsPath) jobs.push(fetchJson(decisionsPath).then(function (report) { state.reports.decisions = report; }).catch(function () { state.reports.decisions = null; }));
+    if (riskPath) jobs.push(fetchJson(riskPath).then(function (report) { state.reports.risk = report; }).catch(function () { state.reports.risk = null; }));
+    if (moduleHealthPath) jobs.push(fetchJson(moduleHealthPath).then(function (report) { state.reports.moduleHealth = report; }).catch(function () { state.reports.moduleHealth = null; }));
+    if (graphInsightsPath) jobs.push(fetchJson(graphInsightsPath).then(function (report) { state.reports.graphInsights = report; }).catch(function () { state.reports.graphInsights = null; }));
+    if (workspacePath) jobs.push(fetchJson(workspacePath).then(function (report) { state.reports.workspace = report; }).catch(function () { state.reports.workspace = null; }));
     if (!graphPaths.length && !jobs.length) {
       loadHostedDefault();
       return;
@@ -315,11 +353,23 @@
       loadGraphPath("./data/kage/graph.json"),
       loadGraphPath("./data/kage/code_graph/graph.json"),
       fetchJson("./data/kage/metrics.json").catch(function () { return null; }),
-      fetchJson("./data/kage/inbox.json").catch(function () { return null; })
+      fetchJson("./data/kage/inbox.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/risk.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/contributors.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/decisions.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/module-health.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/graph-insights.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/workspace.json").catch(function () { return null; })
     ]).then(function (items) {
       var merged = mergeNormalizedGraphs([normalizeGraph(items[0]), normalizeGraph(items[1])]);
       state.metrics = items[2];
       state.inbox = items[3];
+      state.reports.risk = items[4];
+      state.reports.contributors = items[5];
+      state.reports.decisions = items[6];
+      state.reports.moduleHealth = items[7];
+      state.reports.graphInsights = items[8];
+      state.reports.workspace = items[9];
       loadNormalizedGraph(merged, "Kage repo graph");
       setAutoLoad("Kage repo graph loaded", true);
     }).catch(function () {
@@ -875,6 +925,7 @@
     renderMetrics();
     renderReviewQueue();
     renderProof();
+    renderIntelligence();
   }
 
   function scheduleRender() {
@@ -2167,6 +2218,442 @@
     });
   }
 
+  function renderIntelligence() {
+    if (!els.intelligenceList) return;
+    var reports = state.reports || {};
+    var cards = buildIntelligenceCards(reports);
+    els.intelligenceList.textContent = "";
+    els.intelligenceStatus.textContent = cards.length ? cards.length + " loaded" : "not loaded";
+    if (!cards.length) {
+      els.intelligenceList.className = "intelligence-list details-empty";
+      els.intelligenceList.textContent = "No repo intelligence reports loaded. Launch with `kage viewer --project <repo>` to load risk, module health, graph insights, and workspace reports.";
+      return;
+    }
+    els.intelligenceList.className = "intelligence-list";
+    cards.forEach(function (card) {
+      var item = document.createElement("article");
+      item.className = "intel-card";
+      item.innerHTML = [
+        "<h3></h3>",
+        "<div class=\"intel-kicker\"></div>",
+        "<div class=\"intel-summary\"></div>",
+        "<ul></ul>"
+      ].join("");
+      item.querySelector("h3").textContent = card.title;
+      item.querySelector(".intel-kicker").textContent = card.kicker;
+      item.querySelector(".intel-summary").textContent = card.summary;
+      var list = item.querySelector("ul");
+      card.rows.slice(0, 5).forEach(function (row) {
+        var li = document.createElement("li");
+        li.innerHTML = "<strong></strong> <span></span>";
+        li.querySelector("strong").textContent = row[0];
+        li.querySelector("span").textContent = row[1];
+        list.appendChild(li);
+      });
+      els.intelligenceList.appendChild(item);
+    });
+    var sections = buildIntelligenceSections(reports);
+    if (sections.length) {
+      var grid = document.createElement("div");
+      grid.className = "intel-deep-grid";
+      sections.forEach(function (section) {
+        grid.appendChild(renderIntelligenceSection(section));
+      });
+      els.intelligenceList.appendChild(grid);
+    }
+  }
+
+  function renderIntelligenceSection(section) {
+    var panel = document.createElement("article");
+    panel.className = "intel-section";
+    var header = document.createElement("div");
+    header.className = "intel-section-header";
+    header.innerHTML = "<div><h3></h3><span></span></div><strong></strong>";
+    header.querySelector("h3").textContent = section.title;
+    header.querySelector("span").textContent = section.kicker || "";
+    header.querySelector("strong").textContent = section.stat || "";
+    panel.appendChild(header);
+    if (section.summary) {
+      var summary = document.createElement("p");
+      summary.className = "intel-section-summary";
+      summary.textContent = section.summary;
+      panel.appendChild(summary);
+    }
+    var list = document.createElement("div");
+    list.className = "intel-section-list";
+    section.rows.slice(0, section.limit || 8).forEach(function (row) {
+      var button = document.createElement("button");
+      button.type = "button";
+      button.className = classNames("intel-row", row.status && "intel-row-" + safeCssName(row.status), row.path && "clickable");
+      button.innerHTML = [
+        "<span class=\"intel-row-main\"><strong></strong><em></em></span>",
+        "<span class=\"intel-row-meta\"></span>",
+        "<span class=\"intel-row-bar\"><i></i></span>"
+      ].join("");
+      button.querySelector("strong").textContent = row.label || "";
+      button.querySelector("em").textContent = row.value || "";
+      button.querySelector(".intel-row-meta").textContent = row.meta || "";
+      button.querySelector(".intel-row-bar i").style.width = clamp(Number(row.score || 0), 4, 100) + "%";
+      if (row.path) {
+        button.title = "Focus " + row.path + " in the graph";
+        button.addEventListener("click", function () {
+          focusGraphPath(row.path);
+        });
+      } else {
+        button.disabled = true;
+      }
+      list.appendChild(button);
+    });
+    panel.appendChild(list);
+    return panel;
+  }
+
+  function buildIntelligenceSections(reports) {
+    var sections = [];
+    var contributors = reports.contributors;
+    var risk = reports.risk;
+    var decisions = reports.decisions;
+    var health = reports.moduleHealth;
+    var insights = reports.graphInsights;
+
+    if (contributors || risk) {
+      var profiles = contributors && Array.isArray(contributors.contributors) ? contributors.contributors : [];
+      var silos = risk && Array.isArray(risk.ownership_silos) ? risk.ownership_silos : [];
+      var maxOwned = Math.max(1, profiles.reduce(function (max, profile) {
+        return Math.max(max, Number(profile.primary_owned_files || 0));
+      }, 0));
+      var rows = profiles.slice(0, 6).map(function (profile) {
+        var owned = Number(profile.primary_owned_files || 0);
+        return {
+          label: shortContributor(profile.contributor),
+          value: owned + " owned",
+          meta: profile.commits_90d + " commits in 90d, " + (profile.silo_files ? profile.silo_files.length : 0) + " silo files",
+          score: owned / maxOwned * 100,
+          status: owned > 0 && profile.silo_files && profile.silo_files.length ? "warn" : "ok",
+        };
+      }).concat(silos.slice(0, 4).map(function (silo) {
+        return {
+          label: silo.file_path,
+          value: Math.round(Number(silo.primary_owner_pct || 0) * 100) + "% owner",
+          meta: shortContributor(silo.primary_owner || "unknown") + ", " + (silo.commit_count_total || 0) + " commits",
+          score: Number(silo.primary_owner_pct || 0) * 100,
+          status: "warn",
+          path: silo.file_path,
+        };
+      }));
+      if (rows.length) {
+        sections.push({
+          title: "Ownership Map",
+          kicker: "who owns what",
+          stat: silos.length + " silos",
+          summary: "Repowise has a dedicated ownership page. Kage now surfaces the same reviewer-critical signal inside the memory viewer, tied back to selectable files.",
+          rows: rows,
+          limit: 10,
+        });
+      }
+    }
+
+    if (health && Array.isArray(health.modules)) {
+      var modules = health.modules.slice().sort(function (a, b) {
+        return Number(a.score || 0) - Number(b.score || 0) || String(a.module).localeCompare(String(b.module));
+      });
+      sections.push({
+        title: "Module Health Map",
+        kicker: "churn / tests / ownership",
+        stat: modules.length + " modules",
+        summary: "Lowest-scoring modules are shown first so the viewer points people toward the riskiest areas instead of only drawing nodes.",
+        rows: modules.slice(0, 8).map(function (item) {
+          return {
+            label: item.module,
+            value: item.grade + " / " + item.score,
+            meta: Array.isArray(item.reasons) ? item.reasons.slice(0, 2).join("; ") : "",
+            score: Number(item.score || 0),
+            status: Number(item.score || 0) < 60 ? "danger" : Number(item.score || 0) < 75 ? "warn" : "ok",
+          };
+        }),
+      });
+    }
+
+    if (decisions && Array.isArray(decisions.coverage_gaps)) {
+      var gaps = decisions.coverage_gaps;
+      sections.push({
+        title: "Onboarding Targets",
+        kicker: "missing repo lore",
+        stat: (decisions.coverage_percent != null ? decisions.coverage_percent + "%" : "n/a"),
+        summary: "Files with centrality, churn, test gaps, or ownership but no linked why-memory. These are the places a future agent is most likely to rediscover context.",
+        rows: gaps.slice(0, 8).map(function (gap) {
+          var score = Math.min(100, Number(gap.dependents || 0) * 18 + Number(gap.churn_90d || 0) * 6 + 12);
+          return {
+            label: gap.path,
+            value: "needs memory",
+            meta: gap.reason || "",
+            score: score,
+            status: "warn",
+            path: gap.path,
+          };
+        }),
+      });
+    }
+
+    if (insights && Array.isArray(insights.communities)) {
+      var communities = insights.communities.slice().sort(function (a, b) {
+        return (b.files ? b.files.length : 0) - (a.files ? a.files.length : 0);
+      });
+      var maxFiles = Math.max(1, communities.reduce(function (max, community) {
+        return Math.max(max, community.files ? community.files.length : 0);
+      }, 0));
+      sections.push({
+        title: "Architecture Communities",
+        kicker: "module clusters",
+        stat: communities.length + " clusters",
+        summary: "Repowise exposes architecture/community views. Kage can show the same high-level clusters next to the memory-code graph so users know what a dense graph means.",
+        rows: communities.slice(0, 8).map(function (community) {
+          var files = community.files || [];
+          var entrypoints = community.entrypoints || [];
+          var routes = community.routes || [];
+          return {
+            label: community.label || ("community " + community.id),
+            value: files.length + " files",
+            meta: entrypoints.length + " entrypoints, " + routes.length + " routes",
+            score: files.length / maxFiles * 100,
+            status: routes.length || entrypoints.length ? "ok" : "",
+            path: files[0],
+          };
+        }),
+      });
+    }
+
+    if (insights && Array.isArray(insights.entry_flows) && insights.entry_flows.length) {
+      sections.push({
+        title: "Execution Flows",
+        kicker: "entrypoint traces",
+        stat: insights.entry_flows.length + " flows",
+        summary: "Short traces make the code graph explainable: where execution starts, what it crosses, and which file to inspect first.",
+        rows: insights.entry_flows.slice(0, 8).map(function (flow) {
+          var path = flow.path || [];
+          return {
+            label: flow.entry,
+            value: Math.max(0, path.length - 1) + " hops",
+            meta: path.slice(0, 5).join(" -> "),
+            score: Math.min(100, Math.max(12, path.length * 18)),
+            status: "ok",
+            path: flow.entry,
+          };
+        }),
+      });
+    }
+
+    if (risk) {
+      var targets = Array.isArray(risk.targets) ? risk.targets : Object.keys(risk.targets || {}).map(function (key) { return risk.targets[key]; });
+      var hotspots = Array.isArray(risk.global_hotspots) ? risk.global_hotspots : [];
+      var riskRows = targets.slice(0, 6).map(function (item) {
+        return {
+          label: item.target,
+          value: item.risk_type || "risk",
+          meta: item.risk_summary || "",
+          score: Math.round(Number(item.hotspot_score || 0) * 100) || Math.min(100, Number(item.dependents_count || 0) * 12 + (item.test_gap ? 24 : 0)),
+          status: item.test_gap || item.risk_type === "single-owner" ? "warn" : "",
+          path: item.target,
+        };
+      }).concat(hotspots.slice(0, 4).map(function (hotspot) {
+        return {
+          label: hotspot.file_path,
+          value: Math.round(Number(hotspot.hotspot_score || 0) * 100) + "% hot",
+          meta: (hotspot.commit_count_90d || 0) + " commits in 90d, owner " + shortContributor(hotspot.primary_owner || "unknown"),
+          score: Math.round(Number(hotspot.hotspot_score || 0) * 100),
+          status: "danger",
+          path: hotspot.file_path,
+        };
+      }));
+      if (riskRows.length) {
+        sections.push({
+          title: "Blast Radius",
+          kicker: "change impact",
+          stat: riskRows.length + " signals",
+          summary: "Change risk is useful only if it is browsable. Rows focus the graph on affected files when the graph node exists.",
+          rows: riskRows,
+          limit: 10,
+        });
+      }
+    }
+
+    return sections.filter(function (section) { return section.rows && section.rows.length; });
+  }
+
+  function focusGraphPath(path) {
+    if (!path) return;
+    var normalized = String(path).replace(/\\/g, "/").replace(/^\.\//, "");
+    var found = state.entities.find(function (entity) {
+      var entityPath = String(entity.path || "").replace(/\\/g, "/").replace(/^\.\//, "");
+      return entityPath === normalized || entity.id === normalized || entity.id === "code:file:" + normalized;
+    }) || state.entities.find(function (entity) {
+      var text = [entity.id, entity.path, entity.name].filter(Boolean).join(" ");
+      return text.indexOf(normalized) !== -1;
+    });
+    if (!found) {
+      els.searchInput.value = normalized;
+      scheduleRender();
+      return;
+    }
+    state.selected = { kind: "entity", id: found.id };
+    els.searchInput.value = normalized;
+    scheduleRender();
+  }
+
+  function shortContributor(value) {
+    var text = String(value || "unknown");
+    return text.replace(/\s*<[^>]+>\s*$/, "");
+  }
+
+  function buildIntelligenceCards(reports) {
+    var cards = [];
+    var memoryCodeEdges = state.edges.filter(isMemoryCodeEdge);
+    if (state.edges.length) {
+      var byRelation = new Map();
+      memoryCodeEdges.forEach(function (edge) {
+        byRelation.set(edge.relation, (byRelation.get(edge.relation) || 0) + 1);
+      });
+      cards.push({
+        title: "Memory-Code Bridge",
+        kicker: "shareable repo lore",
+        summary: memoryCodeEdges.length
+          ? "Approved memory is linked back to concrete code artifacts so future agents can recall why the code exists."
+          : "No memory-code links are visible in the loaded graph.",
+        rows: [
+          ["Links", String(memoryCodeEdges.length)],
+          ["Visible", String(memoryCodeEdges.filter(function (edge) { return state.visibleEdgeIds.has(edge.id); }).length)],
+          ["Precise", String(memoryCodeEdges.filter(function (edge) { return edge.relation !== "affects_code_path"; }).length)]
+        ].concat(Array.from(byRelation.entries()).sort(function (a, b) { return b[1] - a[1] || a[0].localeCompare(b[0]); }).slice(0, 2).map(function (entry) {
+          return [entry[0], String(entry[1])];
+        }))
+      });
+    }
+    var risk = reports.risk;
+    if (risk) {
+      var targets = Array.isArray(risk.targets) ? risk.targets : Object.keys(risk.targets || {}).map(function (key) { return risk.targets[key]; });
+      var silos = Array.isArray(risk.ownership_silos) ? risk.ownership_silos : [];
+      cards.push({
+        title: "Change Risk",
+        kicker: "blast radius",
+        summary: risk.summary || "Local risk report from code graph and git history.",
+        rows: targets.slice(0, 5).map(function (item) {
+          return [item.target || "target", item.risk_summary || [item.risk_type, item.dependents_count != null ? item.dependents_count + " dependents" : ""].filter(Boolean).join(", ")];
+        }).concat(targets.length ? [] : [["Hotspots", Array.isArray(risk.global_hotspots) ? risk.global_hotspots.length + " global" : "none"]])
+          .concat(silos.length ? [["Silos", silos.length + " ownership concentration(s)"]] : [])
+      });
+    }
+    var contributors = reports.contributors;
+    if (contributors) {
+      var profiles = Array.isArray(contributors.contributors) ? contributors.contributors : [];
+      cards.push({
+        title: "Contributors",
+        kicker: "local git profiles",
+        summary: contributors.summary || "Contributor profiles from git history, ownership, modules, and hotspots.",
+        rows: profiles.slice(0, 5).map(function (profile) {
+          return [
+            profile.contributor || "contributor",
+            profile.commits_total + " commits, " + profile.commits_90d + " in 90d, " + profile.primary_owned_files + " owned file(s)"
+          ];
+        }).concat(profiles.length ? [] : [["Profiles", "No contributor profiles loaded"]])
+      });
+    }
+    var decisions = reports.decisions;
+    if (decisions) {
+      var topDecisions = Array.isArray(decisions.top_decisions) ? decisions.top_decisions : [];
+      var gaps = Array.isArray(decisions.coverage_gaps) ? decisions.coverage_gaps : [];
+      cards.push({
+        title: "Decision Memory",
+        kicker: "why / gotchas / runbooks",
+        summary: decisions.summary || "Decision memory connected to code paths, plus important uncovered files.",
+        rows: [
+          ["Coverage", (decisions.coverage_percent != null ? decisions.coverage_percent + "%" : "n/a") + " of code paths"],
+          ["Why-memory", String(decisions.decision_memory_count || 0)],
+          ["Coverage gaps", String(gaps.length)]
+        ].concat(topDecisions.slice(0, 2).map(function (item) {
+          return [item.type || "memory", item.title || item.summary || "decision memory"];
+        })).concat(gaps.slice(0, 1).map(function (gap) {
+          return ["Uncovered", gap.path + " - " + gap.reason];
+        }))
+      });
+    }
+    var health = reports.moduleHealth;
+    if (health) {
+      var modules = Array.isArray(health.modules) ? health.modules : [];
+      cards.push({
+        title: "Module Health",
+        kicker: "churn / tests / ownership",
+        summary: health.summary || "Module scorecards from local graph and git signals.",
+        rows: modules.slice(0, 5).map(function (item) {
+          return [item.module + " " + item.grade, "score " + item.score + " - " + (Array.isArray(item.reasons) ? item.reasons.slice(0, 2).join("; ") : "")];
+        }).concat(modules.length ? [] : [["Modules", "No module scorecards loaded"]])
+      });
+    }
+    var insights = reports.graphInsights;
+    if (insights) {
+      var central = Array.isArray(insights.central_files) ? insights.central_files : [];
+      var cycles = Array.isArray(insights.dependency_cycles) ? insights.dependency_cycles : [];
+      var communities = Array.isArray(insights.communities) ? insights.communities : [];
+      var coverage = Array.isArray(insights.language_coverage) ? insights.language_coverage : [];
+      var edgeMix = insights.edge_mix || {};
+      cards.push({
+        title: "Graph Insights",
+        kicker: "centrality / cycles / communities",
+        summary: insights.summary || "Deterministic source graph intelligence.",
+        rows: [
+          ["Central", central[0] ? central[0].path + " (" + central[0].dependents + " dependents)" : "none"],
+          ["Cycles", String(cycles.length)],
+          ["Communities", String(communities.length)],
+          ["Edges", [edgeMix.imports || 0, "imports", edgeMix.calls || 0, "calls"].join(" ")]
+        ].concat(central.slice(1, 3).map(function (item) { return ["Central", item.path]; }))
+          .concat(coverage.slice(0, 1).map(function (item) { return [item.language, item.coverage_percent + "% indexed across " + item.files + " files"]; }))
+      });
+    }
+    var workspace = reports.workspace;
+    if (workspace) {
+      var repos = Array.isArray(workspace.repos) ? workspace.repos : [];
+      var deps = Array.isArray(workspace.package_dependencies) ? workspace.package_dependencies : [];
+      var contracts = Array.isArray(workspace.route_contracts) ? workspace.route_contracts : [];
+      cards.push({
+        title: "Workspace",
+        kicker: "multi-repo memory",
+        summary: workspace.summary || "Workspace scan across local git repos.",
+        rows: [
+          ["Repos", String(repos.length)],
+          ["Indexed", String(repos.filter(function (repo) { return repo.indexed; }).length)],
+          ["Package deps", String(deps.length)],
+          ["Route links", String(contracts.length)]
+        ].concat(repos.slice(0, 2).map(function (repo) { return [repo.alias, repo.approved_packets + " packets, " + repo.code_files + " files"]; }))
+      });
+    }
+    var quality = reports.quality;
+    if (quality) {
+      cards.push({
+        title: "Memory Quality",
+        kicker: "review gate",
+        summary: quality.summary || "Packet quality, duplicates, staleness, and grounding.",
+        rows: [
+          ["Useful", quality.useful_memory_ratio_percent != null ? quality.useful_memory_ratio_percent + "%" : "n/a"],
+          ["Evidence", quality.evidence_coverage_percent != null ? quality.evidence_coverage_percent + "%" : "n/a"],
+          ["Path grounded", quality.path_grounding_coverage_percent != null ? quality.path_grounding_coverage_percent + "%" : "n/a"],
+          ["Pending", quality.totals ? String(quality.totals.pending) : "n/a"]
+        ]
+      });
+    }
+    var benchmark = reports.benchmark;
+    if (benchmark) {
+      var checks = Array.isArray(benchmark.checks) ? benchmark.checks : [];
+      cards.push({
+        title: "Benchmark",
+        kicker: "local proof",
+        summary: benchmark.summary || "Local memory and graph benchmark signals.",
+        rows: checks.slice(0, 5).map(function (item) {
+          return [item.name || "check", (item.pass ? "pass" : "check") + " - " + item.actual + "/" + item.target];
+        })
+      });
+    }
+    return cards;
+  }
+
   function renderStatusStrip(visibleEntities, visibleEdges, official) {
     if (!els.statusStrip) return;
     var memoryCount = visibleEntities.filter(function (entity) { return entity.graph_kind === "memory"; }).length;

package/viewer/index.html

@@ -4,7 +4,7 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <title>Kage Memory Terminal</title>
-    <link rel="stylesheet" href="./styles.css?v=19">
+    <link rel="stylesheet" href="./styles.css?v=21">
   </head>
   <body>
     <header class="app-header">
@@ -146,6 +146,14 @@
         <div id="proofList" class="proof-list"></div>
       </section>
 
+      <section class="intelligence-panel" aria-label="Repo intelligence">
+        <div class="panel-heading">
+          <h2>Repo Intelligence</h2>
+          <span id="intelligenceStatus">reports</span>
+        </div>
+        <div id="intelligenceList" class="intelligence-list"></div>
+      </section>
+
       <section class="table-panel entities-panel" aria-label="Nodes">
         <div class="panel-heading">
           <h2>Nodes</h2>
@@ -163,6 +171,6 @@
       </section>
     </main>
 
-    <script src="./app.js?v=19"></script>
+    <script src="./app.js?v=21"></script>
   </body>
 </html>