@kage-core/kage-graph-mcp 1.1.34 → 1.1.36

package/viewer/app.js

@@ -13,6 +13,16 @@
     visibleEntityIds: new Set(),
     visibleEdgeIds: new Set(),
     selected: null,
+    viewerPage: "overview",
+    viewerSection: "overview",
+    viewerAction: null,
+    graphActionFilter: "",
+    pathHighlight: {
+      nodes: new Set(),
+      edges: new Set(),
+      direction: "",
+      steps: []
+    },
     metrics: null,
     inbox: null,
     reports: {
@@ -119,10 +129,20 @@
     graphSubhead: document.getElementById("graphSubhead"),
     selectionStatus: document.getElementById("selectionStatus"),
     searchInput: document.getElementById("searchInput"),
+    pathFromInput: document.getElementById("pathFromInput"),
+    pathToInput: document.getElementById("pathToInput"),
+    pathNodeOptions: document.getElementById("pathNodeOptions"),
+    findPath: document.getElementById("findPath"),
+    clearPath: document.getElementById("clearPath"),
+    pathStatus: document.getElementById("pathStatus"),
+    pathResult: document.getElementById("pathResult"),
     viewMode: document.getElementById("viewMode"),
     renderMode: document.getElementById("renderMode"),
     typeFilter: document.getElementById("typeFilter"),
     relationFilter: document.getElementById("relationFilter"),
+    showUntrusted: document.getElementById("showUntrusted"),
+    showUncovered: document.getElementById("showUncovered"),
+    showMemoryCode: document.getElementById("showMemoryCode"),
     scopeFilter: document.getElementById("scopeFilter"),
     maxNodes: document.getElementById("maxNodes"),
     showDependencies: document.getElementById("showDependencies"),
@@ -143,17 +163,75 @@
     entityList: document.getElementById("entityList"),
     edgeList: document.getElementById("edgeList"),
     metricsSummary: document.getElementById("metricsSummary"),
+    graphInsightStatus: document.getElementById("graphInsightStatus"),
+    graphInsights: document.getElementById("graphInsights"),
     entityCount: document.getElementById("entityCount"),
     edgeCount: document.getElementById("edgeCount"),
     reviewCount: document.getElementById("reviewCount"),
+    dashboardStats: document.getElementById("dashboardStats"),
+    dashboardCharts: document.getElementById("dashboardCharts"),
+    memoryStatus: document.getElementById("memoryStatus"),
+    memoryStats: document.getElementById("memoryStats"),
+    memoryOverview: document.getElementById("memoryOverview"),
+    memorySearch: document.getElementById("memorySearch"),
+    memoryFilter: document.getElementById("memoryFilter"),
+    memoryList: document.getElementById("memoryList"),
+    ownersStatus: document.getElementById("ownersStatus"),
+    ownersSummary: document.getElementById("ownersSummary"),
+    ownersList: document.getElementById("ownersList"),
+    reviewOverview: document.getElementById("reviewOverview"),
     reviewList: document.getElementById("reviewList"),
+    proofOverview: document.getElementById("proofOverview"),
     proofStatus: document.getElementById("proofStatus"),
     proofList: document.getElementById("proofList"),
     intelligenceStatus: document.getElementById("intelligenceStatus"),
-    intelligenceList: document.getElementById("intelligenceList")
+    intelligenceList: document.getElementById("intelligenceList"),
+    debugOverview: document.getElementById("debugOverview"),
+    pageEyebrow: document.getElementById("pageEyebrow"),
+    pageTitle: document.getElementById("pageTitle"),
+    viewerPageLinks: typeof document.querySelectorAll === "function" ? Array.from(document.querySelectorAll("[data-viewer-page]")) : [],
+  };
+
+  var PAGE_META = {
+    overview: {
+      eyebrow: "kage://overview",
+      title: "Repo dashboard",
+      summary: "What is safe to change next, what needs attention, and what is ready to hand off."
+    },
+    graph: {
+      eyebrow: "kage://graph",
+      title: "Dependency graph",
+      summary: "Search a file or symbol, then follow connected memory, routes, and tests before editing."
+    },
+    memory: {
+      eyebrow: "kage://memory",
+      title: "Memory library",
+      summary: "Find repo lore by file, feature, bug, command, or decision. Pick a packet to see linked code."
+    },
+    intel: {
+      eyebrow: "kage://risks",
+      title: "Risks",
+      summary: "Files, owners, and modules to inspect before changes. Each card links into the graph."
+    },
+    review: {
+      eyebrow: "kage://review",
+      title: "Review & handoff",
+      summary: "Blockers that must clear before another agent or teammate picks up this branch."
+    },
+    owners: {
+      eyebrow: "kage://owners",
+      title: "Owners & reviewers",
+      summary: "Local git ownership signal. Use it for reviewer routing and bus-factor checks."
+    },
+    data: {
+      eyebrow: "kage://artifacts",
+      title: "Artifacts & diagnostics",
+      summary: "Raw nodes, relations, and indexing health. Use only when graph or recall looks wrong."
+    }
   };
 
   var MEMORY_CODE_RELATIONS = new Set(["explains_symbol", "informs_symbol", "fixes_symbol", "applies_to_route", "verified_by_test", "affects_code_path"]);
+  var MEMORY_PACKET_TYPES = new Set(["memory", "command", "repo_map", "runbook", "bug_fix", "decision", "rationale", "convention", "workflow", "gotcha", "reference", "policy", "issue_context", "code_explanation", "negative_result", "constraint"]);
   var INSPECTOR_CONNECTION_LIMIT = 8;
   var PATH_BRIDGE_EDGE_LIMIT_PER_PATH = 8;
   var PATH_BRIDGE_EDGE_LIMIT_TOTAL = 160;
@@ -161,21 +239,40 @@
   var VISIBLE_EDGE_MIN = 160;
   var VISIBLE_EDGE_MAX = 560;
 
+  state.viewerPage = initialViewerPage();
+  applyViewerPage(state.viewerPage);
+  els.viewerPageLinks.forEach(function (link) {
+    link.addEventListener("click", function (event) {
+      var page = link.getAttribute("data-viewer-page") || "overview";
+      if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || event.button !== 0) return;
+      event.preventDefault();
+      navigateViewerPage(page);
+    });
+  });
   els.graphFile.addEventListener("change", handleFile);
   els.searchInput.addEventListener("input", scheduleRender);
-  els.viewMode.addEventListener("change", render);
+  els.findPath.addEventListener("click", findDependencyPath);
+  els.clearPath.addEventListener("click", clearDependencyPath);
+  els.pathFromInput.addEventListener("keydown", function (event) { if (event.key === "Enter") findDependencyPath(); });
+  els.pathToInput.addEventListener("keydown", function (event) { if (event.key === "Enter") findDependencyPath(); });
+  els.viewMode.addEventListener("change", function () { clearGraphActionFilter(); render(); });
   els.renderMode.addEventListener("change", function () {
     state.lastVisibleSignature = "";
     render();
   });
-  els.typeFilter.addEventListener("change", render);
-  els.relationFilter.addEventListener("change", render);
+  els.typeFilter.addEventListener("change", function () { clearGraphActionFilter(); render(); });
+  els.relationFilter.addEventListener("change", function () { clearGraphActionFilter(); render(); });
   els.scopeFilter.addEventListener("change", render);
   els.maxNodes.addEventListener("change", render);
   els.showDependencies.addEventListener("change", render);
+  if (els.showUntrusted) els.showUntrusted.addEventListener("click", function () { applyGraphActionFilter("untrusted"); });
+  if (els.showUncovered) els.showUncovered.addEventListener("click", function () { applyGraphActionFilter("uncovered"); });
+  if (els.showMemoryCode) els.showMemoryCode.addEventListener("click", function () { applyGraphActionFilter("memory-code"); });
   els.zoomOut.addEventListener("click", function () { zoomGraph(0.82); });
   els.zoomIn.addEventListener("click", function () { zoomGraph(1.22); });
   els.fitView.addEventListener("click", fitActiveGraph);
+  if (els.memorySearch) els.memorySearch.addEventListener("input", renderMemoryLibrary);
+  if (els.memoryFilter) els.memoryFilter.addEventListener("change", renderMemoryLibrary);
   els.canvas.addEventListener("mousedown", startCanvasPointer);
   els.canvas.addEventListener("mousemove", moveCanvasPointer);
   els.canvas.addEventListener("mouseup", endCanvasPointer);
@@ -196,7 +293,9 @@
   window.addEventListener("resize", function () {
     resizeActiveGraph();
   });
-  els.resetView.addEventListener("click", function () {
+  els.resetView.addEventListener("click", resetGraphView);
+
+  function resetGraphView() {
     els.searchInput.value = "";
     els.viewMode.value = "combined";
     els.renderMode.value = "2d";
@@ -206,11 +305,173 @@
     els.maxNodes.value = "90";
     els.showDependencies.checked = false;
     state.selected = null;
+    state.graphActionFilter = "";
+    clearDependencyPath(false);
     state.lastVisibleSignature = "";
     render();
-  });
+  }
   loadFromUrlParams();
 
+  function initialViewerPage() {
+    var fileName = "";
+    try {
+      fileName = String(window.location.pathname || "").split("/").pop() || "index.html";
+    } catch (_error) {
+      fileName = "index.html";
+    }
+    var pageByFile = {
+      "index.html": "overview",
+      "": "overview",
+      "graph.html": "graph",
+      "memory.html": "memory",
+      "owners.html": "owners",
+      "intel.html": "intel",
+      "review.html": "review",
+      "data.html": "data"
+    };
+    return pageByFile[fileName] || "overview";
+  }
+
+  function applyViewerPage(page, updateLinks) {
+    var normalized = normalizeViewerPage(page);
+    state.viewerPage = normalized;
+    if (normalized === "overview") {
+      setViewerSection("overview");
+    } else if (normalized === "graph") {
+      setViewerSection("graph");
+    } else {
+      setViewerSection("graph", pageToAction(normalized));
+    }
+    state.viewerPage = normalized;
+    applyPageHeader(normalized);
+    if (updateLinks !== false) syncViewerPageLinks();
+    syncViewerPageClass();
+  }
+
+  function applyPageHeader(page) {
+    var meta = PAGE_META[page] || PAGE_META.overview;
+    if (els.pageEyebrow) els.pageEyebrow.textContent = meta.eyebrow;
+    if (els.pageTitle) els.pageTitle.textContent = meta.title;
+    if (els.graphSummary && !state.graph) els.graphSummary.textContent = meta.summary;
+    try {
+      if (typeof document !== "undefined" && document.title !== undefined) {
+        document.title = "Kage " + meta.title.toLowerCase() + " viewer";
+      }
+    } catch (_error) {
+      // ignore
+    }
+  }
+
+  function normalizeViewerPage(page) {
+    var normalized = String(page || "overview").toLowerCase();
+    if (normalized === "intelligence") normalized = "intel";
+    if (["overview", "graph", "memory", "owners", "intel", "review", "data"].indexOf(normalized) === -1) return "overview";
+    return normalized;
+  }
+
+  function pageToAction(page) {
+    if (page === "intel") return "intelligence";
+    if (page === "owners") return "intelligence";
+    if (page === "memory") return "memory";
+    if (page === "review") return "review";
+    if (page === "data") return "data";
+    return null;
+  }
+
+  function pageFromSection(section, action) {
+    if (section === "overview") return "overview";
+    if (action === "intelligence") return "intel";
+    if (action === "memory") return "memory";
+    if (action === "review") return "review";
+    if (action === "data") return "data";
+    return "graph";
+  }
+
+  function viewerPageHref(page) {
+    var fileByPage = {
+      overview: "./",
+      graph: "./graph.html",
+      memory: "./memory.html",
+      owners: "./owners.html",
+      intel: "./intel.html",
+      review: "./review.html",
+      data: "./data.html"
+    };
+    var search = "";
+    try {
+      search = window.location.search || "";
+    } catch (_error) {
+      search = "";
+    }
+    return (fileByPage[normalizeViewerPage(page)] || "./") + search;
+  }
+
+  function navigateViewerPage(page) {
+    window.location.href = viewerPageHref(page);
+  }
+
+  function showViewerPageInPlace(page) {
+    applyViewerPage(page);
+    try {
+      window.history.pushState({}, "", viewerPageHref(page));
+    } catch (_error) {
+      // Static/file viewers can ignore history failures; visual state is enough.
+    }
+  }
+
+  function syncViewerPageLinks() {
+    els.viewerPageLinks.forEach(function (link) {
+      var page = normalizeViewerPage(link.getAttribute("data-viewer-page"));
+      link.setAttribute("href", viewerPageHref(page));
+      var active = page === state.viewerPage;
+      link.classList.toggle("active", active);
+      if (active) link.setAttribute("aria-current", "page");
+      else link.removeAttribute("aria-current");
+    });
+  }
+
+  function syncViewerPageClass() {
+    if (!document.body || !document.body.classList) return;
+    document.body.classList.remove(
+      "viewer-page-overview",
+      "viewer-page-graph",
+      "viewer-page-memory",
+      "viewer-page-owners",
+      "viewer-page-intel",
+      "viewer-page-review",
+      "viewer-page-data"
+    );
+    document.body.classList.add("viewer-page-" + normalizeViewerPage(state.viewerPage));
+  }
+
+  function setViewerSection(section, action) {
+    state.viewerSection = section === "graph" ? "graph" : "overview";
+    state.viewerAction = action || null;
+    state.viewerPage = pageFromSection(state.viewerSection, state.viewerAction);
+    if (state.viewerSection === "overview") closeWorkspace();
+    if (document.body && document.body.classList) {
+      document.body.classList.remove("viewer-section-overview", "viewer-section-graph");
+      document.body.classList.add("viewer-section-" + state.viewerSection);
+    }
+    syncViewerPageLinks();
+    syncViewerPageClass();
+    if (state.viewerSection === "graph") resizeActiveGraph();
+  }
+
+  function closeWorkspace() {
+    if (document.body && document.body.classList) {
+      document.body.classList.remove("viewer-workspace-open");
+    }
+  }
+
+  function selectEntity(id, openInspector) {
+    state.selected = { kind: "entity", id: id };
+  }
+
+  function selectEdge(id, openInspector) {
+    state.selected = { kind: "edge", id: id };
+  }
+
   function handleFile(event) {
     var files = Array.from(event.target.files || []);
     if (!files.length) return;
@@ -224,7 +485,8 @@
         state.entityById = new Map();
         state.episodesById = new Map();
         els.emptyState.classList.add("hidden");
-        els.graphSummary.textContent = "Metrics loaded.";
+        var pageMeta = PAGE_META[state.viewerPage] || PAGE_META.overview;
+        els.graphSummary.textContent = state.viewerPage === "graph" ? "Metrics loaded." : pageMeta.summary;
         renderMetrics();
         return;
       }
