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

package/README.md

@@ -72,6 +72,7 @@ kage reviewers --project . --changed-files src/auth.ts,src/session.ts --json
 kage risk --project . --targets src/auth.ts --json
 kage learn --project . --learning "Use npm test after parser changes."
 kage refresh --project .
+kage hook install --project .
 kage pr check --project .
 kage metrics --project . --json
 kage audit --project . --json
@@ -133,6 +134,7 @@ Kage is optimized so repeat work scales with changed files, not the whole repo:
 - read-only recall reuses fresh graph artifacts
 - unchanged structural file facts are reused
 - generated graphs are compact and avoid duplicated structural JSON
+- optional git `post-commit` hooks keep repo memory and branch summaries current
 - generated/vendor/cache paths are ignored
 - huge files are represented safely instead of deeply expanded
 - recall builds lookup maps once per query instead of repeatedly scanning graph

package/dist/cli.js

@@ -24,6 +24,9 @@ Usage:
   kage daemon status --project <dir> [--json]
   kage daemon doctor --project <dir> [--json]
   kage viewer --project <dir> [--port 3113]
+  kage hook install --project <dir> [--json]
+  kage hook status --project <dir> [--json]
+  kage hook uninstall --project <dir> [--json]
   kage refresh --project <dir> [--full] [--json]
   kage gc --project <dir> [--dry-run] [--force] [--json]
   kage pr summarize --project <dir> [--json]
@@ -319,6 +322,37 @@ async function main() {
         await (0, daemon_js_1.startViewer)(projectArg(args), { port: numberArg(args, "--port", 3113) });
         return;
     }
