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

package/viewer/app.js

@@ -13,6 +13,7 @@
     visibleEntityIds: new Set(),
     visibleEdgeIds: new Set(),
     selected: null,
+    revealSelection: false,
     viewerPage: "overview",
     viewerSection: "overview",
     viewerAction: null,
@@ -29,11 +30,24 @@
       quality: null,
       benchmark: null,
       contributors: null,
+      profile: null,
+      capabilities: null,
+      slots: null,
       decisions: null,
       risk: null,
       moduleHealth: null,
       graphInsights: null,
-      workspace: null
+      xray: null,
+      workspace: null,
+      sessions: null,
+      replay: null,
+      memoryAccess: null,
+      memoryAudit: null,
+      handoff: null,
+      lifecycle: null,
+      timeline: null,
+      lineage: null,
+      setup: null
     },
     pendingPackets: [],
     reviewText: "",
@@ -169,10 +183,31 @@
     edgeCount: document.getElementById("edgeCount"),
     reviewCount: document.getElementById("reviewCount"),
     dashboardStats: document.getElementById("dashboardStats"),
+    repoXray: document.getElementById("repoXray"),
+    repoXrayStatus: document.getElementById("repoXrayStatus"),
+    repoXrayScript: document.getElementById("repoXrayScript"),
+    repoXrayLayers: document.getElementById("repoXrayLayers"),
     dashboardCharts: document.getElementById("dashboardCharts"),
     memoryStatus: document.getElementById("memoryStatus"),
     memoryStats: document.getElementById("memoryStats"),
     memoryOverview: document.getElementById("memoryOverview"),
+    lifecycleStatus: document.getElementById("lifecycleStatus"),
+    lifecycleSummary: document.getElementById("lifecycleSummary"),
+    lifecycleList: document.getElementById("lifecycleList"),
+    memoryReviewStatus: document.getElementById("memoryReviewStatus"),
+    memoryReviewActions: document.getElementById("memoryReviewActions"),
+    memoryTimelineStatus: document.getElementById("memoryTimelineStatus"),
+    memoryTimelineSummary: document.getElementById("memoryTimelineSummary"),
+    memoryTimelineList: document.getElementById("memoryTimelineList"),
+    memoryAuditStatus: document.getElementById("memoryAuditStatus"),
+    memoryAuditSummary: document.getElementById("memoryAuditSummary"),
+    memoryAuditList: document.getElementById("memoryAuditList"),
+    memoryLineageStatus: document.getElementById("memoryLineageStatus"),
+    memoryLineageSummary: document.getElementById("memoryLineageSummary"),
+    memoryLineageList: document.getElementById("memoryLineageList"),
+    sessionCaptureStatus: document.getElementById("sessionCaptureStatus"),
+    sessionCaptureSummary: document.getElementById("sessionCaptureSummary"),
+    sessionCaptureList: document.getElementById("sessionCaptureList"),
     memorySearch: document.getElementById("memorySearch"),
     memoryFilter: document.getElementById("memoryFilter"),
     memoryList: document.getElementById("memoryList"),
@@ -180,6 +215,9 @@
     ownersSummary: document.getElementById("ownersSummary"),
     ownersList: document.getElementById("ownersList"),
     reviewOverview: document.getElementById("reviewOverview"),
+    handoffStatus: document.getElementById("handoffStatus"),
+    handoffSummary: document.getElementById("handoffSummary"),
+    handoffList: document.getElementById("handoffList"),
     reviewList: document.getElementById("reviewList"),
     proofOverview: document.getElementById("proofOverview"),
     proofStatus: document.getElementById("proofStatus"),
@@ -209,9 +247,9 @@
       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."
+      eyebrow: "kage://before-edit",
+      title: "Before You Edit",
+      summary: "What can go wrong, why it matters, and the first safety step before an agent changes code."
     },
     review: {
       eyebrow: "kage://review",
@@ -256,10 +294,12 @@
   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();
-  });
+  if (els.renderMode) {
+    els.renderMode.addEventListener("change", function () {
+      state.lastVisibleSignature = "";
+      render();
+    });
+  }
   els.typeFilter.addEventListener("change", function () { clearGraphActionFilter(); render(); });
   els.relationFilter.addEventListener("change", function () { clearGraphActionFilter(); render(); });
   els.scopeFilter.addEventListener("change", render);
@@ -298,7 +338,7 @@
   function resetGraphView() {
     els.searchInput.value = "";
     els.viewMode.value = "combined";
-    els.renderMode.value = "2d";
+    if (els.renderMode) els.renderMode.value = "2d";
     els.typeFilter.value = "";
     els.relationFilter.value = "";
     els.scopeFilter.value = "signal";
@@ -466,10 +506,12 @@
 
   function selectEntity(id, openInspector) {
     state.selected = { kind: "entity", id: id };
+    state.revealSelection = Boolean(openInspector);
   }
 
   function selectEdge(id, openInspector) {
     state.selected = { kind: "edge", id: id };
+    state.revealSelection = Boolean(openInspector);
   }
 
   function handleFile(event) {
@@ -562,11 +604,24 @@
     var qualityPath = params.get("quality");
     var benchmarkPath = params.get("benchmark");
     var contributorsPath = params.get("contributors");
+    var profilePath = params.get("profile") || params.get("projectProfile") || params.get("project-profile");
+    var capabilitiesPath = params.get("capabilities") || params.get("capabilityAudit") || params.get("capability-audit");
+    var slotsPath = params.get("slots") || params.get("contextSlots") || params.get("context-slots");
     var decisionsPath = params.get("decisions");
     var riskPath = params.get("risk");
     var moduleHealthPath = params.get("moduleHealth") || params.get("module-health");
     var graphInsightsPath = params.get("graphInsights") || params.get("graph-insights");
+    var xrayPath = params.get("xray") || params.get("repoXray") || params.get("repo-xray");
     var workspacePath = params.get("workspace");
+    var sessionsPath = params.get("sessions");
+    var replayPath = params.get("replay") || params.get("sessionReplay") || params.get("session-replay");
+    var memoryAccessPath = params.get("memoryAccess") || params.get("memory-access");
+    var memoryAuditPath = params.get("memoryAudit") || params.get("memory-audit") || params.get("auditLog") || params.get("audit-log");
+    var handoffPath = params.get("handoff") || params.get("memoryHandoff") || params.get("memory-handoff");
+    var lifecyclePath = params.get("lifecycle") || params.get("memoryLifecycle") || params.get("memory-lifecycle");
+    var timelinePath = params.get("timeline") || params.get("memoryTimeline") || params.get("memory-timeline");
+    var lineagePath = params.get("lineage") || params.get("memoryLineage") || params.get("memory-lineage");
+    var setupPath = params.get("setup") || params.get("setupDoctor") || params.get("setup-doctor");
     var inferredRoot = inferMemoryRoot(graphPaths[0] || "");
     if (!inboxPath && inferredRoot) inboxPath = inferredRoot + "/inbox.json";
     if (!reviewPath && inferredRoot) reviewPath = inferredRoot + "/review/memory-review.md";
@@ -575,11 +630,24 @@
       if (!qualityPath) qualityPath = inferredRoot + "/reports/quality.json";
       if (!benchmarkPath) benchmarkPath = inferredRoot + "/reports/benchmark.json";
       if (!contributorsPath) contributorsPath = inferredRoot + "/reports/contributors.json";
+      if (!profilePath) profilePath = inferredRoot + "/reports/profile.json";
+      if (!capabilitiesPath) capabilitiesPath = inferredRoot + "/reports/capabilities.json";
+      if (!slotsPath) slotsPath = inferredRoot + "/reports/context-slots.json";
       if (!decisionsPath) decisionsPath = inferredRoot + "/reports/decisions.json";
       if (!riskPath) riskPath = inferredRoot + "/reports/risk.json";
       if (!moduleHealthPath) moduleHealthPath = inferredRoot + "/reports/module-health.json";
       if (!graphInsightsPath) graphInsightsPath = inferredRoot + "/reports/graph-insights.json";
+      if (!xrayPath) xrayPath = inferredRoot + "/reports/xray.json";
       if (!workspacePath) workspacePath = inferredRoot + "/reports/workspace.json";
+      if (!sessionsPath) sessionsPath = inferredRoot + "/reports/sessions.json";
+      if (!replayPath) replayPath = inferredRoot + "/reports/replay.json";
+      if (!memoryAccessPath) memoryAccessPath = inferredRoot + "/reports/memory-access.json";
+      if (!memoryAuditPath) memoryAuditPath = inferredRoot + "/reports/memory-audit.json";
+      if (!handoffPath) handoffPath = inferredRoot + "/reports/handoff.json";
+      if (!lifecyclePath) lifecyclePath = inferredRoot + "/reports/lifecycle.json";
+      if (!timelinePath) timelinePath = inferredRoot + "/reports/timeline.json";
+      if (!lineagePath) lineagePath = inferredRoot + "/reports/lineage.json";
+      if (!setupPath) setupPath = inferredRoot + "/reports/setup.json";
     }
     var jobs = [];
     if (metricsPath) jobs.push(fetchJson(metricsPath).then(function (metrics) { state.metrics = metrics; }));
@@ -589,11 +657,24 @@
     if (qualityPath) jobs.push(fetchJson(qualityPath).then(function (report) { state.reports.quality = report; }).catch(function () { state.reports.quality = null; }));
     if (benchmarkPath) jobs.push(fetchJson(benchmarkPath).then(function (report) { state.reports.benchmark = report; }).catch(function () { state.reports.benchmark = null; }));
     if (contributorsPath) jobs.push(fetchJson(contributorsPath).then(function (report) { state.reports.contributors = report; }).catch(function () { state.reports.contributors = null; }));
+    if (profilePath) jobs.push(fetchJson(profilePath).then(function (report) { state.reports.profile = report; }).catch(function () { state.reports.profile = null; }));
+    if (capabilitiesPath) jobs.push(fetchJson(capabilitiesPath).then(function (report) { state.reports.capabilities = report; }).catch(function () { state.reports.capabilities = null; }));
+    if (slotsPath) jobs.push(fetchJson(slotsPath).then(function (report) { state.reports.slots = report; }).catch(function () { state.reports.slots = null; }));
     if (decisionsPath) jobs.push(fetchJson(decisionsPath).then(function (report) { state.reports.decisions = report; }).catch(function () { state.reports.decisions = null; }));
     if (riskPath) jobs.push(fetchJson(riskPath).then(function (report) { state.reports.risk = report; }).catch(function () { state.reports.risk = null; }));
     if (moduleHealthPath) jobs.push(fetchJson(moduleHealthPath).then(function (report) { state.reports.moduleHealth = report; }).catch(function () { state.reports.moduleHealth = null; }));
     if (graphInsightsPath) jobs.push(fetchJson(graphInsightsPath).then(function (report) { state.reports.graphInsights = report; }).catch(function () { state.reports.graphInsights = null; }));
+    if (xrayPath) jobs.push(fetchJson(xrayPath).then(function (report) { state.reports.xray = report; }).catch(function () { state.reports.xray = null; }));
     if (workspacePath) jobs.push(fetchJson(workspacePath).then(function (report) { state.reports.workspace = report; }).catch(function () { state.reports.workspace = null; }));
+    if (sessionsPath) jobs.push(fetchJson(sessionsPath).then(function (report) { state.reports.sessions = report; }).catch(function () { state.reports.sessions = null; }));
+    if (replayPath) jobs.push(fetchJson(replayPath).then(function (report) { state.reports.replay = report; }).catch(function () { state.reports.replay = null; }));
+    if (memoryAccessPath) jobs.push(fetchJson(memoryAccessPath).then(function (report) { state.reports.memoryAccess = report; }).catch(function () { state.reports.memoryAccess = null; }));
+    if (memoryAuditPath) jobs.push(fetchJson(memoryAuditPath).then(function (report) { state.reports.memoryAudit = report; }).catch(function () { state.reports.memoryAudit = null; }));
+    if (handoffPath) jobs.push(fetchJson(handoffPath).then(function (report) { state.reports.handoff = report; }).catch(function () { state.reports.handoff = null; }));
+    if (lifecyclePath) jobs.push(fetchJson(lifecyclePath).then(function (report) { state.reports.lifecycle = report; }).catch(function () { state.reports.lifecycle = null; }));
+    if (timelinePath) jobs.push(fetchJson(timelinePath).then(function (report) { state.reports.timeline = report; }).catch(function () { state.reports.timeline = null; }));
+    if (lineagePath) jobs.push(fetchJson(lineagePath).then(function (report) { state.reports.lineage = report; }).catch(function () { state.reports.lineage = null; }));
+    if (setupPath) jobs.push(fetchJson(setupPath).then(function (report) { state.reports.setup = report; }).catch(function () { state.reports.setup = null; }));
     if (!graphPaths.length && !jobs.length) {
       loadHostedDefault();
       return;
@@ -626,20 +707,46 @@
       fetchJson("./data/kage/inbox.json").catch(function () { return null; }),
       fetchJson("./data/kage/reports/risk.json").catch(function () { return null; }),
       fetchJson("./data/kage/reports/contributors.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/profile.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/capabilities.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/context-slots.json").catch(function () { return null; }),
       fetchJson("./data/kage/reports/decisions.json").catch(function () { return null; }),
       fetchJson("./data/kage/reports/module-health.json").catch(function () { return null; }),
       fetchJson("./data/kage/reports/graph-insights.json").catch(function () { return null; }),
-      fetchJson("./data/kage/reports/workspace.json").catch(function () { return null; })
+      fetchJson("./data/kage/reports/xray.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/workspace.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/sessions.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/replay.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/memory-access.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/memory-audit.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/handoff.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/lifecycle.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/timeline.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/lineage.json").catch(function () { return null; }),
+      fetchJson("./data/kage/reports/setup.json").catch(function () { return null; })
     ]).then(function (items) {
       var merged = mergeNormalizedGraphs([normalizeGraph(items[0]), normalizeGraph(items[1])]);
       state.metrics = items[2];
       state.inbox = items[3];
       state.reports.risk = items[4];
       state.reports.contributors = items[5];
-      state.reports.decisions = items[6];
-      state.reports.moduleHealth = items[7];
-      state.reports.graphInsights = items[8];
-      state.reports.workspace = items[9];
+      state.reports.profile = items[6];
+      state.reports.capabilities = items[7];
+      state.reports.slots = items[8];
+      state.reports.decisions = items[9];
+      state.reports.moduleHealth = items[10];
+      state.reports.graphInsights = items[11];
+      state.reports.xray = items[12];
+      state.reports.workspace = items[13];
+      state.reports.sessions = items[14];
+      state.reports.replay = items[15];
+      state.reports.memoryAccess = items[16];
+      state.reports.memoryAudit = items[17];
+      state.reports.handoff = items[18];
+      state.reports.lifecycle = items[19];
+      state.reports.timeline = items[20];
+      state.reports.lineage = items[21];
+      state.reports.setup = items[22];
       loadNormalizedGraph(merged, "Kage repo graph");
       setAutoLoad("Kage repo graph loaded", true);
     }).catch(function () {
@@ -1383,6 +1490,7 @@
 
     renderActiveGraph(graphChanged);
     renderPagePanels();
+    revealSelectionIfRequested();
   }
 
   function scheduleRender() {
@@ -2438,6 +2546,18 @@
     document.body.classList.toggle("has-code-selection", Boolean(entity && entity.graph_kind === "code"));
   }
 
+  function revealSelectionIfRequested() {
+    if (!state.revealSelection) return;
+    state.revealSelection = false;
+    window.requestAnimationFrame(function () {
+      var panel = document.querySelector(".details-panel");
+      if (!panel || window.getComputedStyle(panel).display === "none") return;
+      panel.scrollIntoView({ block: "nearest", inline: "nearest" });
+      var selectedRow = document.querySelector("[aria-selected=\"true\"], .node.selected");
+      if (selectedRow && selectedRow.scrollIntoView) selectedRow.scrollIntoView({ block: "nearest", inline: "nearest" });
+    });
+  }
+
   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");
@@ -2877,22 +2997,22 @@
     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 riskTargets = userFacingRiskTargets(risk);
     var inboxCounts = state.inbox && state.inbox.counts ? state.inbox.counts : {};
+    var handoff = memoryHandoffSummary(reports.handoff);
     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 hotspots = userFacingRiskHotspots(risk).length;
+    var readiness = handoff || 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 riskHealth = riskTargets.length || hotspots ? (riskTargets.length + hotspots) + " checks" : "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"]
+      ["Before edit", riskHealth, riskTargets.length + " edit areas, " + ownerSilos + " ownership silos", riskTargets.length || ownerSilos || hotspots ? "warn" : "ok"]
     ];
     els.dashboardStats.textContent = "";
     statRows.forEach(function (row) {
@@ -2916,16 +3036,23 @@
       ["Coverage", codeGraph.indexer_coverage_percent != null ? codeGraph.indexer_coverage_percent + "%" : "not loaded"]
     ]);
     setDashboardRows("dashboardIntel", [
-      ["Risk targets", riskTargets.length || "none"],
+      ["Edit checks", riskTargets.length || "none"],
       ["Ownership silos", ownerSilos || "none"],
       ["Decision coverage", reports.decisions && reports.decisions.coverage_percent != null ? reports.decisions.coverage_percent + "%" : "not loaded"]
     ]);