@@ -258,11 +520,17 @@
       return [episode.id, episode];
     }));
     state.selected = null;
+    closeWorkspace();
+    clearDependencyPath(false);
     state.lastVisibleSignature = "";
 
     populateFilters();
+    populatePathOptions();
     els.emptyState.classList.add("hidden");
-    els.graphSummary.textContent = fileName + " loaded: " + entities.length + " nodes, " + edges.length + " relations.";
+    var meta = PAGE_META[state.viewerPage] || PAGE_META.overview;
+    els.graphSummary.textContent = state.viewerPage === "graph"
+      ? fileName + " loaded: " + entities.length + " nodes, " + edges.length + " relations."
+      : meta.summary;
     render();
   }
 
@@ -277,6 +545,8 @@
 
   function loadFromUrlParams() {
     var params = new URLSearchParams(window.location.search);
+    var requestedSection = String(params.get("section") || "").toLowerCase();
+    if (requestedSection === "graph" || requestedSection === "overview") setViewerSection(requestedSection);
     applyRequestedView(params.get("view") || params.get("mode"));
     applyRequestedRenderMode(params.get("render") || params.get("graphMode"));
     var memoryGraphPaths = splitParamValues(params.getAll("graph"));
@@ -836,6 +1106,188 @@
     });
   }
 
+  function populatePathOptions() {
+    if (!els.pathNodeOptions) return;
+    var seen = new Set();
+    els.pathNodeOptions.textContent = "";
+    pathCandidateEntities().slice(0, 500).forEach(function (entity) {
+      [entity.path, displayName(entity), entity.id].filter(Boolean).forEach(function (value) {
+        var text = String(value);
+        if (seen.has(text)) return;
+        seen.add(text);
+        var option = document.createElement("option");
+        option.value = text;
+        els.pathNodeOptions.appendChild(option);
+      });
+    });
+  }
+
+  function pathCandidateEntities() {
+    return state.entities
+      .filter(function (entity) {
+        return entity.graph_kind === "code" && ["file", "symbol", "route", "test", "script"].indexOf(entity.type) !== -1;
+      })
+      .sort(function (a, b) {
+        return entityImportance(b) - entityImportance(a) || displayName(a).localeCompare(displayName(b));
+      });
+  }
+
+  function resolvePathEntity(value) {
+    var query = String(value || "").trim();
+    if (!query) return null;
+    var lower = query.toLowerCase();
+    var candidates = pathCandidateEntities();
+    var exact = candidates.filter(function (entity) {
+      return String(entity.id || "").toLowerCase() === lower ||
+        String(entity.path || "").toLowerCase() === lower ||
+        displayName(entity).toLowerCase() === lower;
+    });
+    if (exact.length) return exact[0];
+    var partial = candidates.filter(function (entity) {
+      return String(entity.path || "").toLowerCase().indexOf(lower) !== -1 ||
+        displayName(entity).toLowerCase().indexOf(lower) !== -1 ||
+        String(entity.id || "").toLowerCase().indexOf(lower) !== -1;
+    });
+    return partial[0] || null;
+  }
+
+  function codePathEdges() {
+    var relations = new Set(["imports", "imports_external", "defines_symbol", "calls", "covers", "defines_route", "handled_by"]);
+    return state.edges.filter(function (edge) {
+      if (!relations.has(edge.relation)) return false;
+      var from = state.entityById.get(edge.from);
+      var to = state.entityById.get(edge.to);
+      return from && to && from.graph_kind === "code" && to.graph_kind === "code";
+    });
+  }
+
+  function shortestCodePath(fromId, toId, undirected) {
+    var adjacency = new Map();
+    codePathEdges().forEach(function (edge) {
+      if (!adjacency.has(edge.from)) adjacency.set(edge.from, []);
+      adjacency.get(edge.from).push({ to: edge.to, edge: edge });
+      if (undirected) {
+        if (!adjacency.has(edge.to)) adjacency.set(edge.to, []);
+        adjacency.get(edge.to).push({ to: edge.from, edge: edge });
+      }
+    });
+    var queue = [fromId];
+    var seen = new Set([fromId]);
+    var previous = new Map();
+    while (queue.length) {
+      var current = queue.shift();
+      if (current === toId) break;
+      (adjacency.get(current) || []).forEach(function (step) {
+        if (seen.has(step.to)) return;
+        seen.add(step.to);
+        previous.set(step.to, { from: current, edge: step.edge });
+        queue.push(step.to);
+      });
+    }
+    if (!seen.has(toId)) return null;
+    var nodes = [toId];
+    var edges = [];
+    var cursor = toId;
+    while (cursor !== fromId) {
+      var prev = previous.get(cursor);
+      if (!prev) return null;
+      edges.unshift(prev.edge.id);
+      cursor = prev.from;
+      nodes.unshift(cursor);
+    }
+    return { nodes: nodes, edges: edges };
+  }
+
+  function findDependencyPath() {
+    var from = resolvePathEntity(els.pathFromInput.value);
+    var to = resolvePathEntity(els.pathToInput.value);
+    if (!from || !to) {
+      setPathStatus("Could not resolve both endpoints. Try a file path or exact symbol name.", "warn");
+      return;
+    }
+    if (from.id === to.id) {
+      setPathStatus("Pick two different code nodes.", "warn");
+      return;
+    }
+    var direction = "forward";
+    var path = shortestCodePath(from.id, to.id, false);
+    if (!path) {
+      var reverse = shortestCodePath(to.id, from.id, false);
+      if (reverse) {
+        direction = "reverse";
+        path = {
+          nodes: reverse.nodes.slice().reverse(),
+          edges: reverse.edges.slice().reverse()
+        };
+      }
+    }
+    if (!path) {
+      direction = "undirected";
+      path = shortestCodePath(from.id, to.id, true);
+    }
+    if (!path) {
+      state.pathHighlight = { nodes: new Set(), edges: new Set(), direction: "", steps: [] };
+      els.pathResult.textContent = "";
+      els.pathResult.className = "path-result";
+      setPathStatus("No code dependency path found between those nodes.", "warn");
+      render();
+      return;
+    }
+    state.pathHighlight = {
+      nodes: new Set(path.nodes),
+      edges: new Set(path.edges),
+      direction: direction,
+      steps: path.nodes
+    };
+    setPathStatus(path.nodes.length + " nodes, " + path.edges.length + " edge(s), " + direction + " path.", "ok");
+    renderPathResult(path.nodes, path.edges);
+    state.lastVisibleSignature = "";
+    render();
+  }
+
+  function setPathStatus(text, status) {
+    els.pathStatus.textContent = text;
+    els.pathStatus.className = "path-status" + (status ? " " + status : "");
+  }
+
+  function clearDependencyPath(renderNow) {
+    state.pathHighlight = { nodes: new Set(), edges: new Set(), direction: "", steps: [] };
+    if (els.pathFromInput) els.pathFromInput.value = "";
+    if (els.pathToInput) els.pathToInput.value = "";
+    if (els.pathResult) {
+      els.pathResult.textContent = "";
+      els.pathResult.className = "path-result";
+    }
+    if (els.pathStatus) setPathStatus("Pick two code nodes to trace a dependency path.", "");
+    if (renderNow !== false) {
+      state.lastVisibleSignature = "";
+      render();
+    }
+  }
+
+  function renderPathResult(nodes, edges) {
+    els.pathResult.textContent = "";
+    nodes.forEach(function (id, index) {
+      var entity = state.entityById.get(id);
+      var edge = index > 0 ? state.edgeById.get(edges[index - 1]) : null;
+      var button = document.createElement("button");
+      button.type = "button";
+      button.className = "path-step";
+      button.innerHTML = "<strong></strong><span></span>";
+      button.querySelector("strong").textContent = entity ? displayName(entity) : id;
+      button.querySelector("span").textContent = [
+        index === 0 ? "start" : edge ? edge.relation : "path",
+        entity && entity.path ? entity.path : id
+      ].filter(Boolean).join(" | ");
+      button.addEventListener("click", function () {
+        selectEntity(id, true);
+        render();
+      });
+      els.pathResult.appendChild(button);
+    });
+    els.pathResult.className = "path-result visible";
+  }
+
   function layoutGraph(visibleIds) {
     state.positions = new Map();
     var candidates = state.entities.filter(function (entity) {
@@ -908,6 +1360,10 @@
       matchedEdgeIds = new Set(state.edges.filter(function (edge) { return mode === "combined" || edge.graph_kind === mode; }).map(function (edge) { return edge.id; }));
     }
 
+    var actionFiltered = applyMatchedGraphActionFilter(matchedEntityIds, matchedEdgeIds);
+    matchedEntityIds = actionFiltered.entities;
+    matchedEdgeIds = actionFiltered.edges;
+
     var visible = refineVisibleGraph(matchedEntityIds, matchedEdgeIds, {
       query: query,
       type: type,
@@ -926,12 +1382,7 @@
     state.lastVisibleSignature = nextSignature;
 
     renderActiveGraph(graphChanged);
-    renderLists();
-    renderDetails();
-    renderMetrics();
-    renderReviewQueue();
-    renderProof();
-    renderIntelligence();
+    renderPagePanels();
   }
 
   function scheduleRender() {
@@ -942,6 +1393,88 @@
     });
   }
 
+  function renderPagePanels() {
+    if (state.viewerPage === "graph") {
+      renderDetails();
+      renderMetrics();
+      return;
+    }
+    if (state.viewerPage === "memory") {
+      renderDetails();
+      renderMemoryLibrary();
+      return;
+    }
+    if (state.viewerPage === "owners") {
+      renderOwners();
+      return;
+    }
+    if (state.viewerPage === "intel") {
+      renderIntelligence();
+      return;
+    }
+    if (state.viewerPage === "review") {
+      renderReviewQueue();
+      renderProof();
+      return;
+    }
+    if (state.viewerPage === "data") {
+      renderDetails();
+      renderArtifactDiagnostics(state.entities, state.edges);
+      renderLists();
+      return;
+    }
+    renderDashboard();
+  }
+
+  function applyGraphActionFilter(filter) {
+    state.graphActionFilter = state.graphActionFilter === filter ? "" : filter;
+    if (filter === "memory-code") {
+      els.viewMode.value = "combined";
+      els.relationFilter.value = "__memory_code__";
+    } else if (state.graphActionFilter) {
+      els.viewMode.value = "combined";
+      els.relationFilter.value = "";
+    }
+    state.lastVisibleSignature = "";
+    render();
+  }
+
+  function clearGraphActionFilter() {
+    state.graphActionFilter = "";
+  }
+
+  function applyMatchedGraphActionFilter(entityIds, edgeIds) {
+    if (!state.graphActionFilter) return { entities: entityIds, edges: edgeIds };
+    if (state.graphActionFilter === "memory-code") {
+      var memoryCodeEdges = state.edges.filter(isMemoryCodeEdge);
+      return entitiesForEdges(memoryCodeEdges);
+    }
+    if (state.graphActionFilter === "untrusted") {
+      var flagged = state.edges.filter(function (edge) { return reviewStatus(edge) !== "ok"; });
+      return entitiesForEdges(flagged);
+    }
+    if (state.graphActionFilter === "uncovered") {
+      var covered = memoryLinkedCodeKeys();
+      var uncovered = state.entities.filter(function (entity) {
+        return entity.graph_kind === "code" && entity.type === "file" && !covered.has(codeCoverageKey(entity));
+      });
+      var entities = new Set(uncovered.map(function (entity) { return entity.id; }));
+      return { entities: entities, edges: edgesWithVisibleEndpoints(new Set(state.edges.map(function (edge) { return edge.id; })), entities) };
+    }
+    return { entities: entityIds, edges: edgeIds };
+  }
+
+  function entitiesForEdges(edges) {
+    var entities = new Set();
+    var edgeIds = new Set();
+    edges.forEach(function (edge) {
+      edgeIds.add(edge.id);
+      if (state.entityById.has(edge.from)) entities.add(edge.from);
+      if (state.entityById.has(edge.to)) entities.add(edge.to);
+    });
+    return { entities: entities, edges: edgeIds };
+  }
+
   function refineVisibleGraph(entityIds, edgeIds, options) {
     var entities = new Set(entityIds);
     var edges = new Set(edgeIds);
@@ -981,7 +1514,16 @@
       }
     }
 