+    if (command === "hook") {
+        const action = args[1];
+        const projectDir = projectArg(args);
+        const result = action === "install"
+            ? (0, kernel_js_1.kageHookInstall)(projectDir)
+            : action === "status"
+                ? (0, kernel_js_1.kageHookStatus)(projectDir)
+                : action === "uninstall"
+                    ? (0, kernel_js_1.kageHookUninstall)(projectDir)
+                    : null;
+        if (!result)
+            usage();
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            if (!result.ok)
+                process.exit(2);
+            return;
+        }
+        console.log(result.message);
+        if (result.hook_path)
+            console.log(`Hook: ${result.hook_path}`);
+        console.log(`Installed: ${result.installed ? "yes" : "no"}`);
+        console.log(`Changed: ${result.changed ? "yes" : "no"}`);
+        if (result.warnings.length)
+            console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        if (result.errors.length)
+            console.log(`Errors:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+        if (!result.ok)
+            process.exit(2);
+        return;
+    }
     if (command === "gc") {
         const project = projectArg(args);
         const dryRun = args.includes("--dry-run");

package/dist/kernel.js

@@ -109,6 +109,9 @@ exports.buildBranchOverlay = buildBranchOverlay;
 exports.createReviewArtifact = createReviewArtifact;
 exports.prSummarize = prSummarize;
 exports.prCheck = prCheck;
+exports.kageHookStatus = kageHookStatus;
+exports.kageHookInstall = kageHookInstall;
+exports.kageHookUninstall = kageHookUninstall;
 exports.exportPublicBundle = exportPublicBundle;
 exports.orgStatus = orgStatus;
 exports.orgUploadPacket = orgUploadPacket;
@@ -8217,6 +8220,156 @@ function prCheck(projectDir) {
         required_actions: requiredActions,
     };
 }
+const KAGE_POST_COMMIT_HOOK_START = "# >>> KAGE_POST_COMMIT_HOOK_V1";
+const KAGE_POST_COMMIT_HOOK_END = "# <<< KAGE_POST_COMMIT_HOOK_V1";
+function regexpEscape(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\"'\"'")}'`;
+}
+function gitHookPath(projectDir) {
+    const raw = readGit(projectDir, ["rev-parse", "--git-path", "hooks/post-commit"]);
+    if (!raw)
+        return null;
+    return (0, node_path_1.resolve)(projectDir, raw);
+}
+function hasKageHookBlock(content) {
+    return content.includes(KAGE_POST_COMMIT_HOOK_START) && content.includes(KAGE_POST_COMMIT_HOOK_END);
+}
+function stripKageHookBlock(content) {
+    const pattern = new RegExp(`\\n?${regexpEscape(KAGE_POST_COMMIT_HOOK_START)}[\\s\\S]*?${regexpEscape(KAGE_POST_COMMIT_HOOK_END)}\\n?`, "g");
+    const stripped = content.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+    return stripped ? `${stripped}\n` : "";
+}
+function kagePostCommitHookBlock(projectDir) {
+    const project = shellQuote((0, node_path_1.resolve)(projectDir));
+    return [
+        KAGE_POST_COMMIT_HOOK_START,
+        "# Kage post-commit hook: keep repo memory and review summary current.",
+        "# Set KAGE_SKIP_HOOK=1 to bypass, or KAGE_BIN=/path/to/kage to override.",
+        "if [ \"${KAGE_SKIP_HOOK:-0}\" != \"1\" ]; then",
+        "  KAGE_BIN=\"${KAGE_BIN:-kage}\"",
+        "  if command -v \"$KAGE_BIN\" >/dev/null 2>&1; then",
+        "    (",
+        `      "$KAGE_BIN" refresh --project ${project} --json >/dev/null 2>&1 || true`,
+        `      "$KAGE_BIN" pr summarize --project ${project} --json >/dev/null 2>&1 || true`,
+        "    ) &",
+        "  fi",
+        "fi",
+        KAGE_POST_COMMIT_HOOK_END,
+    ].join("\n");
+}
+function kageHookStatus(projectDir) {
+    const hookPath = gitHookPath(projectDir);
+    if (!hookPath) {
+        return {
+            ok: false,
+            action: "status",
+            project_dir: projectDir,
+            hook_path: null,
+            installed: false,
+            changed: false,
+            message: "Not a git repository or git is unavailable.",
+            errors: ["Not a git repository or git is unavailable."],
+            warnings: [],
+        };
+    }
+    const content = safeReadText(hookPath) ?? "";
+    const installed = hasKageHookBlock(content);
+    return {
+        ok: true,
+        action: "status",
+        project_dir: projectDir,
+        hook_path: hookPath,
+        installed,
+        changed: false,
+        message: installed ? "Kage post-commit hook is installed." : "Kage post-commit hook is not installed.",
+        errors: [],
+        warnings: (0, node_fs_1.existsSync)(hookPath) ? [] : ["No post-commit hook file exists yet."],
+    };
+}
+function kageHookInstall(projectDir) {
+    const hookPath = gitHookPath(projectDir);
+    if (!hookPath) {
+        return {
+            ok: false,
+            action: "install",
+            project_dir: projectDir,
+            hook_path: null,
+            installed: false,
+            changed: false,
+            message: "Not a git repository or git is unavailable.",
+            errors: ["Not a git repository or git is unavailable."],
+            warnings: [],
+        };
+    }
+    ensureDir((0, node_path_1.dirname)(hookPath));
+    const existing = safeReadText(hookPath) ?? "";
+    const base = stripKageHookBlock(existing);
+    const prefix = base.trim() ? base.trimEnd() : "#!/bin/sh";
+    const next = `${prefix}\n\n${kagePostCommitHookBlock(projectDir)}\n`;
+    const changed = existing !== next;
+    if (changed)
+        (0, node_fs_1.writeFileSync)(hookPath, next, "utf8");
+    (0, node_fs_1.chmodSync)(hookPath, 0o755);
+    return {
+        ok: true,
+        action: "install",
+        project_dir: projectDir,
+        hook_path: hookPath,
+        installed: true,
+        changed,
+        message: changed ? "Installed Kage post-commit hook." : "Kage post-commit hook is already current.",
+        errors: [],
+        warnings: [],
+    };
+}
+function kageHookUninstall(projectDir) {
+    const hookPath = gitHookPath(projectDir);
+    if (!hookPath) {
+        return {
+            ok: false,
+            action: "uninstall",
+            project_dir: projectDir,
+            hook_path: null,
+            installed: false,
+            changed: false,
+            message: "Not a git repository or git is unavailable.",
+            errors: ["Not a git repository or git is unavailable."],
+            warnings: [],
+        };
+    }
+    const existing = safeReadText(hookPath) ?? "";
+    const installed = hasKageHookBlock(existing);
+    if (!installed) {
+        return {
+            ok: true,
+            action: "uninstall",
+            project_dir: projectDir,
+            hook_path: hookPath,
+            installed: false,
+            changed: false,
+            message: "Kage post-commit hook was not installed.",
+            errors: [],
+            warnings: (0, node_fs_1.existsSync)(hookPath) ? [] : ["No post-commit hook file exists."],
+        };
+    }
+    const next = stripKageHookBlock(existing);
+    (0, node_fs_1.writeFileSync)(hookPath, next, "utf8");
+    (0, node_fs_1.chmodSync)(hookPath, 0o755);
+    return {
+        ok: true,
+        action: "uninstall",
+        project_dir: projectDir,
+        hook_path: hookPath,
+        installed: false,
+        changed: true,
+        message: "Removed Kage post-commit hook.",
+        errors: [],
+        warnings: [],
+    };
+}
 function exportPublicBundle(projectDir) {
     ensureMemoryDirs(projectDir);
     const candidates = loadPacketsFromDir(publicCandidatesDir(projectDir));

package/package.json

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

package/viewer/app.js

@@ -2252,6 +2252,257 @@
       });
       els.intelligenceList.appendChild(item);
     });