-    setDashboardRows("dashboardReview", [
+    setDashboardRows("dashboardReview", handoff ? [
+      ["Next", handoff.actionLabel],
+      ["Open", handoff.openItems ? handoff.openItems + " item" + (handoff.openItems === 1 ? "" : "s") : "none"],
+      ["Distill", handoff.distillableSessions ? handoff.distillableSessions + " session" + (handoff.distillableSessions === 1 ? "" : "s") : "none"],
+      ["Recent", handoff.recentChanges + " changes"],
+      ["Mutations", handoff.recentMutations || "none"]
+    ] : [
       ["Handoff", readiness.label],
       ["Pending", pendingReview || "none"],
       ["Stale / duplicate", staleFlags + " / " + duplicateFlags],
       ["Missing context", missingContext || "none"]
     ]);
+    renderRepoXray(reports.xray);
     renderDashboardCharts({
       metrics: metrics,
       reports: reports,
@@ -2940,7 +3067,63 @@
       missingContext: missingContext,
       riskTargets: riskTargets,
       ownerSilos: ownerSilos,
-      hotspots: hotspots
+      hotspots: hotspots,
+      handoff: handoff
+    });
+  }
+
+  function renderRepoXray(report) {
+    if (!els.repoXray || !els.repoXrayLayers) return;
+    if (!report || !Array.isArray(report.layers)) {
+      if (els.repoXrayStatus) els.repoXrayStatus.textContent = "not loaded";
+      if (els.repoXrayScript) els.repoXrayScript.textContent = "Open with `kage viewer --project <repo>` after refresh to see the first-use repo map.";
+      els.repoXrayLayers.textContent = "";
+      return;
+    }
+    var layers = report.layers.filter(function (layer) { return Array.isArray(layer.items) && layer.items.length; });
+    if (els.repoXrayStatus) els.repoXrayStatus.textContent = layers.length ? layers.length + " layers" : "empty";
+    if (els.repoXrayScript) {
+      var script = Array.isArray(report.first_use_script) ? report.first_use_script : [];
+      els.repoXrayScript.textContent = script[0] || report.summary || "Kage mapped the repo structure.";
+    }
+    els.repoXrayLayers.textContent = "";
+    if (!layers.length) {
+      els.repoXrayLayers.className = "repo-xray-layers details-empty";
+      els.repoXrayLayers.textContent = "No X-Ray layers have items yet. Run kage refresh so code graph, risk, tests, and memory links are current.";
+      return;
+    }
+    els.repoXrayLayers.className = "repo-xray-layers";
+    layers.slice(0, 6).forEach(function (layer) {
+      var card = document.createElement("article");
+      card.className = "repo-xray-layer";
+      card.innerHTML = [
+        "<div class=\"repo-xray-layer-head\"><div><strong></strong><span></span></div><em></em></div>",
+        "<div class=\"repo-xray-items\"></div>"
+      ].join("");
+      card.querySelector("strong").textContent = layer.title || layer.id || "Layer";
+      card.querySelector("span").textContent = layer.summary || "";
+      card.querySelector("em").textContent = String(layer.items.length || 0);
+      var list = card.querySelector(".repo-xray-items");
+      layer.items.slice(0, 3).forEach(function (item) {
+        var button = document.createElement("button");
+        button.type = "button";
+        button.className = classNames("repo-xray-item", item.status && "repo-xray-item-" + safeCssName(item.status));
+        button.innerHTML = [
+          "<span><strong></strong><em></em></span>",
+          "<i></i>"
+        ].join("");
+        button.querySelector("strong").textContent = item.label || item.path || "signal";
+        button.querySelector("em").textContent = Array.isArray(item.evidence) && item.evidence.length ? item.evidence.slice(0, 2).join("; ") : item.action || "";
+        button.querySelector("i").style.width = clamp(Number(item.strength || 0), 4, 100) + "%";
+        if (item.path) {
+          button.title = "Focus " + item.path + " in the graph";
+          button.addEventListener("click", function () {
+            focusGraphPath(item.path);
+          });
+        }
+        list.appendChild(button);
+      });
+      els.repoXrayLayers.appendChild(card);
     });
   }
 
@@ -2956,24 +3139,315 @@
     });
     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 blockers = data.handoff ? data.handoff.openItems : data.pendingReview + data.staleFlags + data.duplicateFlags + data.missingContext;
     var riskSignals = data.riskTargets.length + data.ownerSilos + data.hotspots;