-    return { entities: entities, edges: capVisibleEdges(edgesWithVisibleEndpoints(edges, entities), entities, options) };
+    if (state.pathHighlight && state.pathHighlight.nodes.size) {
+      state.pathHighlight.nodes.forEach(function (id) { entities.add(id); });
+      state.pathHighlight.edges.forEach(function (id) { edges.add(id); });
+    }
+
+    var cappedEdges = capVisibleEdges(edgesWithVisibleEndpoints(edges, entities), entities, options);
+    if (state.pathHighlight && state.pathHighlight.edges.size) {
+      state.pathHighlight.edges.forEach(function (id) { if (edges.has(id)) cappedEdges.add(id); });
+    }
+    return { entities: entities, edges: cappedEdges };
   }
 
   function capVisibleEdges(edgeIds, entityIds, options) {
@@ -1444,8 +1986,8 @@
     ctx.fillStyle = graphPalette.background;
     ctx.fillRect(0, 0, width, height);
     var gradient = ctx.createRadialGradient(width * 0.52, height * 0.44, 40, width * 0.52, height * 0.44, Math.max(width, height) * 0.72);
-    gradient.addColorStop(0, "rgba(65,255,143,0.080)");
-    gradient.addColorStop(0.48, "rgba(65,255,143,0.018)");
+    gradient.addColorStop(0, "rgba(65,255,143,0.145)");
+    gradient.addColorStop(0.48, "rgba(65,255,143,0.030)");
     gradient.addColorStop(1, "rgba(2,5,3,0)");
     ctx.fillStyle = gradient;
     ctx.fillRect(0, 0, width, height);
@@ -1484,9 +2026,10 @@
       var to = nodeMap.get(edge.to);
       if (!from || !to) return;
       var connected = focusId && (edge.from === focusId || edge.to === focusId);
+      var pathEdge = state.pathHighlight && state.pathHighlight.edges.has(edge.id);
       var matches = matchesSearchQuery(edge, query) || matchesSearchQuery(from.entity, query) || matchesSearchQuery(to.entity, query);
-      var alpha = !matches ? 0.035 : focusId ? (connected ? 0.62 : 0.055) : (dense ? 0.13 : 0.22);
-      var color = hexToRgb(edgeThemeColor(edge, from.entity, to.entity));
+      var alpha = pathEdge ? 0.92 : !matches ? 0.035 : focusId ? (connected ? 0.62 : 0.055) : (dense ? 0.13 : 0.22);
+      var color = hexToRgb(pathEdge ? graphPalette.bridge : edgeThemeColor(edge, from.entity, to.entity));
       var dx = to.x - from.x;
       var dy = to.y - from.y;
       var dist = Math.max(1, Math.sqrt(dx * dx + dy * dy));
@@ -1497,10 +2040,10 @@
       ctx.moveTo(from.x, from.y);
       ctx.quadraticCurveTo(cx, cy, to.x, to.y);
       ctx.strokeStyle = "rgba(" + color.r + "," + color.g + "," + color.b + "," + alpha + ")";
-      ctx.lineWidth = connected ? 2.2 : 1;
+      ctx.lineWidth = pathEdge ? 3 : connected ? 2.2 : 1;
       ctx.stroke();
-      if (connected || (!dense && state.sim.zoom > 1.25)) drawArrow(ctx, from, to, cx, cy, color, alpha);
-      if (connected && state.sim.zoom > 0.62) drawEdgeLabel(ctx, edge, cx, cy);
+      if (pathEdge || connected || (!dense && state.sim.zoom > 1.25)) drawArrow(ctx, from, to, cx, cy, color, alpha);
+      if ((pathEdge || connected) && state.sim.zoom > 0.62) drawEdgeLabel(ctx, edge, cx, cy);
     });
   }
 
@@ -1514,14 +2057,15 @@
       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 || (focusNeighbors && focusNeighbors.has(node.id)));
+      var pathNode = state.pathHighlight && state.pathHighlight.nodes.has(node.id);
       var matches = matchesSearchQuery(entity, query);
-      var alpha = !matches ? 0.12 : focusId && !connected ? 0.20 : 1;
+      var alpha = pathNode ? 1 : !matches ? 0.12 : focusId && !connected ? 0.20 : 1;
       var color = nodeThemeColor(entity);
       ctx.save();
       ctx.globalAlpha = alpha;
-      if (selected || hovered) {
-        ctx.shadowColor = color;
-        ctx.shadowBlur = selected ? 14 : 10;
+      if (selected || hovered || pathNode || entity.graph_kind === "memory") {
+        ctx.shadowColor = pathNode ? graphPalette.bridge : color;
+        ctx.shadowBlur = selected ? 16 : pathNode ? 14 : entity.graph_kind === "memory" ? 9 : 10;
       }
       drawNodeShape(ctx, node.x, node.y, node.r, entity);
       ctx.fillStyle = nodeFillColor(entity);
@@ -1538,18 +2082,18 @@
       }
       ctx.restore();
 
-      if (selected || hovered) {
+      if (selected || hovered || pathNode) {
         ctx.save();
         drawNodeShape(ctx, node.x, node.y, node.r + 4, entity);
-        ctx.strokeStyle = color;
-        ctx.lineWidth = selected ? 2.6 : 1.8;
-        ctx.shadowColor = color;
+        ctx.strokeStyle = pathNode ? graphPalette.bridge : color;
+        ctx.lineWidth = selected ? 2.6 : pathNode ? 2.2 : 1.8;
+        ctx.shadowColor = pathNode ? graphPalette.bridge : color;
         ctx.shadowBlur = 8;
         ctx.stroke();
         ctx.restore();
       }
 
-      var shouldLabel = matches && (selected || hovered || (query.active && matches) || (!dense && state.sim.zoom > 0.75) || (dense && state.sim.zoom > 1.55 && node.r > 13));
+      var shouldLabel = pathNode || (matches && (selected || hovered || (query.active && matches) || (!dense && state.sim.zoom > 0.75) || (dense && state.sim.zoom > 1.55 && node.r > 13)));
       if (shouldLabel) drawNodeLabel(ctx, node, selected || hovered);
     });
   }
