scopecairn 0.3.0 → 0.6.0

package/dist/cli.js

@@ -1,12 +1,20 @@
 #!/usr/bin/env node
+import {
+  ensureMetrics,
+  getMetrics
+} from "./chunk-ID4PMSFQ.js";
+import {
+  nodeInCycle
+} from "./chunk-UU5WHX3D.js";
 
 // src/cli.ts
 import { Command } from "commander";
-import path17 from "path";
+import fs27 from "fs";
+import path27 from "path";
 
 // src/scanner.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs13 from "fs";
+import path14 from "path";
 
 // src/languages.ts
 var EXT_MAP = {
@@ -58,7 +66,7 @@ function loadDatabaseSync() {
 }
 var DATA_DIR_NAME = ".scopecairn";
 var DB_FILE_NAME = "scopecairn.db";
-var SCHEMA_VERSION = 4;
+var SCHEMA_VERSION = 5;
 function dataDir(repoRoot2) {
   return path.join(repoRoot2, DATA_DIR_NAME);
 }
@@ -134,6 +142,31 @@ function openDb(repoRoot2) {
       timestamp TEXT NOT NULL DEFAULT (datetime('now'))
     );
     CREATE INDEX IF NOT EXISTS idx_invocations_cmd ON invocations(command);
+    -- Graphify Engine: node centrality, community clustering, cycle cache.
+    CREATE TABLE IF NOT EXISTS node_metrics (
+      node_id INTEGER PRIMARY KEY,
+      pagerank REAL NOT NULL DEFAULT 0.0,
+      betweenness REAL NOT NULL DEFAULT 0.0,
+      in_degree INTEGER NOT NULL DEFAULT 0,
+      out_degree INTEGER NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY(node_id) REFERENCES symbols(id) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS clusters (
+      node_id INTEGER PRIMARY KEY,
+      cluster_id INTEGER NOT NULL,
+      cluster_name TEXT,
+      modularity REAL,
+      FOREIGN KEY(node_id) REFERENCES symbols(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_clusters_cid ON clusters(cluster_id);
+    CREATE TABLE IF NOT EXISTS cycles (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      cycle_hash TEXT UNIQUE,
+      length INTEGER NOT NULL DEFAULT 0,
+      nodes_json TEXT NOT NULL DEFAULT '[]',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
   `);
   db.prepare(
     `INSERT INTO meta(key, value) VALUES ('schema_version', ?)
@@ -1242,8 +1275,8 @@ top_n: 20
 }
 
 // src/adapters/index.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs11 from "fs";
+import path12 from "path";
 
 // src/adapters/types.ts
 function findSymbolId(db, name, types) {
@@ -1640,15 +1673,458 @@ var drizzleAdapter = {
   }
 };
 
+// src/adapters/express.ts
+import fs6 from "fs";
+import path7 from "path";
+var METHODS = ["get", "post", "put", "delete", "patch", "use"];
+function parseExpressRoutes(content) {
+  const out = [];
+  const re = new RegExp(
+    `\\b(?:app|router)\\s*\\.\\s*(${METHODS.join("|")})\\s*\\(\\s*["'\`]([^"'\`]+)["'\`]\\s*,\\s*([^,)\\s]+)?`,
+    "g"
+  );
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    const rawHandler = m[3] ?? null;
+    const handler = rawHandler && /^[A-Za-z_$][\w$]*$/.test(rawHandler) ? rawHandler : null;
+    out.push({
+      method: m[1].toUpperCase(),
+      path: m[2],
+      handler,
+      line: lineOf4(content, m.index)
+    });
+  }
+  return out;
+}
+function hasExpressMarker(content) {
+  return content.includes("express") || /\b(?:app|router)\s*\.\s*(get|post|put|delete|patch|use)\s*\(/.test(content);
+}
+function findInFile2(db, fileId, name) {
+  const row = db.prepare(`SELECT id FROM symbols WHERE file_id = ? AND name = ? LIMIT 1`).get(fileId, name);
+  return row ? row.id : null;
+}
+var expressAdapter = {
+  id: "express",
+  label: "Express",
+  detect: (files) => files.some(
+    (f) => f.endsWith("package.json") || /\.(js|ts|mjs|cjs)$/.test(f)
+  ),
+  confirm: (repoRoot2) => {
+    try {
+      const pkg = fs6.readFileSync(path7.join(repoRoot2, "package.json"), "utf8");
+      return pkg.includes('"express"') || pkg.includes("'express'");
+    } catch {
+      return false;
+    }
+  },
+  relevant: (rel) => /\.(js|ts|mjs|cjs)$/.test(rel),
+  apply(ctx, files) {
+    let symbols = 0;
+    let relations = 0;
+    for (const f of files) {
+      if (!hasExpressMarker(f.content)) continue;
+      const fileSym = fileSymbolOf(ctx.db, f.fileId);
+      if (!fileSym) continue;
+      for (const r of parseExpressRoutes(f.content)) {
+        const routeId = ensureAdapterSymbol(ctx.db, f.fileId, {
+          name: `${r.method} ${r.path}`,
+          type: "route",
+          signature: `${r.method} ${r.path}`,
+          startLine: r.line,
+          endLine: r.line
+        });
+        symbols++;
+        insertRelation(ctx.db, fileSym, routeId, "CONTAINS", 1, 1);
+        relations++;
+        if (r.handler) {
+          const handlerId = findInFile2(ctx.db, f.fileId, r.handler);
+          if (handlerId) {
+            insertRelation(ctx.db, fileSym, handlerId, "USES", WEIGHT.USES, 0.9);
+            relations++;
+            const enclosing = enclosingFunction(ctx.db, f.fileId, r.line);
+            if (enclosing && enclosing !== handlerId) {
+              insertRelation(ctx.db, enclosing, handlerId, "CALLS", WEIGHT.CALLS, 0.7);
+              relations++;
+            }
+          }
+        }
+      }
+    }
+    return { symbols, relations };
+  }
+};
+
+// src/adapters/fastapi.ts
+import fs7 from "fs";
+import path8 from "path";
+var METHODS2 = ["get", "post", "put", "delete", "patch", "head", "options"];
+function parseFastApiRoutes(content) {
+  const out = [];
+  const re = new RegExp(
+    `^\\s*@\\w+\\s*\\.\\s*(${METHODS2.join("|")})\\s*\\(\\s*["']([^"']+)["']`,
+    "gm"
+  );
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    const window = content.slice(m.index, m.index + 400);
+    const hm = /(?:async\s+)?def\s+(\w+)/.exec(window);
+    out.push({
+      method: m[1].toUpperCase(),
+      path: m[2],
+      handler: hm ? hm[1] : null,
+      line: lineOf4(content, m.index)
+    });
+  }
+  return out;
+}
+function hasFastApiMarker(content) {
+  return content.includes("fastapi") || /^\s*@\w+\s*\.\s*(get|post|put|delete|patch|head|options)\s*\(/m.test(content);
+}
+function findInFile3(db, fileId, name) {
+  const row = db.prepare(`SELECT id FROM symbols WHERE file_id = ? AND name = ? LIMIT 1`).get(fileId, name);
+  return row ? row.id : null;
+}
+function readDepFile(repoRoot2, names) {
+  let out = "";
+  for (const n of names) {
+    try {
+      out += fs7.readFileSync(path8.join(repoRoot2, n), "utf8");
+    } catch {
+    }
+  }
+  try {
+    const dir = fs7.readdirSync(repoRoot2);
+    for (const f of dir) {
+      if (/^requirements.*\.txt$/.test(f)) {
+        try {
+          out += fs7.readFileSync(path8.join(repoRoot2, f), "utf8");
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+var fastapiAdapter = {
+  id: "fastapi",
+  label: "FastAPI",
+  detect: (files) => files.some(
+    (f) => /\.py$/.test(f) || /(^|\/)requirements.*\.txt$/.test(f) || /(^|\/)pyproject\.toml$/.test(f)
+  ),
+  confirm: (repoRoot2) => {
+    try {
+      const pkg = fs7.readFileSync(path8.join(repoRoot2, "package.json"), "utf8");
+      if (pkg.includes('"fastapi"')) return true;
+    } catch {
+    }
+    const deps = readDepFile(repoRoot2, ["requirements.txt", "pyproject.toml"]);
+    return deps.toLowerCase().includes("fastapi");
+  },
+  relevant: (rel) => /\.py$/.test(rel),
+  apply(ctx, files) {
+    let symbols = 0;
+    let relations = 0;
+    for (const f of files) {
+      if (!hasFastApiMarker(f.content)) continue;
+      const fileSym = fileSymbolOf(ctx.db, f.fileId);
+      if (!fileSym) continue;
+      for (const r of parseFastApiRoutes(f.content)) {
+        const routeId = ensureAdapterSymbol(ctx.db, f.fileId, {
+          name: `${r.method} ${r.path}`,
+          type: "route",
+          signature: `${r.method} ${r.path}`,
+          startLine: r.line,
+          endLine: r.line
+        });
+        symbols++;
+        insertRelation(ctx.db, fileSym, routeId, "CONTAINS", 1, 1);
+        relations++;
+        if (r.handler) {
+          const handlerId = findInFile3(ctx.db, f.fileId, r.handler);
+          if (handlerId) {
+            insertRelation(ctx.db, fileSym, handlerId, "USES", 0.5, 0.9);
+            relations++;
+            insertRelation(ctx.db, handlerId, routeId, "ROUTES_TO", 0.9, 1);
+            relations++;
+          }
+        }
+      }
+    }
+    return { symbols, relations };
+  }
+};
+
+// src/adapters/sqlalchemy.ts
+import fs8 from "fs";
+import path9 from "path";
+function parseSqlAlchemyModels(content) {
+  const out = [];
+  const re = /^class\s+(\w+)\s*\(([^)]*)\)\s*:/gm;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    const rest = content.slice(m.index, m.index + 1500);
+    const nextClass = rest.slice(1).search(/^class\s+\w+/m);
+    const body = nextClass > 0 ? rest.slice(0, nextClass + 1) : rest;
+    const tm = /__tablename__\s*=\s*["']([^"']+)["']/.exec(body);
+    const isBase = /\b(Base|DeclarativeBase|declarative_base|Model)\b/.test(m[2]);
+    if (tm || isBase) {
+      out.push({
+        name: m[1],
+        table: tm ? tm[1] : null,
+        line: lineOf4(content, m.index)
+      });
+    }
+  }
+  return out;
+}
+function parseSqlAlchemyQueries(content) {
+  const out = [];
+  const re = /(?:session\s*\.\s*query|select)\s*\(\s*(\w+)/g;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    out.push({ model: m[1], index: m.index });
+  }
+  return out;
+}
+function hasSqlAlchemyMarker(content) {
+  return content.includes("sqlalchemy") || /__tablename__/.test(content) || /session\s*\.\s*query\s*\(/.test(content) || /\bselect\s*\(/.test(content);
+}
+function findModelGlobal2(db, name) {
+  const rows = db.prepare(`SELECT id, name FROM symbols WHERE type = 'model'`).all();
+  const lower = name.toLowerCase();
+  return rows.find((r) => r.name.toLowerCase() === lower)?.id ?? null;
+}
+function refreshSqlAlchemyQueries(db, files) {
+  let n = 0;
+  const del = db.prepare(
+    `DELETE FROM relationships WHERE relationship_type = 'QUERIES' AND source_id IN (SELECT id FROM symbols WHERE file_id = ?)`
+  );
+  const ins = db.prepare(
+    `INSERT INTO relationships(source_id, target_id, relationship_type, weight, confidence)
+     VALUES (?, ?, 'QUERIES', ${WEIGHT.QUERIES}, 0.85)`
+  );
+  for (const f of files) {
+    if (!hasSqlAlchemyMarker(f.content)) continue;
+    const fileSym = fileSymbolOf(db, f.fileId);
+    if (!fileSym) continue;
+    del.run(f.fileId);
+    for (const q of parseSqlAlchemyQueries(f.content)) {
+      const target = findModelGlobal2(db, q.model);
+      if (!target) continue;
+      const caller = enclosingFunction(db, f.fileId, lineOf4(f.content, q.index)) ?? fileSym;
+      if (caller === target) continue;
+      ins.run(caller, target);
+      n++;
+    }
+  }
+  return n;
+}
+var sqlalchemyAdapter = {
+  id: "sqlalchemy",
+  label: "SQLAlchemy",
+  detect: (files) => files.some(
+    (f) => /\.py$/.test(f) || /(^|\/)requirements.*\.txt$/.test(f) || /(^|\/)pyproject\.toml$/.test(f)
+  ),
+  confirm: (repoRoot2) => {
+    let deps = "";
+    try {
+      const dir = fs8.readdirSync(repoRoot2);
+      for (const f of dir) {
+        if (/^requirements.*\.txt$/.test(f) || f === "pyproject.toml") {
+          try {
+            deps += fs8.readFileSync(path9.join(repoRoot2, f), "utf8");
+          } catch {
+          }
+        }
+      }
+    } catch {
+      return false;
+    }
+    return deps.toLowerCase().includes("sqlalchemy");
+  },
+  relevant: (rel) => /\.py$/.test(rel),
+  apply(ctx, files) {
+    let symbols = 0;
+    let relations = 0;
+    for (const f of files) {
+      if (!hasSqlAlchemyMarker(f.content)) continue;
+      const fileSym = fileSymbolOf(ctx.db, f.fileId);
+      if (!fileSym) continue;
+      for (const model of parseSqlAlchemyModels(f.content)) {
+        const id = ensureAdapterSymbol(ctx.db, f.fileId, {
+          name: model.name,
+          type: "model",
+          signature: model.table ? `model ${model.name} ("${model.table}")` : `model ${model.name}`,
+          startLine: model.line,
+          endLine: model.line
+        });
+        symbols++;
+        insertRelation(ctx.db, fileSym, id, "CONTAINS", 1, 1);
+        relations++;
+      }
+    }
+    const del = ctx.db.prepare(
+      `DELETE FROM relationships WHERE relationship_type = 'QUERIES' AND source_id IN (SELECT id FROM symbols WHERE file_id = ?)`
+    );
+    const ins = ctx.db.prepare(
+      `INSERT INTO relationships(source_id, target_id, relationship_type, weight, confidence)
+       VALUES (?, ?, 'QUERIES', ${WEIGHT.QUERIES}, 0.85)`
+    );
+    for (const f of files) {
+      if (!hasSqlAlchemyMarker(f.content)) continue;
+      const fileSym = fileSymbolOf(ctx.db, f.fileId);
+      if (!fileSym) continue;
+      del.run(f.fileId);
+      for (const q of parseSqlAlchemyQueries(f.content)) {
+        const target = findModelGlobal2(ctx.db, q.model);
+        if (!target) continue;
+        const caller = enclosingFunction(ctx.db, f.fileId, lineOf4(f.content, q.index)) ?? fileSym;
+        if (caller === target) continue;
+        ins.run(caller, target);
+        relations++;
+      }
+    }
+    return { symbols, relations };
+  }
+};
+
+// src/adapters/vue.ts
+import fs9 from "fs";
+import path10 from "path";
+function parseVueImports(content) {
+  const out = [];
+  const re = /import\s+(\w+)\s+from\s+["']([^"']+\.vue)["']/g;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    out.push({ name: m[1], source: m[2], line: lineOf4(content, m.index) });
+  }
+  return out;
+}
+function parseTemplateTags(content) {
+  const tm = /<template[^>]*>([\s\S]*?)<\/template>/.exec(content);
+  if (!tm) return [];
+  const body = tm[1];
+  const tags = /* @__PURE__ */ new Set();
+  const re = /<\s*([A-Z][\w]*|[a-z][\w]*(?:-[\w]+)+)/g;
+  let m;
+  while ((m = re.exec(body)) !== null) tags.add(m[1]);
+  return [...tags];
+}
+function kebabToPascal(s) {
+  return s.split("-").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+function usedVueComponents(content) {
+  const imports = parseVueImports(content);
+  if (imports.length === 0) return [];
+  const tags = new Set(parseTemplateTags(content));
+  return imports.filter((imp) => {
+    const kebab = imp.name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+    return tags.has(imp.name) || tags.has(kebab) || tags.has(kebabToPascal(kebab));
+  });
+}
+function vueComponentName(rel) {
+  const base = rel.split("/").pop() ?? rel;
+  return base.replace(/\.vue$/, "");
+}
+function hasVueDefineComponent(content) {
+  return /\bdefineComponent\s*\(/.test(content);
+}
+function resolveImportRel(fromRel, source) {
+  if (!source.startsWith(".")) return null;
+  const dir = fromRel.includes("/") ? fromRel.slice(0, fromRel.lastIndexOf("/")) : "";
+  const parts = (dir ? dir + "/" + source : source).split("/");
+  const out = [];
+  for (const p of parts) {
+    if (p === "" || p === ".") continue;
+    if (p === "..") out.pop();
+    else out.push(p);
+  }
+  return out.join("/");
+}
+var vueAdapter = {
+  id: "vue",
+  label: "Vue",
+  detect: (files) => files.some((f) => /\.vue$/.test(f) || f.endsWith("package.json")),
+  confirm: (repoRoot2) => {
+    try {
+      const pkg = fs9.readFileSync(path10.join(repoRoot2, "package.json"), "utf8");
+      return pkg.includes('"vue"') || pkg.includes("'vue'");
+    } catch {
+      return false;
+    }
+  },
+  relevant: (rel) => /\.vue$/.test(rel),
+  apply(ctx, files) {
+    let symbols = 0;
+    let relations = 0;
+    for (const f of files) {
+      const fileSym = fileSymbolOf(ctx.db, f.fileId);
+      if (!fileSym) continue;
+      const name = vueComponentName(f.rel);
+      const line = hasVueDefineComponent(f.content) ? lineOf4(f.content, f.content.search(/\bdefineComponent\s*\(/)) : 1;
+      const id = ensureAdapterSymbol(ctx.db, f.fileId, {
+        name,
+        type: "component",
+        signature: `component ${name}`,
+        startLine: line,
+        endLine: line
+      });
+      symbols++;
+      insertRelation(ctx.db, fileSym, id, "CONTAINS", 1, 1);
+      relations++;
+      for (const imp of usedVueComponents(f.content)) {
+        const targetRel = resolveImportRel(f.rel, imp.source);
+        if (!targetRel) continue;
+        const row = ctx.db.prepare(`SELECT id FROM files WHERE path = ? LIMIT 1`).get(targetRel);
+        if (!row) continue;
+        const targetFileSym = fileSymbolOf(ctx.db, row.id);
+        if (!targetFileSym) continue;
+        insertRelation(ctx.db, fileSym, targetFileSym, "IMPORTS", WEIGHT.IMPORTS, 0.9);
+        relations++;
+      }
+    }
+    return { symbols, relations };
+  }
+};
+
+// src/log.ts
+import fs10 from "fs";
+import path11 from "path";
+function lastRunLogPath(repoRoot2 = process.cwd()) {
+  return path11.join(repoRoot2, ".scopecairn", "last-run.log");
+}
+function append(repoRoot2, scope, text) {
+  const root = repoRoot2 ?? process.cwd();
+  try {
+    fs10.mkdirSync(path11.dirname(lastRunLogPath(root)), { recursive: true });
+    fs10.appendFileSync(lastRunLogPath(root), text + "\n", "utf8");
+  } catch {
+  }
+}
+function logError(scope, err, repoRoot2) {
+  const message = err instanceof Error ? err.message : String(err);
+  append(repoRoot2, scope, `${(/* @__PURE__ */ new Date()).toISOString()} [${scope}] ${message}`);
+}
+
 // src/adapters/index.ts
-var ADAPTERS = [prismaAdapter, drizzleAdapter, nextjsAdapter];
+var ADAPTERS = [
+  prismaAdapter,
+  drizzleAdapter,
+  sqlalchemyAdapter,
+  nextjsAdapter,
+  expressAdapter,
+  fastapiAdapter,
+  vueAdapter
+];
 function detectAdapters(files, repoRoot2) {
   return ADAPTERS.filter((a) => {
     try {
       if (!a.detect(files)) return false;
       if (repoRoot2 && a.confirm) return a.confirm(repoRoot2, files);
       return true;
-    } catch {
+    } catch (err) {
+      logError("adapters", err, repoRoot2);
       return false;
     }
   });
@@ -1664,10 +2140,10 @@ function runAdapters(db, repoRoot2, changed) {
     const inputs = [];
     for (const c of changed) {
       if (!adapter.relevant(c.rel)) continue;
-      const abs = path7.join(repoRoot2, ...c.rel.split("/"));
+      const abs = path12.join(repoRoot2, ...c.rel.split("/"));
       let content;
       try {
-        content = fs6.readFileSync(abs, "utf8");
+        content = fs11.readFileSync(abs, "utf8");
       } catch {
         continue;
       }
@@ -1679,7 +2155,8 @@ function runAdapters(db, repoRoot2, changed) {
       symbols += r.symbols;
       relations += r.relations;
       for (const i of inputs) touched.add(i.fileId);
-    } catch {
+    } catch (err) {
+      logError("adapters", err, repoRoot2);
     }
   }
   for (const fileId of touched) {
@@ -1687,7 +2164,8 @@ function runAdapters(db, repoRoot2, changed) {
     if (row) {
       try {
         syncFileIndex(db, fileId, row.path);
-      } catch {
+      } catch (err) {
+        logError("adapters", err, repoRoot2);
       }
     }
   }
@@ -1701,28 +2179,1199 @@ function runAdapters(db, repoRoot2, changed) {
           inputs.push({
             fileId: r.id,
             rel: r.path,
-            content: fs6.readFileSync(path7.join(repoRoot2, ...r.path.split("/")), "utf8")
+            content: fs11.readFileSync(path12.join(repoRoot2, ...r.path.split("/")), "utf8")
           });
         } catch {
         }
       }
-      relations += refresh(db, inputs);
-    } catch {
+      relations += refresh(db, inputs);
+    } catch (err) {
+      logError("adapters", err, repoRoot2);
+    }
+  };
+  refreshTargets("nextjs", nextjsAdapter.relevant, refreshQueries);
+  refreshTargets("drizzle", drizzleAdapter.relevant, refreshDrizzleQueries);
+  refreshTargets("sqlalchemy", sqlalchemyAdapter.relevant, refreshSqlAlchemyQueries);
+  return { adapters: active.map((a) => a.id), symbols, relations };
+}
+
+// src/graph/export.ts
+import fs12 from "fs";
+import path13 from "path";
+var GRAPH_MD_NAME = "GRAPH.md";
+var MAX_ROWS = 20;
+var MAX_LINES = 160;
+function buildGraphMd(db, repoRoot2) {
+  const one = (sql) => {
+    try {
+      return db.prepare(sql).get().n;
+    } catch {
+      return 0;
+    }
+  };
+  const files = one(`SELECT COUNT(*) AS n FROM files`);
+  const symbols = one(`SELECT COUNT(*) AS n FROM symbols`);
+  const rels = one(`SELECT COUNT(*) AS n FROM relationships`);
+  const lines = [
+    `# Codebase Graph`,
+    ``,
+    `> Generated by \`scopecairn scan\`. Do not edit \u2014 regenerated when the graph changes.`,
+    `> Visual map: open \`.scopecairn/GRAPH.html\` in a browser (offline, no dependencies).`,
+    `> For task-specific context, run \`scopecairn context "<task>"\` instead of reading this whole file.`,
+    ``,
+    `## Stats`,
+    ``,
+    `- Files: ${files} | Symbols: ${symbols} | Relationships: ${rels}`,
+    ``
+  ];
+  try {
+    const mods = db.prepare(
+      `SELECT CASE WHEN instr(path, '/') > 0 THEN substr(path, 1, instr(path, '/') - 1) ELSE '.' END AS mod,
+                COUNT(*) AS n FROM files GROUP BY mod ORDER BY n DESC LIMIT ${MAX_ROWS}`
+    ).all();
+    if (mods.length > 0) {
+      lines.push(`## Modules`, ``);
+      for (const m of mods) lines.push(`- ${m.mod}/ \u2014 ${m.n} files`);
+      lines.push(``);
+    }
+  } catch {
+  }
+  try {
+    const top = db.prepare(
+      `SELECT s.name, s.type, f.path AS file, COUNT(*) AS fanin
+         FROM relationships r
+         JOIN symbols s ON s.id = r.target_id
+         JOIN files f ON f.id = s.file_id
+         WHERE s.type IN ('function','class','method','component','interface','type')
+         GROUP BY r.target_id ORDER BY fanin DESC LIMIT ${MAX_ROWS}`
+    ).all();
+    if (top.length > 0) {
+      lines.push(`## Most-used symbols`, ``);
+      for (const t of top) lines.push(`- ${t.name} (${t.type}, ${t.file}) \u2190 ${t.fanin}x`);
+      lines.push(``);
+    }
+  } catch {
+  }
+  const symList = (type, title) => {
+    try {
+      const rows = db.prepare(
+        `SELECT s.name, f.path AS file FROM symbols s
+           JOIN files f ON f.id = s.file_id
+           WHERE s.type = ? ORDER BY s.name LIMIT ${MAX_ROWS}`
+      ).all(type);
+      if (rows.length > 0) {
+        lines.push(`## ${title}`, ``);
+        for (const r of rows) lines.push(`- ${r.name} \u2014 ${r.file}`);
+        lines.push(``);
+      }
+    } catch {
+    }
+  };
+  symList("route", "Routes");
+  symList("model", "Models");
+  try {
+    const top = db.prepare(
+      `SELECT s.name, s.type, f.path AS file, m.pagerank AS pr
+         FROM node_metrics m
+         JOIN symbols s ON s.id = m.node_id
+         JOIN files f ON f.id = s.file_id
+         ORDER BY m.pagerank DESC LIMIT 5`
+    ).all();
+    if (top.length > 0) {
+      lines.push(`## Critical hotspots (PageRank)`, ``);
+      for (const t of top) lines.push(`- ${t.name} (${t.type}, ${t.file}) [pr=${t.pr.toFixed(4)}]`);
+      lines.push(``);
+    }
+  } catch {
+  }
+  try {
+    const c = db.prepare(`SELECT COUNT(*) AS n FROM cycles`).get().n;
+    if (c > 0) {
+      lines.push(`## Circular dependencies`, ``);
+      lines.push(`- ${c} dependency cycle(s) detected \u2014 see \`scopecairn doctor\`.`);
+      lines.push(``);
+    }
+  } catch {
+  }
+  try {
+    const patterns = loadProtectedPatterns(repoRoot2);
+    if (patterns.length > 0) {
+      lines.push(`## Protected (ask before touching)`, ``);
+      for (const p of patterns.slice(0, MAX_ROWS)) lines.push(`- \`${p}\``);
+      lines.push(``);
+    }
+  } catch {
+  }
+  const out = lines.join("\n");
+  const trimmed = out.split("\n");
+  if (trimmed.length > MAX_LINES) {
+    return trimmed.slice(0, MAX_LINES).join("\n") + "\n";
+  }
+  return out;
+}
+function graphMdPath(repoRoot2) {
+  return path13.join(dataDir(repoRoot2), GRAPH_MD_NAME);
+}
+function writeGraphMdIfChanged(db, repoRoot2, dirty) {
+  if (!dirty) return false;
+  try {
+    fs12.mkdirSync(dataDir(repoRoot2), { recursive: true });
+    fs12.writeFileSync(graphMdPath(repoRoot2), buildGraphMd(db, repoRoot2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+var EXPORT_NODE_CAP = 500;
+var EXPORT_EDGE_CAP = 1500;
+function readExportGraph(db) {
+  let nodes = [];
+  try {
+    nodes = db.prepare(
+      `SELECT s.id, s.name, s.type, f.path AS file,
+              (SELECT COUNT(*) FROM relationships r WHERE r.target_id = s.id) +
+              (SELECT COUNT(*) FROM relationships r WHERE r.source_id = s.id) AS deg
+       FROM symbols s JOIN files f ON f.id = s.file_id
+       ORDER BY deg DESC LIMIT ${EXPORT_NODE_CAP}`
+    ).all();
+  } catch {
+    try {
+      nodes = db.prepare(
+        `SELECT s.id, s.name, s.type, f.path AS file
+         FROM symbols s JOIN files f ON f.id = s.file_id LIMIT ${EXPORT_NODE_CAP}`
+      ).all();
+    } catch {
+      return { nodes: [], edges: [] };
+    }
+  }
+  if (nodes.length === 0) return { nodes, edges: [] };
+  const keep = new Set(nodes.map((n) => n.id));
+  let edges = [];
+  try {
+    edges = db.prepare(
+      `SELECT source_id AS s, target_id AS t, relationship_type AS rel,
+                weight AS w FROM relationships LIMIT ${EXPORT_EDGE_CAP * 4}`
+    ).all().filter((e) => keep.has(e.s) && keep.has(e.t)).slice(0, EXPORT_EDGE_CAP);
+  } catch {
+    edges = [];
+  }
+  return { nodes, edges };
+}
+function escXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function mermaidId(n) {
+  return `n${n}`;
+}
+function mermaidLabel(n) {
+  return `${n.name} [${n.type}]`.replace(/["#<>`]/g, "").slice(0, 60);
+}
+function exportMermaid(db) {
+  const { nodes, edges } = readExportGraph(db);
+  const lines = ["graph TD"];
+  for (const n of nodes) {
+    lines.push(`    ${mermaidId(n.id)}["${mermaidLabel(n)}"]`);
+  }
+  for (const e of edges) {
+    const rel = e.rel.replace(/[^A-Za-z0-9_]/g, "_").slice(0, 24) || "REL";
+    lines.push(`    ${mermaidId(e.s)} -->|${rel}| ${mermaidId(e.t)}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function exportGraphML(db) {
+  const { nodes, edges } = readExportGraph(db);
+  const out = [
+    `<?xml version="1.0" encoding="UTF-8"?>`,
+    `<graphml xmlns="http://graphml.graphdrawing.org/xmlns">`,
+    `  <key id="name" for="node" attr.name="name" attr.type="string"/>`,
+    `  <key id="type" for="node" attr.name="type" attr.type="string"/>`,
+    `  <key id="file" for="node" attr.name="file" attr.type="string"/>`,
+    `  <key id="rel" for="edge" attr.name="relationship" attr.type="string"/>`,
+    `  <key id="weight" for="edge" attr.name="weight" attr.type="double"/>`,
+    `  <graph id="scopecairn" edgedefault="directed">`
+  ];
+  for (const n of nodes) {
+    out.push(
+      `    <node id="${mermaidId(n.id)}"><data key="name">${escXml(n.name)}</data><data key="type">${escXml(n.type)}</data><data key="file">${escXml(n.file)}</data></node>`
+    );
+  }
+  edges.forEach((e, i) => {
+    out.push(
+      `    <edge id="e${i}" source="${mermaidId(e.s)}" target="${mermaidId(e.t)}"><data key="rel">${escXml(e.rel)}</data><data key="weight">${e.w}</data></edge>`
+    );
+  });
+  out.push(`  </graph>`, `</graphml>`);
+  return out.join("\n") + "\n";
+}
+function exportDot(db) {
+  const { nodes, edges } = readExportGraph(db);
+  const q = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  const lines = [`digraph scopecairn {`, `  rankdir=LR;`, `  node [shape=box, style=rounded];`];
+  for (const n of nodes) {
+    lines.push(`  ${mermaidId(n.id)} [label=${q(`${n.name}
+(${n.type})`)}];`);
+  }
+  for (const e of edges) {
+    lines.push(`  ${mermaidId(e.s)} -> ${mermaidId(e.t)} [label=${q(e.rel)}];`);
+  }
+  lines.push(`}`);
+  return lines.join("\n") + "\n";
+}
+function exportJson(db) {
+  const { nodes, edges } = readExportGraph(db);
+  return JSON.stringify(
+    {
+      generated_by: "scopecairn export",
+      node_count: nodes.length,
+      edge_count: edges.length,
+      nodes: nodes.map((n) => ({ id: n.id, name: n.name, type: n.type, file: n.file })),
+      edges: edges.map((e) => ({ source: e.s, target: e.t, relationship: e.rel, weight: e.w }))
+    },
+    null,
+    2
+  ) + "\n";
+}
+function exportGraph(db, format) {
+  switch (format) {
+    case "mermaid":
+      return exportMermaid(db);
+    case "graphml":
+      return exportGraphML(db);
+    case "dot":
+      return exportDot(db);
+    case "json":
+      return exportJson(db);
+  }
+}
+
+// src/graph/clusters.ts
+function readUndirected(db) {
+  let ids = [];
+  try {
+    ids = db.prepare(`SELECT id FROM symbols ORDER BY id`).all().map((r) => r.id);
+  } catch {
+    return { ids: [], edges: [] };
+  }
+  const agg = /* @__PURE__ */ new Map();
+  try {
+    const rows = db.prepare(
+      `SELECT source_id AS s, target_id AS t, SUM(MAX(weight, 0.01)) AS w
+       FROM relationships GROUP BY source_id, target_id`
+    ).all();
+    for (const r of rows) {
+      if (r.s === r.t) continue;
+      const key = r.s < r.t ? `${r.s}:${r.t}` : `${r.t}:${r.s}`;
+      const e = agg.get(key);
+      if (e) e.w += r.w;
+      else agg.set(key, { a: Math.min(r.s, r.t), b: Math.max(r.s, r.t), w: r.w });
+    }
+  } catch {
+  }
+  return { ids, edges: [...agg.values()] };
+}
+function modularity(comm, edges, degree, m2) {
+  if (m2 === 0) return 0;
+  const inSum = /* @__PURE__ */ new Map();
+  const totSum = /* @__PURE__ */ new Map();
+  for (const [node, c] of comm) {
+    totSum.set(c, (totSum.get(c) ?? 0) + (degree.get(node) ?? 0));
+  }
+  for (const e of edges) {
+    if (comm.get(e.a) === comm.get(e.b)) {
+      inSum.set(comm.get(e.a), (inSum.get(comm.get(e.a)) ?? 0) + 2 * e.w);
+    }
+  }
+  let q = 0;
+  for (const [c, tot] of totSum) {
+    q += (inSum.get(c) ?? 0) / m2 - tot / m2 * (tot / m2);
+  }
+  return q;
+}
+function localMove(nodes, adj, comm, commTot, degree, m2) {
+  let moved = false;
+  for (const node of nodes) {
+    const cur = comm.get(node);
+    const ki = degree.get(node) ?? 0;
+    const toComm = /* @__PURE__ */ new Map();
+    for (const { to, w } of adj.get(node) ?? []) {
+      const c = comm.get(to);
+      toComm.set(c, (toComm.get(c) ?? 0) + w);
+    }
+    commTot.set(cur, (commTot.get(cur) ?? 0) - ki);
+    let best = cur;
+    let bestGain = 0;
+    for (const [c, kin] of toComm) {
+      if (c === cur) continue;
+      const gain = kin - (commTot.get(c) ?? 0) * ki / Math.max(m2, 1e-9);
+      if (gain > bestGain) {
+        bestGain = gain;
+        best = c;
+      }
+    }
+    const selfGain = (toComm.get(cur) ?? 0) - (commTot.get(cur) ?? 0) * ki / Math.max(m2, 1e-9);
+    if (best !== cur && bestGain > selfGain) {
+      comm.set(node, best);
+      commTot.set(best, (commTot.get(best) ?? 0) + ki);
+      moved = true;
+    } else {
+      commTot.set(cur, (commTot.get(cur) ?? 0) + ki);
+    }
+  }
+  return moved;
+}
+function louvain(db) {
+  const { ids, edges } = readUndirected(db);
+  const assignment = /* @__PURE__ */ new Map();
+  if (ids.length === 0) return { assignment, modularity: 0 };
+  let levelNodes = [...ids].sort((a, b) => a - b);
+  let levelEdges = edges;
+  let members = /* @__PURE__ */ new Map();
+  for (const id of ids) members.set(id, [id]);
+  for (let level = 0; level < 8; level++) {
+    const adj = /* @__PURE__ */ new Map();
+    const degree2 = /* @__PURE__ */ new Map();
+    for (const n of levelNodes) {
+      adj.set(n, []);
+      degree2.set(n, 0);
+    }
+    let m22 = 0;
+    for (const e of levelEdges) {
+      adj.get(e.a)?.push({ to: e.b, w: e.w });
+      adj.get(e.b)?.push({ to: e.a, w: e.w });
+      degree2.set(e.a, (degree2.get(e.a) ?? 0) + e.w);
+      degree2.set(e.b, (degree2.get(e.b) ?? 0) + e.w);
+      m22 += 2 * e.w;
+    }
+    const comm = /* @__PURE__ */ new Map();
+    const commTot = /* @__PURE__ */ new Map();
+    for (const n of levelNodes) {
+      comm.set(n, n);
+      commTot.set(n, degree2.get(n) ?? 0);
+    }
+    for (let pass = 0; pass < 10; pass++) {
+      if (!localMove(levelNodes, adj, comm, commTot, degree2, m22)) break;
+    }
+    const remap2 = /* @__PURE__ */ new Map();
+    let next2 = 0;
+    for (const n of levelNodes) {
+      const c = comm.get(n);
+      if (!remap2.has(c)) remap2.set(c, next2++);
+      comm.set(n, remap2.get(c));
+    }
+    const newMembers = /* @__PURE__ */ new Map();
+    for (const n of levelNodes) {
+      const c = comm.get(n);
+      if (!newMembers.has(c)) newMembers.set(c, []);
+      newMembers.get(c).push(...members.get(n) ?? [n]);
+    }
+    members = newMembers;
+    if (remap2.size === levelNodes.length || remap2.size <= 1) break;
+    const agg = /* @__PURE__ */ new Map();
+    for (const e of levelEdges) {
+      const ca = comm.get(e.a);
+      const cb = comm.get(e.b);
+      if (ca === cb) continue;
+      const key = ca < cb ? `${ca}:${cb}` : `${cb}:${ca}`;
+      agg.set(key, (agg.get(key) ?? 0) + e.w);
+    }
+    levelNodes = [...members.keys()].sort((a, b) => a - b);
+    levelEdges = [...agg.entries()].map(([k, w]) => {
+      const [a, b] = k.split(":").map(Number);
+      return { a, b, w };
+    });
+    if (levelEdges.length === 0) break;
+  }
+  for (const [superId, mems] of members) {
+    for (const m of mems) assignment.set(m, superId);
+  }
+  const remap = /* @__PURE__ */ new Map();
+  let next = 0;
+  for (const id of ids) {
+    const c = assignment.get(id) ?? 0;
+    if (!remap.has(c)) remap.set(c, next++);
+    assignment.set(id, remap.get(c));
+  }
+  const degree = /* @__PURE__ */ new Map();
+  let m2 = 0;
+  for (const e of edges) {
+    degree.set(e.a, (degree.get(e.a) ?? 0) + e.w);
+    degree.set(e.b, (degree.get(e.b) ?? 0) + e.w);
+    m2 += 2 * e.w;
+  }
+  const q = modularity(assignment, edges, degree, m2);
+  return { assignment, modularity: q };
+}
+function refreshClusters(db) {
+  const { assignment, modularity: q } = louvain(db);
+  if (assignment.size === 0) return { count: 0, modularity: 0 };
+  try {
+    db.prepare(`DELETE FROM clusters WHERE node_id NOT IN (SELECT id FROM symbols)`).run();
+  } catch {
+  }
+  const names = /* @__PURE__ */ new Map();
+  try {
+    const byCluster = /* @__PURE__ */ new Map();
+    for (const [nodeId, cid] of assignment) {
+      const r = db.prepare(`SELECT f.path AS p FROM symbols s JOIN files f ON f.id = s.file_id WHERE s.id = ?`).get(nodeId);
+      const top = (r?.p ?? "").split("/")[0] || ".";
+      if (!byCluster.has(cid)) byCluster.set(cid, /* @__PURE__ */ new Map());
+      const m = byCluster.get(cid);
+      m.set(top, (m.get(top) ?? 0) + 1);
+    }
+    for (const [cid, m] of byCluster) {
+      let best = ".";
+      let bestN = -1;
+      for (const [k, v] of m) {
+        if (v > bestN) {
+          bestN = v;
+          best = k;
+        }
+      }
+      names.set(cid, `cluster-${cid} (${best}/)`);
+    }
+  } catch {
+  }
+  const up = db.prepare(
+    `INSERT INTO clusters(node_id, cluster_id, cluster_name, modularity)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(node_id) DO UPDATE SET
+       cluster_id = excluded.cluster_id, cluster_name = excluded.cluster_name,
+       modularity = excluded.modularity`
+  );
+  for (const [nodeId, cid] of assignment) {
+    up.run(nodeId, cid, names.get(cid) ?? `cluster-${cid}`, q);
+  }
+  return { count: new Set(assignment.values()).size, modularity: q };
+}
+function ensureClusters(db) {
+  try {
+    const syms = db.prepare(`SELECT COUNT(*) AS n FROM symbols`).get().n;
+    if (syms === 0) return 0;
+    const c = db.prepare(`SELECT COUNT(*) AS n FROM clusters`).get().n;
+    if (c === syms) return c;
+    refreshClusters(db);
+    return db.prepare(`SELECT COUNT(*) AS n FROM clusters`).get().n;
+  } catch {
+    return 0;
+  }
+}
+function getCluster(db, nodeId) {
+  try {
+    const r = db.prepare(`SELECT * FROM clusters WHERE node_id = ?`).get(nodeId);
+    if (!r) return null;
+    return { nodeId: r.node_id, clusterId: r.cluster_id, clusterName: r.cluster_name ?? "", modularity: r.modularity ?? 0 };
+  } catch {
+    return null;
+  }
+}
+
+// src/graph/visual.ts
+var GRAPH_HTML_NAME = "GRAPH.html";
+var MAX_FILES = 600;
+var MAX_EDGES = 1500;
+var MAX_SYMBOLS = 800;
+var MAX_SYM_EDGES = 2e3;
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function moduleOf(file) {
+  const i = file.indexOf("/");
+  return i === -1 ? "." : file.slice(0, i);
+}
+function colorFor(mod) {
+  let h = 0;
+  for (const c of mod) h = (h * 31 + c.charCodeAt(0)) % 360;
+  return `hsl(${h}, 55%, 55%)`;
+}
+function buildVisualModel(db) {
+  const empty = {
+    nodes: [],
+    edges: [],
+    truncatedFiles: 0,
+    truncatedEdges: 0,
+    symbols: [],
+    symbolEdges: [],
+    truncatedSymbols: 0,
+    clusterNames: [],
+    modularity: 0
+  };
+  let files = [];
+  try {
+    files = db.prepare(`SELECT id, path, language AS lang FROM files`).all();
+  } catch {
+    return empty;
+  }
+  if (files.length === 0) return empty;
+  let prBySym = /* @__PURE__ */ new Map();
+  let clusterBySym = /* @__PURE__ */ new Map();
+  const clusterNames = /* @__PURE__ */ new Map();
+  let modularity2 = 0;
+  try {
+    ensureMetrics(db);
+    for (const r of db.prepare(`SELECT node_id AS id, pagerank AS pr FROM node_metrics`).all()) prBySym.set(r.id, r.pr);
+  } catch {
+  }
+  try {
+    ensureClusters(db);
+    for (const r of db.prepare(
+      `SELECT node_id AS id, cluster_id AS c, cluster_name AS n, modularity AS q FROM clusters`
+    ).all()) {
+      clusterBySym.set(r.id, r.c);
+      if (r.n) clusterNames.set(r.c, r.n);
+      modularity2 = r.q ?? modularity2;
+    }
+  } catch {
+  }
+  const useClusters = clusterBySym.size > 0;
+  const symCount = /* @__PURE__ */ new Map();
+  try {
+    for (const r of db.prepare(`SELECT file_id AS f, COUNT(*) AS n FROM symbols GROUP BY file_id`).all()) {
+      symCount.set(r.f, r.n);
+    }
+  } catch {
+  }
+  const deg = /* @__PURE__ */ new Map();
+  const pair = /* @__PURE__ */ new Map();
+  try {
+    const rows = db.prepare(
+      `SELECT s1.file_id AS fa, s2.file_id AS fb, r.relationship_type AS rel, r.confidence AS c
+       FROM relationships r
+       JOIN symbols s1 ON s1.id = r.source_id
+       JOIN symbols s2 ON s2.id = r.target_id
+       WHERE s1.file_id != s2.file_id`
+    ).all();
+    for (const r of rows) {
+      const d1 = deg.get(r.fa) ?? { inn: 0, out: 0 };
+      d1.out++;
+      deg.set(r.fa, d1);
+      const d2 = deg.get(r.fb) ?? { inn: 0, out: 0 };
+      d2.inn++;
+      deg.set(r.fb, d2);
+      const key = r.fa < r.fb ? `${r.fa}:${r.fb}` : `${r.fb}:${r.fa}`;
+      let p = pair.get(key);
+      if (!p) {
+        p = { a: r.fa, b: r.fb, rels: /* @__PURE__ */ new Map() };
+        pair.set(key, p);
+      }
+      const e = p.rels.get(r.rel) ?? { n: 0, c: 0 };
+      e.n++;
+      e.c += r.c;
+      p.rels.set(r.rel, e);
+    }
+  } catch {
+  }
+  const scored = files.map((f) => ({
+    f,
+    score: (deg.get(f.id)?.inn ?? 0) + (deg.get(f.id)?.out ?? 0) + (symCount.get(f.id) ?? 0) * 0.5
+  }));
+  scored.sort((a, b) => b.score - a.score);
+  const kept = scored.slice(0, MAX_FILES);
+  const keptIds = new Set(kept.map((k) => k.f.id));
+  const truncatedFiles = scored.length - kept.length;
+  const fileCluster = /* @__PURE__ */ new Map();
+  if (useClusters) {
+    try {
+      const rows = db.prepare(
+        `SELECT file_id AS f, cluster_id AS c, COUNT(*) AS n FROM
+           (SELECT s.file_id, c.cluster_id FROM symbols s JOIN clusters c ON c.node_id = s.id)
+         GROUP BY file_id, cluster_id`
+      ).all();
+      const best = /* @__PURE__ */ new Map();
+      for (const r of rows) {
+        if (!keptIds.has(r.f)) continue;
+        if ((best.get(r.f)?.n ?? -1) < r.n) best.set(r.f, { c: r.c, n: r.n });
+      }
+      for (const [f, v] of best) fileCluster.set(f, v.c);
+    } catch {
+    }
+  }
+  const filePr = /* @__PURE__ */ new Map();
+  if (prBySym.size > 0) {
+    try {
+      for (const r of db.prepare(
+        `SELECT s.file_id AS f, SUM(m.pagerank) AS pr FROM symbols s
+         JOIN node_metrics m ON m.node_id = s.id GROUP BY s.file_id`
+      ).all()) filePr.set(r.f, r.pr);
+    } catch {
+    }
+  }
+  const nodes = kept.map((k) => {
+    const cid = fileCluster.get(k.f.id) ?? -1;
+    const mod = moduleOf(k.f.path);
+    return {
+      id: k.f.id,
+      file: k.f.path,
+      lang: k.f.lang,
+      symbols: symCount.get(k.f.id) ?? 0,
+      module: mod,
+      cluster: cid,
+      clusterName: cid >= 0 ? clusterNames.get(cid) ?? `cluster-${cid}` : mod,
+      pagerank: filePr.get(k.f.id) ?? 0,
+      inDeg: deg.get(k.f.id)?.inn ?? 0,
+      outDeg: deg.get(k.f.id)?.out ?? 0,
+      x: 0,
+      y: 0,
+      r: 0,
+      color: ""
+    };
+  });
+  const edges = [];
+  for (const p of pair.values()) {
+    if (!keptIds.has(p.a) || !keptIds.has(p.b)) continue;
+    let top = "";
+    let topN = 0;
+    let confSum = 0;
+    let total = 0;
+    for (const [rel, e] of p.rels) {
+      total += e.n;
+      confSum += e.c;
+      if (e.n > topN) {
+        topN = e.n;
+        top = rel;
+      }
+    }
+    edges.push({ a: p.a, b: p.b, rel: top, n: total, conf: total > 0 ? confSum / total : 1 });
+  }
+  edges.sort((a, b) => b.n - a.n);
+  const truncatedEdges = Math.max(0, edges.length - MAX_EDGES);
+  const keptEdges = edges.slice(0, MAX_EDGES);
+  layout(nodes, keptEdges);
+  const { symbols, symbolEdges, truncatedSymbols } = buildSymbolLayer(
+    db,
+    keptIds,
+    nodes,
+    prBySym,
+    clusterBySym
+  );
+  return {
+    nodes,
+    edges: keptEdges,
+    truncatedFiles,
+    truncatedEdges,
+    symbols,
+    symbolEdges,
+    truncatedSymbols,
+    clusterNames: [...clusterNames.entries()].map(([id, name]) => ({ id, name })),
+    modularity: modularity2
+  };
+}
+function buildSymbolLayer(db, keptFileIds, fileNodes, prBySym, clusterBySym) {
+  const none = { symbols: [], symbolEdges: [], truncatedSymbols: 0 };
+  let rows = [];
+  try {
+    rows = db.prepare(
+      `SELECT s.id, s.name, s.type, f.path AS file, s.file_id AS fid,
+              (SELECT COUNT(*) FROM relationships r WHERE r.target_id = s.id) +
+              (SELECT COUNT(*) FROM relationships r WHERE r.source_id = s.id) AS deg
+       FROM symbols s JOIN files f ON f.id = s.file_id
+       ORDER BY deg DESC LIMIT ${MAX_SYMBOLS * 2}`
+    ).all();
+  } catch {
+    return none;
+  }
+  rows = rows.filter((r) => keptFileIds.has(r.fid));
+  if (prBySym.size > 0) {
+    rows.sort((a, b) => {
+      const pa = (prBySym.get(a.id) ?? 0) * 100 + a.deg;
+      const pb = (prBySym.get(b.id) ?? 0) * 100 + b.deg;
+      return pb - pa;
+    });
+  }
+  const truncatedSymbols = Math.max(0, rows.length - MAX_SYMBOLS);
+  const kept = rows.slice(0, MAX_SYMBOLS);
+  const keepIds = new Set(kept.map((r) => r.id));
+  const byFile = /* @__PURE__ */ new Map();
+  for (const n of fileNodes) byFile.set(n.id, n);
+  const rnd = mulberry32(777);
+  const callers = /* @__PURE__ */ new Map();
+  const callees = /* @__PURE__ */ new Map();
+  const symEdges = [];
+  try {
+    const rels = db.prepare(
+      `SELECT r.source_id AS s, r.target_id AS t, r.relationship_type AS rel,
+              s1.name AS sn, s2.name AS tn
+       FROM relationships r
+       JOIN symbols s1 ON s1.id = r.source_id
+       JOIN symbols s2 ON s2.id = r.target_id
+       LIMIT 20000`
+    ).all();
+    for (const r of rels) {
+      if (keepIds.has(r.s) && keepIds.has(r.t)) {
+        if (symEdges.length < MAX_SYM_EDGES) symEdges.push({ s: r.s, t: r.t, rel: r.rel });
+      }
+      if (keepIds.has(r.t) && (callers.get(r.t) ?? []).length < 8) {
+        if (!callers.has(r.t)) callers.set(r.t, []);
+        callers.get(r.t).push(`${r.sn} (${r.rel})`);
+      }
+      if (keepIds.has(r.s) && (callees.get(r.s) ?? []).length < 8) {
+        if (!callees.has(r.s)) callees.set(r.s, []);
+        callees.get(r.s).push(`${r.tn} (${r.rel})`);
+      }
+    }
+  } catch {
+  }
+  const symbols = kept.map((r) => {
+    const f = byFile.get(r.fid);
+    const fx = f?.x ?? 500;
+    const fy = f?.y ?? 380;
+    return {
+      id: r.id,
+      name: r.name,
+      type: r.type,
+      file: r.file,
+      cluster: clusterBySym.get(r.id) ?? -1,
+      pr: prBySym.get(r.id) ?? 0,
+      inn: 0,
+      out: 0,
+      callers: callers.get(r.id) ?? [],
+      callees: callees.get(r.id) ?? [],
+      x: Math.round(fx + (rnd() - 0.5) * 120),
+      y: Math.round(fy + (rnd() - 0.5) * 120)
+    };
+  });
+  const symById = new Map(symbols.map((s) => [s.id, s]));
+  for (const e of symEdges) {
+    const a = symById.get(e.s);
+    const b = symById.get(e.t);
+    if (a) a.out++;
+    if (b) b.inn++;
+  }
+  return { symbols, symbolEdges: symEdges, truncatedSymbols };
+}
+function mulberry32(seed) {
+  let a = seed;
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function layout(nodes, edges) {
+  for (const n of nodes) {
+    n.color = colorFor(n.cluster >= 0 ? `cluster-${n.cluster}` : n.module);
+    n.r = Math.min(15, 5 + Math.sqrt(n.symbols) * 1.6);
+  }
+  if (nodes.length === 0) return;
+  if (nodes.length === 1) {
+    nodes[0].x = 400;
+    nodes[0].y = 300;
+    return;
+  }
+  const rnd = mulberry32(1337);
+  const groups = [...new Set(nodes.map((n) => n.cluster >= 0 ? `c${n.cluster}` : n.module))];
+  const modAngle = new Map(groups.map((m, i) => [m, i / groups.length * Math.PI * 2]));
+  const R0 = 260;
+  const px = /* @__PURE__ */ new Map();
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  for (const n of nodes) {
+    const key = n.cluster >= 0 ? `c${n.cluster}` : n.module;
+    const a = (modAngle.get(key) ?? 0) + rnd() * 0.6;
+    const r = R0 * (0.5 + rnd() * 0.7);
+    px.set(n.id, { x: 500 + Math.cos(a) * r, y: 380 + Math.sin(a) * r * 0.75 });
+  }
+  const AREA = 1e3 * 760;
+  const k = Math.sqrt(AREA / nodes.length) * 0.9;
+  const adj = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    const w = Math.min(2, 0.5 + e.n * 0.25);
+    if (!adj.has(e.a)) adj.set(e.a, []);
+    if (!adj.has(e.b)) adj.set(e.b, []);
+    adj.get(e.a).push({ to: e.b, w });
+    adj.get(e.b).push({ to: e.a, w });
+  }
+  const ITERS = 110;
+  let temp = 90;
+  const dTemp = Math.pow(0.5 / temp, 1 / ITERS);
+  for (let it = 0; it < ITERS; it++) {
+    const disp = /* @__PURE__ */ new Map();
+    for (const n of nodes) disp.set(n.id, { x: 0, y: 0 });
+    for (let i = 0; i < nodes.length; i++) {
+      for (let j = i + 1; j < nodes.length; j++) {
+        const a = px.get(nodes[i].id);
+        const b = px.get(nodes[j].id);
+        let dx = a.x - b.x;
+        let dy = a.y - b.y;
+        let d2 = dx * dx + dy * dy;
+        if (d2 < 0.01) {
+          dx = (rnd() - 0.5) * 2;
+          dy = (rnd() - 0.5) * 2;
+          d2 = dx * dx + dy * dy;
+        }
+        const d = Math.sqrt(d2);
+        const f = Math.min(k * k / d, temp * 2);
+        const fx = dx / d * f;
+        const fy = dy / d * f;
+        const da = disp.get(nodes[i].id);
+        const db2 = disp.get(nodes[j].id);
+        da.x += fx;
+        da.y += fy;
+        db2.x -= fx;
+        db2.y -= fy;
+      }
     }
-  };
-  refreshTargets("nextjs", nextjsAdapter.relevant, refreshQueries);
-  refreshTargets("drizzle", drizzleAdapter.relevant, refreshDrizzleQueries);
-  return { adapters: active.map((a) => a.id), symbols, relations };
+    for (const n of nodes) {
+      const p = px.get(n.id);
+      const d = disp.get(n.id);
+      for (const e of adj.get(n.id) ?? []) {
+        const q = px.get(e.to);
+        if (!q) continue;
+        const dx = p.x - q.x;
+        const dy = p.y - q.y;
+        const dist = Math.max(1, Math.sqrt(dx * dx + dy * dy));
+        const f = dist * dist / k * 0.02 * e.w;
+        d.x -= dx / dist * f;
+        d.y -= dy / dist * f;
+      }
+      d.x += (500 - p.x) * 0.03;
+      d.y += (380 - p.y) * 0.03;
+    }
+    const cent = /* @__PURE__ */ new Map();
+    for (const n of nodes) {
+      const key = n.cluster >= 0 ? `c${n.cluster}` : n.module;
+      const p = px.get(n.id);
+      const c = cent.get(key) ?? { x: 0, y: 0, n: 0 };
+      c.x += p.x;
+      c.y += p.y;
+      c.n++;
+      cent.set(key, c);
+    }
+    for (const n of nodes) {
+      const key = n.cluster >= 0 ? `c${n.cluster}` : n.module;
+      const c = cent.get(key);
+      const p = px.get(n.id);
+      const d = disp.get(n.id);
+      d.x += (c.x / c.n - p.x) * 0.05;
+      d.y += (c.y / c.n - p.y) * 0.05;
+    }
+    for (const n of nodes) {
+      const p = px.get(n.id);
+      const d = disp.get(n.id);
+      const dl = Math.max(1e-3, Math.sqrt(d.x * d.x + d.y * d.y));
+      const step = Math.min(dl, temp);
+      p.x += d.x / dl * step;
+      p.y += d.y / dl * step;
+    }
+    temp *= dTemp;
+  }
+  for (const n of nodes) {
+    const p = px.get(n.id);
+    n.x = Math.round(p.x);
+    n.y = Math.round(p.y);
+  }
+  void byId;
+}
+function renderHtml(model, title, generated) {
+  const payload = JSON.stringify({
+    files: model.nodes.map((n) => ({
+      id: n.id,
+      file: n.file,
+      lang: n.lang,
+      symbols: n.symbols,
+      module: n.module,
+      cluster: n.cluster,
+      clusterName: n.clusterName,
+      pr: n.pagerank,
+      inn: n.inDeg,
+      out: n.outDeg,
+      x: n.x,
+      y: n.y,
+      r: n.r,
+      color: n.color
+    })),
+    edges: model.edges,
+    symbols: model.symbols,
+    symbolEdges: model.symbolEdges,
+    clusters: model.clusterNames,
+    modularity: model.modularity,
+    truncated: {
+      files: model.truncatedFiles,
+      edges: model.truncatedEdges,
+      symbols: model.truncatedSymbols
+    }
+  }).replace(/</g, "\\u003c");
+  const truncNote = model.truncatedFiles > 0 || model.truncatedSymbols > 0 ? ` (+${model.truncatedFiles} files, +${model.truncatedSymbols} symbols beyond budget)` : "";
+  const clusterNote = model.clusterNames.length > 0 ? ` \xB7 ${model.clusterNames.length} communities (Louvain Q=${model.modularity.toFixed(3)})` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(title)} \u2014 ScopeCairn graph explorer</title>
+<style>
+:root{--bg:#fafafa;--panel:#fff;--line:#ddd;--ink:#222;--mut:#666;--acc:#0969da}
+*{box-sizing:border-box}
+body{font-family:system-ui,-apple-system,sans-serif;margin:0;background:var(--bg);color:var(--ink)}
+header{padding:10px 14px;background:var(--panel);border-bottom:1px solid var(--line);position:sticky;top:0;z-index:3}
+header h1{font-size:15px;margin:0 0 2px}
+header p{font-size:12px;color:var(--mut);margin:2px 0}
+#bar{display:flex;gap:8px;align-items:center;margin-top:8px;flex-wrap:wrap}
+#bar input,#bar select{padding:5px 8px;font-size:13px;border:1px solid var(--line);border-radius:6px}
+#q{flex:1;min-width:160px;max-width:320px}
+.seg{display:flex;border:1px solid var(--line);border-radius:6px;overflow:hidden}
+.seg button{border:0;background:#f3f4f6;padding:5px 10px;font-size:12.5px;cursor:pointer}
+.seg button.on{background:#1f2328;color:#fff}
+#main{display:flex;height:calc(100vh - 158px);min-height:420px}
+#wrap{flex:1;position:relative;overflow:hidden;cursor:grab;background:#fff}
+#cv{position:absolute;inset:0;width:100%;height:100%}
+#side{width:320px;max-width:38vw;overflow:auto;background:var(--panel);border-left:1px solid var(--line);padding:12px 14px;font-size:13px}
+#side h2{font-size:14px;margin:0 0 4px;word-break:break-all}
+#side .meta{color:var(--mut);font-size:12px;margin:0 0 8px}
+#side h3{font-size:12px;text-transform:uppercase;letter-spacing:.04em;color:var(--mut);margin:12px 0 4px}
+#side ul{margin:0;padding-left:18px}
+#side code{background:#f3f4f6;border-radius:4px;padding:0 4px}
+#tip{position:fixed;display:none;background:#111;color:#eee;font:12px ui-monospace,monospace;padding:6px 9px;border-radius:6px;pointer-events:none;white-space:pre;z-index:5;max-width:60vw}
+.hint{font-size:12px;color:var(--mut);padding:6px 14px}
+kbd{background:#f3f4f6;border:1px solid var(--line);border-radius:4px;padding:0 5px;font-size:11px}
+</style>
+</head>
+<body>
+<header>
+<h1>${esc(title)} \u2014 ${model.nodes.length} files, ${model.symbols.length} symbols, ${model.edges.length} links${esc(truncNote)}</h1>
+<p>Generated by <code>scopecairn scan</code> \xB7 ${esc(generated)} \xB7 interactive Canvas explorer (offline, zero dependencies)${esc(clusterNote)}</p>
+<div id="bar">
+<div class="seg" role="tablist" aria-label="hierarchy">
+<button data-mode="cluster" class="on">Cluster</button><button data-mode="file">File</button><button data-mode="symbol">Symbol</button>
+</div>
+<input id="q" placeholder="live search: name, type, module\u2026" autocomplete="off">
+<select id="tf"><option value="">all types</option><option>function</option><option>class</option><option>method</option><option>route</option><option>model</option><option>component</option><option>interface</option><option>type</option></select>
+<button id="fit">fit</button>
+<span style="font-size:12px;color:var(--mut)">drag pan \xB7 wheel zoom \xB7 hover inspect \xB7 click details</span>
+</div>
+</header>
+<div class="hint" id="count"></div>
+<div id="main">
+<div id="wrap"><canvas id="cv"></canvas></div>
+<aside id="side"><h2>Graph explorer</h2><p class="meta">Klik node untuk melihat sumber singkat, pengimpor / yang dipanggil, dan skor centrality.</p><p class="meta">Toggle <kbd>Cluster</kbd>\u2194<kbd>File</kbd>\u2194<kbd>Symbol</kbd> untuk ganti hierarki tampilan.</p></aside>
+</div>
+<div id="tip"></div>
+<script>
+(function(){
+"use strict";
+var DATA=${payload};
+var files=DATA.files, fedges=DATA.edges, syms=DATA.symbols, sedges=DATA.symbolEdges;
+var byFileId={}, bySymId={};
+files.forEach(function(n){byFileId[n.id]=n;});
+syms.forEach(function(s){bySymId[s.id]=s;});
+// Cluster view: agregat file per komunitas Louvain (fallback modul folder).
+var clusters=[];
+(function(){
+  var m={};
+  files.forEach(function(n){
+    var key=n.cluster>=0?("c"+n.cluster):("m:"+n.module);
+    if(!m[key])m[key]={key:key,cluster:n.cluster,name:n.cluster>=0?n.clusterName:n.module,members:[],x:0,y:0,r:0};
+    m[key].members.push(n);
+  });
+  Object.keys(m).forEach(function(k){
+    var c=m[k],sx=0,sy=0;
+    c.members.forEach(function(n){sx+=n.x;sy+=n.y;});
+    c.x=sx/c.members.length;c.y=sy/c.members.length;
+    c.r=Math.min(46,14+Math.sqrt(c.members.length)*6);
+    clusters.push(c);
+  });
+})();
+var cv=document.getElementById('cv'),ctx=cv.getContext('2d'),wrap=document.getElementById('wrap');
+var side=document.getElementById('side'),tip=document.getElementById('tip'),count=document.getElementById('count');
+var mode='cluster',query='',typeF='';
+var cam={x:0,y:0,scale:1},drag=null,hover=null,sel=null,dpr=1;
+function resize(){
+  dpr=Math.min(2,window.devicePixelRatio||1);
+  var r=wrap.getBoundingClientRect();
+  cv.width=Math.max(1,r.width*dpr);cv.height=Math.max(1,r.height*dpr);
+  draw();
+}
+window.addEventListener('resize',resize);
+function w2s(p){return [(p[0]-cam.x)*cam.scale*dpr,(p[1]-cam.y)*cam.scale*dpr];}
+function fit(){
+  var pts=currentPoints();
+  if(!pts.length){cam={x:0,y:0,scale:1};draw();return;}
+  var xs=pts.map(function(p){return p.x;}),ys=pts.map(function(p){return p.y;});
+  var x0=Math.min.apply(0,xs)-60,x1=Math.max.apply(0,xs)+60;
+  var y0=Math.min.apply(0,ys)-60,y1=Math.max.apply(0,ys)+60;
+  var r=wrap.getBoundingClientRect();
+  var s=Math.min(r.width/(x1-x0),r.height/(y1-y0));
+  s=Math.min(3,Math.max(.05,s));
+  cam.scale=s;cam.x=x0-(r.width/s-(x1-x0))/2;cam.y=y0-(r.height/s-(y1-y0))/2;
+  draw();
+}
+function match(n){
+  if(typeF && (n.type||'')!==typeF)return false;
+  if(!query)return true;
+  var hay=((n.name||n.file||'')+' '+(n.type||'')+' '+(n.module||'')+' '+(n.clusterName||'')).toLowerCase();
+  return hay.indexOf(query)>=0;
+}
+function currentPoints(){
+  if(mode==='symbol')return syms.filter(match);
+  if(mode==='file')return files.filter(match);
+  return clusters;
+}
+function draw(){
+  var r=wrap.getBoundingClientRect(),W=r.width*dpr,H=r.height*dpr;
+  ctx.clearRect(0,0,W,H);
+  ctx.fillStyle='#fff';ctx.fillRect(0,0,W,H);
+  var s=cam.scale*dpr,ox=-cam.x*s,oy=-cam.y*s;
+  function X(x){return x*s+ox;} function Y(y){return y*s+oy;}
+  ctx.lineWidth=1;
+  if(mode==='cluster'){
+    clusters.forEach(function(c){
+      ctx.beginPath();ctx.arc(X(c.x),Y(c.y),c.r*s,0,7);
+      ctx.fillStyle='rgba(9,105,218,.10)';ctx.fill();
+      ctx.fillStyle='#1f2328';ctx.font=(12*dpr)+'px system-ui';
+      ctx.textAlign='center';
+      ctx.fillText(c.name+' ('+c.members.length+')',X(c.x),Y(c.y)-c.r*s-6*dpr);
+    });
+    clusters.forEach(function(c){
+      var sel2=(sel&&sel.kind==='cluster'&&sel.key===c.key);
+      ctx.beginPath();ctx.arc(X(c.x),Y(c.y),Math.max(3,c.r*s),0,7);
+      ctx.fillStyle=sel2?'#0969da':'#57606a';ctx.fill();
+      if(sel2){ctx.strokeStyle='#0969da';ctx.lineWidth=3*dpr;ctx.stroke();}
+    });
+  }else if(mode==='file'){
+    fedges.forEach(function(e){
+      var a=byFileId[e.a],b=byFileId[e.b];
+      if(!a||!b||!match(a)||!match(b))return;
+      ctx.beginPath();ctx.moveTo(X(a.x),Y(a.y));ctx.lineTo(X(b.x),Y(b.y));
+      ctx.strokeStyle=e.conf<0.8?'rgba(150,150,150,.45)':'rgba(120,120,120,.55)';
+      ctx.setLineDash(e.conf<0.8?[5,4]:[]);
+      ctx.lineWidth=Math.min(3,(0.5+e.n*0.4))*dpr*0.6;ctx.stroke();ctx.setLineDash([]);
+    });
+    var ranked=files.slice().sort(function(a,b){return (b.inn+b.out)-(a.inn+a.out);});
+    var labeled={};ranked.slice(0,25).forEach(function(n){labeled[n.id]=1;});
+    files.forEach(function(n){
+      if(!match(n))return;
+      var rad=Math.max(2.5,n.r*s),isH=hover&&hover.kind==='file'&&hover.id===n.id;
+      var isS=sel&&sel.kind==='file'&&sel.id===n.id;
+      ctx.beginPath();ctx.arc(X(n.x),Y(n.y),rad+(isH?2:0),0,7);
+      ctx.fillStyle=n.color||'#57606a';ctx.fill();
+      ctx.lineWidth=(isS?3:1.2)*dpr;ctx.strokeStyle=isS?'#0969da':'#1f2328';ctx.stroke();
+      if(labeled[n.id]&&s>0.35){
+        ctx.fillStyle='#24292f';ctx.font=(10.5*dpr)+'px ui-monospace,monospace';ctx.textAlign='left';
+        var nm=n.file.split('/');var sh=nm.length>2?(nm[0]+'/\u2026/'+nm[nm.length-1]):n.file;
+        ctx.fillText(sh,X(n.x)+rad+4*dpr,Y(n.y)+4*dpr);
+      }
+    });
+  }else{
+    var se={};
+    sedges.forEach(function(e){
+      var a=bySymId[e.s],b=bySymId[e.t];
+      if(!a||!b||!match(a)||!match(b))return;
+      var k=e.s+':'+e.t;if(se[k])return;se[k]=1;
+      ctx.beginPath();ctx.moveTo(X(a.x),Y(a.y));ctx.lineTo(X(b.x),Y(b.y));
+      ctx.strokeStyle='rgba(120,120,120,.4)';ctx.lineWidth=1*dpr;ctx.stroke();
+    });
+    var top=syms.slice().sort(function(a,b){return b.pr-a.pr;});
+    var lab={};top.slice(0,30).forEach(function(x){lab[x.id]=1;});
+    syms.forEach(function(n){
+      if(!match(n))return;
+      var base=4+Math.min(9,Math.sqrt(n.inn+n.out)*2+(n.pr*400));
+      var rad=Math.max(2.5,base*s),isH=hover&&hover.kind==='symbol'&&hover.id===n.id;
+      var isS=sel&&sel.kind==='symbol'&&sel.id===n.id;
+      ctx.beginPath();ctx.arc(X(n.x),Y(n.y),rad+(isH?2:0),0,7);
+      ctx.fillStyle=isS?'#0969da':'#8250df';ctx.fill();
+      ctx.lineWidth=1.2*dpr;ctx.strokeStyle='#1f2328';ctx.stroke();
+      if(lab[n.id]&&s>0.5){
+        ctx.fillStyle='#24292f';ctx.font=(10*dpr)+'px ui-monospace,monospace';ctx.textAlign='left';
+        ctx.fillText(n.name.slice(0,32),X(n.x)+rad+4*dpr,Y(n.y)+4*dpr);
+      }
+    });
+  }
+  var pts=currentPoints();
+  count.textContent='showing '+pts.length+' / '+(mode==='symbol'?syms.length:mode==='file'?files.length:clusters.length)+' \xB7 '+mode+' view \xB7 scroll zoom \xB7 drag pan';
+}
+function pick(mx,my){
+  var r=wrap.getBoundingClientRect(),s=cam.scale*dpr;
+  var wx=(mx*dpr+cam.x*s)/s,wy=(my*dpr+cam.y*s)/s;
+  var best=null,bd=1e12;
+  currentPoints().forEach(function(n){
+    var rad=(n.r||8)+8/s;
+    var dx=n.x-wx,dy=n.y-wy,d=Math.sqrt(dx*dx+dy*dy);
+    if(d<rad&&d<bd){bd=d;best=n;}
+  });
+  if(!best)return null;
+  if(mode==='cluster')return {kind:'cluster',key:best.key};
+  if(mode==='file')return {kind:'file',id:best.id};
+  return {kind:'symbol',id:best.id};
+}
+function detailHTML(p){
+  function li(a){return '<li><code>'+a.replace(/&/g,'&amp;').replace(/</g,'&lt;')+'</code></li>';}
+  if(p.kind==='cluster'){
+    var c=clusters.filter(function(x){return x.key===p.key;})[0];
+    if(!c)return '';
+    return '<h2>'+c.name+'</h2><p class="meta">community \xB7 '+c.members.length+' files</p><h3>Members</h3><ul>'+
+      c.members.slice(0,20).map(function(n){return li(n.file);}).join('')+'</ul>'+
+      (c.members.length>20?'<p class="meta">+'+(c.members.length-20)+' more</p>':'');
+  }
+  if(p.kind==='file'){
+    var n=byFileId[p.id];if(!n)return '';
+    var nbrs=fedges.filter(function(e){return e.a===n.id||e.b===n.id;}).slice(0,12);
+    return '<h2>'+n.file+'</h2><p class="meta">'+n.lang+' \xB7 '+n.symbols+' symbols \xB7 in '+n.inn+' / out '+n.out+
+      (n.cluster>=0?' \xB7 '+n.clusterName:'')+(n.pr?' \xB7 pr='+n.pr.toFixed(4):'')+'</p><h3>Links</h3><ul>'+
+      nbrs.map(function(e){var o=e.a===n.id?byFileId[e.b]:byFileId[e.a];return li((o?o.file:e.a===n.id?e.b:e.a)+' ('+e.rel+' \xD7'+e.n+')');}).join('')+'</ul>';
+  }
+  var x=bySymId[p.id];if(!x)return '';
+  return '<h2>'+x.name+'</h2><p class="meta">'+x.type+' \xB7 '+x.file+(x.cluster>=0?' \xB7 cluster '+x.cluster:'')+
+    ' \xB7 pr='+(x.pr||0).toFixed(4)+' \xB7 in '+x.inn+' / out '+x.out+'</p>'+
+    '<h3>Callers / importers</h3><ul>'+(x.callers.slice(0,8).map(li).join('')||'<li>\u2014</li>')+'</ul>'+
+    '<h3>Calls / depends on</h3><ul>'+(x.callees.slice(0,8).map(li).join('')||'<li>\u2014</li>')+'</ul>';
+}
+wrap.addEventListener('mousedown',function(e){drag={x:e.clientX-cam.x*cam.scale,y:e.clientY-cam.y*cam.scale};wrap.style.cursor='grabbing';});
+window.addEventListener('mouseup',function(){drag=null;wrap.style.cursor='grab';});
+window.addEventListener('mousemove',function(e){
+  var r=wrap.getBoundingClientRect();
+  if(drag){
+    cam.x=(e.clientX-drag.x)/cam.scale;cam.y=(e.clientY-drag.y)/cam.scale;draw();tip.style.display='none';return;
+  }
+  if(e.clientX<r.left||e.clientX>r.right||e.clientY<r.top||e.clientY>r.bottom){tip.style.display='none';hover=null;return;}
+  var p=pick(e.clientX-r.left,e.clientY-r.top);
+  hover=p;
+  if(p){
+    var t=p.kind==='cluster'?p.key:(p.kind==='file'?byFileId[p.id].file:bySymId[p.id].name+' ('+bySymId[p.id].type+', '+bySymId[p.id].file+')');
+    tip.textContent=t;tip.style.display='block';tip.style.left=(e.clientX+12)+'px';tip.style.top=(e.clientY+12)+'px';
+    cv.style.cursor='pointer';
+  }else{tip.style.display='none';cv.style.cursor='default';}
+  draw();
+});
+wrap.addEventListener('click',function(e){
+  if(drag&&Math.abs(e.clientX-drag.x)>4)return;
+  var r=wrap.getBoundingClientRect();
+  var p=pick(e.clientX-r.left,e.clientY-r.top);
+  sel=p;draw();
+  if(p)side.innerHTML=detailHTML(p);
+});
+wrap.addEventListener('wheel',function(e){
+  e.preventDefault();
+  var f=e.deltaY<0?1.12:0.89;
+  cam.scale=Math.min(8,Math.max(.05,cam.scale*f));draw();
+},{passive:false});
+document.querySelectorAll('.seg button').forEach(function(b){
+  b.addEventListener('click',function(){
+    document.querySelectorAll('.seg button').forEach(function(x){x.classList.remove('on');});
+    b.classList.add('on');mode=b.dataset.mode;sel=null;fit();
+  });
+});
+var q=document.getElementById('q');
+q.addEventListener('input',function(){query=q.value.toLowerCase();draw();});
+var tf=document.getElementById('tf');
+tf.addEventListener('change',function(){typeF=tf.value;if(mode!=='symbol'&&typeF)mode='symbol';
+  document.querySelectorAll('.seg button').forEach(function(x){x.classList.toggle('on',x.dataset.mode===mode);});
+  draw();});
+document.getElementById('fit').addEventListener('click',fit);
+resize();fit();
+})();
+</script>
+</body>
+</html>`;
 }
 
 // src/scanner.ts
 function toPosixRel(repoRoot2, abs) {
-  return path8.relative(repoRoot2, abs).split(path8.sep).join("/");
+  return path14.relative(repoRoot2, abs).split(path14.sep).join("/");
 }
 function walk(absDir, out) {
-  const entries = fs7.readdirSync(absDir, { withFileTypes: true });
+  const entries = fs13.readdirSync(absDir, { withFileTypes: true });
   for (const e of entries) {
-    const abs = path8.join(absDir, e.name);
+    const abs = path14.join(absDir, e.name);
     if (e.isDirectory()) {
       if (e.isSymbolicLink()) continue;
       walk(abs, out);
@@ -1775,7 +3424,7 @@ function scanRepository(repoRoot2) {
       seenPaths.add(rel);
       let buf;
       try {
-        buf = fs7.readFileSync(abs);
+        buf = fs13.readFileSync(abs);
       } catch {
         continue;
       }
@@ -1831,6 +3480,24 @@ function scanRepository(repoRoot2) {
     ).run();
     linkTests(db);
     cleanupIndex(db);
+    const graphDirty = inserted + updated + removed > 0 || adapterRun.symbols > 0 || adapterRun.relations > 0;
+    const graphWritten = writeGraphMdIfChanged(db, repoRoot2, graphDirty);
+    let visualWritten = false;
+    if (graphDirty) {
+      try {
+        const model = buildVisualModel(db);
+        const html = renderHtml(
+          model,
+          path14.basename(path14.resolve(repoRoot2)),
+          (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ")
+        );
+        fs13.mkdirSync(dataDir(repoRoot2), { recursive: true });
+        fs13.writeFileSync(path14.join(dataDir(repoRoot2), GRAPH_HTML_NAME), html);
+        visualWritten = true;
+      } catch {
+        visualWritten = false;
+      }
+    }
     const symbols = db.prepare(`SELECT COUNT(*) AS n FROM symbols`).get().n;
     const relationships = db.prepare(`SELECT COUNT(*) AS n FROM relationships`).get().n;
     return {
@@ -1841,6 +3508,8 @@ function scanRepository(repoRoot2) {
       symbols,
       relationships,
       adapters: adapterRun.adapters,
+      graphWritten,
+      visualWritten,
       inserted,
       updated,
       unchanged,
@@ -1867,6 +3536,12 @@ function cmdScan(repoRoot2) {
   if (stats.adapters.length > 0) {
     console.log(`\u2713 adapters: ${stats.adapters.join(", ")}`);
   }
+  if (stats.graphWritten) {
+    console.log(`\u2713 GRAPH.md updated (.scopecairn/GRAPH.md)`);
+  }
+  if (stats.visualWritten) {
+    console.log(`\u2713 GRAPH.html updated (.scopecairn/GRAPH.html \u2014 open in browser)`);
+  }
   console.log(
     `\u2713 index: +${stats.inserted} new, ~${stats.updated} updated, =${stats.unchanged} unchanged, -${stats.removed} removed`
   );
@@ -1875,11 +3550,11 @@ function cmdScan(repoRoot2) {
 }
 
 // src/commands/status.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs14 from "fs";
+import path15 from "path";
 function cmdStatus(repoRoot2) {
   const dir = dataDir(repoRoot2);
-  if (!fs8.existsSync(path9.join(dir, "scopecairn.db"))) {
+  if (!fs14.existsSync(path15.join(dir, "scopecairn.db"))) {
     console.log("ScopeCairn");
     console.log("Status: NOT INITIALIZED (run `scopecairn scan`)");
     return;
@@ -1931,17 +3606,17 @@ function cmdStatus(repoRoot2) {
 }
 
 // src/commands/rebuild.ts
-import fs9 from "fs";
+import fs15 from "fs";
 function cmdRebuild(repoRoot2) {
   const dir = dataDir(repoRoot2);
-  fs9.rmSync(dir, { recursive: true, force: true });
+  fs15.rmSync(dir, { recursive: true, force: true });
   console.log(`Cleaned ${dir}`);
   cmdScan(repoRoot2);
 }
 
 // src/commands/doctor.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs17 from "fs";
+import path17 from "path";
 
 // src/treesitter.ts
 var cached = null;
@@ -1966,18 +3641,18 @@ async function checkTreeSitter() {
 }
 
 // src/integrate/detect.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs16 from "fs";
+import path16 from "path";
 function detectAgentDir(repoRoot2) {
-  const plural = fs10.existsSync(path10.join(repoRoot2, ".agents"));
-  const singular = fs10.existsSync(path10.join(repoRoot2, ".agent"));
+  const plural = fs16.existsSync(path16.join(repoRoot2, ".agents"));
+  const singular = fs16.existsSync(path16.join(repoRoot2, ".agent"));
   if (singular && !plural) return ".agent";
   return ".agents";
 }
 function detectPrefix(repoRoot2) {
   try {
     const pkg = JSON.parse(
-      fs10.readFileSync(path10.join(repoRoot2, "package.json"), "utf8")
+      fs16.readFileSync(path16.join(repoRoot2, "package.json"), "utf8")
     );
     if (pkg.dependencies?.["scopecairn"] || pkg.devDependencies?.["scopecairn"]) {
       return "npx scopecairn";
@@ -2021,9 +3696,28 @@ Jalankan \`${prefix} scan\` agar indeks ScopeCairn mencerminkan perubahanmu.
 Lewati ScopeCairn hanya untuk pertanyaan non-coding.
 `;
 }
-function agentsMd(prefix) {
-  return `${MARKER}
-${ruleBody(prefix)}`;
+function claudeSkillMd(prefix) {
+  return `---
+name: scopecairn
+description: ScopeCairn codebase context + scope. Use for ALL coding tasks
+  (feature, bugfix, refactor, code questions) before exploring the repo,
+  and when the user says "scopecairn", asks for a repo overview, or asks
+  to set up ScopeCairn.
+allowed-tools: Bash
+---
+
+# ScopeCairn
+
+1. Jika \`.scopecairn/scopecairn.db\` belum ada: jalankan \`${prefix} init\`
+   (bila CLI belum ada: \`npm install -g scopecairn\`), laporkan file/simbol/relasi, berhenti.
+2. Jika sudah ada: jalankan \`${prefix} context "<task user>"\`.
+   Mulai dari Relevant Files. Jangan menjelajah dari nol.
+3. Ubah hanya Required/Optional; Protected perlu persetujuan user.
+   Simbol bersama \u2192 \`${prefix} impact <path>\`.
+   Butuh isi fungsi \u2192 \`${prefix} read symbol <nama>\`, bukan baca file penuh.
+4. Task membesar (>2 file)? Panggil ulang \`${prefix} context --escalate\`.
+5. Setelah mengedit: \`${prefix} scan\`. Berhenti saat acceptance criteria terpenuhi.
+`;
 }
 function genericRuleMd(prefix) {
   return `${MARKER}
@@ -2064,6 +3758,37 @@ Shortcut manual bila agent lupa memanggil ScopeCairn otomatis.
 4. Perlu source simbol? \`${prefix} read symbol <nama>\`.
 `;
 }
+function opencodeCommandMd(prefix) {
+  return `---
+description: ScopeCairn codebase context + scope for a task
+---
+
+Run \`${prefix} context "$ARGUMENTS"\` with the bash tool, then:
+
+1. Use Relevant Files as the starting point \u2014 do not explore from zero.
+2. Change only Required and Optional files; Protected needs user approval.
+3. If shared symbols change, run \`${prefix} impact <path>\`.
+4. Need a function body? Use \`${prefix} read symbol <nama>\`, not full reads.
+5. After editing, run \`${prefix} scan\` so the ScopeCairn index stays fresh.
+<!-- scopecairn:managed -->
+`;
+}
+function opencodePermissionGuide(prefix) {
+  const cmds = ["context", "impact", "read", "graph", "status", "doctor"];
+  const rules = cmds.map((c) => `      "${prefix} ${c} *": "allow"`).join(",\n");
+  return `Agar command di atas jalan tanpa persetujuan, gabungkan ke opencode.json
+(project root atau ~/.config/opencode/opencode.json):
+
+{
+  "permission": {
+    "bash": {
+${rules}
+    }
+  }
+}
+
+Catatan: ScopeCairn tidak mengubah opencode.json Anda secara otomatis.`;
+}
 var ALLOWLIST_COMMANDS = [
   "context",
   "impact",
@@ -2085,29 +3810,13 @@ Catatan: ScopeCairn tidak mengubah pengaturan IDE Anda secara otomatis.`;
 
 // src/integrate/matrix.ts
 var AGENT_MATRIX = [
-  {
-    id: "agents",
-    label: "AGENTS.md (universal: Codex, Aider, Opencode, Amp, Jules, ...)",
-    rel: "AGENTS.md",
-    mode: "merge",
-    render: agentsMd,
-    presentMarker: "AGENTS.md"
-  },
   {
     id: "claude",
     label: "Claude Code",
-    rel: "CLAUDE.md",
-    mode: "merge",
-    render: genericRuleMd,
-    presentMarker: "CLAUDE.md"
-  },
-  {
-    id: "gemini",
-    label: "Gemini / Antigravity CLI",
-    rel: "GEMINI.md",
-    mode: "merge",
-    render: genericRuleMd,
-    presentMarker: "GEMINI.md"
+    rel: ".claude/skills/scopecairn/SKILL.md",
+    mode: "new",
+    render: claudeSkillMd,
+    presentMarker: ".claude"
   },
   {
     id: "cursor",
@@ -2140,6 +3849,14 @@ var AGENT_MATRIX = [
     mode: "new",
     render: genericRuleMd,
     presentMarker: ".kiro"
+  },
+  {
+    id: "opencode",
+    label: "OpenCode",
+    rel: ".opencode/commands/scopecairn.md",
+    mode: "new",
+    render: opencodeCommandMd,
+    presentMarker: ".opencode"
   }
 ];
 function findTarget(id) {
@@ -2155,7 +3872,7 @@ function parseAgentsOption(raw) {
 function tick(ok) {
   return ok ? "\u2713" : "\u2717";
 }
-async function cmdDoctor(repoRoot2) {
+async function cmdDoctor(repoRoot2, opts) {
   const nodeOk = Number(process.versions.node.split(".")[0]) >= 20;
   console.log(`${tick(nodeOk)} Node.js ${process.version} (need >=20)`);
   let sqliteOk = false;
@@ -2164,8 +3881,10 @@ async function cmdDoctor(repoRoot2) {
     const req = createRequire2(import.meta.url);
     const m = req("node:sqlite");
     sqliteOk = typeof m.DatabaseSync === "function";
-  } catch {
+  } catch (err) {
     sqliteOk = false;
+    logError("doctor", err, repoRoot2);
+    if (opts?.verbose) console.error(err);
   }
   console.log(`${tick(sqliteOk)} SQLite (node:sqlite built-in)`);
   const ts = await checkTreeSitter();
@@ -2178,23 +3897,62 @@ async function cmdDoctor(repoRoot2) {
     const s = db.prepare(`SELECT COUNT(*) AS n FROM symbols`).get().n;
     const r = db.prepare(`SELECT COUNT(*) AS n FROM relationships`).get().n;
     db.close();
-    dbOk = fs11.existsSync(dbPath(repoRoot2));
+    dbOk = fs17.existsSync(dbPath(repoRoot2));
     graphDetail = ` (${s} symbols, ${r} rels)`;
-  } catch {
+  } catch (err) {
     dbOk = false;
+    logError("doctor", err, repoRoot2);
+    if (opts?.verbose) console.error(err);
   }
   console.log(`${tick(dbOk)} Database ${dbPath(repoRoot2)}${graphDetail}`);
-  const protPath = path11.join(dataDir(repoRoot2), "protected.yml");
-  console.log(`${tick(fs11.existsSync(protPath))} Protected ${protPath}`);
+  try {
+    const db = openDb(repoRoot2);
+    try {
+      const { refreshCycles, getCycles, describeCycle } = await import("./cycles-6KSI4OPZ.js");
+      const { ensureMetrics: ensureMetrics2, topByPageRank } = await import("./metrics-ZWWLUYJW.js");
+      const cycles = getCycles(db, 5);
+      if (cycles.length === 0) {
+        try {
+          refreshCycles(db);
+        } catch (err) {
+          logError("doctor", err, repoRoot2);
+          if (opts?.verbose) console.error(err);
+        }
+      }
+      const found = getCycles(db, 5);
+      console.log(`${tick(found.length === 0)} Circular dependencies (${found.length} cycle(s))`);
+      for (const c of found.slice(0, 3)) {
+        console.log(`  ~ cycle[${c.length}]: ${describeCycle(db, c)}`);
+      }
+      ensureMetrics2(db);
+      const gods = topByPageRank(db, 3);
+      if (gods.length > 0) {
+        console.log(`i Critical hotspots (PageRank):`);
+        for (const g of gods) {
+          console.log(
+            `  ! ${g.name} (${g.type}, ${g.file}) pr=${g.pagerank.toFixed(4)} in=${g.inDegree} out=${g.outDegree}`
+          );
+        }
+      }
+    } finally {
+      db.close();
+    }
+  } catch (err) {
+    logError("doctor", err, repoRoot2);
+    if (opts?.verbose) console.error(err);
+    console.log(`i Graph metrics unavailable (run \`scopecairn scan\` first)`);
+  }
+  const protPath = path17.join(dataDir(repoRoot2), "protected.yml");
+  console.log(`${tick(fs17.existsSync(protPath))} Protected ${protPath}`);
   const expectedPrefix = detectPrefix(repoRoot2);
   const agentDir = detectAgentDir(repoRoot2);
   let prefixOk = true;
   let matrixOk = 0;
   for (const t of AGENT_MATRIX) {
-    const abs = path11.join(repoRoot2, t.rel);
-    if (!fs11.existsSync(abs)) continue;
-    const text = fs11.readFileSync(abs, "utf8");
-    if (!text.includes(MARKER)) continue;
+    const abs = path17.join(repoRoot2, t.rel);
+    if (!fs17.existsSync(abs)) continue;
+    const text = fs17.readFileSync(abs, "utf8");
+    if (t.mode === "merge" && !text.includes(MARKER)) continue;
     matrixOk++;
     const used = extractPrefixUsed(text);
     if (used && used !== expectedPrefix) {
@@ -2210,13 +3968,13 @@ async function cmdDoctor(repoRoot2) {
   } else if (prefixOk) {
     console.log(`\u2713 Prefix konsisten (\`${expectedPrefix} context\`)`);
   }
-  const skillPath = path11.join(repoRoot2, agentDir, "skills", "scopecairn", "SKILL.md");
-  const skillOk = fs11.existsSync(skillPath);
+  const skillPath = path17.join(repoRoot2, agentDir, "skills", "scopecairn", "SKILL.md");
+  const skillOk = fs17.existsSync(skillPath);
   console.log(`${tick(skillOk)} Skill (${agentDir}/skills/scopecairn/SKILL.md)`);
-  const wfPath = path11.join(repoRoot2, "workflows", "scopecairn.md");
-  console.log(`${tick(fs11.existsSync(wfPath))} Workflow (workflows/scopecairn.md, opsional)`);
+  const wfPath = path17.join(repoRoot2, "workflows", "scopecairn.md");
+  console.log(`${tick(fs17.existsSync(wfPath))} Workflow (workflows/scopecairn.md, opsional)`);
   console.log(`i Strict Mode mengabaikan allowlist \u2014 semua perintah tetap perlu persetujuan.`);
-  const healthy = nodeOk && sqliteOk && ts.ok && dbOk && matrixOk > 0 && skillOk && prefixOk;
+  const healthy = nodeOk && sqliteOk && ts.ok && dbOk && (matrixOk > 0 || skillOk) && prefixOk;
   console.log(`Status: ${healthy ? "HEALTHY" : "DEGRADED (see \u2717 above)"}`);
 }
 
@@ -2285,6 +4043,71 @@ function neighbors(db, id, limit = 50) {
     }))
   ];
 }
+function findShortestPath(db, fromId, toId, maxDepth = 8, fanout = 200) {
+  if (fromId === toId) return [];
+  const prev = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set([fromId]);
+  let frontier = [fromId];
+  let found = false;
+  for (let d = 0; d < maxDepth && frontier.length > 0; d++) {
+    const next = [];
+    for (const cur2 of frontier) {
+      let rows = [];
+      try {
+        rows = db.prepare(
+          `SELECT target_id AS t, relationship_type AS rel FROM relationships
+             WHERE source_id = ? LIMIT ${Math.max(1, Math.min(1e3, fanout))}`
+        ).all(cur2);
+      } catch {
+        rows = [];
+      }
+      for (const r of rows) {
+        if (seen.has(r.t)) continue;
+        seen.add(r.t);
+        prev.set(r.t, { p: cur2, rel: r.rel });
+        if (r.t === toId) {
+          found = true;
+          break;
+        }
+        next.push(r.t);
+      }
+      if (found) break;
+    }
+    if (found) break;
+    frontier = next;
+  }
+  if (!found) return null;
+  const chain = [toId];
+  let cur = toId;
+  while (cur !== fromId) {
+    const step = prev.get(cur);
+    if (!step) return null;
+    chain.push(step.p);
+    cur = step.p;
+  }
+  chain.reverse();
+  const info = /* @__PURE__ */ new Map();
+  try {
+    const rows = db.prepare(
+      `SELECT s.id, s.name, s.type, f.path AS file FROM symbols s
+         JOIN files f ON f.id = s.file_id`
+    ).all();
+    for (const r of rows) {
+      const n = asNode(r);
+      if (chain.includes(n.id)) info.set(n.id, n);
+    }
+  } catch {
+    return null;
+  }
+  const hops = [];
+  for (let i = 0; i < chain.length - 1; i++) {
+    const a = info.get(chain[i]);
+    const b = info.get(chain[i + 1]);
+    if (!a || !b) return null;
+    hops.push({ from: a, rel: prev.get(chain[i + 1]).rel, to: b });
+  }
+  return hops;
+}
 
 // src/commands/graph.ts
 function cmdGraph(repoRoot2, key) {
@@ -2306,6 +4129,21 @@ function cmdGraph(repoRoot2, key) {
       console.log("");
     }
     const edges = neighbors(db, node.id);
+    try {
+      ensureMetrics(db);
+      ensureClusters(db);
+      const m = getMetrics(db, node.id);
+      const c = getCluster(db, node.id);
+      const parts = [];
+      if (m) parts.push(`pr=${m.pagerank.toFixed(4)} btw=${m.betweenness.toFixed(4)} in=${m.inDegree} out=${m.outDegree}`);
+      if (c) parts.push(`community=${c.clusterName}`);
+      try {
+        if (nodeInCycle(db, node.id)) parts.push(`IN CYCLE`);
+      } catch {
+      }
+      if (parts.length > 0) console.log(`Metrics: ${parts.join(" \xB7 ")}`);
+    } catch {
+    }
     if (edges.length === 0) {
       console.log("(no relations)");
       return;
@@ -2333,9 +4171,82 @@ function cmdGraph(repoRoot2, key) {
   }
 }
 
+// src/commands/path.ts
+function cmdPath(repoRoot2, from, to) {
+  const db = openDb(repoRoot2);
+  try {
+    logInvocation(db, "path");
+    const aHits = findSymbols(db, from);
+    const bHits = findSymbols(db, to);
+    if (aHits.length === 0) {
+      console.log(`No symbol or file matching "${from}".`);
+      return;
+    }
+    if (bHits.length === 0) {
+      console.log(`No symbol or file matching "${to}".`);
+      return;
+    }
+    const a = aHits.find((h) => h.name === from) ?? aHits[0];
+    const b = bHits.find((h) => h.name === to) ?? bHits[0];
+    const hops = findShortestPath(db, a.id, b.id);
+    if (!hops) {
+      console.log(`No path from "${a.name}" to "${b.name}" (max 8 hops).`);
+      if (aHits.length > 1 || bHits.length > 1) {
+        console.log(
+          `From candidates: ${aHits.slice(0, 5).map((h) => `${h.name} (${h.file})`).join(" | ")}`
+        );
+        console.log(
+          `To candidates: ${bHits.slice(0, 5).map((h) => `${h.name} (${h.file})`).join(" | ")}`
+        );
+      }
+      return;
+    }
+    if (hops.length === 0) {
+      console.log(`"${a.name}" and "${b.name}" resolve to the same symbol.`);
+      return;
+    }
+    console.log(`Path found (${hops.length} hop${hops.length === 1 ? "" : "s"}):`);
+    hops.forEach((h, i) => {
+      console.log(`[${i + 1}] ${h.from.name} (${h.from.type}, ${h.from.file})`);
+      console.log(`     \u2514\u2500(${h.rel})\u2500> ${h.to.name} (${h.to.type}, ${h.to.file})`);
+    });
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/export.ts
+import fs18 from "fs";
+import path18 from "path";
+var FORMATS = ["mermaid", "graphml", "dot", "json"];
+var EXT = {
+  mermaid: "mmd",
+  graphml: "graphml",
+  dot: "dot",
+  json: "json"
+};
+function cmdExport(repoRoot2, format, out) {
+  const fmt = format.toLowerCase();
+  if (!FORMATS.includes(fmt)) {
+    console.log(`Unknown format "${format}". Choose: ${FORMATS.join(", ")}.`);
+    return;
+  }
+  const db = openDb(repoRoot2);
+  try {
+    logInvocation(db, "export");
+    const text = exportGraph(db, fmt);
+    const dest = out ?? path18.join(dataDir(repoRoot2), `graph.${EXT[fmt]}`);
+    fs18.mkdirSync(path18.dirname(dest), { recursive: true });
+    fs18.writeFileSync(dest, text);
+    console.log(`Exported ${fmt} \u2192 ${dest}`);
+  } finally {
+    db.close();
+  }
+}
+
 // src/commands/read.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs19 from "fs";
+import path19 from "path";
 function cmdRead(repoRoot2, kind, name) {
   if (kind !== "symbol") {
     console.log(`Unknown read kind "${kind}". Usage: scopecairn read symbol <nama>`);
@@ -2351,10 +4262,10 @@ function cmdRead(repoRoot2, kind, name) {
       return;
     }
     const row = db.prepare(`SELECT start_line, end_line FROM symbols WHERE id = ?`).get(node.id);
-    const abs = path12.join(repoRoot2, node.file);
+    const abs = path19.join(repoRoot2, node.file);
     let lines;
     try {
-      lines = fs12.readFileSync(abs, "utf8").split("\n");
+      lines = fs19.readFileSync(abs, "utf8").split("\n");
     } catch {
       console.log(`Cannot read ${node.file}.`);
       return;
@@ -2464,29 +4375,36 @@ function retrieve(db, repoRoot2, task, opts) {
     proximity.set(s.symbolId, Math.max(proximity.get(s.symbolId) ?? 0, s.bm25));
     visited.add(s.symbolId);
   });
-  const edgeStmt = db.prepare(
-    `SELECT source_id, target_id, weight FROM relationships`
-  );
-  const adj = /* @__PURE__ */ new Map();
-  for (const r of edgeStmt.all()) {
-    if (!adj.has(r.source_id)) adj.set(r.source_id, []);
-    adj.get(r.source_id).push({ to: r.target_id, w: r.weight });
-    if (!adj.has(r.target_id)) adj.set(r.target_id, []);
-    adj.get(r.target_id).push({ to: r.source_id, w: r.weight * 0.8 });
+  const CHUNK = 2e3;
+  function neighborsOf(ids) {
+    const out = [];
+    for (let i = 0; i < ids.length; i += CHUNK) {
+      const c = ids.slice(i, i + CHUNK);
+      const ph = c.map(() => "?").join(",");
+      for (const r of db.prepare(
+        `SELECT source_id AS f, target_id AS t, weight AS w FROM relationships WHERE source_id IN (${ph})`
+      ).all(...c)) {
+        out.push({ from: r.f, to: r.t, w: r.w });
+      }
+      for (const r of db.prepare(
+        `SELECT target_id AS f, source_id AS t, weight * 0.8 AS w FROM relationships WHERE target_id IN (${ph})`
+      ).all(...c)) {
+        out.push({ from: r.f, to: r.t, w: r.w });
+      }
+    }
+    return out;
   }
   let hopScore = 1;
   for (let depth = 1; depth <= config.maxDepth; depth++) {
     hopScore *= config.decayPerHop;
     const next = [];
-    for (const id of frontier) {
-      const base = proximity.get(id) ?? 0;
-      for (const e of adj.get(id) ?? []) {
-        const cand = base * e.w * hopScore;
-        if (cand > (proximity.get(e.to) ?? 0)) proximity.set(e.to, cand);
-        if (!visited.has(e.to)) {
-          visited.add(e.to);
-          next.push(e.to);
-        }
+    for (const e of neighborsOf(frontier)) {
+      const base = proximity.get(e.from) ?? 0;
+      const cand = base * e.w * hopScore;
+      if (cand > (proximity.get(e.to) ?? 0)) proximity.set(e.to, cand);
+      if (!visited.has(e.to)) {
+        visited.add(e.to);
+        next.push(e.to);
       }
     }
     frontier = next;
@@ -2568,14 +4486,14 @@ function retrieve(db, repoRoot2, task, opts) {
 
 // src/retrieval/classify.ts
 var FANIN_THRESHOLD = 5;
-function moduleOf(file) {
+function moduleOf2(file) {
   const i = file.indexOf("/");
   return i === -1 ? "." : file.slice(0, i);
 }
 function classify(ranked, faninOf, threshold = 0.15) {
   const relevant = ranked.filter((r) => r.score >= threshold);
   const files = [...new Set(relevant.map((r) => r.file))];
-  const modules = [...new Set(files.map(moduleOf))];
+  const modules = [...new Set(files.map(moduleOf2))];
   const reasons = [];
   const DEFINITIONAL = /* @__PURE__ */ new Set([
     "function",
@@ -2745,6 +4663,36 @@ Task sederhana. Gunakan pencarian langsung. Kandidat: ${cand}
   }
   const tests = [...testSet].slice(0, 10);
   const symLine = (r) => `- ${r.name} (${r.type}) \u2014 \`${r.file}\` [${r.score.toFixed(2)} ${r.reason}]`;
+  let hotspots = [];
+  let cycleWarn = "";
+  try {
+    const ids = ranked.slice(0, 20).map((r) => r.id);
+    if (ids.length > 0) {
+      const ph = ids.map(() => "?").join(",");
+      const prRows = db.prepare(`SELECT node_id AS id, pagerank AS pr FROM node_metrics WHERE node_id IN (${ph})`).all(...ids);
+      const pr = new Map(prRows.map((r) => [r.id, r.pr]));
+      const boosted = ranked.slice(0, 20).map((r) => ({ r, boost: r.score + (pr.get(r.id) ?? 0) * 2 })).sort((a, b) => b.boost - a.boost).slice(0, 5);
+      hotspots = boosted.map(
+        (b) => `- ${b.r.name} (${b.r.type}) \u2014 \`${b.r.file}\` [pr=${(pr.get(b.r.id) ?? 0).toFixed(4)}]`
+      );
+      const cycRows = db.prepare(`SELECT nodes_json AS js FROM cycles`).all();
+      const inCycle = /* @__PURE__ */ new Set();
+      for (const c of cycRows) {
+        try {
+          for (const n of JSON.parse(c.js)) inCycle.add(n);
+        } catch {
+        }
+      }
+      const trapped = ranked.slice(0, 10).filter((r) => inCycle.has(r.id));
+      if (trapped.length > 0) {
+        cycleWarn = `
+## Circular dependency warning
+` + trapped.slice(0, 5).map((r) => `- ${r.name} (\`${r.file}\`) is inside a dependency cycle`).join("\n") + `
+`;
+      }
+    }
+  } catch {
+  }
   const scope = computeScope(
     highFiles,
     medFiles,
@@ -2768,20 +4716,23 @@ ${medFiles.map((f) => `- ${f}`).join("\n") || "-"}
 ## Key Symbols
 ${hi.slice(0, 8).map(symLine).join("\n") || "-"}
 
-## Dependencies
+` + (hotspots.length > 0 ? `## Critical hotspots (PageRank)
+${hotspots.join("\n")}
+
+` : ``) + `## Dependencies
 ${deps.map((d) => `- ${d}`).join("\n") || "-"}
 
 ## Related Tests
 ${tests.map((t) => `- ${t}`).join("\n") || "-"}
 
-` + scopeBlock(scope) + `
+` + cycleWarn + scopeBlock(scope) + `
 ` + guardBlock();
   return { markdown: md, high: highFiles, medium: medFiles, tests, dependencies: deps };
 }
 
 // src/commands/orientasi.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs20 from "fs";
+import path20 from "path";
 function isPathLike(task) {
   const t = task.trim().replace(/^["']|["']$/g, "");
   return t === "." || t === "./" || t === "/" || t.startsWith("./") || t.startsWith("../") || t.startsWith("/") || t.startsWith("~");
@@ -2791,7 +4742,7 @@ function looksLikeRepoPath(db, repoRoot2, task) {
   if (/\s/.test(t)) return false;
   if (isPathLike(task)) return true;
   try {
-    fs13.statSync(path13.resolve(repoRoot2, t));
+    fs20.statSync(path20.resolve(repoRoot2, t));
     return true;
   } catch {
   }
@@ -2827,11 +4778,11 @@ function cmdOrientasi(repoRoot2, task) {
     const byLang = db.prepare(`SELECT language, COUNT(*) AS n FROM files GROUP BY language ORDER BY n DESC`).all();
     const symbols = db.prepare(`SELECT COUNT(*) AS n FROM symbols`).get().n;
     const t = task.trim().replace(/^["']|["']$/g, "");
-    const abs = path13.resolve(repoRoot2, t);
+    const abs = path20.resolve(repoRoot2, t);
     let rel = null;
     try {
-      const stat = fs13.statSync(abs);
-      if (stat.isFile()) rel = path13.relative(repoRoot2, abs).split(path13.sep).join("/");
+      const stat = fs20.statSync(abs);
+      if (stat.isFile()) rel = path20.relative(repoRoot2, abs).split(path20.sep).join("/");
     } catch {
       rel = null;
     }
@@ -2889,6 +4840,46 @@ Mulai dari simbol di atas, atau jalankan \`scopecairn context "<deskripsi task>"
   }
 }
 
+// src/decisions.ts
+import fs21 from "fs";
+import path21 from "path";
+function decisionsPath(repoRoot2) {
+  return path21.join(dataDir(repoRoot2), "decisions.md");
+}
+function loadDecisions(repoRoot2) {
+  try {
+    return fs21.readFileSync(decisionsPath(repoRoot2), "utf8");
+  } catch {
+    return null;
+  }
+}
+
+// src/retrieval/gitChanged.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function changedFilesVsHead(repoRoot2) {
+  let out;
+  try {
+    out = execFileSync2("git", ["status", "--porcelain"], {
+      cwd: repoRoot2,
+      encoding: "utf8",
+      timeout: 8e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const line of out.split("\n")) {
+    if (line.length < 4) continue;
+    let p = line.slice(3).trim();
+    const arrow = p.indexOf(" -> ");
+    if (arrow >= 0) p = p.slice(arrow + 4);
+    if (p.startsWith('"') && p.endsWith('"')) p = p.slice(1, -1);
+    if (p) files.push(p);
+  }
+  return files;
+}
+
 // src/commands/context.ts
 function cmdContext(repoRoot2, task, opts = {}) {
   if (!opts.noRefresh) {
@@ -2943,11 +4934,37 @@ Task sederhana. Gunakan pencarian langsung. Bila istilah domain tak cocok dengan
       insCtx.run(taskId, r.id, r.score, r.reason);
     }
     logInvocation(db, "context", taskId);
+    const mode = opts.mode ?? "NORMAL";
+    const effectiveMode = mode === "NORMAL" && cls.complexity === "SIMPLE" && cls.estimatedFiles <= 1 ? "FAST" : mode;
+    const escalate = opts.escalate === true || effectiveMode === "SAFE" || effectiveMode === "AUDIT" || mode === "SAFE" || mode === "AUDIT";
+    const changed = changedFilesVsHead(repoRoot2);
+    if (changed.length > 0) {
+      console.log(
+        `> Working tree: ${changed.length} file berubah vs HEAD (${changed.slice(0, 5).join(", ")}${changed.length > 5 ? ", ..." : ""}).
+`
+      );
+    }
+    const decisions = loadDecisions(repoRoot2);
     const built = buildContext(db, task, result, cls, {
-      escalate: opts.escalate,
+      escalate,
       repoRoot: repoRoot2
     });
-    console.log(built.markdown);
+    let out = built.markdown;
+    if (effectiveMode !== "NORMAL") {
+      out += `
+
+## Mode
+${effectiveMode}
+`;
+    }
+    if (decisions) {
+      out += `
+
+## Keputusan Arsitektur (.scopecairn/decisions.md)
+${decisions}
+`;
+    }
+    console.log(out);
   } finally {
     db.close();
   }
@@ -3081,14 +5098,14 @@ function cmdImpact(repoRoot2, target, opts = {}) {
 }
 
 // src/commands/init.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs23 from "fs";
+import path23 from "path";
 
 // src/integrate/install.ts
-import fs14 from "fs";
-import path14 from "path";
+import fs22 from "fs";
+import path22 from "path";
 function installTarget(repoRoot2, target, prefix) {
-  const abs = path14.join(repoRoot2, target.rel);
+  const abs = path22.join(repoRoot2, target.rel);
   const block = target.render(prefix);
   const finish = (how) => ({
     agent: target.id,
@@ -3096,25 +5113,25 @@ function installTarget(repoRoot2, target, prefix) {
     how
   });
   if (target.mode === "new") {
-    const existed = fs14.existsSync(abs);
-    fs14.mkdirSync(path14.dirname(abs), { recursive: true });
-    fs14.writeFileSync(abs, block.endsWith("\n") ? block : block + "\n");
+    const existed = fs22.existsSync(abs);
+    fs22.mkdirSync(path22.dirname(abs), { recursive: true });
+    fs22.writeFileSync(abs, block.endsWith("\n") ? block : block + "\n");
     return finish(existed ? "updated" : "generated");
   }
-  if (fs14.existsSync(abs)) {
-    const cur = fs14.readFileSync(abs, "utf8");
+  if (fs22.existsSync(abs)) {
+    const cur = fs22.readFileSync(abs, "utf8");
     if (cur.includes(MARKER)) {
       const { next: next2 } = removeManagedBlock(cur, (p) => target.render(p));
-      fs14.writeFileSync(abs, (next2 + "\n\n" + block).trimEnd() + "\n");
+      fs22.writeFileSync(abs, (next2 + "\n\n" + block).trimEnd() + "\n");
       return finish("updated");
     }
     const { next, changed } = removeManagedBlock(cur, (p) => target.render(p));
     const base = changed ? next : cur;
-    fs14.writeFileSync(abs, (base.trimEnd() + "\n\n" + block).trimEnd() + "\n");
+    fs22.writeFileSync(abs, (base.trimEnd() + "\n\n" + block).trimEnd() + "\n");
     return finish("extended");
   }
-  fs14.mkdirSync(path14.dirname(abs), { recursive: true });
-  fs14.writeFileSync(abs, block.endsWith("\n") ? block : block + "\n");
+  fs22.mkdirSync(path22.dirname(abs), { recursive: true });
+  fs22.writeFileSync(abs, block.endsWith("\n") ? block : block + "\n");
   return finish("generated");
 }
 function removeManagedBlock(content, render) {
@@ -3142,19 +5159,19 @@ function foldBlank(s) {
   return s.replace(/\n{3,}/g, "\n\n").trim();
 }
 function uninstallTarget(repoRoot2, target) {
-  const abs = path14.join(repoRoot2, target.rel);
+  const abs = path22.join(repoRoot2, target.rel);
   const finish = (how) => ({
     agent: target.id,
     rel: target.rel,
     how
   });
-  if (!fs14.existsSync(abs)) return finish("absent");
+  if (!fs22.existsSync(abs)) return finish("absent");
   if (target.mode === "new") {
-    fs14.rmSync(abs, { force: true });
-    pruneEmptyDirs(path14.dirname(abs), repoRoot2);
+    fs22.rmSync(abs, { force: true });
+    pruneEmptyDirs(path22.dirname(abs), repoRoot2);
     return finish("removed");
   }
-  const cur = fs14.readFileSync(abs, "utf8");
+  const cur = fs22.readFileSync(abs, "utf8");
   if (!cur.includes(MARKER)) return finish("skipped");
   const render = (p) => {
     const t = resolveAgent(target.id);
@@ -3163,52 +5180,52 @@ function uninstallTarget(repoRoot2, target) {
   const { next, changed } = removeManagedBlock(cur, render);
   if (!changed) return finish("skipped");
   if (!next) {
-    fs14.rmSync(abs, { force: true });
+    fs22.rmSync(abs, { force: true });
     return finish("removed");
   }
-  fs14.writeFileSync(abs, next + "\n");
+  fs22.writeFileSync(abs, next + "\n");
   return finish("removed");
 }
 function pruneEmptyDirs(dir, stop) {
   let cur = dir;
   while (cur.startsWith(stop) && cur !== stop) {
     try {
-      fs14.rmdirSync(cur);
+      fs22.rmdirSync(cur);
     } catch {
       return;
     }
-    cur = path14.dirname(cur);
+    cur = path22.dirname(cur);
   }
 }
 function installAntigravity(repoRoot2, prefix = detectPrefix(repoRoot2)) {
   const agentDir = detectAgentDir(repoRoot2);
   const out = [];
-  const skillPath = path14.join(repoRoot2, agentDir, "skills", "scopecairn", "SKILL.md");
-  fs14.mkdirSync(path14.dirname(skillPath), { recursive: true });
-  fs14.writeFileSync(skillPath, skillMd(prefix));
-  out.push(`Skill installed (${path14.relative(repoRoot2, skillPath)})`);
-  const wfPath = path14.join(repoRoot2, "workflows", "scopecairn.md");
-  fs14.mkdirSync(path14.dirname(wfPath), { recursive: true });
-  fs14.writeFileSync(wfPath, workflowMd(prefix));
-  out.push(`Workflow installed (${path14.relative(repoRoot2, wfPath)})`);
+  const skillPath = path22.join(repoRoot2, agentDir, "skills", "scopecairn", "SKILL.md");
+  fs22.mkdirSync(path22.dirname(skillPath), { recursive: true });
+  fs22.writeFileSync(skillPath, skillMd(prefix));
+  out.push(`Skill installed (${path22.relative(repoRoot2, skillPath)})`);
+  const wfPath = path22.join(repoRoot2, "workflows", "scopecairn.md");
+  fs22.mkdirSync(path22.dirname(wfPath), { recursive: true });
+  fs22.writeFileSync(wfPath, workflowMd(prefix));
+  out.push(`Workflow installed (${path22.relative(repoRoot2, wfPath)})`);
   return out;
 }
 function uninstallAntigravity(repoRoot2) {
   const out = [];
   for (const dir of [".agents", ".agent"]) {
-    const p = path14.join(repoRoot2, dir, "skills", "scopecairn", "SKILL.md");
-    if (fs14.existsSync(p)) {
-      fs14.rmSync(p, { force: true });
-      pruneEmptyDirs(path14.dirname(p), repoRoot2);
-      out.push(`Skill removed (${path14.relative(repoRoot2, p)})`);
+    const p = path22.join(repoRoot2, dir, "skills", "scopecairn", "SKILL.md");
+    if (fs22.existsSync(p)) {
+      fs22.rmSync(p, { force: true });
+      pruneEmptyDirs(path22.dirname(p), repoRoot2);
+      out.push(`Skill removed (${path22.relative(repoRoot2, p)})`);
     }
   }
-  const wf = path14.join(repoRoot2, "workflows", "scopecairn.md");
-  if (fs14.existsSync(wf)) {
-    const text = fs14.readFileSync(wf, "utf8");
+  const wf = path22.join(repoRoot2, "workflows", "scopecairn.md");
+  if (fs22.existsSync(wf)) {
+    const text = fs22.readFileSync(wf, "utf8");
     if (text.includes("scopecairn")) {
-      fs14.rmSync(wf, { force: true });
-      out.push(`Workflow removed (${path14.relative(repoRoot2, wf)})`);
+      fs22.rmSync(wf, { force: true });
+      out.push(`Workflow removed (${path22.relative(repoRoot2, wf)})`);
     } else {
       out.push(`Workflow skipped (bukan milik ScopeCairn)`);
     }
@@ -3256,22 +5273,21 @@ function withCore(ids) {
       console.log(`! Unknown agent "${id}" (pilihan: ${AGENT_MATRIX.map((x) => x.id).join(", ")}, all)`);
       continue;
     }
-    out.push(t);
+    if (!out.includes(t)) out.push(t);
   }
-  if (!out.includes(AGENT_MATRIX[0])) out.unshift(AGENT_MATRIX[0]);
   return out;
 }
 function withDetected(repoRoot2) {
-  const targets = [AGENT_MATRIX[0]];
-  for (const t of AGENT_MATRIX.slice(1)) {
-    if (fs15.existsSync(path15.join(repoRoot2, t.presentMarker))) targets.push(t);
+  const targets = [];
+  for (const t of AGENT_MATRIX) {
+    if (fs23.existsSync(path23.join(repoRoot2, t.presentMarker))) targets.push(t);
   }
   return targets;
 }
 
 // src/benchmark/run.ts
-import fs16 from "fs";
-import path16 from "path";
+import fs24 from "fs";
+import path24 from "path";
 
 // src/benchmark/dataset.ts
 var BENCHMARK_TASKS = [
@@ -3328,7 +5344,7 @@ var BENCHMARK_TASKS = [
 // src/benchmark/run.ts
 function fileChars(repoRoot2, rel) {
   try {
-    return fs16.readFileSync(path16.join(repoRoot2, rel), "utf8").length;
+    return fs24.readFileSync(path24.join(repoRoot2, rel), "utf8").length;
   } catch {
     return 0;
   }
@@ -3477,6 +5493,126 @@ function cmdBenchmark(repoRoot2, opts = {}) {
   }
 }
 
+// src/commands/dashboard.ts
+import fs25 from "fs";
+import path25 from "path";
+function cmdDashboard(repoRoot2, opts) {
+  const db = openDb(repoRoot2);
+  try {
+    const files = db.prepare(`SELECT COUNT(*) AS n FROM files`).get().n;
+    const symbols = db.prepare(`SELECT COUNT(*) AS n FROM symbols`).get().n;
+    const rels = db.prepare(`SELECT COUNT(*) AS n FROM relationships`).get().n;
+    const top = db.prepare(
+      `SELECT s.name AS name, COUNT(r.target_id) AS n
+         FROM relationships r JOIN symbols s ON s.id = r.target_id
+         GROUP BY r.target_id ORDER BY n DESC LIMIT 20`
+    ).all();
+    let adapters = [];
+    try {
+      const paths = db.prepare(`SELECT path FROM files`).all().map((r) => r.path);
+      adapters = detectAdapters(paths, repoRoot2).map((a) => a.id);
+    } catch {
+    }
+    let tasks = [];
+    try {
+      tasks = db.prepare(
+        `SELECT description, complexity, created_at, completed_at FROM tasks ORDER BY id DESC LIMIT 20`
+      ).all();
+    } catch {
+    }
+    const esc2 = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+    const topRows = top.map((t) => `<tr><td>${esc2(t.name)}</td><td>${t.n}</td></tr>`).join("\n") || `<tr><td colspan="2">-</td></tr>`;
+    const adapterList = adapters.length > 0 ? adapters.map(esc2).join(", ") : "-";
+    const taskRows = tasks.map(
+      (t) => `<tr><td>${esc2(t.description)}</td><td>${esc2(t.complexity)}</td><td>${esc2(t.created_at)}</td><td>${t.completed_at ? esc2(t.completed_at) : "-"}</td></tr>`
+    ).join("\n") || `<tr><td colspan="4">-</td></tr>`;
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>ScopeCairn Dashboard</title>
+<style>
+  body { font-family: system-ui, sans-serif; margin: 2rem; max-width: 900px; color: #222; }
+  h1 { font-size: 1.5rem; }
+  h2 { font-size: 1.1rem; margin-top: 2rem; }
+  .cards { display: flex; gap: 1rem; }
+  .card { border: 1px solid #ddd; border-radius: 8px; padding: 1rem 1.5rem; }
+  .card .n { font-size: 1.8rem; font-weight: 700; }
+  table { border-collapse: collapse; width: 100%; margin-top: 0.5rem; }
+  th, td { border: 1px solid #ddd; padding: 0.4rem 0.8rem; text-align: left; }
+  th { background: #f5f5f5; }
+  tr:nth-child(even) { background: #fafafa; }
+</style>
+</head>
+<body>
+<h1>ScopeCairn Dashboard</h1>
+<div class="cards">
+  <div class="card"><div class="n">${files}</div>files</div>
+  <div class="card"><div class="n">${symbols}</div>symbols</div>
+  <div class="card"><div class="n">${rels}</div>relationships</div>
+</div>
+<h2>Top Symbols by Fan-in</h2>
+<table><thead><tr><th>Symbol</th><th>Incoming</th></tr></thead><tbody>
+${topRows}
+</tbody></table>
+<h2>Detected Adapters</h2>
+<p>${adapterList}</p>
+<h2>Recent Tasks</h2>
+<table><thead><tr><th>Description</th><th>Complexity</th><th>Created</th><th>Completed</th></tr></thead><tbody>
+${taskRows}
+</tbody></table>
+</body>
+</html>
+`;
+    const dest = opts.out ?? path25.join(dataDir(repoRoot2), "dashboard.html");
+    fs25.mkdirSync(path25.dirname(dest), { recursive: true });
+    fs25.writeFileSync(dest, html, "utf8");
+    console.log(`Dashboard written \u2192 ${dest}`);
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/testselect.ts
+import fs26 from "fs";
+import path26 from "path";
+function isTestPath(p) {
+  return p.includes(".test.") || p.includes(".spec.") || p.includes("__tests__") || path26.basename(p).startsWith("test_");
+}
+function cmdTestSelect(repoRoot2, target) {
+  const db = openDb(repoRoot2);
+  try {
+    const rows = db.prepare(`SELECT path FROM files`).all();
+    const testPaths = rows.map((r) => r.path).filter(isTestPath);
+    const base = path26.basename(target);
+    const baseNoExt = base.replace(/\.[^./\\]+$/, "");
+    const needles = new Set([target, base, baseNoExt].filter((s) => s.length > 0));
+    const matches = [];
+    for (const rel of testPaths) {
+      let content;
+      try {
+        content = fs26.readFileSync(path26.join(repoRoot2, ...rel.split("/")), "utf8");
+      } catch {
+        continue;
+      }
+      for (const n of needles) {
+        if (content.includes(n)) {
+          matches.push(rel);
+          break;
+        }
+      }
+    }
+    if (matches.length === 0) {
+      console.log(`No tests reference "${target}".`);
+      return;
+    }
+    console.log(`Tests referencing "${target}":`);
+    for (const m of matches) console.log(`  ${m}`);
+  } finally {
+    db.close();
+  }
+}
+
 // src/commands/agents.ts
 function registerAgentCommands(program2, repoRoot2) {
   const list = program2.command("agents").description("List supported agent installers");
@@ -3499,8 +5635,13 @@ function registerAgentCommands(program2, repoRoot2) {
     const cmd = program2.command(t.id).description(`${t.label} integration`);
     cmd.command("install").description(`Write ${t.rel}`).action(() => {
       const root = repoRoot2();
-      const r = installTarget(root, t, detectPrefix(root));
+      const prefix = detectPrefix(root);
+      const r = installTarget(root, t, prefix);
       console.log(`\u2713 ${t.label}: ${r.rel} (${r.how})`);
+      if (t.id === "opencode") {
+        console.log("");
+        console.log(opencodePermissionGuide(prefix));
+      }
     });
     cmd.command("uninstall").description(`Remove ScopeCairn block from ${t.rel}`).action(() => {
       const r = uninstallTarget(repoRoot2(), t);
@@ -3512,7 +5653,7 @@ function registerAgentCommands(program2, repoRoot2) {
 // package.json
 var package_default = {
   name: "scopecairn",
-  version: "0.3.0",
+  version: "0.6.0",
   description: "ScopeCairn \u2014 Codebase Intelligence & Agent Optimization Layer (local-first)",
   license: "MIT",
   type: "module",
@@ -3545,6 +5686,7 @@ var package_default = {
     doctor: "tsx src/cli.ts doctor",
     clean: "tsx src/cli.ts clean",
     rebuild: "tsx src/cli.ts rebuild",
+    test: "tsx --test tests/*.test.ts",
     typecheck: "tsc --noEmit"
   },
   dependencies: {
@@ -3572,6 +5714,8 @@ Examples:
   $ scopecairn context ./                 repository orientation map
   $ scopecairn impact src/auth/login.ts   change impact analysis
   $ scopecairn read symbol approveRequest  symbol-level source excerpt
+  $ scopecairn path handleLogin dbQuery    shortest call path between symbols
+  $ scopecairn export --format mermaid     export graph (mermaid|graphml|dot|json)
   $ scopecairn doctor                     health + integration check
 
 Agent commands (context, impact, read, graph, status, doctor) are
@@ -3579,27 +5723,36 @@ read-only toward source and only write to .scopecairn/ \u2014 safe to allowlist.
 `
 );
 function repoRoot() {
-  return path17.resolve(process.cwd());
+  return path27.resolve(process.cwd());
 }
 function resolveRoot(given) {
   if (!given) return repoRoot();
-  return path17.resolve(process.cwd(), given);
+  return path27.resolve(process.cwd(), given);
 }
 program.command("scan").description("Index repository (files + symbols + relations)").action(() => cmdScan(repoRoot()));
 program.command("status").description("Show index status").action(() => cmdStatus(repoRoot()));
 program.command("rebuild").description("Rebuild index from scratch (recover from corrupt index)").action(() => cmdRebuild(repoRoot()));
-program.command("doctor").description("Check integration health").action(async () => {
-  await cmdDoctor(repoRoot());
+program.command("doctor").description("Check integration health").option("--verbose", "print adapter/graph errors to stderr as well").action(async (opts) => {
+  await cmdDoctor(repoRoot(), { verbose: opts.verbose });
+});
+program.command("clean").description("Remove local index (.scopecairn) \u2014 forces full rescan").action(() => {
+  const dir = path27.join(repoRoot(), ".scopecairn");
+  fs27.rmSync(dir, { recursive: true, force: true });
+  console.log("Removed .scopecairn/. Run `scopecairn scan` to rebuild.");
 });
+program.command("dashboard").description("Generate a local HTML dashboard into .scopecairn/dashboard.html").option("--out <path>", "output file (default .scopecairn/dashboard.html)").action((opts) => cmdDashboard(repoRoot(), opts));
+program.command("test-select <target>").description("List test files affected by a change target (file/symbol)").action((target) => cmdTestSelect(repoRoot(), target));
 program.command("graph <symbol>").description("Show relations of a symbol").action((symbol) => cmdGraph(repoRoot(), symbol));
+program.command("path <from> <to>").description("Show shortest call/dependency path between two symbols").action((from, to) => cmdPath(repoRoot(), from, to));
+program.command("export").description("Export codebase graph (mermaid|graphml|dot|json)").option("--format <fmt>", "export format", "mermaid").option("--out <path>", "output file (default .scopecairn/graph.<ext>)").action((opts) => cmdExport(repoRoot(), opts.format, opts.out));
 program.command("read").argument("<kind>", "what to read (symbol)").argument("<name>", "symbol name").description("Read a symbol's source excerpt (not the whole file)").action((kind, name) => cmdRead(repoRoot(), kind, name));
-program.command("context <task>").description("Main entry point: auto-refresh + classify + relevant context + scope").option("--escalate", "force full COMPLEX context").option("--no-refresh", "skip incremental refresh (debugging/benchmark)").action(
+program.command("context <task>").description("Main entry point: auto-refresh + classify + relevant context + scope").option("--escalate", "force full COMPLEX context").option("--no-refresh", "skip incremental refresh (debugging/benchmark)").option("--mode <mode>", "agent mode: NORMAL|FAST|SAFE|AUDIT", "NORMAL").action(
   (task, opts) => cmdContext(repoRoot(), task, opts)
 );
 program.command("impact <target>").description("Change impact analysis: file, symbol, function, or class").option("--no-refresh", "skip incremental refresh (debugging/benchmark)").action(
   (target, opts) => cmdImpact(repoRoot(), target, opts)
 );
-program.command("init [path]").description("Initial indexing + generate AGENTS.md, Skill, Workflow, agent matrix").option("--agents <list>", "agent targets: comma list from agents,claude,gemini,cursor,windsurf,copilot,kiro, or 'all'").action(
+program.command("init [path]").description("Initial indexing + Skill, Workflow, agent skills (never touches AGENTS.md)").option("--agents <list>", "agent targets: comma list from claude,cursor,windsurf,copilot,kiro,opencode, or 'all'").action(
   (targetPath, opts) => cmdInit(resolveRoot(targetPath), opts)
 );
 program.command("benchmark").description("Retrieval recall, irrelevant ratio, context reduction + weight tuning").option("--tune", "grid search bobot FR-05").option("--no-refresh", "skip incremental refresh (debugging/benchmark)").action(