-    els.dashboardCharts.textContent = "";
-    [
+    var retrieval = benchmarkRetrievalSummary(data.reports && data.reports.benchmark);
+    var scale = benchmarkScaleSummary(data.reports && data.reports.benchmark);
+    var access = memoryAccessSummary(data.reports && data.reports.memoryAccess, approvedPackets);
+    var audit = memoryAuditSummary(data.reports && data.reports.memoryAudit);
+    var lifecycle = memoryLifecycleSummary(data.reports && data.reports.lifecycle);
+    var timeline = memoryTimelineSummary(data.reports && data.reports.timeline);
+    var lineage = memoryLineageSummary(data.reports && data.reports.lineage);
+    var setup = setupDoctorSummary(data.reports && data.reports.setup);
+    var profile = projectProfileSummary(data.reports && data.reports.profile);
+    var capabilities = capabilityAuditSummary(data.reports && data.reports.capabilities);
+    var slots = contextSlotsSummary(data.reports && data.reports.slots);
+    var replay = sessionReplaySummary(data.reports && data.reports.replay);
+    var cards = [
       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", [
+      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")
+    ];
+    if (capabilities) {
+      cards.push(metricBars("Capability audit", capabilities.label, capabilities.rows, capabilities.action, capabilities.status));
+    }
+    if (profile) {
+      cards.push(metricBars("Project profile", profile.label, [
+        { label: "Concepts", value: profile.concepts, score: Math.min(100, profile.concepts * 10), status: profile.concepts ? "ok" : "warn" },
+        { label: "Key files", value: profile.keyFiles, score: Math.min(100, profile.keyFiles * 8), status: profile.keyFiles ? "ok" : "warn" },
+        { label: "Commands", value: profile.commands, score: Math.min(100, profile.commands * 16), status: profile.commands ? "ok" : "warn" }
+      ], profile.action, profile.status));
+    }
+    if (slots) {
+      cards.push(metricBars("Pinned context", slots.label, [
+        { label: "Pinned", value: slots.pinned, score: Math.min(100, slots.pinned * 30), status: slots.pinned ? "ok" : "warn" },
+        { label: "Slots", value: slots.total, score: Math.min(100, slots.total * 20), status: slots.total ? "ok" : "warn" },
+        { label: "Chars", value: slots.chars, score: slots.chars ? Math.min(100, Math.round(slots.chars / 60)) : 0, status: slots.chars ? "ok" : "warn" }
+      ], slots.action, slots.status));
+    }
+    if (replay) {
+      cards.push(metricBars("Session replay", replay.label, [
+        { label: "Events", value: replay.events, score: Math.min(100, replay.events * 8), status: replay.events ? "ok" : "warn" },
+        { label: "Candidates", value: replay.candidates, score: Math.min(100, replay.candidates * 24), status: replay.candidates ? "warn" : "ok" },
+        { label: "Sessions", value: replay.sessions, score: Math.min(100, replay.sessions * 24), status: replay.sessions ? "ok" : "warn" }
+      ], replay.action, replay.status));
+    }
+    if (setup) {
+      cards.push(metricBars("Agent setup", setup.label, [
+        { label: "Configured", value: setup.configured + "/" + setup.total, score: setup.total ? Math.round(setup.configured / setup.total * 100) : 0, status: setup.configured ? "ok" : "warn" },
+        { label: "Claude hooks", value: setup.claudeHookReady ? "ready" : "missing", score: setup.claudeHookReady ? 100 : 0, status: setup.claudeHookReady ? "ok" : "warn" },
+        { label: "Missing", value: setup.missingCount, score: setup.missingCount ? Math.min(100, setup.missingCount * 18) : 0, status: setup.missingCount ? "warn" : "ok" }
+      ], setup.action, setup.status));
+    }
+    if (access) {
+      cards.push(metricBars("Memory reuse", access.uses30d + " recalls", [
+        { label: "Hot", value: access.hot, score: Math.min(100, access.hot * 24), status: access.hot ? "ok" : "warn" },
+        { label: "Cold", value: access.cold, score: approvedPackets ? Math.round(access.cold / approvedPackets * 100) : 0, status: access.cold ? "warn" : "ok" },
+        { label: "Tracked", value: access.tracked, score: approvedPackets ? Math.round(access.tracked / approvedPackets * 100) : 0, status: access.tracked ? "ok" : "warn" }
+      ], access.tracked ? "Cold packets may be stale, too broad, or never needed by agents." : "Recall a task to start measuring which memories actually help.", access.cold ? "warn" : "ok"));
+    }
+    if (audit) {
+      cards.push(metricBars("Memory audit", audit.total + " mutations", [
+        { label: "Capture", value: audit.capture, score: Math.min(100, audit.capture * 12), status: audit.capture ? "ok" : "warn" },
+        { label: "Review", value: audit.review, score: Math.min(100, audit.review * 20), status: audit.review ? "ok" : "warn" },
+        { label: "Supersede", value: audit.supersede, score: Math.min(100, audit.supersede * 24), status: audit.supersede ? "ok" : "warn" }
+      ], audit.total ? "Memory changes are auditable for team handoff." : "No explicit memory mutations audited yet.", audit.total ? "ok" : "warn"));
+    }
+    if (data.handoff) {
+      cards.push(metricBars("Memory handoff", data.handoff.label, [
+        { label: "Open", value: data.handoff.openItems, score: Math.min(100, data.handoff.openItems * 24), status: data.handoff.openItems ? "warn" : "ok" },
+        { label: "Distill", value: data.handoff.distillableSessions, score: Math.min(100, data.handoff.distillableSessions * 30), status: data.handoff.distillableSessions ? "warn" : "ok" },
+        { label: "Recent", value: data.handoff.recentChanges, score: Math.min(100, data.handoff.recentChanges * 8), status: data.handoff.recentChanges ? "ok" : "warn" },
+        { label: "Mutations", value: data.handoff.recentMutations, score: Math.min(100, data.handoff.recentMutations * 18), status: data.handoff.recentMutations ? "ok" : "warn" }
+      ], data.handoff.action, data.handoff.status));
+    }
+    if (lifecycle) {
+      cards.push(metricBars("Memory lifecycle", lifecycle.needsReview ? lifecycle.needsReview + " need review" : "healthy", [
+        { label: "Hot/healthy", value: lifecycle.ready, score: approvedPackets ? Math.round(lifecycle.ready / approvedPackets * 100) : 0, status: lifecycle.ready ? "ok" : "warn" },
+        { label: "Ungrounded", value: lifecycle.ungrounded, score: approvedPackets ? Math.round(lifecycle.ungrounded / approvedPackets * 100) : 0, status: lifecycle.ungrounded ? "warn" : "ok" },
+        { label: "Stale/disputed", value: lifecycle.stale, score: approvedPackets ? Math.round(lifecycle.stale / approvedPackets * 100) : 0, status: lifecycle.stale ? "danger" : "ok" }
+      ], lifecycle.needsReview ? "Open Memory and resolve lifecycle actions before handoff." : "Repo memory is ready for agent handoff.", lifecycle.needsReview ? "warn" : "ok"));
+    }
+    if (timeline) {
+      cards.push(metricBars("Memory timeline", timeline.total + " recent", [
+        { label: "Added", value: timeline.added, score: Math.min(100, timeline.added * 16), status: timeline.added ? "ok" : "warn" },
+        { label: "Updated", value: timeline.updated, score: Math.min(100, timeline.updated * 16), status: timeline.updated ? "ok" : "warn" },
+        { label: "Pending", value: timeline.pending, score: Math.min(100, timeline.pending * 24), status: timeline.pending ? "warn" : "ok" }
+      ], timeline.total ? "Review recent memory changes before teammate handoff." : "No recent memory activity loaded.", timeline.pending ? "warn" : "ok"));
+    }
+    if (lineage) {
+      cards.push(metricBars("Memory lineage", lineage.chains + " chains", [
+        { label: "Replaced", value: lineage.superseded, score: Math.min(100, lineage.superseded * 18), status: lineage.superseded ? "ok" : "warn" },
+        { label: "Chains", value: lineage.chains, score: Math.min(100, lineage.chains * 24), status: lineage.chains ? "ok" : "warn" },
+        { label: "Needs repair", value: lineage.orphans, score: Math.min(100, lineage.orphans * 32), status: lineage.orphans ? "danger" : "ok" }
+      ], lineage.orphans ? "Fix superseded memory without replacement links." : "Retired memory points at current replacements.", lineage.orphans ? "danger" : "ok"));
+    }
+    if (retrieval) {
+      cards.push(metricBars("Retrieval proof", retrieval.r10 + "% R@10", [
+        { label: "R@5", value: retrieval.r5 != null ? retrieval.r5 + "%" : "n/a", score: retrieval.r5 || 0, status: retrieval.r5 >= 95 ? "ok" : "warn" },
+        { label: "R@10", value: retrieval.r10 + "%", score: retrieval.r10, status: retrieval.r10 >= 95 ? "ok" : "warn" },
+        { label: "MRR", value: retrieval.mrr != null ? retrieval.mrr : "n/a", score: retrieval.mrr != null ? retrieval.mrr * 100 : 0, status: retrieval.mrr >= 0.85 ? "ok" : "warn" }
+      ], retrieval.label + ". Measures memory retrieval proof, not answer accuracy.", retrieval.r10 >= 95 ? "ok" : "warn"));
+    }
+    if (scale) {
+      cards.push(metricBars("Scale proof", scale.hitRate + "% hit", [
+        { label: "Packets", value: scale.packets, score: Math.min(100, scale.packets / 10), status: scale.packets >= 240 ? "ok" : "warn" },
+        { label: "Median", value: scale.medianLatency + "ms", score: Math.max(0, 100 - scale.medianLatency), status: scale.medianLatency <= 50 ? "ok" : "warn" },
+        { label: "Context cut", value: scale.contextReduction + "%", score: scale.contextReduction, status: scale.contextReduction >= 80 ? "ok" : "warn" }
+      ], "Large memory corpus stays searchable without loading every packet.", scale.hitRate >= 95 ? "ok" : "warn"));
+    }
+    els.dashboardCharts.textContent = "";
+    var tailCards = [];
+    if (!data.handoff) {
+      tailCards.push(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" },
+      ], blockers ? "Resolve Review before handing work to another agent." : "Memory is clean for handoff.", blockers ? "warn" : "ok"));
+    }
+    tailCards.push(
+      metricBars("Before edit", riskSignals ? riskSignals + " checks" : "none", [
+        { label: "Edit areas", 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); });
+      ], riskSignals ? "Open Before Edit and do the listed safety step before changing code." : "No loaded risk flags.", riskSignals ? "warn" : "ok")
+    );
+    cards.concat(tailCards).slice(0, 3).forEach(function (card) { els.dashboardCharts.appendChild(card); });
+  }
+
+  function projectProfileSummary(report) {
+    if (!report || !report.totals) return null;
+    var concepts = Array.isArray(report.top_concepts) ? report.top_concepts.length : 0;
+    var keyFiles = Array.isArray(report.key_files) ? report.key_files.length : 0;
+    var commands = Array.isArray(report.run_commands) ? report.run_commands.length : 0;
+    var coverage = Number(report.totals.memory_code_coverage_percent || 0);
+    var topConcept = concepts ? report.top_concepts[0].concept : "no concepts";
+    var actions = Array.isArray(report.next_actions) ? report.next_actions : [];
+    return {
+      concepts: concepts,
+      keyFiles: keyFiles,
+      commands: commands,
+      label: topConcept,
+      action: actions[0] || report.summary || "Use this as the first orientation packet for agents.",
+      status: coverage >= 60 && keyFiles ? "ok" : "warn"
+    };
+  }
+
+  function capabilityAuditSummary(report) {
+    if (!report || !Array.isArray(report.pillars)) return null;
+    var rows = report.pillars.slice(0, 4).map(function (pillar) {
+      return {
+        label: pillar.label || pillar.id || "pillar",
+        value: Number(pillar.score || 0) + "%",
+        score: Number(pillar.score || 0),
+        status: pillar.status === "ready" ? "ok" : (pillar.status === "gap" ? "danger" : "warn")
+      };
+    });
+    var open = report.pillars.filter(function (pillar) { return pillar.status !== "ready"; }).length;
+    return {
+      label: Number(report.overall_score || 0) + "/100",
+      rows: rows,
+      action: open
+        ? (Array.isArray(report.next_actions) && report.next_actions[0] ? report.next_actions[0] : "Review capability gaps before publishing claims.")
+        : "Memory, benchmark, collaboration, and viewer proof surfaces are ready.",
+      status: report.status === "ready" ? "ok" : (report.status === "gap" ? "danger" : "warn")
+    };
+  }
+
+  function contextSlotsSummary(report) {
+    if (!report || !report.totals) return null;
+    var slots = Array.isArray(report.slots) ? report.slots : [];
+    var pinned = Number(report.totals.pinned || 0);
+    var total = Number(report.totals.slots || slots.length || 0);
+    var chars = Number(report.totals.context_chars || 0);
+    var firstPinned = slots.find(function (slot) { return slot && slot.pinned && slot.content; });
+    return {
+      pinned: pinned,
+      total: total,
+      chars: chars,
+      label: firstPinned ? firstPinned.label : (pinned ? String(pinned) + " pinned" : "none"),
+      action: pinned
+        ? "Pinned slots are included before task-specific recall for stable repo guidance."
+        : "Add a slot for tiny always-relevant repo context instead of repeating it every session.",
+      status: pinned ? "ok" : "warn"
+    };
+  }
+
+  function sessionReplaySummary(report) {
+    if (!report || !report.totals) return null;
+    var events = Number(report.totals.events || 0);
+    var candidates = Number(report.totals.durable_candidates || 0);
+    var sessions = Number(report.totals.sessions || 0);
+    return {
+      events: events,
+      candidates: candidates,
+      sessions: sessions,
+      label: candidates ? candidates + " distillable" : (events ? events + " observed" : "none"),
+      action: candidates
+        ? "Open Memory and distill durable session observations into reviewable packets."
+        : "Replay digest proves what agents observed without exposing raw transcripts.",
+      status: candidates ? "warn" : (events ? "ok" : "warn")
+    };
+  }
+
+  function setupDoctorSummary(report) {
+    if (!Array.isArray(report) || !report.length) return null;
+    var configured = report.filter(function (item) { return item && item.configured; }).length;
+    var claude = report.find(function (item) { return item && item.agent === "claude-code"; });
+    var hookSummary = claude && claude.hook_summary;
+    var missing = hookSummary && Array.isArray(hookSummary.missing) ? hookSummary.missing : [];
+    var claudeHookReady = Boolean(hookSummary && hookSummary.ready);
+    var missingCount = missing.length;
+    var action = "";
+    if (missingCount) {
+      action = "Run kage setup claude-code --project . --write before relying on automatic memory.";
+    } else if (configured) {
+      action = "Automatic memory setup is visible for teammate handoff.";
+    } else {
+      action = "Run kage setup doctor to choose the next agent setup step.";
+    }
+    return {
+      total: report.length,
+      configured: configured,
+      claudeHookReady: claudeHookReady,
+      missingCount: missingCount,
+      label: missingCount ? missingCount + " missing" : configured + "/" + report.length + " ready",
+      action: action,
+      status: missingCount || !configured ? "warn" : "ok"
+    };
+  }
+
+  function memoryAccessSummary(report, approvedPackets) {
+    var totals = report && report.totals;
+    if (!totals) return null;
+    return {
+      tracked: Number(totals.tracked_packets || 0),
+      uses30d: Number(totals.uses_30d || 0),
+      hot: Number(totals.hot_packets || 0),
+      cold: Number(totals.cold_packets == null ? Math.max(0, approvedPackets) : totals.cold_packets)
+    };
+  }
+
+  function memoryAuditSummary(report) {
+    var totals = report && report.totals;
+    if (!totals) return null;
+    return {
+      total: Number(totals.total || 0),
+      capture: Number(totals.capture || 0),
+      review: Number(totals.approve || 0) + Number(totals.reject || 0),
+      supersede: Number(totals.supersede || 0)
+    };
+  }
+
+  function memoryHandoffSummary(report) {
+    var totals = report && report.totals;
+    if (!totals) return null;
+    var primary = report.primary_action || {};
+    var openItems = Number(firstNumber(totals.open_items, 0));
+    var severity = primary.severity || (openItems ? "warning" : "ok");
+    var status = severity === "blocker" ? "danger" : severity === "warning" ? "warn" : severity === "ok" ? "ok" : "memory";
+    var label = primary.label || (openItems ? "Resolve handoff" : "Ready for handoff");
+    return {
+      label: label,
+      actionLabel: label.indexOf("Resolve") === 0 ? "Resolve" : label.indexOf("Ready") === 0 ? "Ready" : label.indexOf("Review") === 0 ? "Review" : label,
+      detail: primary.summary || report.summary || "",
+      action: primary.action || report.summary || "Open Review before handing work to another agent.",
+      status: status,
+      openItems: openItems,
+      blockers: Number(firstNumber(totals.blockers, 0)),
+      warnings: Number(firstNumber(totals.warnings, 0)),
+      recentChanges: Number(firstNumber(totals.recent_changes, 0)),
+      recentMutations: Number(firstNumber(totals.recent_mutations, 0)),
+      distillableSessions: Number(firstNumber(totals.distillable_sessions, 0)),
+      durableObservations: Number(firstNumber(totals.durable_observations, 0))
+    };
+  }
+
+  function memoryLifecycleSummary(report) {
+    var totals = report && report.totals;
+    if (!totals) return null;
+    var stale = Number(totals.stale || 0) + Number(totals.disputed || 0);
+    var ungrounded = Number(totals.ungrounded || 0);
+    var pending = Number(totals.pending || 0);
+    return {
+      ready: Number(totals.hot || 0) + Number(totals.healthy || 0),
+      ungrounded: ungrounded,
+      stale: stale,
+      needsReview: stale + ungrounded + pending
+    };
+  }
+
+  function memoryTimelineSummary(report) {
+    var totals = report && report.totals;
+    if (!totals) return null;
+    return {
+      total: Number(totals.total || 0),
+      added: Number(totals.added || 0),
+      updated: Number(totals.updated || 0),
+      pending: Number(totals.pending || 0),
+      deprecated: Number(totals.deprecated || 0)
+    };
+  }
+
+  function memoryLineageSummary(report) {
+    var totals = report && report.totals;
+    if (!totals) return null;
+    return {
+      superseded: Number(totals.superseded || 0),
+      chains: Number(totals.chains || 0),
+      orphans: Number(totals.orphans || 0),
+      replacementsMissing: Number(totals.replacements_missing || 0)
+    };
   }
 
   function metricDonut(title, percent, detail, action, status) {
@@ -3104,6 +3578,7 @@
       }
     });
     var linkedCount = memoryEntities.filter(function (entity) { return (memoryLinkCounts.get(entity.id) || 0) > 0; }).length;