@@ -1681,7 +2225,7 @@
         class: "edge-hit"
       });
       hit.addEventListener("click", function () {
-        state.selected = { kind: "edge", id: edge.id };
+        selectEdge(edge.id, true);
         render();
       });
       hit.addEventListener("mousedown", function (event) {
@@ -1733,7 +2277,7 @@
       var title = svgEl("title");
       title.textContent = displayName(entity) + "\n" + (entity.summary || "");
       group.addEventListener("click", function () {
-        state.selected = { kind: "entity", id: entity.id };
+        selectEntity(entity.id, true);
         render();
       });
       group.addEventListener("mousedown", function (event) {
@@ -1764,12 +2308,16 @@
   }
 
   function renderLists() {
-    var visibleEntities = state.entities.filter(function (entity) {
-      return state.visibleEntityIds.has(entity.id);
-    });
-    var visibleEdges = state.edges.filter(function (edge) {
-      return state.visibleEdgeIds.has(edge.id);
-    }).sort(function (a, b) {
+    var visibleEntities = state.viewerPage === "data"
+      ? state.entities.slice()
+      : state.entities.filter(function (entity) {
+        return state.visibleEntityIds.has(entity.id);
+      });
+    var visibleEdges = (state.viewerPage === "data"
+      ? state.edges.slice()
+      : state.edges.filter(function (edge) {
+        return state.visibleEdgeIds.has(edge.id);
+      })).sort(function (a, b) {
       return reviewRank(a) - reviewRank(b);
     });
 
@@ -1778,7 +2326,11 @@
     els.entityList.textContent = "";
     els.edgeList.textContent = "";
 
-    visibleEntities.forEach(function (entity) {
+    var rowLimit = state.viewerPage === "data" ? 40 : 80;
+    var entityRows = visibleEntities.slice(0, rowLimit);
+    var edgeRows = visibleEdges.slice(0, rowLimit);
+
+    entityRows.forEach(function (entity) {
       var button = document.createElement("button");
       button.type = "button";
       button.className = classNames("list-item", state.selected && state.selected.kind === "entity" && state.selected.id === entity.id && "selected");
@@ -1786,13 +2338,16 @@
       button.querySelector(".item-title").textContent = displayName(entity);
       button.querySelector(".item-meta").textContent = (entity.type || "unknown") + " | " + entity.id;
       button.addEventListener("click", function () {
-        state.selected = { kind: "entity", id: entity.id };
+        selectEntity(entity.id, true);
         render();
       });
       els.entityList.appendChild(button);
     });
+    if (visibleEntities.length > entityRows.length) {
+      appendListNote(els.entityList, "Showing " + entityRows.length + " of " + visibleEntities.length + ". Use search to narrow.");
+    }
 
-    visibleEdges.forEach(function (edge) {
+    edgeRows.forEach(function (edge) {
       var button = document.createElement("button");
       button.type = "button";
       button.className = classNames("list-item", state.selected && state.selected.kind === "edge" && state.selected.id === edge.id && "selected");
@@ -1800,18 +2355,30 @@
       button.querySelector(".item-title").textContent = edge.relation || "related";
       button.querySelector(".item-meta").textContent = displayName(state.entityById.get(edge.from)) + " -> " + displayName(state.entityById.get(edge.to)) + " | " + reviewStatus(edge);
       button.addEventListener("click", function () {
-        state.selected = { kind: "edge", id: edge.id };
+        selectEdge(edge.id, true);
         render();
       });
       els.edgeList.appendChild(button);
     });
+    if (visibleEdges.length > edgeRows.length) {
+      appendListNote(els.edgeList, "Showing " + edgeRows.length + " of " + visibleEdges.length + ". Filter by relation or select a node first.");
+    }
+  }
+
+  function appendListNote(parent, text) {
+    var note = document.createElement("div");
+    note.className = "list-note";
+    note.textContent = text;
+    parent.appendChild(note);
   }
 
   function renderDetails() {
     if (!state.selected) {
+      setSelectionBodyState(null);
       els.selectionDetails.className = "details-empty";
-      els.selectionDetails.textContent = "Select an entity or edge.";
+      els.selectionDetails.textContent = "Select a node or relation to see what it means, why it exists, and which connected memory or code to inspect next.";
       els.selectionStatus.textContent = "No selection";
+      if (!state.pathHighlight.steps.length) setPathStatus("Select a code node, then trace to another code node when you need impact proof.", "");
       return;
     }
 
@@ -1820,10 +2387,12 @@
       : state.edges.find(function (edge) { return edge.id === state.selected.id; });
 
     if (!item) {
+      setSelectionBodyState(null);
       els.selectionDetails.textContent = "Selection no longer exists.";
       return;
     }
 
+    setSelectionBodyState(state.selected.kind === "entity" ? item : null);
     els.selectionDetails.className = "";
     els.selectionDetails.textContent = "";
     var title = document.createElement("div");
@@ -1860,6 +2429,32 @@
     els.selectionDetails.appendChild(kind);
     els.selectionDetails.appendChild(rows);
     renderInspectorConnections(item);
+    if (state.selected.kind === "entity" && item.graph_kind === "code") prefillPathFromSelection(true);
+  }
+
+  function setSelectionBodyState(entity) {
+    if (!document.body || !document.body.classList) return;
+    document.body.classList.toggle("has-selection", Boolean(state.selected));
+    document.body.classList.toggle("has-code-selection", Boolean(entity && entity.graph_kind === "code"));
+  }
+
+  function prefillPathFromSelection(silent) {
+    if (!state.selected || state.selected.kind !== "entity") {
+      if (!silent) setPathStatus("Select a code node first. Path tracing is for files, symbols, routes, tests, and scripts.", "warn");
+      return;
+    }
+    var entity = state.entityById.get(state.selected.id);
+    if (!entity || entity.graph_kind !== "code" || ["file", "symbol", "route", "test", "script"].indexOf(entity.type) === -1) {
+      if (!silent) setPathStatus("Select a code node first. Memory nodes are shown through memory-code links, not code path tracing.", "warn");
+      return;
+    }
+    if (!els.pathFromInput.value || silent) {
+      els.pathFromInput.value = entity.path || displayName(entity) || entity.id;
+    }
+    if (!silent) {
+      els.pathToInput.focus();
+      setPathStatus("Selected " + displayName(entity) + ". Pick a target test, route, file, or symbol to trace impact.", "ok");
+    }
   }
 
   function entityDetailRows(entity) {
@@ -1987,6 +2582,23 @@
     return Boolean(edge && (edge.memory_code_link || isMemoryCodeRelation(edge.relation)));
   }
 
+  function codeCoverageKey(entity) {
+    if (!entity) return "";
+    return String(entity.path || entity.id || "").replace(/\\/g, "/").replace(/^\.\//, "");
+  }
+
+  function memoryLinkedCodeKeys() {
+    var keys = new Set();
+    state.edges.filter(isMemoryCodeEdge).forEach(function (edge) {
+      [state.entityById.get(edge.from), state.entityById.get(edge.to)].forEach(function (entity) {
+        if (!entity || entity.graph_kind !== "code") return;
+        var key = codeCoverageKey(entity);
+        if (key) keys.add(key);
+      });
+    });
+    return keys;
+  }
+
   function connectionImportance(link) {
     var relation = String(link.edge.relation || "");
     var score = entityImportance(link.other);
@@ -2029,7 +2641,8 @@
       button.querySelector(".detail-link-meta").textContent = item.meta;
       button.querySelector(".detail-link-body").textContent = item.body;
       button.addEventListener("click", function () {
-        state.selected = item.entity ? { kind: "entity", id: item.entity.id } : { kind: "edge", id: item.edge.id };
+        if (item.entity) selectEntity(item.entity.id, true);
+        else selectEdge(item.edge.id, true);
         render();
       });
       list.appendChild(button);
@@ -2088,13 +2701,15 @@
     }).length;
     var evidenceEdges = visibleEdges.filter(function (edge) { return Array.isArray(edge.evidence) && edge.evidence.length > 0; }).length;
     var official = state.metrics;
+    var memoryCodeLinks = state.edges.filter(isMemoryCodeEdge).length;
+    var pendingReview = official && official.memory_graph ? Number(firstNumber(official.memory_graph.pending_packets, 0)) : 0;
     var metrics = official ? [
-      ["Readiness", official.harness.readiness_score + "/100"],
-      ["Code Files", official.code_graph.files],
-      ["Structural Symbols", official.structural_index ? official.structural_index.symbols : official.code_graph.symbols],
-      ["Parser Coverage", official.code_graph.indexer_coverage_percent + "%"],
-      ["Cache Hits", official.structural_index ? official.structural_index.cache_hits : official.code_graph.cache_hits],
-      ["Tokens Saved", official.savings ? official.savings.estimated_tokens_saved_per_recall : "n/a"]
+      ["Validation", official.harness && official.harness.validation_ok ? "Clean" : "Check"],
+      ["Review queue", pendingReview ? pendingReview + " pending" : "Clear"],
+      ["Reusable memory", official.memory_graph ? official.memory_graph.approved_packets + " packets" : "n/a"],
+      ["Code indexed", official.structural_index ? official.structural_index.files + " files" : official.code_graph.files + " files"],
+      ["Parser coverage", official.code_graph.indexer_coverage_percent + "%"],
+      ["Memory-code links", memoryCodeLinks]
     ] : [
       ["Nodes", visibleEntities.length + "/" + state.entities.length],
       ["Relations", visibleEdges.length + "/" + state.edges.length],
@@ -2116,6 +2731,625 @@
     els.workspaceMode.textContent = (els.viewMode.value || "combined").replace(/^./, function (letter) { return letter.toUpperCase(); });
     els.graphSubhead.textContent = visibleEntities.length + " visible nodes and " + visibleEdges.length + " visible relations" +
       (hiddenDependencies && !els.showDependencies.checked ? " (" + hiddenDependencies + " dependency/noise nodes hidden)." : ".");
+    renderGraphInsights(visibleEntities, visibleEdges, hiddenDependencies);
+    updateGraphActionButtons();
+  }
+
+  function renderGraphInsights(visibleEntities, visibleEdges, hiddenDependencies) {
+    if (!els.graphInsights) return;
+    els.graphInsights.textContent = "";
+    var allMemoryCode = state.edges.filter(isMemoryCodeEdge);
+    var visibleMemoryCode = visibleEdges.filter(isMemoryCodeEdge);
+    var reviewFlags = visibleEdges.filter(function (edge) { return reviewStatus(edge) !== "ok"; });
+    var visibleCodeFiles = visibleEntities.filter(function (entity) { return entity.graph_kind === "code" && entity.type === "file"; });
+    var coveredKeys = memoryLinkedCodeKeys();
+    var uncoveredCodeFiles = visibleCodeFiles.filter(function (entity) { return !coveredKeys.has(codeCoverageKey(entity)); });
+    var evidenceEdges = visibleEdges.filter(function (edge) { return Array.isArray(edge.evidence) && edge.evidence.length; }).length;
+    var evidencePercent = visibleEdges.length ? Math.round(evidenceEdges / visibleEdges.length * 100) : 0;
+    var coveragePercent = visibleCodeFiles.length ? Math.round((visibleCodeFiles.length - uncoveredCodeFiles.length) / visibleCodeFiles.length * 100) : 0;
+    var queryActive = parseSearchQuery(els.searchInput.value).active;
+    var hasActiveFilters = queryActive || state.graphActionFilter || els.viewMode.value !== "combined" || els.typeFilter.value || els.relationFilter.value || els.showDependencies.checked;
+    if (!visibleEntities.length || hasActiveFilters) {
+      var recovery = document.createElement("article");
+      recovery.className = classNames("metric-card graph-action-card graph-recovery-card", !visibleEntities.length && "metric-card-warn");
+      recovery.innerHTML = [
+        "<div class=\"metric-card-head\"><span></span><strong></strong></div>",
+        "<p></p>",
+        "<button type=\"button\">Clear search/filter</button>",
+        "<em></em>"
+      ].join("");
+      recovery.querySelector(".metric-card-head span").textContent = !visibleEntities.length ? "No graph results" : "Active graph filter";
+      recovery.querySelector(".metric-card-head strong").textContent = !visibleEntities.length ? "0 visible" : "filtered";
+      recovery.querySelector("p").textContent = !visibleEntities.length
+        ? "The current search or filter hides every node. Clear it to recover the graph."
+        : "A search, relation, or journey filter is active.";
+      recovery.querySelector("button").addEventListener("click", resetGraphView);
+      recovery.querySelector("em").textContent = queryActive ? "Search: " + els.searchInput.value : (state.graphActionFilter || "custom filter");
+      els.graphInsights.appendChild(recovery);
+    }
+    var cards = [
+      graphActionCard("Memory coverage", coveragePercent + "%", uncoveredCodeFiles.length
+        ? uncoveredCodeFiles.length + " visible code file(s) have no linked repo memory."
+        : "Visible code files have linked repo memory.",
+        "Show uncovered code", "uncovered", uncoveredCodeFiles.length ? "warn" : "ok"),
+      graphActionCard("Untrusted edges", reviewFlags.length ? reviewFlags.length + " flagged" : "clear", reviewFlags.length
+        ? "Low-confidence, missing-evidence, or invalidated relations are visible."
+        : "Visible relations are evidence-backed enough for inspection.",
+        "Filter to untrusted", "untrusted", reviewFlags.length ? "warn" : "ok", [
+        { label: "Low confidence", value: reviewFlags.filter(function (edge) { return reviewStatus(edge) === "low confidence"; }).length, score: Math.min(100, reviewFlags.length * 20), status: reviewFlags.length ? "warn" : "ok" },
+        { label: "Missing evidence", value: reviewFlags.filter(function (edge) { return reviewStatus(edge) === "missing evidence"; }).length, score: Math.min(100, reviewFlags.length * 20), status: reviewFlags.length ? "warn" : "ok" },
+        { label: "Invalidated", value: reviewFlags.filter(function (edge) { return reviewStatus(edge) === "invalidated"; }).length, score: Math.min(100, reviewFlags.length * 20), status: reviewFlags.length ? "danger" : "ok" }
+      ]),
+      graphActionCard("Evidence in view", evidencePercent + "%", evidenceEdges + " of " + visibleEdges.length + " visible relation(s) carry evidence.",
+        "Show memory-code links", "memory-code", evidencePercent >= 80 ? "ok" : "warn"),
+      graphActionCard("Trace impact", visibleMemoryCode.length + " links", "Select a code node, then trace to a test, route, or symbol from the Inspector.",
+        "Use selected node", "path", visibleMemoryCode.length ? "ok" : "warn")
+    ];
+    cards.forEach(function (card) { els.graphInsights.appendChild(card); });
+    if (els.graphInsightStatus) els.graphInsightStatus.textContent = state.graphActionFilter || (hiddenDependencies ? hiddenDependencies + " external hidden" : "ready");
+  }
+
+  function graphActionCard(title, value, detail, actionLabel, action, status, rows) {
+    var card = document.createElement("article");
+    card.className = classNames("metric-card graph-action-card", status && "metric-card-" + status, state.graphActionFilter === action && "active");
+    card.innerHTML = [
+      "<div class=\"metric-card-head\"><span></span><strong></strong></div>",
+      "<p></p>",
+      "<div class=\"metric-bars\"></div>",
+      "<button type=\"button\"></button>",
+      "<em></em>"
+    ].join("");
+    card.querySelector(".metric-card-head span").textContent = title;
+    card.querySelector(".metric-card-head strong").textContent = value;
+    card.querySelector("p").textContent = detail;
+    var bars = card.querySelector(".metric-bars");
+    if (Array.isArray(rows) && rows.length) {
+      rows.forEach(function (row) {
+        var item = document.createElement("div");
+        item.className = classNames("metric-bar", row.status && "metric-bar-" + row.status);
+        item.innerHTML = "<span></span><strong></strong><i></i>";
+        item.querySelector("span").textContent = row.label;
+        item.querySelector("strong").textContent = formatDashboardValue(row.value);
+        item.querySelector("i").style.width = clamp(Number(row.score || 0), row.value ? 8 : 0, 100) + "%";
+        bars.appendChild(item);
+      });
+    } else {
+      bars.remove();
+    }
+    var button = card.querySelector("button");
+    button.textContent = actionLabel;
+    button.addEventListener("click", function () {
+      if (action === "path") {
+        prefillPathFromSelection();
+        return;
+      }
+      applyGraphActionFilter(action);
+    });
+    card.querySelector("em").textContent = state.graphActionFilter === action ? "Active filter" : "";
+    return card;
+  }
+
+  function updateGraphActionButtons() {
+    [
+      [els.showUntrusted, "untrusted"],
+      [els.showUncovered, "uncovered"],
+      [els.showMemoryCode, "memory-code"]
+    ].forEach(function (entry) {
+      if (!entry[0]) return;
+      entry[0].classList.toggle("active", state.graphActionFilter === entry[1]);
+    });
+  }
+
+  function renderArtifactDiagnostics(visibleEntities, visibleEdges) {
+    if (!els.debugOverview) return;
+    els.debugOverview.textContent = "";
+    var episodes = state.episodesById ? state.episodesById.size : 0;
+    var evidenceEdges = state.edges.filter(function (edge) { return Array.isArray(edge.evidence) && edge.evidence.length; }).length;
+    var evidencePercent = state.edges.length ? Math.round(evidenceEdges / state.edges.length * 100) : 0;
+    var memoryCodeEdges = state.edges.filter(isMemoryCodeEdge).length;
+    var reviewFlags = state.edges.filter(function (edge) { return reviewStatus(edge) !== "ok"; }).length;
+    [
+      metricBars("Artifact shape", state.entities.length + " nodes", [
+        { label: "Visible nodes", value: visibleEntities.length, score: state.entities.length ? visibleEntities.length / state.entities.length * 100 : 0, status: "ok" },
+        { label: "Relations", value: state.edges.length, score: 100, status: "ok" },
+        { label: "Episodes", value: episodes, score: episodes ? 100 : 0, status: episodes ? "ok" : "warn" }
+      ], "Use this when graph generation seems incomplete.", "ok"),
+      metricDonut("Evidence", evidencePercent, evidenceEdges + " of " + state.edges.length + " relation(s) have evidence", "Low evidence means recall may explain less than expected.", evidencePercent >= 80 ? "ok" : "warn"),
+      metricBars("Link diagnostics", memoryCodeEdges + " memory-code", [
+        { label: "Memory-code", value: memoryCodeEdges, score: Math.min(100, memoryCodeEdges / Math.max(1, state.edges.length) * 100), status: memoryCodeEdges ? "ok" : "warn" },
+        { label: "Review flags", value: reviewFlags, score: Math.min(100, reviewFlags * 12), status: reviewFlags ? "warn" : "ok" },
+        { label: "Visible edges", value: visibleEdges.length, score: state.edges.length ? visibleEdges.length / state.edges.length * 100 : 0, status: "ok" }
+      ], "Use raw rows below to inspect exact IDs, relations, and evidence.", reviewFlags ? "warn" : "ok")
+    ].forEach(function (card) { els.debugOverview.appendChild(card); });
+  }
+
+  function renderDashboard() {
+    if (!els.dashboardStats) return;
+    var metrics = state.metrics || {};
+    var memoryGraph = metrics.memory_graph || {};
+    var codeGraph = metrics.code_graph || {};
+    var structural = metrics.structural_index || {};
+    var savings = metrics.savings || {};
+    var pain = metrics.pain || {};
+    var memoryNodes = state.entities.filter(function (entity) { return entity.graph_kind === "memory"; }).length;
+    var codeNodes = state.entities.filter(function (entity) { return entity.graph_kind === "code"; }).length;
+    var memoryCodeEdges = state.edges.filter(isMemoryCodeEdge);
+    var reports = state.reports || {};
+    var reportCount = Object.keys(reports).filter(function (key) { return reports[key]; }).length;
+    var risk = reports.risk || {};
+    var riskTargets = Array.isArray(risk.targets) ? risk.targets : Object.keys(risk.targets || {});
+    var inboxCounts = state.inbox && state.inbox.counts ? state.inbox.counts : {};
+    var pendingReview = Number(firstNumber(inboxCounts.pending, memoryGraph.pending_packets, (state.pendingPackets || []).length, 0));
+    var staleFlags = Number(firstNumber(inboxCounts.stale, 0));
+    var duplicateFlags = Number(firstNumber(inboxCounts.duplicates, memoryGraph.duplicate_candidate_pairs, 0));
+    var missingContext = Number(firstNumber(inboxCounts.missing_context, 0));
+    var ownerSilos = Array.isArray(risk.ownership_silos) ? risk.ownership_silos.length : 0;
+    var hotspots = Array.isArray(risk.global_hotspots) ? risk.global_hotspots.length : 0;
+    var readiness = dashboardReadiness(metrics, pendingReview, staleFlags, duplicateFlags, missingContext);
+    var memoryCoverage = dashboardMemoryCoverage(reports, memoryCodeEdges, memoryGraph, memoryNodes);
+    var riskHealth = riskTargets.length || hotspots ? (riskTargets.length + hotspots) + " signals" : "No flags";
+    var statRows = [
+      ["Handoff", readiness.label, readiness.detail, readiness.status],
+      ["Memory", memoryCoverage.label, memoryCoverage.detail, memoryCoverage.status],
+      ["Risk", riskHealth, riskTargets.length + " targets, " + ownerSilos + " ownership silos", riskTargets.length || ownerSilos || hotspots ? "warn" : "ok"],
+      ["Code map", firstNumber(codeGraph.files, structural.files, countEntitiesByType("file")) + " files", firstNumber(codeGraph.symbols, structural.symbols, codeNodes) + " symbols indexed", "code"]
+    ];
+    els.dashboardStats.textContent = "";
+    statRows.forEach(function (row) {
+      var item = document.createElement("div");
+      item.className = classNames("dashboard-stat", row[3] && "dashboard-stat-" + row[3]);
+      item.innerHTML = "<span></span><strong></strong><em></em>";
+      item.querySelector("strong").textContent = formatDashboardValue(row[1]);
+      item.querySelector("span").textContent = row[0];
+      item.querySelector("em").textContent = row[2] || "";
+      els.dashboardStats.appendChild(item);
+    });
+
+    setDashboardRows("dashboardMemory", [
+      ["Reusable", firstNumber(memoryGraph.approved_packets, memoryNodes) + " packets"],
+      ["Linked", memoryCodeEdges.length + " code links"],
+      ["Review", pendingReview ? pendingReview + " pending" : "clear"]
+    ]);
+    setDashboardRows("dashboardGraph", [
+      ["Files", firstNumber(codeGraph.files, structural.files, countEntitiesByType("file"))],
+      ["Symbols", firstNumber(codeGraph.symbols, structural.symbols, countEntitiesByType("symbol"))],
+      ["Coverage", codeGraph.indexer_coverage_percent != null ? codeGraph.indexer_coverage_percent + "%" : "not loaded"]
+    ]);
+    setDashboardRows("dashboardIntel", [
+      ["Risk targets", riskTargets.length || "none"],
+      ["Ownership silos", ownerSilos || "none"],
+      ["Decision coverage", reports.decisions && reports.decisions.coverage_percent != null ? reports.decisions.coverage_percent + "%" : "not loaded"]
+    ]);
+    setDashboardRows("dashboardReview", [
+      ["Handoff", readiness.label],
+      ["Pending", pendingReview || "none"],
+      ["Stale / duplicate", staleFlags + " / " + duplicateFlags],
+      ["Missing context", missingContext || "none"]
+    ]);
+    renderDashboardCharts({
+      metrics: metrics,
+      reports: reports,
+      memoryGraph: memoryGraph,
+      codeGraph: codeGraph,
+      structural: structural,
+      memoryCodeEdges: memoryCodeEdges,
+      memoryNodes: memoryNodes,
+      pendingReview: pendingReview,
+      staleFlags: staleFlags,
+      duplicateFlags: duplicateFlags,
+      missingContext: missingContext,
+      riskTargets: riskTargets,
+      ownerSilos: ownerSilos,
+      hotspots: hotspots
+    });
+  }
+
+  function renderDashboardCharts(data) {
+    if (!els.dashboardCharts) return;
+    var approvedPackets = Number(firstNumber(data.memoryGraph.approved_packets, data.memoryNodes, 0));
+    var linkedPacketIds = new Set();
+    data.memoryCodeEdges.forEach(function (edge) {
+      var from = state.entityById.get(edge.from);
+      var to = state.entityById.get(edge.to);
+      if (from && isMemoryPacketEntity(from)) linkedPacketIds.add(from.id);
+      if (to && isMemoryPacketEntity(to)) linkedPacketIds.add(to.id);
+    });
+    var memoryGrounding = approvedPackets ? Math.round(linkedPacketIds.size / approvedPackets * 100) : 0;
+    var sourceCoverage = Number(firstNumber(data.codeGraph.indexer_coverage_percent, 0));
+    var blockers = data.pendingReview + data.staleFlags + data.duplicateFlags + data.missingContext;
+    var riskSignals = data.riskTargets.length + data.ownerSilos + data.hotspots;
+    els.dashboardCharts.textContent = "";
+    [
+      metricDonut("Memory grounding", memoryGrounding, linkedPacketIds.size + " of " + approvedPackets + " packets linked to code", "Open Memory and fix Needs paths first.", memoryGrounding >= 70 ? "ok" : "warn"),
+      metricDonut("Source map", sourceCoverage, firstNumber(data.codeGraph.files, data.structural.files, 0) + " files indexed for graph recall", "If this drops, refresh indexing before relying on graph answers.", sourceCoverage >= 90 ? "ok" : "warn"),
+      metricBars("Handoff blockers", blockers ? blockers + " open" : "clear", [
+        { label: "Pending", value: data.pendingReview, score: Math.min(100, data.pendingReview * 24), status: data.pendingReview ? "warn" : "ok" },
+        { label: "Stale", value: data.staleFlags, score: Math.min(100, data.staleFlags * 24), status: data.staleFlags ? "warn" : "ok" },
+        { label: "Duplicate", value: data.duplicateFlags, score: Math.min(100, data.duplicateFlags * 24), status: data.duplicateFlags ? "warn" : "ok" },
+        { label: "Missing context", value: data.missingContext, score: Math.min(100, data.missingContext * 18), status: data.missingContext ? "warn" : "ok" }
+      ], blockers ? "Resolve Review before handing work to another agent." : "Memory is clean for handoff.", blockers ? "warn" : "ok"),
+      metricBars("Change risk", riskSignals ? riskSignals + " signals" : "none", [
+        { label: "Targets", value: data.riskTargets.length, score: Math.min(100, data.riskTargets.length * 18), status: data.riskTargets.length ? "warn" : "ok" },
+        { label: "Silos", value: data.ownerSilos, score: Math.min(100, data.ownerSilos * 18), status: data.ownerSilos ? "warn" : "ok" },
+        { label: "Hotspots", value: data.hotspots, score: Math.min(100, data.hotspots * 18), status: data.hotspots ? "danger" : "ok" }
+      ], riskSignals ? "Open Intel or Owners before editing risky files." : "No loaded risk flags.", riskSignals ? "warn" : "ok")
+    ].forEach(function (card) { els.dashboardCharts.appendChild(card); });
+  }
+
+  function metricDonut(title, percent, detail, action, status) {
+    var card = document.createElement("article");
+    var value = clamp(Number(percent || 0), 0, 100);
+    card.className = classNames("metric-card", status && "metric-card-" + status);
+    card.innerHTML = [
+      "<div class=\"metric-card-head\"><span></span><strong></strong></div>",
+      "<div class=\"metric-visual\"><div class=\"metric-donut\"><span></span></div><p></p></div>",
+      "<em></em>"
+    ].join("");
+    card.querySelector(".metric-card-head span").textContent = title;
+    card.querySelector(".metric-card-head strong").textContent = value + "%";
+    card.querySelector(".metric-donut").style.setProperty("--value", value);
+    card.querySelector(".metric-donut span").textContent = value + "%";
+    card.querySelector("p").textContent = detail || "";
+    card.querySelector("em").textContent = action || "";
+    return card;
+  }
+
+  function metricBars(title, value, rows, action, status) {
+    var card = document.createElement("article");
+    card.className = classNames("metric-card", status && "metric-card-" + status);
+    card.innerHTML = [
+      "<div class=\"metric-card-head\"><span></span><strong></strong></div>",
+      "<div class=\"metric-bars\"></div>",
+      "<em></em>"
+    ].join("");
+    card.querySelector(".metric-card-head span").textContent = title;
+    card.querySelector(".metric-card-head strong").textContent = formatDashboardValue(value);
+    var list = card.querySelector(".metric-bars");
+    rows.forEach(function (row) {
+      var item = document.createElement("div");
+      item.className = classNames("metric-bar", row.status && "metric-bar-" + row.status);
+      item.innerHTML = "<span></span><strong></strong><i></i>";
+      item.querySelector("span").textContent = row.label;
+      item.querySelector("strong").textContent = formatDashboardValue(row.value);
+      item.querySelector("i").style.width = clamp(Number(row.score || 0), row.value ? 8 : 0, 100) + "%";
+      list.appendChild(item);
+    });
+    card.querySelector("em").textContent = action || "";
+    return card;
+  }
+
+  function dashboardReadiness(metrics, pendingReview, staleFlags, duplicateFlags, missingContext) {
+    if (pendingReview || staleFlags || duplicateFlags || missingContext) {
+      return { label: "Needs review", detail: pendingReview + " pending, " + staleFlags + " stale, " + duplicateFlags + " duplicate, " + missingContext + " missing context", status: "warn" };
+    }
+    if (metrics && metrics.harness && metrics.harness.validation_ok) {
+      return { label: "Ready", detail: "Memory and graph checks are clean", status: "ok" };
+    }
+    return { label: "Unknown", detail: "Run kage refresh or open local viewer with metrics", status: "warn" };
+  }
+
+  function dashboardMemoryCoverage(reports, memoryCodeEdges, memoryGraph, memoryNodes) {
+    var coverage = reports.decisions && reports.decisions.coverage_percent;
+    if (coverage != null) {
+      return {
+        label: coverage + "%",
+        detail: "Decision memory coverage for important code paths",
+        status: Number(coverage) >= 70 ? "ok" : "warn"
+      };
+    }
+    var packets = Number(firstNumber(memoryGraph.approved_packets, memoryNodes, 0));
+    if (!packets) return { label: "No memory", detail: "Agents will rediscover repo context", status: "warn" };
+    return {
+      label: memoryCodeEdges.length + " links",
+      detail: "Memory packets connected back to code",
+      status: memoryCodeEdges.length ? "ok" : "warn"
+    };
+  }
+
+  function setDashboardRows(cardId, rows) {
+    var card = document.getElementById(cardId);
+    if (!card) return;
+    var list = card.querySelector("ul");
+    if (!list) return;
+    list.textContent = "";
+    rows.forEach(function (row) {
+      var item = document.createElement("li");
+      item.innerHTML = "<strong></strong><span></span>";
+      item.querySelector("strong").textContent = row[0];
+      item.querySelector("span").textContent = formatDashboardValue(row[1]);
+      list.appendChild(item);
+    });
+  }
+
+  function firstNumber() {
+    for (var index = 0; index < arguments.length; index += 1) {
+      var value = arguments[index];
+      if (value !== null && value !== undefined && value !== "") return value;
+    }
+    return "n/a";
+  }
+
+  function countEntitiesByType(type) {
+    return state.entities.filter(function (entity) { return entity.type === type; }).length;
+  }
+
+  function formatDashboardValue(value) {
+    if (typeof value === "number" && Number.isFinite(value)) return value.toLocaleString();
+    return String(value == null ? "n/a" : value);
+  }
+
+  function escapeHtml(value) {
+    return String(value == null ? "" : value).replace(/[&<>"']/g, function (char) {
+      return { "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;", "'": "&#39;" }[char] || char;
+    });
+  }
+
+  function renderMemoryLibrary() {
+    if (!els.memoryList) return;
+    var memoryEntities = state.entities.filter(function (entity) {
+      return isMemoryPacketEntity(entity);
+    }).sort(function (a, b) {
+      return entityImportance(b) - entityImportance(a) || displayName(a).localeCompare(displayName(b));
+    });
+    var memoryLinkCounts = new Map();
+    state.edges.forEach(function (edge) {
+      if (!isMemoryCodeEdge(edge)) return;
+      var fromEntity = state.entityById.get(edge.from);
+      var toEntity = state.entityById.get(edge.to);
+      if (fromEntity && fromEntity.graph_kind === "memory" && toEntity && toEntity.graph_kind === "code") {
+        memoryLinkCounts.set(edge.from, (memoryLinkCounts.get(edge.from) || 0) + 1);
+      }
+      if (toEntity && toEntity.graph_kind === "memory" && fromEntity && fromEntity.graph_kind === "code") {
+        memoryLinkCounts.set(edge.to, (memoryLinkCounts.get(edge.to) || 0) + 1);
+      }
+    });
+    var linkedCount = memoryEntities.filter(function (entity) { return (memoryLinkCounts.get(entity.id) || 0) > 0; }).length;
+    var query = parseSearchQuery(els.memorySearch ? els.memorySearch.value : "");
+    var filter = els.memoryFilter ? els.memoryFilter.value : "all";
+    var filtered = memoryEntities.filter(function (entity) {
+      var linkCount = memoryLinkCounts.get(entity.id) || 0;
+      if (filter === "linked" && !linkCount) return false;
+      if (filter === "needs-paths" && linkCount) return false;
+      if (["decision", "runbook", "bug_fix"].indexOf(filter) !== -1 && !memoryMatchesKind(entity, filter)) return false;
+      return matchesSearchQuery(entity, query);
+    });
+    els.memoryStatus.textContent = filtered.length + " shown";
+    if (els.memoryStats) {
+      els.memoryStats.innerHTML = [
+        memoryStat("Reusable", memoryEntities.length),
+        memoryStat("Code-linked", linkedCount),
+        memoryStat("Needs paths", memoryEntities.length - linkedCount)
+      ].join("");
+    }
+    if (els.memoryOverview) renderMemoryOverview(memoryEntities, linkedCount);
+    els.memoryList.textContent = "";
+    if (!memoryEntities.length) {
+      els.memoryList.className = "memory-list details-empty";
+      els.memoryList.textContent = "No memory packets loaded. Launch with `kage viewer --project <repo>` to load repo memory.";
+      return;
+    }
+    if (!filtered.length) {
+      els.memoryList.className = "memory-list details-empty";
+      els.memoryList.textContent = "No matching memory. Clear search or switch the filter.";
+      return;
+    }
+    filtered.sort(function (a, b) {
+      return (memoryLinkCounts.get(b.id) || 0) - (memoryLinkCounts.get(a.id) || 0) ||
+        entityImportance(b) - entityImportance(a) ||
+        displayName(a).localeCompare(displayName(b));
+    });
+    els.memoryList.className = "memory-list";
+    filtered.slice(0, 60).forEach(function (entity) {
+      var links = memoryCodeLinksForEntity(entity.id);
+      var firstCodeTarget = primaryCodeTargetForMemory(entity.id, links);
+      var item = document.createElement("button");
+      item.type = "button";
+      var selected = state.selected && state.selected.kind === "entity" && state.selected.id === entity.id;
+      item.className = classNames("memory-row", selected && "selected");
+      item.setAttribute("aria-selected", selected ? "true" : "false");
+      item.innerHTML = [
+        "<span class=\"memory-row-main\"><strong></strong><em></em></span>",
+        "<span class=\"memory-row-meta\"></span>",
+        "<span class=\"memory-row-target\"></span>"
+      ].join("");
+      item.querySelector("strong").textContent = displayName(entity);
+      item.querySelector("em").textContent = entity.type || "memory";
+      item.querySelector(".memory-row-meta").textContent = trimIntelText(entity.summary || entity.description || entity.path || "No summary", 150);
+      item.querySelector(".memory-row-target").textContent = links.length
+        ? links.length + " code link" + (links.length === 1 ? "" : "s") + (firstCodeTarget ? " | " + trimIntelText(codeTargetLabel(firstCodeTarget), 64) : "")
+        : "needs code paths";
+      item.addEventListener("click", function () {
+        selectEntity(entity.id, true);
+        render();
+      });
+      els.memoryList.appendChild(item);
+    });
+    if (filtered.length > 60) appendListNote(els.memoryList, "Showing 60 of " + filtered.length + ". Search a path or topic to narrow.");
+  }
+
+  function memoryStat(label, value) {
+    return "<div><strong>" + escapeHtml(String(value)) + "</strong><span>" + escapeHtml(label) + "</span></div>";
+  }
+
+  function renderMemoryOverview(memoryEntities, linkedCount) {
+    els.memoryOverview.textContent = "";
+    var total = memoryEntities.length;
+    var linkedPercent = total ? Math.round(linkedCount / total * 100) : 0;
+    var typeCounts = new Map();
+    memoryEntities.forEach(function (entity) {
+      typeCounts.set(entity.type || "memory", (typeCounts.get(entity.type || "memory") || 0) + 1);
+    });
+    var topTypes = Array.from(typeCounts.entries()).sort(function (a, b) { return b[1] - a[1] || a[0].localeCompare(b[0]); }).slice(0, 4);
+    var maxType = Math.max(1, topTypes.reduce(function (max, row) { return Math.max(max, row[1]); }, 0));
+    els.memoryOverview.appendChild(metricDonut(
+      "Code grounding",
+      linkedPercent,
+      linkedCount + " packet(s) are connected to files, symbols, routes, or tests",
+      linkedPercent >= 70 ? "Use linked memory before edits." : "Filter Needs paths and add concrete code references.",
+      linkedPercent >= 70 ? "ok" : "warn"
+    ));
+    els.memoryOverview.appendChild(metricBars("Memory mix", total + " packets", topTypes.map(function (row) {
+      return {
+        label: row[0],
+        value: row[1],
+        score: row[1] / maxType * 100,
+        status: row[0] === "memory" ? "" : "ok"
+      };
+    }), "A healthy repo has decisions, bug fixes, runbooks, gotchas, and code explanations.", "ok"));
+  }
+
+  function memoryCodeLinksForEntity(entityId) {
+    return state.edges.filter(function (edge) {
+      if ((edge.from !== entityId && edge.to !== entityId) || !isMemoryCodeEdge(edge)) return false;
+      var other = state.entityById.get(edge.from === entityId ? edge.to : edge.from);
+      return Boolean(other && other.graph_kind === "code");
+    });
+  }
+
+  function primaryCodeTargetForMemory(entityId, links) {
+    return links.map(function (edge) {
+      return state.entityById.get(edge.from === entityId ? edge.to : edge.from);
+    }).filter(Boolean).sort(function (a, b) {
+      return codeTargetScore(b) - codeTargetScore(a) || codeTargetLabel(a).localeCompare(codeTargetLabel(b));
+    })[0] || null;
+  }
+
+  function codeTargetScore(entity) {
+    var score = 0;
+    if (!entity) return score;
+    if (entity.type === "file") score += 80;
+    if (entity.type === "route" || entity.type === "test") score += 60;
+    if (entity.type === "symbol") score += 45;
+    if (entity.path) score += 35;
+    if (entity.line) score += 8;
+    if (String(entity.path || "").indexOf(".agent_memory/") === 0) score -= 100;
+    return score;
+  }
+
+  function codeTargetLabel(entity) {
+    if (!entity) return "";
+    if (entity.type === "file" && entity.path) return entity.path;
+    if (entity.type === "route") {
+      return (entity.method && entity.route_path ? entity.method + " " + entity.route_path : displayName(entity)) +
+        (entity.path ? " in " + entity.path : "");
+    }
+    if ((entity.type === "symbol" || entity.type === "test") && entity.path) {
+      return displayName(entity) + " in " + entity.path;
+    }
+    return entity.path || displayName(entity);
+  }
+
+  function memoryMatchesKind(entity, kind) {
+    if (!entity) return false;
+    if (entity.type === kind) return true;
+    var normalizedKind = String(kind || "").replace(/_/g, " ");
+    var text = [
+      entity.type,
+      entity.name,
+      entity.summary,
+      entity.description,
+      entity.path
+    ].join(" ").toLowerCase();
+    return text.indexOf(kind) !== -1 || text.indexOf(normalizedKind) !== -1;
+  }
+
+  function isMemoryPacketEntity(entity) {
+    return Boolean(entity && entity.graph_kind === "memory" && MEMORY_PACKET_TYPES.has(entity.type));
+  }
+
+  function renderOwners() {
+    if (!els.ownersList) return;
+    var contributors = state.reports && state.reports.contributors;
+    var risk = state.reports && state.reports.risk;
+    var profiles = contributors && Array.isArray(contributors.contributors) ? contributors.contributors : [];
+    var silos = risk && Array.isArray(risk.ownership_silos) ? risk.ownership_silos : [];
+    els.ownersStatus.textContent = profiles.length ? profiles.length + " contributors" : "not loaded";
+    els.ownersList.textContent = "";
+    if (els.ownersSummary) renderOwnersSummary(profiles, silos);
+    if (!profiles.length && !silos.length) {
+      els.ownersList.className = "owners-list details-empty";
+      els.ownersList.textContent = "No owner report loaded. Launch with `kage viewer --project <repo>` to load contributor and ownership reports.";
+      return;
+    }
+    els.ownersList.className = "owners-list";
+    profiles.slice(0, 24).forEach(function (profile) {
+      var item = document.createElement("article");
+      item.className = "owner-card";
+      item.innerHTML = [
+        "<div class=\"owner-head\"><strong></strong><span></span></div>",
+        "<div class=\"owner-stats\"></div>",
+        "<p></p>"
+      ].join("");
+      item.querySelector("strong").textContent = shortContributor(profile.contributor);
+      item.querySelector(".owner-head span").textContent = (profile.primary_owned_files || 0) + " owned files";
+      item.querySelector(".owner-stats").textContent = [
+        (profile.commits_total || 0) + " commits",
+        (profile.commits_90d || 0) + " in 90d",
+        (profile.silo_files && profile.silo_files.length ? profile.silo_files.length + " silo files" : "no silo flags")
+      ].join(" | ");
+      item.querySelector("p").textContent = Array.isArray(profile.top_modules) && profile.top_modules.length
+        ? "Modules: " + profile.top_modules.slice(0, 4).join(", ")
+        : "Local git ownership signal.";
+      els.ownersList.appendChild(item);
+    });
+    if (silos.length) {
+      var siloSection = document.createElement("section");
+      siloSection.className = "owner-silos";
+      siloSection.innerHTML = "<h3>Ownership Silos</h3>";
+      silos.slice(0, 16).forEach(function (silo) {
+        var row = document.createElement("button");
+        row.type = "button";
+        row.className = "owner-silo-row";
+        row.innerHTML = "<strong></strong><span></span>";
+        row.querySelector("strong").textContent = silo.file_path || "file";
+        row.querySelector("span").textContent = [
+          shortContributor(silo.primary_owner || "unknown"),
+          silo.primary_owner_pct != null ? Math.round(Number(silo.primary_owner_pct || 0) * 100) + "% ownership" : "",
+          (silo.commit_count_total || 0) + " commits"
+        ].filter(Boolean).join(" | ");
+        row.addEventListener("click", function () {
+          focusGraphPath(silo.file_path);
+        });
+        siloSection.appendChild(row);
+      });
+      els.ownersList.appendChild(siloSection);
+    }
+  }
+
+  function renderOwnersSummary(profiles, silos) {
+    els.ownersSummary.textContent = "";
+    if (!profiles.length && !silos.length) return;
+    var totalOwned = profiles.reduce(function (sum, profile) { return sum + Number(profile.primary_owned_files || 0); }, 0);
+    var topOwned = profiles.reduce(function (max, profile) { return Math.max(max, Number(profile.primary_owned_files || 0)); }, 0);
+    var topOwnerShare = totalOwned ? Math.round(topOwned / totalOwned * 100) : 0;
+    var commits90 = profiles.reduce(function (sum, profile) { return sum + Number(profile.commits_90d || 0); }, 0);
+    var maxOwned = Math.max(1, topOwned);
+    els.ownersSummary.appendChild(metricDonut(
+      "Backup coverage",
+      Math.max(0, 100 - topOwnerShare),
+      silos.length ? silos.length + " single-owner file(s) need backup reviewers" : "No loaded ownership silos",
+      silos.length ? "Click silo rows to inspect the file in Graph." : "Keep ownership spread visible before large changes.",
+      silos.length ? "warn" : "ok"
+    ));
+    els.ownersSummary.appendChild(metricBars("Owner concentration", profiles.length + " profiles", profiles.slice(0, 4).map(function (profile) {
+      var owned = Number(profile.primary_owned_files || 0);
+      return {
+        label: shortContributor(profile.contributor),
+        value: owned + " files",
+        score: owned / maxOwned * 100,
+        status: owned && Array.isArray(profile.silo_files) && profile.silo_files.length ? "warn" : "ok"
+      };
+    }), "Use this for reviewer routing and bus-factor checks.", silos.length ? "warn" : "ok"));
+    els.ownersSummary.appendChild(metricBars("Recent activity", commits90 + " commits", profiles.slice(0, 4).map(function (profile) {
+      var commits = Number(profile.commits_90d || 0);
+      var maxCommits = Math.max(1, profiles.reduce(function (max, item) { return Math.max(max, Number(item.commits_90d || 0)); }, 0));
+      return {
+        label: shortContributor(profile.contributor),
+        value: commits,
+        score: commits / maxCommits * 100,
+        status: commits ? "ok" : ""
+      };
+    }), "Prefer recent editors for fast review context.", "ok"));
   }
 
   function renderReviewQueue() {
@@ -2123,8 +3357,11 @@
     var packets = state.pendingPackets || [];
     var inbox = state.inbox;
     var inboxItems = inbox && Array.isArray(inbox.items) ? inbox.items : [];
-    els.reviewCount.textContent = String(packets.length + inboxItems.length);
+    var counts = inbox && inbox.counts ? inbox.counts : {};
+    var openCount = reviewOpenCount(counts, packets, inboxItems);
+    els.reviewCount.textContent = String(openCount);
     els.reviewList.textContent = "";
+    if (els.reviewOverview) renderReviewOverview(inbox, packets, inboxItems);
     if (!packets.length && !inboxItems.length && !state.reviewText) {
       els.reviewList.className = "review-list details-empty";
       els.reviewList.textContent = "No pending packets loaded. Launch with `kage viewer --project <repo>` to load review context automatically.";
@@ -2134,7 +3371,6 @@
     if (inbox) {
       var summary = document.createElement("div");
       summary.className = "review-item";
-      var counts = inbox.counts || {};
       summary.innerHTML = [
         "<div class=\"review-title\"></div>",
         "<div class=\"review-meta\"></div>",
@@ -2151,10 +3387,10 @@
       summary.querySelector(".review-summary").textContent = Array.isArray(inbox.recommendations) && inbox.recommendations.length
         ? inbox.recommendations.slice(0, 2).join(" ")
         : "No inbox recommendations.";
-      summary.querySelector(".review-risks").textContent = inbox.ok ? "ready for handoff" : "requires review";
+      summary.querySelector(".review-risks").textContent = openCount ? "Resolve inbox items before merge" : "Ready for handoff";
       els.reviewList.appendChild(summary);
     }
-    inboxItems.slice(0, 20).forEach(function (entry) {
+    inboxItems.slice(0, 8).forEach(function (entry) {
       var item = document.createElement("div");
       item.className = "review-item";
       item.innerHTML = [
@@ -2166,7 +3402,9 @@
       item.querySelector(".review-title").textContent = entry.title || entry.summary || entry.kind;
       item.querySelector(".review-meta").textContent = [entry.kind, entry.severity, entry.type, entry.status].filter(Boolean).join(" | ");
       item.querySelector(".review-summary").textContent = entry.action || entry.summary || "";
-      item.querySelector(".review-risks").textContent = Array.isArray(entry.reasons) && entry.reasons.length ? "reasons: " + entry.reasons.slice(0, 3).join(", ") : "reasons: none";
+      item.querySelector(".review-risks").textContent = Array.isArray(entry.reasons) && entry.reasons.length
+        ? trimIntelText(entry.reasons[0], 86)
+        : "Review before handoff";
       els.reviewList.appendChild(item);
     });
     packets.forEach(function (packet) {
@@ -2182,7 +3420,9 @@
       item.querySelector(".review-title").textContent = packet.title || packet.id;
       item.querySelector(".review-meta").textContent = [packet.type, packet.status, "score " + (quality.score == null ? "n/a" : quality.score + "/100")].filter(Boolean).join(" | ");
       item.querySelector(".review-summary").textContent = packet.summary || "";
-      item.querySelector(".review-risks").textContent = Array.isArray(quality.risks) && quality.risks.length ? "risks: " + quality.risks.join(", ") : "risks: none";
+      item.querySelector(".review-risks").textContent = Array.isArray(quality.risks) && quality.risks.length
+        ? "Resolve " + quality.risks.join(", ")
+        : "Evidence looks clean";
       els.reviewList.appendChild(item);
     });
     if (state.reviewText) {
@@ -2194,25 +3434,58 @@
     }
   }
 
+  function renderReviewOverview(inbox, packets, inboxItems) {
+    els.reviewOverview.textContent = "";
+    var counts = inbox && inbox.counts ? inbox.counts : {};
+    var pending = Number(firstNumber(counts.pending, packets.length, 0));
+    var stale = Number(firstNumber(counts.stale, 0));
+    var duplicates = Number(firstNumber(counts.duplicates, 0));
+    var missingContext = Number(firstNumber(counts.missing_context, 0));
+    var blockers = reviewOpenCount(counts, packets, inboxItems);
+    els.reviewOverview.appendChild(metricDonut(
+      "Handoff readiness",
+      blockers ? 0 : 100,
+      blockers ? blockers + " review blocker(s) need attention" : "No pending, stale, duplicate, or missing-context memory",
+      blockers ? "Resolve these before trusting branch memory." : "Ready to hand work to another agent or teammate.",
+      blockers ? "warn" : "ok"
+    ));
+    els.reviewOverview.appendChild(metricBars("Inbox breakdown", blockers ? blockers + " open" : "clear", [
+      { label: "Pending", value: pending, score: Math.min(100, pending * 24), status: pending ? "warn" : "ok" },
+      { label: "Stale", value: stale, score: Math.min(100, stale * 24), status: stale ? "warn" : "ok" },
+      { label: "Duplicates", value: duplicates, score: Math.min(100, duplicates * 24), status: duplicates ? "warn" : "ok" },
+      { label: "Missing context", value: missingContext, score: Math.min(100, missingContext * 24), status: missingContext ? "warn" : "ok" }
+    ], "These are the only review metrics that should block merge or handoff.", blockers ? "warn" : "ok"));
+  }
+
+  function reviewOpenCount(counts, packets, inboxItems) {
+    var pending = Number(firstNumber(counts && counts.pending, packets && packets.length, 0));
+    var stale = Number(firstNumber(counts && counts.stale, 0));
+    var duplicates = Number(firstNumber(counts && counts.duplicates, 0));
+    var missingContext = Number(firstNumber(counts && counts.missing_context, 0));
+    var counted = pending + stale + duplicates + missingContext;
+    if (counted) return counted;
+    return Array.isArray(inboxItems) ? inboxItems.length : 0;
+  }
+
   function renderProof() {
     if (!els.proofList) return;
     var metrics = state.metrics;
     els.proofList.textContent = "";
     if (!metrics) {
       els.proofStatus.textContent = "not loaded";
+      if (els.proofOverview) els.proofOverview.textContent = "";
       els.proofList.className = "proof-list details-empty";
       els.proofList.textContent = "Metrics not loaded. Run `kage metrics --project <repo> --json > .agent_memory/metrics.json` or launch with `kage viewer`.";
       return;
     }
     els.proofStatus.textContent = "loaded";
     els.proofList.className = "proof-list";
+    if (els.proofOverview) renderProofOverview(metrics, state.reports || {});
     var rows = [
-      ["Readiness", metrics.harness && metrics.harness.readiness_score != null ? metrics.harness.readiness_score + "/100" : "n/a"],
-      ["Useful memory", metrics.quality ? metrics.quality.useful_memory_ratio_percent + "%" : "n/a"],
+      ["Validation", metrics.harness && metrics.harness.validation_ok ? "clean" : "check"],
       ["Evidence", metrics.memory_graph ? metrics.memory_graph.evidence_coverage_percent + "%" : "n/a"],
       ["Pending review", metrics.memory_graph ? String(metrics.memory_graph.pending_packets) : "n/a"],
-      ["Recall hit rate", metrics.pain ? metrics.pain.recall_hit_rate_percent + "%" : "n/a"],
-      ["Tokens saved", metrics.pain ? String(metrics.pain.estimated_tokens_saved) : metrics.savings ? String(metrics.savings.estimated_tokens_saved_per_recall) : "n/a"]
+      ["Recall savings", metrics.pain ? String(metrics.pain.estimated_tokens_saved) : metrics.savings ? String(metrics.savings.estimated_tokens_saved_per_recall) : "n/a"]
     ];
     rows.forEach(function (row) {
       var item = document.createElement("div");
@@ -2224,6 +3497,29 @@
     });
   }
 
+  function renderProofOverview(metrics, reports) {
+    els.proofOverview.textContent = "";
+    var quality = reports.quality || {};
+    var benchmark = reports.benchmark || {};
+    var gates = Array.isArray(benchmark.gates) ? benchmark.gates : [];
+    var passingGates = gates.filter(function (gate) { return gate.pass; }).length;
+    var gatePercent = gates.length ? Math.round(passingGates / gates.length * 100) : (benchmark.ok ? 100 : 0);
+    var evidence = Number(firstNumber(metrics.memory_graph && metrics.memory_graph.evidence_coverage_percent, quality.evidence_coverage_percent, 0));
+    var pathGrounding = Number(firstNumber(quality.path_grounding_coverage_percent, 0));
+    els.proofOverview.appendChild(metricDonut(
+      "Trust gate",
+      gatePercent,
+      gates.length ? passingGates + " of " + gates.length + " benchmark gates passing" : "Benchmark report not loaded",
+      gatePercent >= 100 ? "Keep this green before publishing or handing off." : "Fix failing proof gates before release.",
+      gatePercent >= 100 ? "ok" : "warn"
+    ));
+    els.proofOverview.appendChild(metricBars("Memory quality", evidence + "% evidence", [
+      { label: "Evidence", value: evidence + "%", score: evidence, status: evidence >= 80 ? "ok" : "warn" },
+      { label: "Path grounded", value: pathGrounding ? pathGrounding + "%" : "n/a", score: pathGrounding || 0, status: pathGrounding >= 80 ? "ok" : "warn" },
+      { label: "Useful", value: quality.useful_memory_ratio_percent != null ? quality.useful_memory_ratio_percent + "%" : "n/a", score: Number(quality.useful_memory_ratio_percent || 0), status: Number(quality.useful_memory_ratio_percent || 0) >= 70 ? "ok" : "warn" }
+    ], "Trust memory only when it is evidence-backed and path-grounded.", evidence >= 80 ? "ok" : "warn"));
+  }
+
   function renderIntelligence() {
     if (!els.intelligenceList) return;
     var reports = state.reports || {};
@@ -2236,36 +3532,40 @@
       return;
     }
     els.intelligenceList.className = "intelligence-list";
-    cards.forEach(function (card) {
+    normalizeIntelCards(cards).slice(0, 6).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>",
+        "<div class=\"intel-card-head\"><div><h3></h3><span></span></div><strong></strong></div>",
+        "<div class=\"intel-metric-label\"></div>",
+        "<p class=\"intel-highlight\"></p>",
+        "<p class=\"intel-action\"><b>Action:</b> <span></span></p>",
         "<ul></ul>"
       ].join("");
       item.querySelector("h3").textContent = card.title;
-      item.querySelector(".intel-kicker").textContent = card.kicker;
-      item.querySelector(".intel-summary").textContent = card.summary;
+      item.querySelector(".intel-card-head span").textContent = card.kicker;
+      item.querySelector(".intel-card-head strong").textContent = card.metric || "n/a";
+      item.querySelector(".intel-metric-label").textContent = card.metricLabel || "signal";
+      item.querySelector(".intel-highlight").textContent = card.highlight || card.summary || "";
+      item.querySelector(".intel-action span").textContent = card.action || "Review this signal before changing related code.";
       var list = item.querySelector("ul");
-      card.rows.slice(0, 5).forEach(function (row) {
+      card.rows.slice(0, 3).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];
+        li.querySelector("span").textContent = trimIntelText(row[1], 92);
         list.appendChild(li);
       });
       els.intelligenceList.appendChild(item);
     });
-    var sections = buildIntelligenceSections(reports);
+    var sections = rankIntelligenceSections(buildIntelligenceSections(reports)).slice(0, 4);
     if (sections.length) {
-      var grid = document.createElement("div");
-      grid.className = "intel-deep-grid";
+      var deepGrid = document.createElement("div");
+      deepGrid.className = "intel-deep-grid";
       sections.forEach(function (section) {
-        grid.appendChild(renderIntelligenceSection(section));
+        deepGrid.appendChild(renderIntelligenceSection(section));
       });
-      els.intelligenceList.appendChild(grid);
+      els.intelligenceList.appendChild(deepGrid);
     }
   }
 
@@ -2288,32 +3588,46 @@
     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 = [
+      var rowEl = document.createElement(row.path ? "button" : "div");
+      if (row.path) rowEl.type = "button";
+      rowEl.className = classNames("intel-row", row.status && "intel-row-" + safeCssName(row.status), row.path && "clickable");
+      rowEl.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) + "%";
+      rowEl.querySelector("strong").textContent = row.label || "";
+      rowEl.querySelector("em").textContent = row.value || "";
+      rowEl.querySelector(".intel-row-meta").textContent = row.meta || "";
+      rowEl.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 () {
+        rowEl.title = "Focus " + row.path + " in the graph";
+        rowEl.setAttribute("aria-label", "Focus " + row.path + " in Graph");
+        rowEl.addEventListener("click", function () {
           focusGraphPath(row.path);
         });
-      } else {
-        button.disabled = true;
       }
-      list.appendChild(button);
+      list.appendChild(rowEl);
     });
     panel.appendChild(list);
     return panel;
   }
 
+  function rankIntelligenceSections(sections) {
+    return sections.slice().sort(function (a, b) {
+      return intelligenceSectionPriority(a) - intelligenceSectionPriority(b);
+    });
+  }
+
+  function intelligenceSectionPriority(section) {
+    var title = String(section && section.title || "").toLowerCase();
+    if (title.indexOf("blast") !== -1 || title.indexOf("risk") !== -1) return 0;
+    if (title.indexOf("onboarding") !== -1 || title.indexOf("decision") !== -1) return 1;
+    if (title.indexOf("module") !== -1 || title.indexOf("health") !== -1) return 2;
+    if (title.indexOf("owner") !== -1 || title.indexOf("contributor") !== -1) return 3;
+    return 4;
+  }
+
   function buildIntelligenceSections(reports) {
     var sections = [];
     var contributors = reports.contributors;
@@ -2353,7 +3667,7 @@
           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.",
+          summary: "Action: assign backup reviewers for silo files before risky changes.",
           rows: rows,
           limit: 10,
         });
@@ -2368,7 +3682,7 @@
         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.",
+        summary: "Action: start cleanup and test planning from the lowest-score modules.",
         rows: modules.slice(0, 8).map(function (item) {
           return {
             label: item.module,
@@ -2387,7 +3701,7 @@
         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.",
+        summary: "Action: capture why-memory for these files before the next agent works there.",
         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 {
@@ -2413,7 +3727,7 @@
         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.",
+        summary: "Action: use clusters to understand the graph before changing architecture.",
         rows: communities.slice(0, 8).map(function (community) {
           var files = community.files || [];
           var entrypoints = community.entrypoints || [];
@@ -2435,7 +3749,7 @@
         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.",
+        summary: "Action: inspect entry files first when debugging runtime behavior.",
         rows: insights.entry_flows.slice(0, 8).map(function (flow) {
           var path = flow.path || [];
           return {
@@ -2494,7 +3808,7 @@
           title: "Workspace Map",
           kicker: "deps / contracts / co-changes",
           stat: workspaceRows.length + " links",
-          summary: "Workspace links show how sibling repos relate through package dependencies, source-evidence contracts, topic/event links, and local git co-change history.",
+          summary: "Action: check linked repos before changing shared packages or contracts.",
           rows: workspaceRows,
           limit: 14,
         });
@@ -2528,7 +3842,7 @@
           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.",
+          summary: "Action: review tests, owners, and dependents before editing these targets.",
           rows: riskRows,
           limit: 10,
         });
@@ -2550,11 +3864,13 @@
     });
     if (!found) {
       els.searchInput.value = normalized;
+      showViewerPageInPlace("graph");
       scheduleRender();
       return;
     }
-    state.selected = { kind: "entity", id: found.id };
+    selectEntity(found.id, true);
     els.searchInput.value = normalized;
+    showViewerPageInPlace("graph");
     scheduleRender();
   }
 
@@ -2716,18 +4032,86 @@
     return cards;
   }
 
+  function normalizeIntelCards(cards) {
+    return cards.map(function (card) {
+      var normalized = Object.assign({}, card);
+      var row = function (label) {
+        var found = (card.rows || []).find(function (item) { return item[0] === label; });
+        return found ? found[1] : null;
+      };
+      if (card.title === "Memory-Code Bridge") {
+        normalized.metric = row("Links") || "0";
+        normalized.metricLabel = "memory-code links";
+        normalized.highlight = "Shows whether saved repo knowledge is tied to actual files, symbols, routes, and tests.";
+        normalized.action = "If this is low, capture memory with concrete paths so agents can recall it during edits.";
+      } else if (card.title === "Change Risk") {
+        var siloText = row("Silos");
+        var siloMatch = siloText && String(siloText).match(/\d+/);
+        normalized.metric = siloMatch ? siloMatch[0] + " silos" : ((card.rows || []).length + " signals");
+        normalized.metricLabel = "risk signals";
+        normalized.highlight = "Flags files with blast radius, test gaps, or ownership concentration.";
+        normalized.action = "Use these rows to pick tests and reviewers before touching risky files.";
+      } else if (card.title === "Contributors") {
+        normalized.metric = (card.rows || []).length + " profiles";
+        normalized.metricLabel = "review routing";
+        normalized.highlight = "Shows who recently touched or owns parts of the repo.";
+        normalized.action = "Use this to find backup reviewers and avoid single-person knowledge bottlenecks.";
+      } else if (card.title === "Decision Memory") {
+        normalized.metric = row("Coverage") || "n/a";
+        normalized.metricLabel = "why-memory coverage";
+        normalized.highlight = "Shows whether important code paths have captured rationale and gotchas.";
+        normalized.action = "Add memory for coverage gaps before future agents rediscover the same context.";
+      } else if (card.title === "Module Health") {
+        normalized.metric = (card.rows || []).length + " modules";
+        normalized.metricLabel = "lowest scores first";
+        normalized.highlight = "Ranks modules by churn, tests, ownership, and graph signals.";
+        normalized.action = "Start with low-score modules when planning cleanup or refactors.";
+      } else if (card.title === "Graph Insights") {
+        normalized.metric = row("Cycles") || row("Communities") || "n/a";
+        normalized.metricLabel = row("Cycles") != null ? "dependency cycles" : "architecture clusters";
+        normalized.highlight = "Explains dense graph structure through central files, cycles, and communities.";
+        normalized.action = "Inspect central files and cycles before making architectural changes.";
+      } else if (card.title === "Workspace") {
+        normalized.metric = row("Repos") || "n/a";
+        normalized.metricLabel = "connected repos";
+        normalized.highlight = "Shows package, route, topic, and co-change links across local repos.";
+        normalized.action = "Check these links before changing shared contracts or packages.";
+      } else if (card.title === "Memory Quality") {
+        normalized.metric = row("Evidence") || row("Useful") || "n/a";
+        normalized.metricLabel = "trust signal";
+        normalized.highlight = "Shows whether memory is evidence-backed, grounded, and reviewable.";
+        normalized.action = "Review pending or weak memory before relying on it for agent handoff.";
+      } else if (card.title === "Benchmark") {
+        normalized.metric = (card.rows || []).filter(function (item) { return String(item[1] || "").indexOf("pass") !== -1; }).length + " pass";
+        normalized.metricLabel = "local proof checks";
+        normalized.highlight = "Shows whether repo memory and graph behavior pass local quality checks.";
+        normalized.action = "Use failed checks as release blockers or cleanup targets.";
+      }
+      return normalized;
+    });
+  }
+
+  function trimIntelText(value, limit) {
+    var text = String(value == null ? "" : value);
+    var max = Number(limit || 90);
+    if (text.length <= max) return text;
+    return text.slice(0, Math.max(0, max - 1)).replace(/\s+\S*$/, "") + "...";
+  }
+
   function renderStatusStrip(visibleEntities, visibleEdges, official) {
     if (!els.statusStrip) return;
     var memoryCount = visibleEntities.filter(function (entity) { return entity.graph_kind === "memory"; }).length;
     var codeCount = visibleEntities.filter(function (entity) { return entity.graph_kind === "code"; }).length;
     var reviewFlags = visibleEdges.filter(function (edge) { return reviewStatus(edge) !== "ok"; }).length;
+    var memoryCodeLinks = state.edges.filter(isMemoryCodeEdge).length;
+    var pendingReview = official && official.memory_graph ? Number(firstNumber(official.memory_graph.pending_packets, 0)) : 0;
     var pills = official ? [
-      ["Readiness", official.harness.readiness_score + "/100", ""],
-      ["Pending", official.memory_graph ? String(official.memory_graph.pending_packets) : "n/a", official.memory_graph && official.memory_graph.pending_packets ? "warn" : ""],
-      ["Structural", official.structural_index ? official.structural_index.files + " files" : official.code_graph.files + " files", "code"],
-      ["Code symbols", String(official.code_graph.symbols), "code"],
-      ["Parser coverage", official.code_graph.indexer_coverage_percent + "%", "code"],
-      ["Memory packets", official.memory_graph ? String(official.memory_graph.approved_packets) : "n/a", "memory"]
+      ["Status", official.harness && official.harness.validation_ok ? "Clean" : "Check", official.harness && official.harness.validation_ok ? "memory" : "warn"],
+      ["Review", pendingReview ? pendingReview + " pending" : "Clear", pendingReview ? "warn" : "memory"],
+      ["Source map", official.structural_index ? official.structural_index.files + " files" : official.code_graph.files + " files", "code"],
+      ["Symbols", String(official.code_graph.symbols), "code"],
+      ["Coverage", official.code_graph.indexer_coverage_percent + "%", "code"],
+      ["Memory links", String(memoryCodeLinks), memoryCodeLinks ? "memory" : "warn"]
     ] : [
       ["Memory", String(memoryCount), "memory"],
       ["Code", String(codeCount), "code"],
@@ -2847,11 +4231,12 @@
 
   function endCanvasPointer() {
     if (state.sim.dragNode) {
-      state.selected = { kind: "entity", id: state.sim.dragNode.id };
+      selectEntity(state.sim.dragNode.id, true);
       state.sim.dragNode = null;
       render();
     } else if (state.sim.panning && !state.sim.panning.moved) {
       state.selected = null;
+      closeWorkspace();
       render();
     }
     state.sim.panning = null;
@@ -2888,7 +4273,7 @@
     var world = canvasToWorld(event);
     var node = findCanvasNode(world.x, world.y);
     if (!node) return;
-    state.selected = { kind: "entity", id: node.id };
+    selectEntity(node.id, true);
     render();
   }
 
@@ -2979,10 +4364,15 @@
     if (state.three.THREE) return Promise.resolve(state.three.THREE);
     if (state.three.loading) return state.three.loading;
     state.three.failed = false;
-    state.three.loading = import("/vendor/three/build/three.module.min.js")
-      .catch(function () {
-        return import("https://unpkg.com/three@0.184.0/build/three.module.min.js");
-      })
+    var threeSources = [
+      "./vendor/three/build/three.module.min.js",
+      "../vendor/three/build/three.module.min.js",
+      "/vendor/three/build/three.module.min.js",
+      "https://unpkg.com/three@0.184.0/build/three.module.min.js"
+    ];
+    state.three.loading = threeSources.reduce(function (chain, source) {
+      return chain.catch(function () { return import(source); });
+    }, Promise.reject())
       .then(function (mod) {
         state.three.THREE = mod;
         return mod;
@@ -2999,7 +4389,7 @@
     ensureThree().then(function () {
       if (activeRenderMode() !== "3d") return;
       setupThreeScene();
-      rebuildThreeScene();
+      if (graphChanged || !state.three.nodeById.size) rebuildThreeScene();
       if (graphChanged || state.three.distance <= 0) fitThreeGraph();
       startThreeGraph();
       renderThreeFrame();
@@ -3062,8 +4452,9 @@
     state.sim.nodes.forEach(function (node, index) {
       var entity = node.entity;
       var selected = state.selected && state.selected.kind === "entity" && state.selected.id === node.id;
+      var pathNode = state.pathHighlight && state.pathHighlight.nodes.has(node.id);
       var material = new THREE.SpriteMaterial({
-        map: threeNodeTexture(entity, selected),
+        map: threeNodeTexture(entity, selected || pathNode),
         transparent: true,
         opacity: isDependencyEntity(entity) ? 0.70 : 1,
         depthWrite: false
@@ -3071,7 +4462,7 @@
       var mesh = new THREE.Sprite(material);
       var position = threePosition(node, index);
       mesh.position.set(position.x, position.y, position.z);
-      var size = threeNodeSize(node, selected);
+      var size = threeNodeSize(node, selected || pathNode);
       mesh.scale.set(size, size, 1);
       mesh.userData.node = node;
       state.three.nodeGroup.add(mesh);
@@ -3085,11 +4476,12 @@
       var fromEntity = from.node.entity;
       var toEntity = to.node.entity;
       var connected = state.selected && state.selected.kind === "entity" && (state.selected.id === edge.from || state.selected.id === edge.to);
+      var pathEdge = state.pathHighlight && state.pathHighlight.edges.has(edge.id);
       var geometry = new THREE.BufferGeometry().setFromPoints([from.mesh.position, to.mesh.position]);
       var material = new THREE.LineBasicMaterial({
-        color: new THREE.Color(edgeThemeColor(edge, fromEntity, toEntity)),
+        color: new THREE.Color(pathEdge ? graphPalette.bridge : edgeThemeColor(edge, fromEntity, toEntity)),
         transparent: true,
-        opacity: threeEdgeOpacity(edge, fromEntity, toEntity, connected),
+        opacity: pathEdge ? 0.82 : threeEdgeOpacity(edge, fromEntity, toEntity, connected),
         depthWrite: false,
         depthTest: false
       });
@@ -3426,7 +4818,7 @@
       : null;
     state.three.drag = null;
     if (picked) {
-      state.selected = { kind: "entity", id: picked.id };
+      selectEntity(picked.id, true);
       render();
     }
   }
@@ -3447,7 +4839,7 @@
   function handleThreeDoubleClick(event) {
     var picked = pickThreeNode(event);
     if (!picked) return;
-    state.selected = { kind: "entity", id: picked.id };
+    selectEntity(picked.id, true);
     render();
   }
 
@@ -3632,6 +5024,7 @@
     if (state.pan && state.pan.moved) return;
     if (event.target !== els.svg) return;
     state.selected = null;
+    closeWorkspace();
     render();
   }