+    var sections = buildIntelligenceSections(reports);
+    if (sections.length) {
+      var grid = document.createElement("div");
+      grid.className = "intel-deep-grid";
+      sections.forEach(function (section) {
+        grid.appendChild(renderIntelligenceSection(section));
+      });
+      els.intelligenceList.appendChild(grid);
+    }
+  }
+
+  function renderIntelligenceSection(section) {
+    var panel = document.createElement("article");
+    panel.className = "intel-section";
+    var header = document.createElement("div");
+    header.className = "intel-section-header";
+    header.innerHTML = "<div><h3></h3><span></span></div><strong></strong>";
+    header.querySelector("h3").textContent = section.title;
+    header.querySelector("span").textContent = section.kicker || "";
+    header.querySelector("strong").textContent = section.stat || "";
+    panel.appendChild(header);
+    if (section.summary) {
+      var summary = document.createElement("p");
+      summary.className = "intel-section-summary";
+      summary.textContent = section.summary;
+      panel.appendChild(summary);
+    }
+    var list = document.createElement("div");
+    list.className = "intel-section-list";
+    section.rows.slice(0, section.limit || 8).forEach(function (row) {
+      var button = document.createElement("button");
+      button.type = "button";
+      button.className = classNames("intel-row", row.status && "intel-row-" + safeCssName(row.status), row.path && "clickable");
+      button.innerHTML = [
+        "<span class=\"intel-row-main\"><strong></strong><em></em></span>",
+        "<span class=\"intel-row-meta\"></span>",
+        "<span class=\"intel-row-bar\"><i></i></span>"
+      ].join("");
+      button.querySelector("strong").textContent = row.label || "";
+      button.querySelector("em").textContent = row.value || "";
+      button.querySelector(".intel-row-meta").textContent = row.meta || "";
+      button.querySelector(".intel-row-bar i").style.width = clamp(Number(row.score || 0), 4, 100) + "%";
+      if (row.path) {
+        button.title = "Focus " + row.path + " in the graph";
+        button.addEventListener("click", function () {
+          focusGraphPath(row.path);
+        });
+      } else {
+        button.disabled = true;
+      }
+      list.appendChild(button);
+    });
+    panel.appendChild(list);
+    return panel;
+  }
+
+  function buildIntelligenceSections(reports) {
+    var sections = [];
+    var contributors = reports.contributors;
+    var risk = reports.risk;
+    var decisions = reports.decisions;
+    var health = reports.moduleHealth;
+    var insights = reports.graphInsights;
+
+    if (contributors || risk) {
+      var profiles = contributors && Array.isArray(contributors.contributors) ? contributors.contributors : [];
+      var silos = risk && Array.isArray(risk.ownership_silos) ? risk.ownership_silos : [];
+      var maxOwned = Math.max(1, profiles.reduce(function (max, profile) {
+        return Math.max(max, Number(profile.primary_owned_files || 0));
+      }, 0));
+      var rows = profiles.slice(0, 6).map(function (profile) {
+        var owned = Number(profile.primary_owned_files || 0);
+        return {
+          label: shortContributor(profile.contributor),
+          value: owned + " owned",
+          meta: profile.commits_90d + " commits in 90d, " + (profile.silo_files ? profile.silo_files.length : 0) + " silo files",
+          score: owned / maxOwned * 100,
+          status: owned > 0 && profile.silo_files && profile.silo_files.length ? "warn" : "ok",
+        };
+      }).concat(silos.slice(0, 4).map(function (silo) {
+        return {
+          label: silo.file_path,
+          value: Math.round(Number(silo.primary_owner_pct || 0) * 100) + "% owner",
+          meta: shortContributor(silo.primary_owner || "unknown") + ", " + (silo.commit_count_total || 0) + " commits",
+          score: Number(silo.primary_owner_pct || 0) * 100,
+          status: "warn",
+          path: silo.file_path,
+        };
+      }));
+      if (rows.length) {
+        sections.push({
+          title: "Ownership Map",
+          kicker: "who owns what",
+          stat: silos.length + " silos",
+          summary: "Repowise has a dedicated ownership page. Kage now surfaces the same reviewer-critical signal inside the memory viewer, tied back to selectable files.",
+          rows: rows,
+          limit: 10,
+        });
+      }
+    }
+
+    if (health && Array.isArray(health.modules)) {
+      var modules = health.modules.slice().sort(function (a, b) {
+        return Number(a.score || 0) - Number(b.score || 0) || String(a.module).localeCompare(String(b.module));
+      });
+      sections.push({
+        title: "Module Health Map",
+        kicker: "churn / tests / ownership",
+        stat: modules.length + " modules",
+        summary: "Lowest-scoring modules are shown first so the viewer points people toward the riskiest areas instead of only drawing nodes.",
+        rows: modules.slice(0, 8).map(function (item) {
+          return {
+            label: item.module,
+            value: item.grade + " / " + item.score,
+            meta: Array.isArray(item.reasons) ? item.reasons.slice(0, 2).join("; ") : "",
+            score: Number(item.score || 0),
+            status: Number(item.score || 0) < 60 ? "danger" : Number(item.score || 0) < 75 ? "warn" : "ok",
+          };
+        }),
+      });
+    }
+
+    if (decisions && Array.isArray(decisions.coverage_gaps)) {
+      var gaps = decisions.coverage_gaps;
+      sections.push({
+        title: "Onboarding Targets",
+        kicker: "missing repo lore",
+        stat: (decisions.coverage_percent != null ? decisions.coverage_percent + "%" : "n/a"),
+        summary: "Files with centrality, churn, test gaps, or ownership but no linked why-memory. These are the places a future agent is most likely to rediscover context.",
+        rows: gaps.slice(0, 8).map(function (gap) {
+          var score = Math.min(100, Number(gap.dependents || 0) * 18 + Number(gap.churn_90d || 0) * 6 + 12);
+          return {
+            label: gap.path,
+            value: "needs memory",
+            meta: gap.reason || "",
+            score: score,
+            status: "warn",
+            path: gap.path,
+          };
+        }),
+      });
+    }
+
+    if (insights && Array.isArray(insights.communities)) {
+      var communities = insights.communities.slice().sort(function (a, b) {
+        return (b.files ? b.files.length : 0) - (a.files ? a.files.length : 0);
+      });
+      var maxFiles = Math.max(1, communities.reduce(function (max, community) {
+        return Math.max(max, community.files ? community.files.length : 0);
+      }, 0));
+      sections.push({
+        title: "Architecture Communities",
+        kicker: "module clusters",
+        stat: communities.length + " clusters",
+        summary: "Repowise exposes architecture/community views. Kage can show the same high-level clusters next to the memory-code graph so users know what a dense graph means.",
+        rows: communities.slice(0, 8).map(function (community) {
+          var files = community.files || [];
+          var entrypoints = community.entrypoints || [];
+          var routes = community.routes || [];
+          return {
+            label: community.label || ("community " + community.id),
+            value: files.length + " files",
+            meta: entrypoints.length + " entrypoints, " + routes.length + " routes",
+            score: files.length / maxFiles * 100,
+            status: routes.length || entrypoints.length ? "ok" : "",
+            path: files[0],
+          };
+        }),
+      });
+    }
+
+    if (insights && Array.isArray(insights.entry_flows) && insights.entry_flows.length) {
+      sections.push({
+        title: "Execution Flows",
+        kicker: "entrypoint traces",
+        stat: insights.entry_flows.length + " flows",
+        summary: "Short traces make the code graph explainable: where execution starts, what it crosses, and which file to inspect first.",
+        rows: insights.entry_flows.slice(0, 8).map(function (flow) {
+          var path = flow.path || [];
+          return {
+            label: flow.entry,
+            value: Math.max(0, path.length - 1) + " hops",
+            meta: path.slice(0, 5).join(" -> "),
+            score: Math.min(100, Math.max(12, path.length * 18)),
+            status: "ok",
+            path: flow.entry,
+          };
+        }),
+      });
+    }
+
+    if (risk) {
+      var targets = Array.isArray(risk.targets) ? risk.targets : Object.keys(risk.targets || {}).map(function (key) { return risk.targets[key]; });
+      var hotspots = Array.isArray(risk.global_hotspots) ? risk.global_hotspots : [];
+      var riskRows = targets.slice(0, 6).map(function (item) {
+        return {
+          label: item.target,
+          value: item.risk_type || "risk",
+          meta: item.risk_summary || "",
+          score: Math.round(Number(item.hotspot_score || 0) * 100) || Math.min(100, Number(item.dependents_count || 0) * 12 + (item.test_gap ? 24 : 0)),
+          status: item.test_gap || item.risk_type === "single-owner" ? "warn" : "",
+          path: item.target,
+        };
+      }).concat(hotspots.slice(0, 4).map(function (hotspot) {
+        return {
+          label: hotspot.file_path,
+          value: Math.round(Number(hotspot.hotspot_score || 0) * 100) + "% hot",
+          meta: (hotspot.commit_count_90d || 0) + " commits in 90d, owner " + shortContributor(hotspot.primary_owner || "unknown"),
+          score: Math.round(Number(hotspot.hotspot_score || 0) * 100),
+          status: "danger",
+          path: hotspot.file_path,
+        };
+      }));
+      if (riskRows.length) {
+        sections.push({
+          title: "Blast Radius",
+          kicker: "change impact",
+          stat: riskRows.length + " signals",
+          summary: "Change risk is useful only if it is browsable. Rows focus the graph on affected files when the graph node exists.",
+          rows: riskRows,
+          limit: 10,
+        });
+      }
+    }
+
+    return sections.filter(function (section) { return section.rows && section.rows.length; });
+  }
+
+  function focusGraphPath(path) {
+    if (!path) return;
+    var normalized = String(path).replace(/\\/g, "/").replace(/^\.\//, "");
+    var found = state.entities.find(function (entity) {
+      var entityPath = String(entity.path || "").replace(/\\/g, "/").replace(/^\.\//, "");
+      return entityPath === normalized || entity.id === normalized || entity.id === "code:file:" + normalized;
+    }) || state.entities.find(function (entity) {
+      var text = [entity.id, entity.path, entity.name].filter(Boolean).join(" ");
+      return text.indexOf(normalized) !== -1;
+    });
+    if (!found) {
+      els.searchInput.value = normalized;
+      scheduleRender();
+      return;
+    }
+    state.selected = { kind: "entity", id: found.id };
+    els.searchInput.value = normalized;
+    scheduleRender();
+  }
+
+  function shortContributor(value) {
+    var text = String(value || "unknown");
+    return text.replace(/\s*<[^>]+>\s*$/, "");
   }
 
   function buildIntelligenceCards(reports) {

package/viewer/index.html

@@ -4,7 +4,7 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <title>Kage Memory Terminal</title>
-    <link rel="stylesheet" href="./styles.css?v=20">
+    <link rel="stylesheet" href="./styles.css?v=21">
   </head>
   <body>
     <header class="app-header">
@@ -171,6 +171,6 @@
       </section>
     </main>
 
-    <script src="./app.js?v=20"></script>
+    <script src="./app.js?v=21"></script>
   </body>
 </html>

package/viewer/styles.css

@@ -608,6 +608,12 @@ input:focus, select:focus, button:focus, .file-picker:focus-within {
   gap: 8px;
   align-content: start;
 }
+.intel-deep-grid {
+  grid-column: 1 / -1;
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 8px;
+}
 .intel-card {
   min-height: 160px;
   padding: 11px;
@@ -648,6 +654,114 @@ input:focus, select:focus, button:focus, .file-picker:focus-within {
   overflow-wrap: anywhere;
 }
 .intel-card strong { color: var(--terminal-strong); }
+.intel-section {
+  min-height: 230px;
+  padding: 11px;
+  border: 1px solid rgba(65, 255, 143, 0.24);
+  border-radius: 4px;
+  background: linear-gradient(180deg, rgba(13, 25, 19, 0.96), rgba(5, 11, 8, 0.96));
+  overflow: hidden;
+}
+.intel-section-header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 10px;
+}
+.intel-section-header h3 {
+  margin: 0;
+  color: var(--terminal);
+  font-size: 12px;
+  letter-spacing: 0;
+}
+.intel-section-header span {
+  display: block;
+  margin-top: 3px;
+  color: var(--terminal-dim);
+  font-size: 10px;
+  font-weight: 760;
+  text-transform: uppercase;
+}
+.intel-section-header strong {
+  flex: 0 0 auto;
+  color: var(--terminal-strong);
+  font-size: 11px;
+}
+.intel-section-summary {
+  margin: 8px 0 10px;
+  color: var(--muted);
+  font-size: 11px;
+  overflow-wrap: anywhere;
+}
+.intel-section-list {
+  display: grid;
+  gap: 7px;
+}
+.intel-row {
+  width: 100%;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  gap: 5px;
+  min-height: 0;
+  padding: 8px;
+  border-color: var(--line);
+  background: rgba(3, 6, 4, 0.55);
+  color: var(--text);
+  text-align: left;
+  white-space: normal;
+  box-shadow: none;
+  cursor: default;
+}
+.intel-row.clickable { cursor: pointer; }
+.intel-row.clickable:hover {
+  border-color: var(--terminal-strong);
+  background: rgba(65, 255, 143, 0.075);
+}
+.intel-row-main {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 8px;
+  min-width: 0;
+}
+.intel-row-main strong {
+  min-width: 0;
+  color: var(--text);
+  font-size: 11px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.intel-row-main em {
+  flex: 0 0 auto;
+  color: var(--terminal-strong);
+  font-size: 10px;
+  font-style: normal;
+}
+.intel-row-meta {
+  color: var(--terminal-dim);
+  font-size: 10px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.intel-row-bar {
+  display: block;
+  height: 4px;
+  overflow: hidden;
+  border-radius: 999px;
+  background: rgba(65, 255, 143, 0.10);
+}
+.intel-row-bar i {
+  display: block;
+  height: 100%;
+  border-radius: inherit;
+  background: var(--terminal-strong);
+}
+.intel-row-warn .intel-row-main em,
+.intel-row-warn .intel-row-bar i { color: var(--warn); background: var(--warn); }
+.intel-row-danger .intel-row-main em,
+.intel-row-danger .intel-row-bar i { color: var(--danger); background: var(--danger); }
 .review-item {
   padding: 10px 0;
   border-top: 1px solid var(--line);
@@ -821,6 +935,8 @@ input:focus, select:focus, button:focus, .file-picker:focus-within {
   .control-panel label, .control-panel button { margin-top: 0; }
   .graph-panel { min-height: 620px; }
   #graphCanvas, .three-graph, .graph-canvas-wrap, #graphSvg { min-height: 560px; }
+  .intelligence-list { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+  .intel-deep-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
   .details-panel {
     height: auto;
     max-height: 70vh;
@@ -835,6 +951,7 @@ input:focus, select:focus, button:focus, .file-picker:focus-within {
   .metrics-grid { grid-template-columns: 1fr 1fr; }
   .proof-list { grid-template-columns: 1fr 1fr; }
   .intelligence-list { grid-template-columns: 1fr; }
+  .intel-deep-grid { grid-template-columns: 1fr; }
   .graph-toolbar { align-items: flex-start; flex-direction: column; }
   .graph-actions { width: 100%; }
   .interaction-hint { flex: 1; white-space: normal; }