+    var accessTotals = state.reports.memoryAccess && state.reports.memoryAccess.totals;
     var query = parseSearchQuery(els.memorySearch ? els.memorySearch.value : "");
     var filter = els.memoryFilter ? els.memoryFilter.value : "all";
     var filtered = memoryEntities.filter(function (entity) {
@@ -3118,10 +3593,17 @@
       els.memoryStats.innerHTML = [
         memoryStat("Reusable", memoryEntities.length),
         memoryStat("Code-linked", linkedCount),
+        memoryStat("Reused 30d", accessTotals ? Number(accessTotals.uses_30d || 0) : "n/a"),
         memoryStat("Needs paths", memoryEntities.length - linkedCount)
       ].join("");
     }
     if (els.memoryOverview) renderMemoryOverview(memoryEntities, linkedCount);
+    if (els.lifecycleList) renderMemoryLifecycle(memoryEntities, memoryLinkCounts);
+    if (els.memoryReviewActions) renderMemoryReviewActions();
+    if (els.memoryTimelineList) renderMemoryTimeline();
+    if (els.memoryAuditList) renderMemoryAudit();
+    if (els.memoryLineageList) renderMemoryLineage();
+    if (els.sessionCaptureList) renderSessionCapture();
     els.memoryList.textContent = "";
     if (!memoryEntities.length) {
       els.memoryList.className = "memory-list details-empty";
@@ -3142,6 +3624,7 @@
     filtered.slice(0, 60).forEach(function (entity) {
       var links = memoryCodeLinksForEntity(entity.id);
       var firstCodeTarget = primaryCodeTargetForMemory(entity.id, links);
+      var access = memoryAccessForEntity(entity);
       var item = document.createElement("button");
       item.type = "button";
       var selected = state.selected && state.selected.kind === "entity" && state.selected.id === entity.id;
@@ -3158,6 +3641,9 @@
       item.querySelector(".memory-row-target").textContent = links.length
         ? links.length + " code link" + (links.length === 1 ? "" : "s") + (firstCodeTarget ? " | " + trimIntelText(codeTargetLabel(firstCodeTarget), 64) : "")
         : "needs code paths";
+      if (access && access.total_uses) {
+        item.querySelector(".memory-row-target").textContent += " | reused " + Number(access.uses_30d || 0) + "x in 30d";
+      }
       item.addEventListener("click", function () {
         selectEntity(entity.id, true);
         render();
@@ -3171,6 +3657,13 @@
     return "<div><strong>" + escapeHtml(String(value)) + "</strong><span>" + escapeHtml(label) + "</span></div>";
   }
 
+  function memoryAccessForEntity(entity) {
+    var report = state.reports && state.reports.memoryAccess;
+    if (!report || !Array.isArray(report.entries)) return null;
+    var ids = new Set([entity.id].concat(entity.aliases || []));
+    return report.entries.find(function (entry) { return ids.has(entry.packet_id); }) || null;
+  }
+
   function renderMemoryOverview(memoryEntities, linkedCount) {
     els.memoryOverview.textContent = "";
     var total = memoryEntities.length;
@@ -3198,6 +3691,592 @@
     }), "A healthy repo has decisions, bug fixes, runbooks, gotchas, and code explanations.", "ok"));
   }
 
+  function renderMemoryReviewActions() {
+    var lifecycle = state.reports && state.reports.lifecycle;
+    var access = state.reports && state.reports.memoryAccess;
+    var recommendations = lifecycle && Array.isArray(lifecycle.recommendations)
+      ? lifecycle.recommendations
+      : (access && Array.isArray(access.recommendations) ? access.recommendations : []);
+    if (els.memoryReviewStatus) {
+      els.memoryReviewStatus.textContent = recommendations.length ? recommendations.length + " action" + (recommendations.length === 1 ? "" : "s") : "clear";
+    }
+    els.memoryReviewActions.textContent = "";
+    if (!lifecycle && !access) {
+      els.memoryReviewActions.className = "memory-action-list details-empty";
+      els.memoryReviewActions.textContent = "No lifecycle report loaded. Run kage lifecycle or open the local viewer after refreshing memory.";
+      return;
+    }
+    if (!recommendations.length) {
+      els.memoryReviewActions.className = "memory-action-list details-empty";
+      els.memoryReviewActions.textContent = "No memory review actions. Recent recall usage does not show obvious hot or cold packets.";
+      return;
+    }
+    els.memoryReviewActions.className = "memory-action-list";
+    recommendations.slice(0, 6).forEach(function (item) {
+      var card = document.createElement("article");
+      card.className = classNames("memory-action", item.severity && "memory-action-" + item.severity);
+      card.innerHTML = [
+        "<div class=\"memory-action-head\"><span></span><strong></strong></div>",
+        "<p></p>",
+        "<em></em>"
+      ].join("");
+      card.querySelector(".memory-action-head span").textContent = memoryActionLabel(item.kind);
+      card.querySelector(".memory-action-head strong").textContent = item.summary || item.title || "Memory action";
+      card.querySelector("p").textContent = item.reason || "";
+      card.querySelector("em").textContent = item.action || "";
+      var entity = item.packet_id ? findMemoryEntityByPacketId(item.packet_id) : null;
+      if (entity) {
+        card.tabIndex = 0;
+        card.setAttribute("role", "button");
+        card.addEventListener("click", function () {
+          selectEntity(entity.id, true);
+          render();
+        });
+        card.addEventListener("keydown", function (event) {
+          if (event.key !== "Enter" && event.key !== " ") return;
+          event.preventDefault();
+          selectEntity(entity.id, true);
+          render();
+        });
+      }
+      els.memoryReviewActions.appendChild(card);
+    });
+  }
+
+  function renderMemoryTimeline() {
+    var report = state.reports && state.reports.timeline;
+    var entries = Array.isArray(report && report.entries) ? report.entries : [];
+    var totals = report && report.totals ? report.totals : {};
+    if (els.memoryTimelineStatus) {
+      els.memoryTimelineStatus.textContent = report ? String(Number(totals.total || entries.length)) + " recent" : "waiting";
+    }
+    if (els.memoryTimelineSummary) {
+      els.memoryTimelineSummary.textContent = "";
+      [
+        lifecycleSummaryStep("+", "Added", Number(totals.added || 0), "New repo memories captured for future agents."),
+        lifecycleSummaryStep("~", "Updated", Number(totals.updated || 0), "Packets with changed rationale, evidence, or paths."),
+        lifecycleSummaryStep("?", "Pending", Number(totals.pending || 0), "Memory waiting for teammate review.")
+      ].forEach(function (step) { els.memoryTimelineSummary.appendChild(step); });
+    }
+    els.memoryTimelineList.textContent = "";
+    if (!report) {
+      els.memoryTimelineList.className = "session-capture-list details-empty";
+      els.memoryTimelineList.textContent = "No memory timeline report loaded. Run kage timeline or open the local viewer after refresh.";
+      return;
+    }
+    if (!entries.length) {
+      els.memoryTimelineList.className = "session-capture-list details-empty";
+      els.memoryTimelineList.textContent = "No recent memory activity. Capture durable repo decisions, bugs, runbooks, or gotchas as work happens.";
+      return;
+    }
+    els.memoryTimelineList.className = "session-capture-list";
+    entries.slice(0, 8).forEach(function (entry) {
+      var card = document.createElement("article");
+      card.className = "session-capture-card";
+      card.innerHTML = [
+        "<div class=\"session-capture-head\"><div><strong></strong><span></span></div><em></em></div>",
+        "<p></p>",
+        "<div class=\"session-capture-meta\"></div>"
+      ].join("");
+      card.querySelector("strong").textContent = entry.title || "Memory packet";
+      card.querySelector("span").textContent = [entry.type, timelineDateLabel(entry.date), entry.source_kind].filter(Boolean).join(" | ");
+      card.querySelector("em").textContent = timelineKindLabel(entry.kind);
+      card.querySelector("p").textContent = entry.action || entry.summary || "Review this memory activity.";
+      var meta = card.querySelector(".session-capture-meta");
+      [
+        ["status", entry.status || "unknown"],
+        ["paths", Array.isArray(entry.paths) ? entry.paths.slice(0, 2).join(", ") || "none" : "none"],
+        ["tags", Array.isArray(entry.tags) ? entry.tags.slice(0, 3).join(", ") || "none" : "none"]
+      ].forEach(function (row) {
+        var chip = document.createElement("span");
+        chip.textContent = row[0] + ": " + row[1];
+        meta.appendChild(chip);
+      });
+      var entity = entry.packet_id ? findMemoryEntityByPacketId(entry.packet_id) : null;
+      if (entity) {
+        card.tabIndex = 0;
+        card.setAttribute("role", "button");
+        card.addEventListener("click", function () {
+          selectEntity(entity.id, true);
+          render();
+        });
+        card.addEventListener("keydown", function (event) {
+          if (event.key !== "Enter" && event.key !== " ") return;
+          event.preventDefault();
+          selectEntity(entity.id, true);
+          render();
+        });
+      }
+      els.memoryTimelineList.appendChild(card);
+    });
+  }
+
+  function renderMemoryAudit() {
+    var report = state.reports && state.reports.memoryAudit;
+    var entries = Array.isArray(report && report.entries) ? report.entries : [];
+    var totals = report && report.totals ? report.totals : {};
+    if (els.memoryAuditStatus) {
+      els.memoryAuditStatus.textContent = report ? String(Number(totals.total || entries.length)) + " mutations" : "waiting";
+    }
+    if (els.memoryAuditSummary) {
+      els.memoryAuditSummary.textContent = "";
+      [
+        lifecycleSummaryStep("1", "Captured", Number(totals.capture || 0), "New packets written to repo memory."),
+        lifecycleSummaryStep("2", "Reviewed", Number(totals.approve || 0) + Number(totals.reject || 0), "Pending packets approved or rejected."),
+        lifecycleSummaryStep("3", "Replaced", Number(totals.supersede || 0), "Old knowledge linked to current replacements.")
+      ].forEach(function (step) { els.memoryAuditSummary.appendChild(step); });
+    }
+    els.memoryAuditList.textContent = "";
+    if (!report) {
+      els.memoryAuditList.className = "session-capture-list details-empty";
+      els.memoryAuditList.textContent = "No memory audit report loaded. Run kage memory-audit or open the local viewer after refresh.";
+      return;
+    }
+    if (!entries.length) {
+      els.memoryAuditList.className = "session-capture-list details-empty";
+      els.memoryAuditList.textContent = "No audited memory mutations yet. Captures, feedback, reviews, and supersedes will appear here.";
+      return;
+    }
+    els.memoryAuditList.className = "session-capture-list";
+    entries.slice(0, 8).forEach(function (entry) {
+      var card = document.createElement("article");
+      card.className = "session-capture-card";
+      card.innerHTML = [
+        "<div class=\"session-capture-head\"><div><strong></strong><span></span></div><em></em></div>",
+        "<p></p>",
+        "<div class=\"session-capture-meta\"></div>"
+      ].join("");
+      card.querySelector("strong").textContent = (entry.packet_titles || []).join(", ") || (entry.packet_ids || []).join(", ") || "Memory mutation";
+      card.querySelector("span").textContent = [entry.actor, entry.branch, timelineDateLabel(entry.timestamp)].filter(Boolean).join(" | ");
+      card.querySelector("em").textContent = entry.operation || "audit";
+      card.querySelector("p").textContent = memoryAuditAction(entry);
+      var meta = card.querySelector(".session-capture-meta");
+      [
+        ["packets", Array.isArray(entry.packet_ids) ? String(entry.packet_ids.length) : "0"],
+        ["head", entry.head ? String(entry.head).slice(0, 8) : "none"],
+        ["details", auditDetailsLabel(entry.details)]
+      ].forEach(function (row) {
+        var chip = document.createElement("span");
+        chip.textContent = row[0] + ": " + row[1];
+        meta.appendChild(chip);
+      });
+      els.memoryAuditList.appendChild(card);
+    });
+  }
+
+  function memoryAuditAction(entry) {
+    if (!entry) return "Review this memory mutation before handoff.";
+    if (entry.operation === "capture") return "New repo knowledge was captured for future agents.";
+    if (entry.operation === "feedback") return "A recalled memory received explicit usefulness or stale feedback.";
+    if (entry.operation === "approve") return "A pending packet became shared repo memory.";
+    if (entry.operation === "reject") return "A pending packet was rejected instead of becoming shared memory.";
+    if (entry.operation === "supersede") return "Old repo knowledge now points at a current replacement packet.";
+    if (entry.operation === "deprecate") return "Stale memory was retired from active use.";
+    if (entry.operation === "delete") return "Memory was removed by an explicit cleanup action.";
+    return "Review this memory mutation before handoff.";
+  }
+
+  function auditDetailsLabel(details) {
+    if (!details || typeof details !== "object") return "none";
+    if (details.feedback) return "feedback " + details.feedback;
+    if (details.reason) return String(details.reason).slice(0, 80);
+    if (details.type) return "type " + details.type;
+    return Object.keys(details).slice(0, 3).join(", ") || "none";
+  }
+
+  function renderMemoryLineage() {
+    var report = state.reports && state.reports.lineage;
+    var chains = Array.isArray(report && report.chains) ? report.chains : [];
+    var orphans = Array.isArray(report && report.orphans) ? report.orphans : [];
+    var totals = report && report.totals ? report.totals : {};
+    if (els.memoryLineageStatus) {
+      els.memoryLineageStatus.textContent = report ? String(Number(totals.chains || chains.length)) + " chains" : "waiting";
+    }
+    if (els.memoryLineageSummary) {
+      els.memoryLineageSummary.textContent = "";
+      [
+        lifecycleSummaryStep("1", "Current", Number(totals.chains || chains.length), "Replacement packets future agents should trust."),
+        lifecycleSummaryStep("2", "Retired", Number(totals.superseded || 0), "Old packets kept as audit history, not active recall."),
+        lifecycleSummaryStep("3", "Repair", Number(totals.orphans || orphans.length), "Superseded packets missing a replacement link.")
+      ].forEach(function (step) { els.memoryLineageSummary.appendChild(step); });
+    }
+    els.memoryLineageList.textContent = "";
+    if (!report) {
+      els.memoryLineageList.className = "session-capture-list details-empty";
+      els.memoryLineageList.textContent = "No lineage report loaded. Run kage lineage or open the local viewer after refresh.";
+      return;
+    }
+    if (!chains.length && !orphans.length) {
+      els.memoryLineageList.className = "session-capture-list details-empty";
+      els.memoryLineageList.textContent = "No retired memory chains yet. Use kage supersede when a newer packet replaces old repo knowledge.";
+      return;
+    }
+    els.memoryLineageList.className = "session-capture-list";
+    chains.slice(0, 6).forEach(function (chain) {
+      var card = document.createElement("article");
+      card.className = "session-capture-card";
+      card.innerHTML = [
+        "<div class=\"session-capture-head\"><div><strong></strong><span></span></div><em>current</em></div>",
+        "<p></p>",
+        "<div class=\"session-capture-meta\"></div>"
+      ].join("");
+      card.querySelector("strong").textContent = chain.current_title || "Replacement memory";
+      card.querySelector("span").textContent = "replaces " + Number((chain.superseded_packet_ids || []).length) + " packet" + ((chain.superseded_packet_ids || []).length === 1 ? "" : "s");
+      card.querySelector("p").textContent = chain.action || "Use the current replacement packet in recall.";
+      var meta = card.querySelector(".session-capture-meta");
+      [
+        ["reason", chain.reason || "replacement linked"],
+        ["paths", Array.isArray(chain.paths) ? chain.paths.slice(0, 2).join(", ") || "none" : "none"],
+        ["updated", timelineDateLabel(chain.updated_at)]
+      ].forEach(function (row) {
+        var chip = document.createElement("span");
+        chip.textContent = row[0] + ": " + row[1];
+        meta.appendChild(chip);
+      });
+      var entity = chain.current_packet_id ? findMemoryEntityByPacketId(chain.current_packet_id) : null;
+      if (entity) {
+        card.tabIndex = 0;
+        card.setAttribute("role", "button");
+        card.addEventListener("click", function () {
+          selectEntity(entity.id, true);
+          render();
+        });
+      }
+      els.memoryLineageList.appendChild(card);
+    });
+    orphans.slice(0, 4).forEach(function (orphan) {
+      var card = document.createElement("article");
+      card.className = "session-capture-card memory-action-danger";
+      card.innerHTML = [
+        "<div class=\"session-capture-head\"><div><strong></strong><span></span></div><em>repair</em></div>",
+        "<p></p>"
+      ].join("");
+      card.querySelector("strong").textContent = orphan.title || "Superseded memory";
+      card.querySelector("span").textContent = timelineDateLabel(orphan.updated_at);
+      card.querySelector("p").textContent = orphan.action || "Add a replacement link before trusting this old context.";
+      els.memoryLineageList.appendChild(card);
+    });
+  }
+
+  function timelineKindLabel(kind) {
+    if (kind === "added") return "added";
+    if (kind === "updated") return "updated";
+    if (kind === "pending") return "pending";
+    if (kind === "deprecated") return "retired";
+    return "activity";
+  }
+
+  function timelineDateLabel(date) {
+    return date ? String(date).slice(0, 10) : "";
+  }
+
+  function memoryActionLabel(kind) {
+    if (kind === "promote_hot") return "Hot";
+    if (kind === "review_cold") return "Cold";
+    if (kind === "connect_paths") return "Ground";
+    if (kind === "add_grounding") return "Ground";
+    if (kind === "review_stale") return "Stale";
+    if (kind === "resolve_feedback") return "Feedback";
+    if (kind === "archive_generated") return "Archive";
+    if (kind === "review_pending") return "Pending";
+    if (kind === "keep_verified") return "Keep";
+    if (kind === "seed_usage") return "Start";
+    return "Review";
+  }
+
+  function findMemoryEntityByPacketId(packetId) {
+    return state.entities.find(function (entity) {
+      if (!isMemoryPacketEntity(entity)) return false;
+      if (entity.id === packetId || entity.packet_id === packetId) return true;
+      return Array.isArray(entity.aliases) && entity.aliases.indexOf(packetId) !== -1;
+    }) || null;
+  }
+
+  function renderMemoryLifecycle(memoryEntities, memoryLinkCounts) {
+    if (!els.lifecycleList) return;
+    var report = state.reports && state.reports.lifecycle;
+    if (report && Array.isArray(report.items)) {
+      renderMemoryLifecycleReport(report);
+      return;
+    }
+    var proofPackets = memoryEntities
+      .map(function (entity) {
+        var links = memoryCodeLinksForEntity(entity.id);
+        return {
+          entity: entity,
+          links: links,
+          score: lifecyclePacketScore(entity, links, memoryLinkCounts.get(entity.id) || 0)
+        };
+      })
+      .sort(function (a, b) {
+        return b.score - a.score ||
+          lifecycleTimestamp(b.entity).localeCompare(lifecycleTimestamp(a.entity)) ||
+          displayName(a.entity).localeCompare(displayName(b.entity));
+      });
+    var grounded = proofPackets.filter(function (item) { return item.links.length; }).length;
+    var recallReady = proofPackets.filter(function (item) {
+      return item.links.length && lifecycleEvidence(item.entity).length && lifecycleRecallQuery(item.entity);
+    }).length;
+    if (els.lifecycleStatus) {
+      els.lifecycleStatus.textContent = proofPackets.length ? recallReady + " recall-ready" : "empty";
+    }
+    if (els.lifecycleSummary) {
+      els.lifecycleSummary.textContent = "";
+      [
+        lifecycleSummaryStep("1", "Captured", proofPackets.length, "Reusable facts agents saved instead of rediscovering."),
+        lifecycleSummaryStep("2", "Grounded", grounded, "Packets linked to files, symbols, routes, or tests."),
+        lifecycleSummaryStep("3", "Recall-ready", recallReady, "Grounded packets with evidence and a likely future query.")
+      ].forEach(function (step) { els.lifecycleSummary.appendChild(step); });
+    }
+    els.lifecycleList.textContent = "";
+    if (!proofPackets.length) {
+      els.lifecycleList.className = "lifecycle-list details-empty";
+      els.lifecycleList.textContent = "No memory lifecycle to show yet. Capture reusable repo knowledge with kage learn or kage propose.";
+      return;
+    }
+    els.lifecycleList.className = "lifecycle-list";
+    proofPackets.slice(0, 5).forEach(function (item) {
+      els.lifecycleList.appendChild(renderLifecycleCard(item.entity, item.links));
+    });
+  }
+
+  function renderMemoryLifecycleReport(report) {
+    var totals = report.totals || {};
+    var needsReview = Number(totals.stale || 0) + Number(totals.ungrounded || 0) + Number(totals.disputed || 0) + Number(totals.pending || 0);
+    if (els.lifecycleStatus) {
+      els.lifecycleStatus.textContent = needsReview ? needsReview + " need review" : "healthy";
+    }
+    if (els.lifecycleSummary) {
+      els.lifecycleSummary.textContent = "";
+      [
+        lifecycleSummaryStep("1", "Approved", Number(totals.approved || 0), "Repo-local packets available to future agents."),
+        lifecycleSummaryStep("2", "Hot/healthy", Number(totals.hot || 0) + Number(totals.healthy || 0), "Memories that are grounded, fresh, or repeatedly recalled."),
+        lifecycleSummaryStep("3", "Needs action", needsReview, "Packets to verify, ground, review, or resolve before trusting.")
+      ].forEach(function (step) { els.lifecycleSummary.appendChild(step); });
+    }
+    els.lifecycleList.textContent = "";
+    var items = Array.isArray(report.items) ? report.items : [];
+    if (!items.length) {
+      els.lifecycleList.className = "lifecycle-list details-empty";
+      els.lifecycleList.textContent = "No memory lifecycle to show yet. Capture reusable repo knowledge with kage learn or kage propose.";
+      return;
+    }
+    els.lifecycleList.className = "lifecycle-list";
+    items.slice(0, 6).forEach(function (item) {
+      els.lifecycleList.appendChild(renderLifecycleReportCard(item));
+    });
+  }
+
+  function renderLifecycleReportCard(item) {
+    var card = document.createElement("article");
+    card.className = classNames("lifecycle-card", item.severity && "memory-action-" + item.severity);
+    card.innerHTML = [
+      "<div class=\"lifecycle-card-head\"><div><strong></strong><span></span></div><button type=\"button\">Inspect</button></div>",
+      "<p></p>",
+      "<div class=\"lifecycle-flow\"></div>"
+    ].join("");
+    card.querySelector("strong").textContent = item.title || "Memory packet";
+    card.querySelector(".lifecycle-card-head span").textContent = [
+      memoryActionLabel(item.recommended_action),
+      item.health,
+      item.type
+    ].filter(Boolean).join(" | ");
+    card.querySelector("p").textContent = item.reason || item.action || "Lifecycle action";
+    var entity = item.packet_id ? findMemoryEntityByPacketId(item.packet_id) : null;
+    var button = card.querySelector("button");
+    if (entity) {
+      button.addEventListener("click", function () {
+        selectEntity(entity.id, true);
+        render();
+      });
+    } else {
+      button.disabled = true;
+      button.textContent = "No node";
+    }
+    var flow = card.querySelector(".lifecycle-flow");
+    [
+      lifecycleFlowCell("Evidence", Number(item.source_refs || 0) + " source ref" + (Number(item.source_refs || 0) === 1 ? "" : "s")),
+      lifecycleFlowCell("Grounding", item.paths && item.paths.length ? trimIntelText(item.paths[0], 100) : "Needs code path or symbol link"),
+      lifecycleFlowCell("Recall", Number(item.uses_30d || 0) + " use" + (Number(item.uses_30d || 0) === 1 ? "" : "s") + " in 30d"),
+      lifecycleFlowCell("Action", item.action || "Keep verified")
+    ].forEach(function (cell) { flow.appendChild(cell); });
+    return card;
+  }
+
+  function lifecycleSummaryStep(number, label, value, detail) {
+    var item = document.createElement("article");
+    item.className = "lifecycle-step";
+    item.innerHTML = "<strong></strong><span></span><em></em><p></p>";
+    item.querySelector("strong").textContent = number;
+    item.querySelector("span").textContent = label;
+    item.querySelector("em").textContent = formatDashboardValue(value);
+    item.querySelector("p").textContent = detail;
+    return item;
+  }
+
+  function renderLifecycleCard(entity, links) {
+    var card = document.createElement("article");
+    card.className = "lifecycle-card";
+    var codeTargets = links.map(function (edge) {
+      return state.entityById.get(edge.from === entity.id ? edge.to : edge.from);
+    }).filter(Boolean).sort(function (a, b) {
+      return codeTargetScore(b) - codeTargetScore(a) || codeTargetLabel(a).localeCompare(codeTargetLabel(b));
+    });
+    var evidence = lifecycleEvidence(entity);
+    var query = lifecycleRecallQuery(entity);
+    card.innerHTML = [
+      "<div class=\"lifecycle-card-head\"><div><strong></strong><span></span></div><button type=\"button\">Inspect</button></div>",
+      "<p></p>",
+      "<div class=\"lifecycle-flow\"></div>"
+    ].join("");
+    card.querySelector("strong").textContent = displayName(entity);
+    card.querySelector(".lifecycle-card-head span").textContent = [
+      entity.type || "memory",
+      lifecycleTimestampLabel(entity)
+    ].filter(Boolean).join(" | ");
+    card.querySelector("p").textContent = trimIntelText(entity.summary || entity.description || entity.path || "No summary", 220);
+    card.querySelector("button").addEventListener("click", function () {
+      selectEntity(entity.id, true);
+      render();
+    });
+    var flow = card.querySelector(".lifecycle-flow");
+    [
+      lifecycleFlowCell("Captured", evidence.length ? trimIntelText(evidence[0], 100) : "No source evidence loaded"),
+      lifecycleFlowCell("Grounded", codeTargets.length ? trimIntelText(codeTargetLabel(codeTargets[0]), 100) : "Needs code path or symbol link"),
+      lifecycleFlowCell("Recall", query ? "\"" + query + "\"" : "Search by title, summary, tag, or path"),
+      lifecycleFlowCell("Handoff", lifecycleHandoffText(entity, codeTargets.length))
+    ].forEach(function (cell) { flow.appendChild(cell); });
+    return card;
+  }
+
+  function lifecycleFlowCell(label, value) {
+    var cell = document.createElement("div");
+    cell.className = "lifecycle-cell";
+    cell.innerHTML = "<span></span><strong></strong>";
+    cell.querySelector("span").textContent = label;
+    cell.querySelector("strong").textContent = value;
+    return cell;
+  }
+
+  function lifecyclePacketScore(entity, links, linkCount) {
+    var score = 0;
+    score += Math.min(80, (links.length || linkCount) * 24);
+    score += lifecycleEvidence(entity).length ? 35 : 0;
+    score += lifecycleRecallQuery(entity) ? 25 : 0;
+    score += ["decision", "bug_fix", "runbook", "gotcha", "code_explanation", "workflow"].indexOf(entity.type) !== -1 ? 20 : 0;
+    score += lifecycleTimestamp(entity) ? 8 : 0;
+    return score;
+  }
+
+  function lifecycleEvidence(entity) {
+    var evidence = [];
+    if (Array.isArray(entity.evidence)) evidence = evidence.concat(entity.evidence);
+    if (Array.isArray(entity.source_refs)) {
+      entity.source_refs.forEach(function (ref) {
+        evidence.push([ref.kind, ref.captured_at || ref.path || ref.source].filter(Boolean).join(" "));
+      });
+    }
+    if (entity.freshness && entity.freshness.verification) evidence.push(entity.freshness.verification);
+    return evidence.map(function (item) { return String(item || "").trim(); }).filter(Boolean);
+  }
+
+  function lifecycleTimestamp(entity) {
+    return String(entity.updated_at || entity.created_at || entity.last_seen_at || entity.first_seen_at || "");
+  }
+
+  function lifecycleTimestampLabel(entity) {
+    var value = lifecycleTimestamp(entity);
+    return value ? value.slice(0, 10) : "";
+  }
+
+  function lifecycleRecallQuery(entity) {
+    var text = String(entity.summary || entity.description || displayName(entity) || "").trim();
+    var path = Array.isArray(entity.paths) && entity.paths.length ? entity.paths[0] : entity.path;
+    if (entity.type === "runbook") return "how to run " + trimIntelText(displayName(entity), 54);
+    if (entity.type === "bug_fix") return "why did " + trimIntelText(displayName(entity), 54) + " break";
+    if (entity.type === "decision") return "why was " + trimIntelText(displayName(entity), 54) + " decided";
+    if (path) return "what should I know before changing " + path;
+    return text ? trimIntelText(text, 76) : "";
+  }
+
+  function lifecycleHandoffText(entity, linkedTargetCount) {
+    if (linkedTargetCount) return "Future agents touching this area can recall the reason before editing.";
+    if (entity.type === "reference") return "Useful context, but add code paths if it should guide edits.";
+    return "Add paths so teammates and agents can use it at change time.";
+  }
+
+  function renderSessionCapture() {
+    if (!els.sessionCaptureList) return;
+    var report = state.reports && state.reports.sessions;
+    var replay = state.reports && state.reports.replay;
+    var totals = report && report.totals ? report.totals : {};
+    var sessions = Array.isArray(report && report.sessions) ? report.sessions : [];
+    var replayEvents = Array.isArray(replay && replay.events) ? replay.events : [];
+    if (els.sessionCaptureStatus) {
+      els.sessionCaptureStatus.textContent = sessions.length ? String(totals.sessions || sessions.length) + " sessions" : "no sessions";
+    }
+    if (els.sessionCaptureSummary) {
+      els.sessionCaptureSummary.textContent = "";
+      [
+        lifecycleSummaryStep("1", "Observed", Number(totals.observations || 0), "Privacy-scanned local events from agent sessions."),
+        lifecycleSummaryStep("2", "Distillable", Number(totals.durable_observations || 0), "Reusable command, workflow, decision, or issue signals."),
+        lifecycleSummaryStep("3", "Needs review", Number(totals.sessions_with_candidates || 0), "Sessions ready for packet review with kage distill.")
+      ].forEach(function (step) { els.sessionCaptureSummary.appendChild(step); });
+    }
+    els.sessionCaptureList.textContent = "";
+    if (!sessions.length) {
+      els.sessionCaptureList.className = "session-capture-list details-empty";
+      els.sessionCaptureList.textContent = "No observed sessions yet. Agents can call kage_observe, then kage_distill turns durable observations into reviewable memory packets.";
+      return;
+    }
+    els.sessionCaptureList.className = "session-capture-list";
+    sessions.slice(0, 6).forEach(function (session) {
+      var card = document.createElement("article");
+      card.className = "session-capture-card";
+      var candidates = Array.isArray(session.candidate_types) && session.candidate_types.length ? session.candidate_types.join(", ") : "none";
+      var agents = Array.isArray(session.agents) && session.agents.length ? session.agents.join(", ") : "unknown agent";
+      card.innerHTML = [
+        "<div class=\"session-capture-head\"><div><strong></strong><span></span></div><em></em></div>",
+        "<p></p>",
+        "<div class=\"session-capture-meta\"></div>"
+      ].join("");
+      card.querySelector("strong").textContent = session.session_id || "default";
+      card.querySelector("span").textContent = [agents, session.last_at || session.first_at || ""].filter(Boolean).join(" · ");
+      card.querySelector("em").textContent = String(session.durable_observations || 0) + " distillable";
+      card.querySelector("p").textContent = session.next_action || "Review this session before saving durable memory.";
+      var meta = card.querySelector(".session-capture-meta");
+      [
+        ["events", session.observations || 0],
+        ["candidates", candidates],
+        ["commands", Array.isArray(session.commands) ? session.commands.slice(0, 2).join(", ") || "none" : "none"],
+        ["paths", Array.isArray(session.paths) ? session.paths.slice(0, 2).join(", ") || "none" : "none"]
+      ].forEach(function (item) {
+        var chip = document.createElement("span");
+        chip.textContent = item[0] + ": " + item[1];
+        meta.appendChild(chip);
+      });
+      els.sessionCaptureList.appendChild(card);
+    });
+    if (replayEvents.length) {
+      var replayCard = document.createElement("article");
+      replayCard.className = "session-capture-card";
+      replayCard.innerHTML = [
+        "<div class=\"session-capture-head\"><div><strong>Replay digest</strong><span>raw transcript text excluded</span></div><em></em></div>",
+        "<p></p>",
+        "<div class=\"session-capture-meta\"></div>"
+      ].join("");
+      replayCard.querySelector("em").textContent = String(replay && replay.totals ? replay.totals.durable_candidates || 0 : 0) + " candidates";
+      replayCard.querySelector("p").textContent = replay && replay.next_action ? replay.next_action : "Review the digest, then distill durable observations into memory packets.";
+      var replayMeta = replayCard.querySelector(".session-capture-meta");
+      replayEvents.slice(0, 6).forEach(function (event) {
+        var chip = document.createElement("span");
+        chip.textContent = (event.durable_candidate ? "candidate: " : "event: ") + (event.label || event.type || "observation") + " · " + trimIntelText(event.summary || "", 90);
+        replayMeta.appendChild(chip);
+      });
+      els.sessionCaptureList.appendChild(replayCard);
+    }
+  }
+
   function memoryCodeLinksForEntity(entityId) {
     return state.edges.filter(function (edge) {
       if ((edge.from !== entityId && edge.to !== entityId) || !isMemoryCodeEdge(edge)) return false;
@@ -3357,17 +4436,28 @@
     var packets = state.pendingPackets || [];
     var inbox = state.inbox;
     var inboxItems = inbox && Array.isArray(inbox.items) ? inbox.items : [];
+    var handoff = state.reports && state.reports.handoff;
+    var handoffItems = handoff && Array.isArray(handoff.items) ? handoff.items : [];
     var counts = inbox && inbox.counts ? inbox.counts : {};
-    var openCount = reviewOpenCount(counts, packets, inboxItems);
-    els.reviewCount.textContent = String(openCount);
+    var openCount = reviewOpenCount(counts, packets);
+    els.reviewCount.textContent = openCount ? String(openCount) : "clear";
     els.reviewList.textContent = "";
-    if (els.reviewOverview) renderReviewOverview(inbox, packets, inboxItems);
-    if (!packets.length && !inboxItems.length && !state.reviewText) {
+    if (els.reviewOverview) renderReviewOverview(inbox, packets, inboxItems, handoff);
+    renderMemoryHandoff(handoff, handoffItems);
+    if (!packets.length && !inboxItems.length && !handoffItems.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.";
       return;
     }
     els.reviewList.className = "review-list";
+    handoffItems.slice(0, 10).forEach(function (entry) {
+      els.reviewList.appendChild(reviewCard({
+        title: entry.title || entry.summary || entry.kind,
+        meta: [entry.kind, entry.severity, entry.date && timelineDateLabel(entry.date)].filter(Boolean).join(" | "),
+        summary: entry.summary || "",
+        risk: entry.action || "Review before handoff"
+      }, "handoff"));
+    });
     if (inbox) {
       var summary = document.createElement("div");
       summary.className = "review-item";
@@ -3387,7 +4477,7 @@
       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 = openCount ? "Resolve inbox items before merge" : "Ready for handoff";
+      summary.querySelector(".review-risks").textContent = openCount ? "Inbox needs review before merge" : "Inbox: clear";
       els.reviewList.appendChild(summary);
     }
     inboxItems.slice(0, 8).forEach(function (entry) {
@@ -3434,37 +4524,95 @@
     }
   }
 
-  function renderReviewOverview(inbox, packets, inboxItems) {
+  function renderReviewOverview(inbox, packets, inboxItems, handoff) {
     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);
+    var inboxBlockers = reviewOpenCount(counts, packets);
+    var handoffReviews = handoffReviewCount(handoff);
+    var blockers = handoff ? handoffReviews : inboxBlockers;
+    var mutations = handoff && handoff.totals ? Number(firstNumber(handoff.totals.recent_mutations, 0)) : 0;
     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 ? blockers + " handoff review item(s) need attention" : "No pending, stale, or duplicate memory",
+      blockers ? "Resolve the handoff queue 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", [
+    els.reviewOverview.appendChild(metricBars(handoff ? "Inbox and handoff" : "Inbox breakdown", inboxBlockers ? inboxBlockers + " inbox blocker(s)" : "Inbox: clear", [
+      { label: "Handoff review", value: handoffReviews || "none", score: Math.min(100, handoffReviews * 24), status: handoffReviews ? "warn" : "ok" },
       { 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"));
+      { label: "Mutations", value: mutations, score: Math.min(100, mutations * 16), status: mutations ? "ok" : "warn" }
+    ], handoff ? (handoff.summary || "Handoff review combines lifecycle, audit, timeline, and lineage.") : "These inbox metrics should block merge or handoff.", blockers ? "warn" : "ok"));
+  }
+
+  function renderMemoryHandoff(handoff, items) {
+    if (!els.handoffList) return;
+    var totals = handoff && handoff.totals ? handoff.totals : {};
+    if (els.handoffStatus) {
+      els.handoffStatus.textContent = handoff ? (Number(totals.open_items || 0) ? Number(totals.open_items || 0) + " open" : "ready") : "waiting";
+    }
+    if (els.handoffSummary) {
+      els.handoffSummary.textContent = "";
+      [
+        lifecycleSummaryStep("1", "Open", Number(totals.open_items || 0), "Blockers and warnings to resolve before another agent trusts memory."),
+        lifecycleSummaryStep("2", "Distill", Number(totals.distillable_sessions || 0), "Observed sessions with reusable learnings that should become memory packets."),
+        lifecycleSummaryStep("3", "Mutations", Number(totals.recent_mutations || 0), "Memory captures, reviews, feedback, and supersedes since audit logging began."),
+        lifecycleSummaryStep("4", "Lineage", Number(totals.supersession_orphans || 0), "Retired packets missing a current replacement.")
+      ].forEach(function (step) { els.handoffSummary.appendChild(step); });
+    }
+    els.handoffList.textContent = "";
+    if (!handoff) {
+      els.handoffList.className = "session-capture-list details-empty";
+      els.handoffList.textContent = "No handoff report loaded. Run kage handoff or open the local viewer after refresh.";
+      return;
+    }
+    if (!items.length) {
+      els.handoffList.className = "session-capture-list details-empty";
+      els.handoffList.textContent = "No memory handoff actions are open.";
+      return;
+    }
+    els.handoffList.className = "session-capture-list";
+    items.slice(0, 8).forEach(function (entry) {
+      els.handoffList.appendChild(reviewCard({
+        title: entry.title || entry.summary || entry.kind,
+        meta: [entry.kind, entry.severity, entry.date && timelineDateLabel(entry.date)].filter(Boolean).join(" | "),
+        summary: entry.summary || "",
+        risk: entry.action || "Review before handoff"
+      }, "handoff"));
+    });
   }
 
-  function reviewOpenCount(counts, packets, inboxItems) {
+  function reviewCard(entry, extraClass) {
+    var item = document.createElement("div");
+    item.className = "review-item" + (extraClass ? " " + extraClass : "");
+    item.innerHTML = [
+      "<div class=\"review-title\"></div>",
+      "<div class=\"review-meta\"></div>",
+      "<div class=\"review-summary\"></div>",
+      "<div class=\"review-risks\"></div>"
+    ].join("");
+    item.querySelector(".review-title").textContent = entry.title || "";
+    item.querySelector(".review-meta").textContent = entry.meta || "";
+    item.querySelector(".review-summary").textContent = entry.summary || "";
+    item.querySelector(".review-risks").textContent = entry.risk || "";
+    return item;
+  }
+
+  function handoffReviewCount(handoff) {
+    return handoff && handoff.totals ? Number(firstNumber(handoff.totals.open_items, 0)) : 0;
+  }
+
+  function reviewOpenCount(counts, packets) {
     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;
+    return pending + stale + duplicates;
   }
 
   function renderProof() {
@@ -3481,6 +4629,7 @@
     els.proofStatus.textContent = "loaded";
     els.proofList.className = "proof-list";
     if (els.proofOverview) renderProofOverview(metrics, state.reports || {});
+    renderProofLedger(state.reports && state.reports.benchmark);
     var rows = [
       ["Validation", metrics.harness && metrics.harness.validation_ok ? "clean" : "check"],
       ["Evidence", metrics.memory_graph ? metrics.memory_graph.evidence_coverage_percent + "%" : "n/a"],
@@ -3497,15 +4646,58 @@
     });
   }
 
+  function renderProofLedger(benchmark) {
+    var ledger = benchmark && Array.isArray(benchmark.proof_ledger) ? benchmark.proof_ledger : [];
+    ledger.forEach(function (entry) {
+      var item = document.createElement("div");
+      item.className = "proof-item proof-ledger-item " + (entry.pass ? "is-ok" : "is-warn");
+      item.innerHTML = [
+        "<strong></strong>",
+        "<span></span>",
+        "<code></code>",
+        "<p></p>"
+      ].join("");
+      item.querySelector("strong").textContent = entry.metric || (entry.pass ? "passing" : "check");
+      item.querySelector("span").textContent = [entry.label, entry.target].filter(Boolean).join(" | ");
+      item.querySelector("code").textContent = entry.command || "";
+      item.querySelector("p").textContent = entry.next_action || "Review this proof before publishing benchmark claims.";
+      els.proofList.appendChild(item);
+    });
+  }
+
   function renderProofOverview(metrics, reports) {
     els.proofOverview.textContent = "";
     var quality = reports.quality || {};
     var benchmark = reports.benchmark || {};
     var gates = Array.isArray(benchmark.gates) ? benchmark.gates : [];
+    var retrieval = benchmarkRetrievalSummary(benchmark);
+    var sourceDiversity = benchmarkSourceDiversitySummary(benchmark);
+    var scale = benchmarkScaleSummary(benchmark);
     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));
+    if (retrieval) {
+      els.proofOverview.appendChild(metricBars("Retrieval proof", retrieval.r10 + "% R@10", [
+        { label: "R@5", value: retrieval.r5 != null ? retrieval.r5 + "%" : "n/a", score: retrieval.r5 || 0, status: retrieval.r5 >= 95 ? "ok" : "warn" },
+        { label: "R@10", value: retrieval.r10 + "%", score: retrieval.r10, status: retrieval.r10 >= 95 ? "ok" : "warn" },
+        { label: "NDCG@10", value: retrieval.ndcg10 != null ? retrieval.ndcg10 : "n/a", score: retrieval.ndcg10 != null ? retrieval.ndcg10 * 100 : 0, status: retrieval.ndcg10 >= 0.85 ? "ok" : "warn" }
+      ], retrieval.label + ". Measures memory retrieval proof, not answer accuracy.", retrieval.r10 >= 95 ? "ok" : "warn"));
+    }
+    if (sourceDiversity) {
+      els.proofOverview.appendChild(metricBars("Source diversity proof", sourceDiversity.uniqueSources + " sources", [
+        { label: "Sources", value: sourceDiversity.uniqueSources, score: Math.min(100, sourceDiversity.uniqueSources * 50), status: sourceDiversity.uniqueSources >= 2 ? "ok" : "warn" },
+        { label: "Max/session", value: sourceDiversity.maxFromOneSource, score: sourceDiversity.maxFromOneSource <= 3 ? 100 : 45, status: sourceDiversity.maxFromOneSource <= 3 ? "ok" : "warn" },
+        { label: "Independent rank", value: sourceDiversity.independentRank != null ? "#" + sourceDiversity.independentRank : "miss", score: sourceDiversity.independentRank != null && sourceDiversity.independentRank <= sourceDiversity.topK ? 100 : 35, status: sourceDiversity.pass ? "ok" : "warn" }
+      ], "Noisy observed sessions should not crowd out independent teammate memory.", sourceDiversity.pass ? "ok" : "warn"));
+    }
+    if (scale) {
+      els.proofOverview.appendChild(metricBars("Scale proof", scale.packets + " packets", [
+        { label: "Hit rate", value: scale.hitRate + "%", score: scale.hitRate, status: scale.hitRate >= 95 ? "ok" : "warn" },
+        { label: "Median", value: scale.medianLatency + "ms", score: Math.max(0, 100 - scale.medianLatency), status: scale.medianLatency <= 50 ? "ok" : "warn" },
+        { label: "Context cut", value: scale.contextReduction + "%", score: scale.contextReduction, status: scale.contextReduction >= 80 ? "ok" : "warn" }
+      ], "Scale benchmark checks large repo-memory retrieval cost.", scale.hitRate >= 95 ? "ok" : "warn"));
+    }
     els.proofOverview.appendChild(metricDonut(
       "Trust gate",
       gatePercent,
@@ -3520,6 +4712,70 @@
     ], "Trust memory only when it is evidence-backed and path-grounded.", evidence >= 80 ? "ok" : "warn"));
   }
 
+  function benchmarkRetrievalSummary(report) {
+    if (!report || !report.summary) return null;
+    var summary = report.summary;
+    var r10 = Number(summary.recall_at_10_percent);
+    if (!Number.isFinite(r10)) return null;
+    var mode = summary.retrieval_mode || report.retrieval_mode || "";
+    var embeddings = summary.embeddings || report.embeddings || null;
+    var modeLabel = mode === "kage-recall-with-dense-local-embeddings"
+      ? "dense local embeddings"
+      : mode === "kage-recall-default"
+        ? "default recall"
+        : mode;
+    var modelLabel = embeddings && embeddings.model ? " · " + embeddings.model : "";
+    return {
+      label: [summary.benchmark || report.benchmark || "Retrieval benchmark", modeLabel].filter(Boolean).join(" · "),
+      mode: modeLabel,
+      model: modelLabel ? modelLabel.slice(3) : "",
+      r5: numberOrNull(summary.recall_at_5_percent),
+      r10: r10,
+      r20: numberOrNull(summary.recall_at_20_percent),
+      mrr: numberOrNull(summary.mrr),
+      ndcg10: numberOrNull(summary.ndcg_at_10),
+      contextReduction: numberOrNull(summary.context_reduction_percent)
+    };
+  }
+
+  function benchmarkSourceDiversitySummary(report) {
+    var diversity = report && report.memory_quality && report.memory_quality.source_diversity
+      ? report.memory_quality.source_diversity
+      : report && report.source_diversity;
+    if (!diversity) return null;
+    var uniqueSources = numberOrNull(diversity.unique_sources);
+    var maxFromOneSource = numberOrNull(diversity.max_results_from_one_source);
+    var topK = numberOrNull(diversity.top_k) || 4;
+    if (uniqueSources == null || maxFromOneSource == null) return null;
+    return {
+      uniqueSources: uniqueSources,
+      maxFromOneSource: maxFromOneSource,
+      independentRank: numberOrNull(diversity.independent_source_rank),
+      topK: topK,
+      pass: Boolean(diversity.pass)
+    };
+  }
+
+  function benchmarkScaleSummary(report) {
+    var scale = report && report.memory_scale;
+    var summary = scale && scale.summary;
+    if (!summary) return null;
+    var hitRate = numberOrNull(summary.largest_hit_rate_percent);
+    var packets = numberOrNull(summary.largest_packets);
+    if (hitRate == null || packets == null) return null;
+    return {
+      packets: packets,
+      hitRate: hitRate,
+      medianLatency: numberOrNull(summary.largest_median_recall_latency_ms) || 0,
+      contextReduction: numberOrNull(summary.largest_context_reduction_percent) || 0
+    };
+  }
+
+  function numberOrNull(value) {
+    var number = Number(value);
+    return Number.isFinite(number) ? number : null;
+  }
+
   function renderIntelligence() {
     if (!els.intelligenceList) return;
     var reports = state.reports || {};
@@ -3528,11 +4784,15 @@
     els.intelligenceStatus.textContent = cards.length ? cards.length + " loaded" : "not loaded";
     if (!cards.length) {
       els.intelligenceList.className = "intelligence-list details-empty";
-      els.intelligenceList.textContent = "No repo intelligence reports loaded. Launch with `kage viewer --project <repo>` to load risk, module health, graph insights, and workspace reports.";
+      els.intelligenceList.textContent = "No before-edit reports loaded. Launch with `kage viewer --project <repo>` to load risk, module health, graph insights, and workspace reports.";
       return;
     }
     els.intelligenceList.className = "intelligence-list";
-    normalizeIntelCards(cards).slice(0, 6).forEach(function (card) {
+    var normalizedCards = normalizeIntelCards(cards);
+    var riskFirst = new Set(["Before You Edit", "Change Risk", "Module Health", "Decision Memory", "Graph Insights", "Memory Quality"]);
+    var primaryCards = normalizedCards.filter(function (card) { return riskFirst.has(card.title); }).slice(0, 3);
+    if (!primaryCards.length) primaryCards = normalizedCards.slice(0, 3);
+    primaryCards.forEach(function (card) {
       var item = document.createElement("article");
       item.className = "intel-card";
       item.innerHTML = [
@@ -3549,23 +4809,27 @@
       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, 3).forEach(function (row) {
+      card.rows.slice(0, Number(card.rowLimit || (card.title === "Before You Edit" ? 3 : 2))).forEach(function (row) {
         var li = document.createElement("li");
         li.innerHTML = "<strong></strong> <span></span>";
         li.querySelector("strong").textContent = row[0];
-        li.querySelector("span").textContent = trimIntelText(row[1], 92);
+        li.querySelector("span").textContent = card.title === "Before You Edit" ? row[1] : trimIntelText(row[1], 92);
         list.appendChild(li);
       });
       els.intelligenceList.appendChild(item);
     });
-    var sections = rankIntelligenceSections(buildIntelligenceSections(reports)).slice(0, 4);
+    var sections = rankIntelligenceSections(buildIntelligenceSections(reports)).slice(0, 2);
     if (sections.length) {
+      var details = document.createElement("details");
+      details.className = "intel-deep-drawer";
+      details.innerHTML = "<summary><span>More repo signals</span><em>cycles, owners, modules</em></summary>";
       var deepGrid = document.createElement("div");
       deepGrid.className = "intel-deep-grid";
       sections.forEach(function (section) {
         deepGrid.appendChild(renderIntelligenceSection(section));
       });
-      els.intelligenceList.appendChild(deepGrid);
+      details.appendChild(deepGrid);
+      els.intelligenceList.appendChild(details);
     }
   }
 
@@ -3621,6 +4885,7 @@
 
   function intelligenceSectionPriority(section) {
     var title = String(section && section.title || "").toLowerCase();
+    if (title.indexOf("before you edit") !== -1 || title.indexOf("checklist") !== -1) return 0;
     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;
@@ -3628,6 +4893,81 @@
     return 4;
   }
 
+  function riskTargetList(risk) {
+    if (!risk) return [];
+    return Array.isArray(risk.targets)
+      ? risk.targets
+      : Object.keys(risk.targets || {}).map(function (key) { return risk.targets[key]; }).filter(Boolean);
+  }
+
+  function isGeneratedMemoryPathValue(path) {
+    var normalized = String(path || "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+    return normalized.indexOf(".agent_memory/") === 0 ||
+      normalized.indexOf("agent_memory/") === 0 ||
+      normalized.indexOf("/.agent_memory/") !== -1 ||
+      normalized.indexOf("/agent_memory/") !== -1;
+  }
+
+  function isUserFacingRiskPath(path) {
+    var normalized = String(path || "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+    if (!normalized || normalized === "." || normalized === "root") return false;
+    if (isGeneratedMemoryPathValue(normalized)) return false;
+    if (normalized.indexOf("node_modules/") !== -1 || normalized.indexOf("dist/") === 0 || normalized.indexOf("build/") === 0) return false;
+    return true;
+  }
+
+  function userFacingRiskTargets(risk) {
+    return riskTargetList(risk).filter(function (target) {
+      return target && isUserFacingRiskPath(target.target);
+    });
+  }
+
+  function userFacingRiskHotspots(risk) {
+    return Array.isArray(risk && risk.global_hotspots)
+      ? risk.global_hotspots.filter(function (hotspot) { return hotspot && isUserFacingRiskPath(hotspot.file_path); })
+      : [];
+  }
+
+  function riskExplanation(item) {
+    var dependents = Number(item && item.dependents_count || 0);
+    var commits = Number(item && item.git && item.git.commit_count_90d || 0);
+    var owner = item && item.git ? shortContributor(item.git.primary_owner || "") : "";
+    if (item && item.test_gap) {
+      return {
+        why: "changes here are not protected by a direct test signal",
+        action: "find or add the closest verification before handoff"
+      };
+    }
+    if (dependents >= 5) {
+      return {
+        why: "many other files depend on this path",
+        action: "inspect dependents and run the full related test suite"
+      };
+    }
+    if (item && item.risk_type === "single-owner") {
+      return {
+        why: owner ? "most history belongs to " + owner : "ownership is concentrated in one person",
+        action: "route review to the owner or write down assumptions before editing"
+      };
+    }
+    if (commits >= 20 || item && item.risk_type === "churn-heavy") {
+      return {
+        why: "this area changed " + commits + " time(s) in the last 90 days",
+        action: "recall recent memory and keep the change narrow"
+      };
+    }
+    if (dependents > 0) {
+      return {
+        why: dependents + " file(s) depend on this path",
+        action: "check the dependent paths before editing"
+      };
+    }
+    return {
+      why: item && item.risk_type ? "Kage sees a " + item.risk_type.replace(/-/g, " ") + " signal" : "Kage sees a local change-risk signal",
+      action: "state the expected behavior and verify it after editing"
+    };
+  }
+
   function buildIntelligenceSections(reports) {
     var sections = [];
     var contributors = reports.contributors;
@@ -3816,13 +5156,14 @@
     }
 
     if (risk) {
-      var targets = Array.isArray(risk.targets) ? risk.targets : Object.keys(risk.targets || {}).map(function (key) { return risk.targets[key]; });
-      var hotspots = Array.isArray(risk.global_hotspots) ? risk.global_hotspots : [];
+      var targets = userFacingRiskTargets(risk);
+      var hotspots = userFacingRiskHotspots(risk);
       var riskRows = targets.slice(0, 6).map(function (item) {
+        var explanation = riskExplanation(item);
         return {
           label: item.target,
-          value: item.risk_type || "risk",
-          meta: item.risk_summary || "",
+          value: explanation.why,
+          meta: "Do first: " + explanation.action,
           score: Math.round(Number(item.hotspot_score || 0) * 100) || Math.min(100, Number(item.dependents_count || 0) * 12 + (item.test_gap ? 24 : 0)),
           status: item.test_gap || item.risk_type === "single-owner" ? "warn" : "",
           path: item.target,
@@ -3830,8 +5171,8 @@
       }).concat(hotspots.slice(0, 4).map(function (hotspot) {
         return {
           label: hotspot.file_path,
-          value: Math.round(Number(hotspot.hotspot_score || 0) * 100) + "% hot",
-          meta: (hotspot.commit_count_90d || 0) + " commits in 90d, owner " + shortContributor(hotspot.primary_owner || "unknown"),
+          value: "changed " + (hotspot.commit_count_90d || 0) + " time(s) in 90 days",
+          meta: "Do first: recall recent repo memory and run the closest tests after editing.",
           score: Math.round(Number(hotspot.hotspot_score || 0) * 100),
           status: "danger",
           path: hotspot.file_path,
@@ -3839,10 +5180,10 @@
       }));
       if (riskRows.length) {
         sections.push({
-          title: "Blast Radius",
-          kicker: "change impact",
-          stat: riskRows.length + " signals",
-          summary: "Action: review tests, owners, and dependents before editing these targets.",
+          title: "Before You Edit Checklist",
+          kicker: "why risky / do first",
+          stat: riskRows.length + " checks",
+          summary: "Each row explains what can go wrong and the first safety step before an agent edits it.",
           rows: riskRows,
           limit: 10,
         });
@@ -3904,16 +5245,24 @@
     }
     var risk = reports.risk;
     if (risk) {
-      var targets = Array.isArray(risk.targets) ? risk.targets : Object.keys(risk.targets || {}).map(function (key) { return risk.targets[key]; });
+      var targets = userFacingRiskTargets(risk);
       var silos = Array.isArray(risk.ownership_silos) ? risk.ownership_silos : [];
+      var hotspots = userFacingRiskHotspots(risk);
+      var riskRows = targets.slice(0, 4).map(function (item) {
+        var explanation = riskExplanation(item);
+        return [item.target || "edit area", "Why: " + explanation.why + " Do first: " + explanation.action];
+      }).concat(targets.length ? [] : hotspots.slice(0, 2).map(function (hotspot) {
+        return [hotspot.file_path || "hotspot", "Why: changed " + (hotspot.commit_count_90d || 0) + " time(s) in 90 days. Do first: recall recent memory and run closest tests after editing."];
+      }));
       cards.push({
-        title: "Change Risk",
-        kicker: "blast radius",
-        summary: risk.summary || "Local risk report from code graph and git history.",
-        rows: targets.slice(0, 5).map(function (item) {
-          return [item.target || "target", item.risk_summary || [item.risk_type, item.dependents_count != null ? item.dependents_count + " dependents" : ""].filter(Boolean).join(", ")];
-        }).concat(targets.length ? [] : [["Hotspots", Array.isArray(risk.global_hotspots) ? risk.global_hotspots.length + " global" : "none"]])
-          .concat(silos.length ? [["Silos", silos.length + " ownership concentration(s)"]] : [])
+        title: "Before You Edit",
+        kicker: "risk checklist",
+        summary: riskRows.length
+          ? "These are places where an agent is more likely to break behavior, miss tests, or rely on unstated knowledge."
+          : "No user-facing risky edit areas were found in the loaded report.",
+        rowLimit: 3,
+        rows: (riskRows.length ? riskRows : [["Risk", "No code-level risk checks loaded"]])
+          .concat(silos.length ? [["Reviewer signal", silos.length + " ownership concentration(s)"]] : [])
       });
     }
     var contributors = reports.contributors;
@@ -4020,13 +5369,26 @@
     var benchmark = reports.benchmark;
     if (benchmark) {
       var checks = Array.isArray(benchmark.checks) ? benchmark.checks : [];
+      var retrieval = benchmarkRetrievalSummary(benchmark);
+      var scale = benchmarkScaleSummary(benchmark);
       cards.push({
-        title: "Benchmark",
-        kicker: "local proof",
-        summary: benchmark.summary || "Local memory and graph benchmark signals.",
-        rows: checks.slice(0, 5).map(function (item) {
-          return [item.name || "check", (item.pass ? "pass" : "check") + " - " + item.actual + "/" + item.target];
-        })
+        title: retrieval ? "Retrieval Proof" : "Benchmark",
+        kicker: retrieval ? (retrieval.mode || "retrieval proof") : "local proof",
+        summary: retrieval
+          ? retrieval.label + (scale ? " plus " + scale.packets + "-packet scale proof." : "") + " Evidence retrieval only, not answer accuracy."
+          : benchmark.summary || "Local memory and graph benchmark signals.",
+        rows: retrieval
+          ? [
+              ["R@5", retrieval.r5 != null ? retrieval.r5 + "%" : "n/a"],
+              ["R@10", retrieval.r10 + "%"],
+              ["MRR", retrieval.mrr != null ? String(retrieval.mrr) : "n/a"],
+              ["Context cut", retrieval.contextReduction != null ? retrieval.contextReduction + "%" : "n/a"],
+              ["Scale", scale ? scale.hitRate + "% hit / " + scale.medianLatency + "ms" : "not loaded"],
+              ["Model", retrieval.model || "dependency-free default"]
+            ]
+          : checks.slice(0, 5).map(function (item) {
+              return [item.name || "check", (item.pass ? "pass" : "check") + " - " + item.actual + "/" + item.target];
+            })
       });
     }
     return cards;
@@ -4044,13 +5406,13 @@
         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");
+      } else if (card.title === "Before You Edit" || card.title === "Change Risk") {
+        var siloText = row("Reviewer signal") || 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.";
+        normalized.metric = (card.rows || []).length + " checks";
+        normalized.metricLabel = siloMatch ? siloMatch[0] + " reviewer silo(s)" : "pre-edit checklist";
+        normalized.highlight = card.summary || "Shows what can go wrong before an agent edits a file.";
+        normalized.action = "Start with the first row: read why it is risky, then do the listed safety step before editing.";
       } else if (card.title === "Contributors") {
         normalized.metric = (card.rows || []).length + " profiles";
         normalized.metricLabel = "review routing";