@titan-design/code-graph 0.11.0 → 0.13.0

package/dist/index.js

@@ -1,16 +1,78 @@
 import {
   aggregateChurnWindows,
   authorLinesByPath,
-  computeChangeCoupling,
   computeOwnership,
-  couplingFor,
   detectGitToplevel,
   entriesWithin,
+  listTreeBlobs,
   loadChurnEntries,
   loadFileFirstSeen,
+  readBlobs,
+  resolveCommit,
   runGit,
   summarizeOwnership
-} from "./chunk-PFI5XMUG.js";
+} from "./chunk-GX563F6R.js";
+import {
+  DEFAULT_HEALTH_WEIGHTS,
+  DEFAULT_MAX_PACKAGE_SIZE,
+  EXTERNAL_BUCKET,
+  SYMBOL_ID_SEP,
+  UNIMPORTED_ROLES,
+  aggregateEdges,
+  bucketFilesByPackage,
+  bucketViolations,
+  buildBlastRadius,
+  buildCentralFiles,
+  buildHotExports,
+  buildNodeMetrics,
+  buildReportContext,
+  busFactorOf,
+  classifyCoupling,
+  collectNodeMetrics,
+  collectSymbolUtil,
+  compilePatterns,
+  computeArch,
+  computeHealth,
+  computePageRank,
+  computePartitionQuality,
+  computeRecencyWindows,
+  computeReportDrift,
+  computeSymbolConsumers,
+  computeSymbolCoupling,
+  filteredFileIds,
+  getEdgeWeight,
+  groupTestsBySource,
+  hotspotScoreOf,
+  invertBuckets,
+  keepNode,
+  linkTestsToSources,
+  lookupMetric,
+  matchesAny,
+  packagesReferencedByEdges,
+  pairKey,
+  parseSymbolId,
+  patternToRegex,
+  publicApiFiles,
+  rebasedViolationKey,
+  referencedNodes,
+  round3,
+  symbolId,
+  testCoverageCountMetrics,
+  toSortedEdges,
+  topBusFactorRisks,
+  topCentralFiles,
+  topDeadModules,
+  topGrowthRisks,
+  topHotspots,
+  topTestCoverageRisks,
+  topUntestedRisks,
+  topUnusedExports,
+  violationKey,
+  windowSuffix
+} from "./chunk-L5KU543A.js";
+import {
+  computeChangeCoupling
+} from "./chunk-HIVVDGWE.js";
 
 // src/store.ts
 import { openDatabase, quoteIdent, runMigrations } from "@titan-design/store-sqlite";
@@ -231,8 +293,8 @@ function readMetricAggregates(stmts, snapshotId, name) {
 
 // src/store.ts
 var NODE_COLS = "id, kind, name, parent_id, language, role, attrs";
-function isStructuralLayer(edge) {
-  return edge.kind !== "references" && edge.kind !== "calls";
+function isStructuralLayer(edge2) {
+  return edge2.kind !== "references" && edge2.kind !== "calls";
 }
 var CodeGraphStore = class {
   constructor(db) {
@@ -252,6 +314,15 @@ var CodeGraphStore = class {
     });
     return Number(result.lastInsertRowid);
   }
+  /**
+   * Run `write` in one transaction so a reader on another connection sees a new
+   * snapshot only once every row written for it is committed, never a snapshot
+   * row whose nodes or edges are still being inserted. The per-table inserts
+   * nest as savepoints inside it.
+   */
+  atomically(write) {
+    return this.db.transaction(write)();
+  }
   insertNodes(snapshotId, nodes) {
     const stmt = this.statements.insertNode;
     this.db.transaction(() => {
@@ -491,30 +562,80 @@ function runPrune(store, options = {}) {
 }
 
 // src/indexer.ts
-import { realpathSync } from "fs";
-import * as path8 from "path";
+import { realpathSync as realpathSync2 } from "fs";
+import * as path10 from "path";
 import { parseFile } from "@titan-design/code-parser";
 
 // src/extractors/ts-morph-extractor.ts
 import {
-  Project,
+  Project as Project2,
   ScriptTarget,
   ModuleKind,
   ModuleResolutionKind
 } from "ts-morph";
 
+// src/index-source.ts
+import { existsSync, readFileSync } from "fs";
+import { Project } from "ts-morph";
+
+// src/file-walk.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { isExcludedDir, shouldIncludeFile } from "@titan-design/code-parser";
+async function walkSourceFiles(rootDirs, languages) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const rootDir of rootDirs) {
+    await collectFiles(rootDir, rootDir, languages, seen, out);
+  }
+  return out;
+}
+async function collectFiles(dir, rootDir, languages, seen, out) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (isExcludedDir(entry.name)) continue;
+      await collectFiles(full, rootDir, languages, seen, out);
+    } else if (entry.isFile() && !seen.has(full)) {
+      const relative5 = path.relative(rootDir, full);
+      if (shouldIncludeFile(relative5, [...languages])) {
+        seen.add(full);
+        out.push(full);
+      }
+    }
+  }
+}
+
+// src/index-source.ts
+var realFileSystem;
+function realFileSystemHost() {
+  realFileSystem ??= new Project().getFileSystem();
+  return realFileSystem;
+}
+function workingTreeSource() {
+  return {
+    listFiles: async (rootDirs, languages) => (await walkSourceFiles(rootDirs, languages)).sort(),
+    readFile: (abs) => readFileSync(abs, "utf-8"),
+    fileExists: existsSync,
+    get fileSystem() {
+      return realFileSystemHost();
+    }
+  };
+}
+
 // src/extractors/file-nodes.ts
-import * as path2 from "path";
+import * as path3 from "path";
 import { getLanguageFromPath } from "@titan-design/code-parser";
 
 // src/extractors/ids.ts
-import * as path from "path";
+import * as path2 from "path";
 var MODULE_EXT_RE = /\.(?:tsx|ts|jsx|js|mts|cts|mjs|cjs|py)$/;
 function toPosix(p) {
-  return p.split(path.sep).join("/");
+  return p.split(path2.sep).join("/");
 }
 function repoRelative(repoRoot, absPath) {
-  const rel = path.relative(repoRoot, absPath);
+  const rel = path2.relative(repoRoot, absPath);
   return toPosix(rel);
 }
 function fileId(repoRoot, absPath) {
@@ -532,15 +653,6 @@ function parentModuleId(id) {
 function packageId(name) {
   return name;
 }
-var SYMBOL_ID_SEP = "#";
-function symbolId(fileId2, qualifiedName) {
-  return `${fileId2}${SYMBOL_ID_SEP}${qualifiedName}`;
-}
-function parseSymbolId(id) {
-  const idx = id.indexOf(SYMBOL_ID_SEP);
-  if (idx < 0) return null;
-  return { fileId: id.slice(0, idx), name: id.slice(idx + 1) };
-}
 function externalId(specifier) {
   if (specifier.startsWith("node:")) {
     return specifier;
@@ -563,8 +675,8 @@ function buildFileModuleNodes(repoRoot, absPath) {
   const parentId = parentModuleId(mId) ?? void 0;
   const language = getLanguageFromPath(absPath) ?? "typescript";
   return [
-    { id: fId, kind: "file", name: path2.basename(fId), parentId: mId, language },
-    { id: mId, kind: "module", name: path2.basename(mId), parentId, language }
+    { id: fId, kind: "file", name: path3.basename(fId), parentId: mId, language },
+    { id: mId, kind: "module", name: path3.basename(mId), parentId, language }
   ];
 }
 
@@ -641,20 +753,29 @@ function isPropertyNamePosition(id) {
 }
 
 // src/scope-path.ts
-var TS_NAMED_SCOPES = /* @__PURE__ */ new Set([
+var TS_CLASS_TYPES = /* @__PURE__ */ new Set([
   "class_declaration",
   "abstract_class_declaration",
-  "class",
+  "class"
+]);
+var TS_FUNCTION_DECL_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
   "generator_function_declaration",
-  "method_definition",
+  "method_definition"
+]);
+var TS_BOUND_FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "arrow_function",
+  "function_expression",
+  "generator_function"
+]);
+var TS_NAMED_SCOPES = /* @__PURE__ */ new Set([
+  ...TS_CLASS_TYPES,
+  ...TS_FUNCTION_DECL_TYPES,
   "internal_module"
 ]);
 var TS_BOUND_SCOPES = /* @__PURE__ */ new Set([
   "class",
-  "arrow_function",
-  "function_expression",
-  "generator_function",
+  ...TS_BOUND_FUNCTION_TYPES,
   "object"
 ]);
 var PY_NAMED_SCOPES = /* @__PURE__ */ new Set(["function_definition", "class_definition"]);
@@ -701,9 +822,9 @@ function walkScopes(root, python, visit) {
 
 // src/declared-names.ts
 var TS_DECL_TYPES = /* @__PURE__ */ new Set([
-  "function_declaration",
-  "method_definition",
-  "class_declaration"
+  ...TS_FUNCTION_DECL_TYPES,
+  "class_declaration",
+  "abstract_class_declaration"
 ]);
 var PY_DECL_TYPES = /* @__PURE__ */ new Set(["function_definition", "class_definition"]);
 function collectDeclarations(file) {
@@ -738,7 +859,7 @@ function declaredNodeAt(node, declTypes) {
     const name = node.childForFieldName("name")?.text;
     return name ? { name, node } : null;
   }
-  if ((node.type === "arrow_function" || node.type === "function_expression") && node.parent?.type === "variable_declarator") {
+  if (TS_BOUND_FUNCTION_TYPES.has(node.type) && node.parent?.type === "variable_declarator") {
     const name = node.parent.childForFieldName("name")?.text;
     return name ? { name, node } : null;
   }
@@ -821,8 +942,59 @@ function hasReceiver(fn) {
 
 // src/extractors/symbol-signature.ts
 import {
-  Node as Node2
+  Node as Node3
 } from "ts-morph";
+
+// src/extractors/ts-scope.ts
+import { Node as Node2 } from "ts-morph";
+function bindingName2(node) {
+  const parent = node.getParent();
+  if (Node2.isVariableDeclaration(parent) || Node2.isPropertyDeclaration(parent)) return parent.getName();
+  if (Node2.isPropertyAssignment(parent)) return parent.getNameNode().getText();
+  if (Node2.isExportAssignment(parent)) return "default";
+  return null;
+}
+function declaredName(node) {
+  const name = node.getName();
+  if (name) return name;
+  return Node2.isExportable(node) && node.isDefaultExport() ? "default" : null;
+}
+function scopeSegment2(node) {
+  if (Node2.isClassDeclaration(node) || Node2.isFunctionDeclaration(node)) return declaredName(node);
+  if (Node2.isMethodDeclaration(node) || Node2.isGetAccessorDeclaration(node) || Node2.isSetAccessorDeclaration(node)) {
+    return node.getName();
+  }
+  if (Node2.isConstructorDeclaration(node)) return "constructor";
+  if (Node2.isModuleDeclaration(node)) return node.hasNamespaceKeyword() ? node.getName() : null;
+  if (Node2.isClassExpression(node) && node.getName()) return node.getName() ?? null;
+  const bound = Node2.isArrowFunction(node) || Node2.isFunctionExpression(node) || Node2.isClassExpression(node) || Node2.isObjectLiteralExpression(node);
+  return bound ? bindingName2(node) ?? ANONYMOUS_SCOPE : null;
+}
+function scopeOf(node) {
+  const segments = node.getAncestors().map(scopeSegment2).filter((s) => s !== null).reverse();
+  let scope = "";
+  for (const segment of segments) {
+    const repeatsAnonymous = segment === ANONYMOUS_SCOPE && (scope === ANONYMOUS_SCOPE || scope.endsWith(`.${ANONYMOUS_SCOPE}`));
+    if (!repeatsAnonymous) scope = qualify(scope, segment);
+  }
+  return scope;
+}
+function declarationQualifiedName(decl) {
+  if (Node2.isVariableDeclaration(decl)) {
+    const init = decl.getInitializer();
+    const callable = Node2.isArrowFunction(init) || Node2.isFunctionExpression(init);
+    return callable ? qualify(scopeOf(decl), decl.getName()) : null;
+  }
+  if (Node2.isArrowFunction(decl) || Node2.isFunctionExpression(decl)) {
+    const parent = decl.getParent();
+    return Node2.isVariableDeclaration(parent) ? qualify(scopeOf(parent), parent.getName()) : null;
+  }
+  const isDeclaration = Node2.isFunctionDeclaration(decl) || Node2.isClassDeclaration(decl) || Node2.isMethodDeclaration(decl) || Node2.isGetAccessorDeclaration(decl) || Node2.isSetAccessorDeclaration(decl) || Node2.isConstructorDeclaration(decl);
+  const own = isDeclaration ? scopeSegment2(decl) : null;
+  return own ? qualify(scopeOf(decl), own) : null;
+}
+
+// src/extractors/symbol-signature.ts
 var MAX_SIGNATURE = 200;
 var MAX_PURPOSE = 240;
 function declarationText(decl) {
@@ -833,31 +1005,72 @@ function declarationText(decl) {
   if (purpose) out.purpose = purpose;
   return out;
 }
+function createDeclarationLookup(sf) {
+  let qualified;
+  return (name) => {
+    const fileLevel = fileLevelDeclaration(sf, name);
+    if (fileLevel) return fileLevel;
+    qualified ??= qualifiedDeclarations(sf);
+    return qualified.get(name);
+  };
+}
 function lookupDeclaration(sf, name) {
+  return createDeclarationLookup(sf)(name);
+}
+function fileLevelDeclaration(sf, name) {
   return sf.getFunction(name) ?? sf.getClass(name) ?? sf.getInterface(name) ?? sf.getTypeAlias(name) ?? sf.getEnum(name) ?? sf.getVariableDeclaration(name);
 }
+function qualifiedDeclarations(sf) {
+  const byName = /* @__PURE__ */ new Map();
+  sf.forEachDescendant((node) => {
+    const name = declarationQualifiedName(node);
+    if (name === null) return;
+    const held = byName.get(name);
+    if (!held || outranks(node, held)) byName.set(name, node);
+  });
+  return byName;
+}
+function outranks(candidate, held) {
+  if (Node3.isOverloadable(held) && held.isOverload()) {
+    return !(Node3.isOverloadable(candidate) && candidate.isOverload());
+  }
+  return Node3.isGetAccessorDeclaration(candidate) && Node3.isSetAccessorDeclaration(held);
+}
 function signatureOf(decl) {
-  if (Node2.isFunctionDeclaration(decl) || Node2.isMethodDeclaration(decl)) {
+  if (Node3.isFunctionDeclaration(decl) || Node3.isMethodDeclaration(decl)) {
     return callableSignature(decl, decl.getName() ?? "");
   }
-  if (Node2.isVariableDeclaration(decl)) return variableSignature(decl);
-  if (Node2.isClassDeclaration(decl)) return clamp(`class ${decl.getName() ?? ""}`.trim());
-  if (Node2.isInterfaceDeclaration(decl)) return clamp(`interface ${decl.getName()}`);
-  if (Node2.isTypeAliasDeclaration(decl)) {
+  if (Node3.isGetAccessorDeclaration(decl) || Node3.isSetAccessorDeclaration(decl)) {
+    return accessorSignature(decl);
+  }
+  if (Node3.isVariableDeclaration(decl)) return variableSignature(decl);
+  if (Node3.isClassDeclaration(decl)) return clamp(`class ${decl.getName() ?? ""}`.trim());
+  if (Node3.isInterfaceDeclaration(decl)) return clamp(`interface ${decl.getName()}`);
+  if (Node3.isTypeAliasDeclaration(decl)) {
     return clamp(`type ${decl.getName()} = ${oneLine(decl.getTypeNode()?.getText() ?? "")}`);
   }
-  if (Node2.isEnumDeclaration(decl)) return clamp(`enum ${decl.getName()}`);
+  if (Node3.isEnumDeclaration(decl)) return clamp(`enum ${decl.getName()}`);
   return void 0;
 }
 function variableSignature(decl) {
   const init = decl.getInitializer();
-  if (init && (Node2.isArrowFunction(init) || Node2.isFunctionExpression(init))) {
+  if (init && (Node3.isArrowFunction(init) || Node3.isFunctionExpression(init))) {
     return callableSignature(init, decl.getName());
   }
   const typeNode = decl.getTypeNode();
   const type = typeNode ? oneLine(typeNode.getText()) : cleanType(() => decl.getType().getText());
   return type ? clamp(`${decl.getName()}: ${type}`) : void 0;
 }
+function accessorSignature(decl) {
+  const type = Node3.isGetAccessorDeclaration(decl) ? returnType(decl) : setterType(decl);
+  return clamp(type ? `${decl.getName()}: ${type}` : decl.getName());
+}
+function setterType(decl) {
+  const param = decl.getParameters()[0];
+  if (!param) return void 0;
+  const node = param.getTypeNode();
+  return node ? oneLine(node.getText()) : cleanType(() => param.getType().getText());
+}
 function callableSignature(decl, name) {
   const params = decl.getParameters().map((p) => oneLine(p.getText())).join(", ");
   const ret = returnType(decl);
@@ -885,8 +1098,8 @@ function purposeOf(decl) {
   return desc ? clamp(oneLine(desc), MAX_PURPOSE) : void 0;
 }
 function jsDocsFor(decl) {
-  if (Node2.isJSDocable(decl)) return decl.getJsDocs();
-  if (Node2.isVariableDeclaration(decl)) return decl.getVariableStatement()?.getJsDocs();
+  if (Node3.isJSDocable(decl)) return decl.getJsDocs();
+  if (Node3.isVariableDeclaration(decl)) return decl.getVariableStatement()?.getJsDocs();
   return void 0;
 }
 function oneLine(s) {
@@ -926,9 +1139,10 @@ function buildSymbolNodes(repoRoot, sourceFile, file) {
     exported.add(name);
     out.push(makeSymbolNode(fId, name, true, spans.get(name), declarationText(own), shapes.get(name)));
   }
+  const lookup = createDeclarationLookup(sourceFile);
   for (const [name, span] of spans) {
     if (exported.has(name)) continue;
-    const decl = lookupDeclaration(sourceFile, name);
+    const decl = lookup(name);
     out.push(makeSymbolNode(fId, name, false, span, decl ? declarationText(decl) : {}, shapes.get(name)));
   }
   return out;
@@ -936,7 +1150,7 @@ function buildSymbolNodes(repoRoot, sourceFile, file) {
 
 // src/extractors/dynamic-imports.ts
 import {
-  Node as Node3,
+  Node as Node4,
   SyntaxKind as SyntaxKind2
 } from "ts-morph";
 function dynamicImportSpecifiers(sourceFile) {
@@ -968,12 +1182,12 @@ function dynamicImportBindings(sourceFile) {
 function destructuredTargetOf(call) {
   const parent = call.getParent();
   if (!parent) return void 0;
-  const init = Node3.isAwaitExpression(parent) ? parent : call;
+  const init = Node4.isAwaitExpression(parent) ? parent : call;
   const decl = init.getParent();
-  if (!decl || !Node3.isVariableDeclaration(decl)) return void 0;
+  if (!decl || !Node4.isVariableDeclaration(decl)) return void 0;
   if (decl.getInitializer() !== init) return void 0;
   const nameNode = decl.getNameNode();
-  return Node3.isObjectBindingPattern(nameNode) ? nameNode : void 0;
+  return Node4.isObjectBindingPattern(nameNode) ? nameNode : void 0;
 }
 function destructuredNames(pattern) {
   const names = [];
@@ -1000,8 +1214,7 @@ function recordDynamicSymbolRefEdges(sourceFile, srcFileId, agg, resolveSpecifie
 }
 
 // src/extractors/module-resolution.ts
-import * as path3 from "path";
-import { existsSync } from "fs";
+import * as path4 from "path";
 var RESOLVABLE_EXTS = [
   ".ts",
   ".tsx",
@@ -1023,45 +1236,45 @@ function* relativeResolutionCandidates(base) {
     const stem = base.slice(0, base.length - jsExt[0].length);
     for (const ext of RESOLVABLE_EXTS) yield stem + ext;
   }
-  for (const ext of RESOLVABLE_EXTS) yield path3.join(base, "index" + ext);
+  for (const ext of RESOLVABLE_EXTS) yield path4.join(base, "index" + ext);
 }
-function resolveRelativeAbs(fs3, fromAbs, specifier) {
+function resolveRelativeAbs(fs2, fromAbs, specifier) {
   if (!isRelativeSpecifier(specifier)) return null;
-  const base = path3.resolve(path3.dirname(fromAbs), specifier);
+  const base = path4.resolve(path4.dirname(fromAbs), specifier);
   for (const candidate of relativeResolutionCandidates(base)) {
-    if (fs3.fileExistsSync(candidate)) return candidate;
+    if (fs2.fileExistsSync(candidate)) return candidate;
   }
   return null;
 }
 function inRepoFileId(repoRoot, abs) {
-  const relative4 = path3.relative(repoRoot, abs);
-  if (relative4.startsWith("..") || path3.isAbsolute(relative4)) return null;
-  if (relative4.split(path3.sep).includes("node_modules")) return null;
+  const relative5 = path4.relative(repoRoot, abs);
+  if (relative5.startsWith("..") || path4.isAbsolute(relative5)) return null;
+  if (relative5.split(path4.sep).includes("node_modules")) return null;
   return fileId(repoRoot, abs);
 }
-function remapDistToSrc(abs) {
+function remapDistToSrc(abs, fileExists) {
   const m = /^(.*)[\\/]dist[\\/](.+)\.d\.ts$/.exec(abs);
   if (!m) return abs;
   const base = m[1];
   const sub = m[2];
   for (const ext of [".ts", ".tsx"]) {
-    const candidate = path3.join(base, "src", sub + ext);
-    if (existsSync(candidate)) return candidate;
+    const candidate = path4.join(base, "src", sub + ext);
+    if (fileExists(candidate)) return candidate;
   }
   return abs;
 }
 function repoTypeRoots(repoRoot) {
   const roots = [];
-  for (let dir = path3.resolve(repoRoot); ; dir = path3.dirname(dir)) {
-    roots.push(path3.join(dir, "node_modules", "@types"));
-    if (path3.dirname(dir) === dir) return roots;
+  for (let dir = path4.resolve(repoRoot); ; dir = path4.dirname(dir)) {
+    roots.push(path4.join(dir, "node_modules", "@types"));
+    if (path4.dirname(dir) === dir) return roots;
   }
 }
 
 // src/extractors/reexport-resolve.ts
 function resolveReExportOrigin(ctx, importerAbs, specifier, name) {
-  const fs3 = ctx.project.getFileSystem();
-  const targetAbs = resolveRelativeAbs(fs3, importerAbs, specifier);
+  const fs2 = ctx.project.getFileSystem();
+  const targetAbs = resolveRelativeAbs(fs2, importerAbs, specifier);
   return targetAbs ? walkReExports(ctx, targetAbs, name, /* @__PURE__ */ new Set()) : null;
 }
 function walkReExports(ctx, fileAbs, name, visited) {
@@ -1073,13 +1286,13 @@ function walkReExports(ctx, fileAbs, name, visited) {
     const id = inRepoFileId(ctx.repoRoot, fileAbs);
     return id ? symbolId(id, name) : null;
   }
-  const fs3 = ctx.project.getFileSystem();
+  const fs2 = ctx.project.getFileSystem();
   for (const ed of sf.getExportDeclarations()) {
     const spec = ed.getModuleSpecifierValue();
     if (!spec) continue;
     const inward = reExportInwardName(ed, name);
     if (inward === null) continue;
-    const targetAbs = resolveRelativeAbs(fs3, fileAbs, spec);
+    const targetAbs = resolveRelativeAbs(fs2, fileAbs, spec);
     if (!targetAbs) continue;
     const origin = walkReExports(ctx, targetAbs, inward, visited);
     if (origin) return origin;
@@ -1105,57 +1318,6 @@ function reExportInwardName(ed, name) {
 
 // src/extractors/ts-calls.ts
 import { Node as Node5, SyntaxKind as SyntaxKind3 } from "ts-morph";
-
-// src/extractors/ts-scope.ts
-import { Node as Node4 } from "ts-morph";
-function bindingName2(node) {
-  const parent = node.getParent();
-  if (Node4.isVariableDeclaration(parent) || Node4.isPropertyDeclaration(parent)) return parent.getName();
-  if (Node4.isPropertyAssignment(parent)) return parent.getNameNode().getText();
-  if (Node4.isExportAssignment(parent)) return "default";
-  return null;
-}
-function declaredName(node) {
-  const name = node.getName();
-  if (name) return name;
-  return Node4.isExportable(node) && node.isDefaultExport() ? "default" : null;
-}
-function scopeSegment2(node) {
-  if (Node4.isClassDeclaration(node) || Node4.isFunctionDeclaration(node)) return declaredName(node);
-  if (Node4.isMethodDeclaration(node) || Node4.isGetAccessorDeclaration(node) || Node4.isSetAccessorDeclaration(node)) {
-    return node.getName();
-  }
-  if (Node4.isConstructorDeclaration(node)) return "constructor";
-  if (Node4.isModuleDeclaration(node)) return node.hasNamespaceKeyword() ? node.getName() : null;
-  if (Node4.isClassExpression(node) && node.getName()) return node.getName() ?? null;
-  const bound = Node4.isArrowFunction(node) || Node4.isFunctionExpression(node) || Node4.isClassExpression(node) || Node4.isObjectLiteralExpression(node);
-  return bound ? bindingName2(node) ?? ANONYMOUS_SCOPE : null;
-}
-function scopeOf(node) {
-  const segments = node.getAncestors().map(scopeSegment2).filter((s) => s !== null).reverse();
-  let scope = "";
-  for (const segment of segments) {
-    const repeatsAnonymous = segment === ANONYMOUS_SCOPE && (scope === ANONYMOUS_SCOPE || scope.endsWith(`.${ANONYMOUS_SCOPE}`));
-    if (!repeatsAnonymous) scope = qualify(scope, segment);
-  }
-  return scope;
-}
-function declarationQualifiedName(decl) {
-  if (Node4.isVariableDeclaration(decl)) {
-    const init = decl.getInitializer();
-    const callable = Node4.isArrowFunction(init) || Node4.isFunctionExpression(init);
-    return callable ? qualify(scopeOf(decl), decl.getName()) : null;
-  }
-  if (Node4.isArrowFunction(decl) || Node4.isFunctionExpression(decl)) {
-    const parent = decl.getParent();
-    return Node4.isVariableDeclaration(parent) ? qualify(scopeOf(parent), parent.getName()) : null;
-  }
-  const isDeclaration = Node4.isFunctionDeclaration(decl) || Node4.isClassDeclaration(decl) || Node4.isMethodDeclaration(decl) || Node4.isGetAccessorDeclaration(decl) || Node4.isSetAccessorDeclaration(decl) || Node4.isConstructorDeclaration(decl);
-  const own = isDeclaration ? scopeSegment2(decl) : null;
-  return own ? qualify(scopeOf(decl), own) : null;
-}
-
-// src/extractors/ts-calls.ts
 function collectTsCallEdges(sourceFile, ctx) {
   const agg = /* @__PURE__ */ new Map();
   sourceFile.forEachDescendant((node) => {
@@ -1181,7 +1343,7 @@ function resolveCallee(call, ctx) {
 }
 function declarationId(decl, ctx) {
   const sf = decl.getSourceFile();
-  const abs = remapDistToSrc(sf.getFilePath());
+  const abs = remapDistToSrc(sf.getFilePath(), ctx.fileExists);
   if (sf.isDeclarationFile() && abs === sf.getFilePath()) return null;
   const fileId2 = inRepoFileId(ctx.repoRoot, abs);
   const name = fileId2 ? declarationQualifiedName(decl) : null;
@@ -1230,12 +1392,15 @@ var TsMorphGraphExtractor = class {
   tsConfigPath;
   project;
   ownsProject;
+  source;
   retired = [];
+  fileExists = (abs) => this.source.fileExists(abs);
   constructor(options) {
     this.repoRoot = options.repoRoot;
     this.tsConfigPath = options.tsConfigPath;
     this.project = options.project;
     this.ownsProject = options.project === void 0;
+    this.source = options.source ?? workingTreeSource();
   }
   extract(file) {
     if (!isTypeScriptFile(file)) return [];
@@ -1259,13 +1424,16 @@ var TsMorphGraphExtractor = class {
     const calls = collectTsCallEdges(sourceFile, {
       repoRoot: this.repoRoot,
       srcFileId: fileId(this.repoRoot, sourceFile.getFilePath()),
-      localSymbols: new Set(symbolNodes2.map((n) => n.name))
+      localSymbols: new Set(symbolNodes2.map((n) => n.name)),
+      fileExists: this.fileExists
     });
     return [{ nodes: [...nodes, ...symbolNodes2, ...externalNodes], edges: [...edges, ...calls] }];
   }
   ensureProject() {
     if (this.project) return this.project;
-    this.project = this.tsConfigPath ? new Project({ tsConfigFilePath: this.tsConfigPath }) : new Project({
+    const fileSystem = this.source.fileSystem;
+    this.project = this.tsConfigPath ? new Project2({ tsConfigFilePath: this.tsConfigPath, fileSystem }) : new Project2({
+      fileSystem,
       compilerOptions: {
         allowJs: true,
         target: ScriptTarget.ESNext,
@@ -1366,7 +1534,7 @@ var TsMorphGraphExtractor = class {
     if (targetSf) {
       const decls = targetSf.getExportedDeclarations().get(importedName);
       const originSf = decls && decls.length > 0 ? decls[0].getSourceFile() : targetSf;
-      const originId = this.inRepoFileId(remapDistToSrc(originSf.getFilePath()));
+      const originId = this.inRepoFileId(remapDistToSrc(originSf.getFilePath(), this.fileExists));
       return originId ? symbolId(originId, importedName) : null;
     }
     return resolveReExportOrigin(
@@ -1405,7 +1573,7 @@ var TsMorphGraphExtractor = class {
   }
   resolveInternal(target) {
     if (!target) return null;
-    return this.inRepoFileId(remapDistToSrc(target.getFilePath()));
+    return this.inRepoFileId(remapDistToSrc(target.getFilePath(), this.fileExists));
   }
   /**
    * Resolve a relative specifier ts-morph failed to link by walking the
@@ -1433,14 +1601,13 @@ function isTypeScriptFile(file) {
 }
 
 // src/extractors/python-extractor.ts
-import * as path4 from "path";
-import { existsSync as existsSync2 } from "fs";
+import * as path5 from "path";
 
 // src/extractors/python-calls.ts
-function collectPythonCallEdges(file, fileId2, resolve4) {
+function collectPythonCallEdges(file, fileId2, resolve5) {
   const declarations = /* @__PURE__ */ new Map();
   forEachDeclaration(file, (_name, qualifiedName, node) => declarations.set(qualifiedName, node));
-  const ctx = { fileId: fileId2, declarations, imports: fromImports(file.tree.rootNode, resolve4) };
+  const ctx = { fileId: fileId2, declarations, imports: fromImports(file.tree.rootNode, resolve5) };
   const agg = /* @__PURE__ */ new Map();
   walkScopes(file.tree.rootNode, true, (node, scope) => {
     if (node.type !== "call") return;
@@ -1504,11 +1671,11 @@ function parameterNames(def) {
   }
   return out;
 }
-function fromImports(root, resolve4) {
+function fromImports(root, resolve5) {
   const out = /* @__PURE__ */ new Map();
   for (const stmt of root.descendantsOfType("import_from_statement")) {
     const moduleName = stmt?.childForFieldName("module_name")?.text;
-    const moduleFile = moduleName ? resolve4(moduleName) : null;
+    const moduleFile = moduleName ? resolve5(moduleName) : null;
     if (!stmt || !moduleFile) continue;
     for (const imported of stmt.childrenForFieldName("name")) {
       const alias = imported?.type === "aliased_import" ? imported.childForFieldName("alias")?.text : void 0;
@@ -1550,13 +1717,15 @@ function addKeyword(site, arg) {
 // src/extractors/python-extractor.ts
 function* candidates(base) {
   yield `${base}.py`;
-  yield path4.join(base, "__init__.py");
+  yield path5.join(base, "__init__.py");
 }
 var PythonGraphExtractor = class {
-  constructor(repoRoot) {
+  constructor(repoRoot, source = workingTreeSource()) {
     this.repoRoot = repoRoot;
+    this.source = source;
   }
   repoRoot;
+  source;
   name = "python-graph";
   extract(file) {
     if (file.language !== "python") return [];
@@ -1588,12 +1757,12 @@ var PythonGraphExtractor = class {
   resolveDotted(fromAbs, specifier) {
     const leadingDots = /^\.*/.exec(specifier)?.[0].length ?? 0;
     const parts = specifier.slice(leadingDots).split(".").filter(Boolean);
-    const relativeBase = path4.resolve(path4.dirname(fromAbs), "../".repeat(Math.max(leadingDots - 1, 0)));
-    const roots = leadingDots > 0 ? [relativeBase] : [path4.dirname(fromAbs), this.repoRoot];
+    const relativeBase = path5.resolve(path5.dirname(fromAbs), "../".repeat(Math.max(leadingDots - 1, 0)));
+    const roots = leadingDots > 0 ? [relativeBase] : [path5.dirname(fromAbs), this.repoRoot];
     for (const root of roots) {
-      for (const candidate of candidates(path4.join(root, ...parts))) {
+      for (const candidate of candidates(path5.join(root, ...parts))) {
         const id = inRepoFileId(this.repoRoot, candidate);
-        if (id !== null && existsSync2(candidate)) return id;
+        if (id !== null && this.source.fileExists(candidate)) return id;
       }
     }
     return null;
@@ -1637,9 +1806,10 @@ var LanguageExtractor = class {
   name = "language-graph";
   delegates;
   constructor(options) {
+    const { repoRoot, tsConfigPath, source } = options;
     this.delegates = [
-      new TsMorphGraphExtractor({ repoRoot: options.repoRoot, tsConfigPath: options.tsConfigPath }),
-      new PythonGraphExtractor(options.repoRoot)
+      new TsMorphGraphExtractor({ repoRoot, tsConfigPath, source }),
+      new PythonGraphExtractor(repoRoot, source)
     ];
   }
   extract(file) {
@@ -1648,7 +1818,7 @@ var LanguageExtractor = class {
 };
 
 // src/git-renames.ts
-import * as path5 from "path";
+import * as path6 from "path";
 function detectGitHead(repoRoot) {
   return runGit(repoRoot, ["rev-parse", "HEAD"]);
 }
@@ -1692,12 +1862,12 @@ function parseRenameOutput(text) {
   return out;
 }
 function classifyRename(oldPath, newPath) {
-  return path5.posix.dirname(oldPath) === path5.posix.dirname(newPath) ? "rename" : "move";
+  return path6.posix.dirname(oldPath) === path6.posix.dirname(newPath) ? "rename" : "move";
 }
 function renameToAliases(repoRoot, pair) {
   const reason = classifyRename(pair.oldPath, pair.newPath);
-  const oldAbs = path5.join(repoRoot, pair.oldPath);
-  const newAbs = path5.join(repoRoot, pair.newPath);
+  const oldAbs = path6.join(repoRoot, pair.oldPath);
+  const newAbs = path6.join(repoRoot, pair.newPath);
   return [
     { oldId: fileId(repoRoot, oldAbs), newId: fileId(repoRoot, newAbs), reason },
     { oldId: moduleId(repoRoot, oldAbs), newId: moduleId(repoRoot, newAbs), reason }
@@ -1790,8 +1960,8 @@ function walk(requestedId, maps) {
 }
 function chainSteps(input) {
   if (input.from === null) return { steps: rootPath(input.lineage, input.to, input.maxHops), connected: true };
-  const path11 = lineagePath(input.lineage, input.from, input.to, input.maxHops);
-  if (path11) return { steps: path11, connected: true };
+  const path14 = lineagePath(input.lineage, input.from, input.to, input.maxHops);
+  if (path14) return { steps: path14, connected: true };
   return { steps: [{ snapshotId: input.to, direction: "forward" }], connected: false };
 }
 function createAliasChain(input) {
@@ -1876,9 +2046,11 @@ function computeAliasBridge(store, input) {
   return { baseSnapshotId: base.id, aliases: [...fileAliases, ...symbols] };
 }
 
+// src/roles.ts
+import * as path8 from "path";
+
 // src/generated.ts
-import { readFileSync } from "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 var HEURISTIC_FILE_RE = /(?:^|\/)[^/]*\.(?:gen|generated)\.[^/]*$/;
 var HEURISTIC_DIR_RE = /(?:^|\/)generated\//;
 function isGeneratedByHeuristic(id) {
@@ -1888,59 +2060,112 @@ function isGeneratedFile(id, patterns) {
   for (const rx of patterns) if (rx.test(id)) return true;
   return isGeneratedByHeuristic(id);
 }
-function loadGeneratedPatterns(rootDir) {
+function loadGeneratedPatterns(rootDir, source = workingTreeSource()) {
   try {
-    const content = readFileSync(path6.join(rootDir, ".gitattributes"), "utf-8");
+    const content = source.readFile(path7.join(rootDir, ".gitattributes"));
     return parseGeneratedPatterns(content);
   } catch {
     return [];
   }
 }
 function parseGeneratedPatterns(content) {
+  const rules = parseGeneratedRules(content);
   const out = [];
+  rules.forEach((rule, i) => {
+    if (!rule.generated) return;
+    const optOuts = rules.slice(i + 1).filter((r) => !r.generated);
+    out.push(excluding(rule.rx, optOuts.map((r) => r.rx)));
+  });
+  return out;
+}
+function parseGeneratedRules(content) {
+  const rules = [];
   for (const raw of content.split("\n")) {
     const line = raw.trim();
     if (!line || line.startsWith("#")) continue;
     const parsed = /^("(?:[^"\\]|\\.)*"|\S+)\s*(.*)$/.exec(line);
     if (!parsed) continue;
-    const pattern = unquote(parsed[1]);
-    if (generatedAttr(parsed[2].split(/\s+/).filter(Boolean)) === true) {
-      out.push(gitattributesPatternToRegex(pattern));
-    }
+    const generated = generatedAttr(parsed[2].split(/\s+/).filter(Boolean));
+    if (generated === void 0) continue;
+    rules.push({ rx: gitattributesPatternToRegex(unquote(parsed[1])), generated });
   }
-  return out;
+  return rules;
+}
+function excluding(rx, optOuts) {
+  if (optOuts.length === 0) return rx;
+  const rejected = optOuts.map((o) => `(?:${o.source})`).join("|");
+  return new RegExp(`(?!${rejected})(?:${rx.source})`);
 }
 function generatedAttr(attrs) {
   let value;
   for (const a of attrs) {
     if (a === "linguist-generated" || a === "linguist-generated=true") value = true;
-    else if (a === "-linguist-generated" || a === "linguist-generated=false") value = false;
+    else if (OPT_OUT_TOKENS.has(a)) value = false;
   }
   return value;
 }
+var OPT_OUT_TOKENS = /* @__PURE__ */ new Set([
+  "-linguist-generated",
+  "linguist-generated=false",
+  "!linguist-generated"
+]);
 function unquote(token) {
   return token.startsWith('"') && token.endsWith('"') ? token.slice(1, -1).replace(/\\(.)/g, "$1") : token;
 }
+var NEVER_MATCHES = /(?!)/;
 function gitattributesPatternToRegex(pattern) {
   let p = pattern;
-  const isDir = p.endsWith("/");
-  if (isDir) p = p.slice(0, -1);
-  let body = "";
-  for (let i = 0; i < p.length; i++) {
-    const c = p[i];
-    if (c === "*" && p[i + 1] === "*") {
-      body += ".*";
-      i++;
-    } else if (c === "*") body += "[^/]*";
-    else if (c === "?") body += "[^/]";
-    else body += c.replace(/[.+(){}|^$\\[\]]/, "\\$&");
-  }
-  const prefix = p.includes("/") ? "^" : "(?:^|/)";
-  return new RegExp(prefix + body + (isDir ? "(?:/|$)" : "$"));
+  if (p.endsWith("/")) return NEVER_MATCHES;
+  const anchored = p.includes("/");
+  if (p.startsWith("/")) p = p.slice(1);
+  const prefix = anchored ? "^" : "^(?:.*/)?";
+  return new RegExp(prefix + globBody(p) + "$");
+}
+function globBody(p) {
+  const segments = p.split("/");
+  return segments.map((seg, i) => {
+    const last = i === segments.length - 1;
+    if (seg === "**") return last ? ".+" : "(?:.*/)?";
+    return globSegment(seg) + (last ? "" : "/");
+  }).join("");
+}
+function globSegment(seg) {
+  let out = "";
+  for (const c of seg) {
+    if (c === "*") out += "[^/]*";
+    else if (c === "?") out += "[^/]";
+    else out += c.replace(/[.+(){}|^$\\[\]]/, "\\$&");
+  }
+  return out;
+}
+
+// src/role-globs.ts
+function parseRoleGlobs(value, label, knownRoles) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${label}: expected an object mapping roles to glob arrays`);
+  }
+  const out = {};
+  for (const [role, globs] of Object.entries(value)) {
+    if (!knownRoles.includes(role)) {
+      throw new Error(`${label}: unknown role "${role}"`);
+    }
+    if (!Array.isArray(globs) || !globs.every((g) => typeof g === "string")) {
+      throw new Error(`${label}: "${role}" must be an array of glob strings`);
+    }
+    out[role] = globs;
+  }
+  return out;
+}
+function roleGlobMatcher(globs, order) {
+  const compiled = order.flatMap(
+    (role) => (globs?.[role] ?? []).map((g) => ({ role, rx: gitattributesPatternToRegex(g) }))
+  );
+  return (id) => compiled.find(({ rx }) => rx.test(id))?.role;
 }
 
 // src/roles.ts
 var TEST_RE = /(?:^|\/)(?:__tests__\/|tests?\/)|\.(?:test|spec)(?:\.[a-z]+)?$/;
+var STORY_RE = /\.stories(?:\.[cm]?[jt]sx?)?$|\.mdx$/;
 var FIXTURE_RE = /(?:^|\/)fixtures(?:\/|$)/;
 var SCRIPT_RE = /(?:^|\/)(?:scripts|archive)(?:\/|$)/;
 var BARREL_RE = /(?:^|\/)index(?:\.[a-z]+)?$/;
@@ -1949,6 +2174,8 @@ var CONFIG_RE = /\.config(?:\.[a-z]+)?$/;
 var ALL_ROLES = [
   "test",
   "fixture",
+  "story",
+  "lab",
   "barrel",
   "types",
   "config",
@@ -1959,7 +2186,9 @@ var ALL_ROLES = [
 ];
 function classifyRole(id, hints) {
   if (hints?.isGenerated) return "generated";
+  if (hints?.configuredRole) return hints.configuredRole;
   if (TEST_RE.test(id)) return "test";
+  if (STORY_RE.test(id)) return "story";
   if (FIXTURE_RE.test(id)) return "fixture";
   if (SCRIPT_RE.test(id)) return "script";
   if (hints?.hasShebang) return "entry";
@@ -1968,8 +2197,14 @@ function classifyRole(id, hints) {
   if (CONFIG_RE.test(id)) return "config";
   return "source";
 }
-function computeRoleHints(readFiles, idRoot, toId) {
-  const patterns = loadGeneratedPatterns(idRoot);
+var ROLE_GLOBS_PATH = ".codewatch/roles.json";
+function loadRoleGlobs(rootDir, source = workingTreeSource()) {
+  const file = path8.join(rootDir, ROLE_GLOBS_PATH);
+  if (!source.fileExists(file)) return {};
+  return parseRoleGlobs(JSON.parse(source.readFile(file)), ROLE_GLOBS_PATH, ALL_ROLES);
+}
+function computeRoleHints(readFiles, idRoot, toId, source) {
+  const patterns = loadGeneratedPatterns(idRoot, source);
   const shebangIds = /* @__PURE__ */ new Set();
   const generatedIds = /* @__PURE__ */ new Set();
   for (const rf of readFiles) {
@@ -1977,47 +2212,320 @@ function computeRoleHints(readFiles, idRoot, toId) {
     if (rf.content.startsWith("#!")) shebangIds.add(id);
     if (isGeneratedFile(id, patterns)) generatedIds.add(id);
   }
-  return { shebangIds, generatedIds };
+  return { shebangIds, generatedIds, roleGlobs: loadRoleGlobs(idRoot, source) };
 }
 function annotateRoles(nodes, options) {
+  const configuredRole = roleGlobMatcher(options?.roleGlobs, ALL_ROLES);
   return nodes.map(
     (n) => n.kind === "file" || n.kind === "module" ? {
       ...n,
       role: n.role ?? classifyRole(n.id, {
         hasShebang: options?.shebangIds?.has(n.id) ?? false,
-        isGenerated: options?.generatedIds?.has(n.id) ?? false
+        isGenerated: options?.generatedIds?.has(n.id) ?? false,
+        configuredRole: configuredRole(n.id)
       })
     } : n
   );
 }
 
-// src/file-walk.ts
-import * as fs from "fs/promises";
-import * as path7 from "path";
-import { isExcludedDir, shouldIncludeFile } from "@titan-design/code-parser";
-async function walkSourceFiles(rootDirs, languages) {
+// src/git-tree-source.ts
+import { readlinkSync, realpathSync, statSync } from "fs";
+import * as path9 from "path";
+import { isExcludedDir as isExcludedDir2, shouldIncludeFile as shouldIncludeFile2 } from "@titan-design/code-parser";
+import { Project as Project3 } from "ts-morph";
+
+// src/git-tree-host.ts
+function readOnly() {
+  throw new Error("a git tree source is read-only");
+}
+function overlayHost(answers, real) {
+  return {
+    isCaseSensitive: () => real.isCaseSensitive(),
+    readDirSync: answers.readDir,
+    readFileSync: (p) => answers.readFile(p),
+    readFile: async (p) => answers.readFile(p),
+    fileExistsSync: answers.fileExists,
+    fileExists: async (p) => answers.fileExists(p),
+    directoryExistsSync: answers.directoryExists,
+    directoryExists: async (p) => answers.directoryExists(p),
+    realpathSync: answers.realpath,
+    getCurrentDirectory: () => real.getCurrentDirectory(),
+    glob: () => Promise.reject(new Error("glob is not supported on a git tree source")),
+    globSync: () => readOnly(),
+    delete: async () => readOnly(),
+    deleteSync: readOnly,
+    writeFile: async () => readOnly(),
+    writeFileSync: readOnly,
+    mkdir: async () => readOnly(),
+    mkdirSync: readOnly,
+    move: async () => readOnly(),
+    moveSync: readOnly,
+    copy: async () => readOnly(),
+    copySync: readOnly
+  };
+}
+
+// src/git-tree-source.ts
+var READ_BY_INDEX = /\.(?:[cm]?[jt]sx?|json|pyi?)$|(?:^|\/)\.gitattributes$/;
+var MAX_LINK_HOPS = 40;
+var emptyHost;
+function missing(abs, kind) {
+  emptyHost ??= new Project3({ useInMemoryFileSystem: true }).getFileSystem();
+  if (kind === "file") emptyHost.readFileSync(abs);
+  else emptyHost.readDirSync(abs);
+  throw new Error(`${abs} was expected to be missing`);
+}
+function linkTarget(abs) {
+  try {
+    return path9.resolve(path9.dirname(abs), readlinkSync(abs));
+  } catch {
+    return null;
+  }
+}
+function relativeInside(root, abs) {
+  const rel = path9.relative(root, abs);
+  return rel === ".." || rel.startsWith(`..${path9.sep}`) || path9.isAbsolute(rel) ? null : rel;
+}
+function canonicalize(abs, hops = 0) {
+  const rest = [];
+  for (let at = path9.resolve(abs); ; at = path9.dirname(at)) {
+    try {
+      return path9.join(realpathSync(at), ...rest.reverse());
+    } catch {
+      const target = hops < MAX_LINK_HOPS ? linkTarget(at) : null;
+      if (target !== null) return canonicalize(path9.join(target, ...rest.reverse()), hops + 1);
+      if (path9.dirname(at) === at) return path9.resolve(abs);
+      rest.push(path9.basename(at));
+    }
+  }
+}
+function firstExcluded(rel, includeSelf) {
+  const segments = rel.split(path9.sep);
+  return (includeSelf ? segments : segments.slice(0, -1)).findIndex(isExcludedDir2);
+}
+var CommitTree = class {
+  constructor(root, commit) {
+    this.root = root;
+    for (const blob of listTreeBlobs(root, commit)) {
+      const rel = blob.path.split("/").join(path9.sep);
+      (blob.link ? this.links : this.oids).set(rel, blob.oid);
+      this.addEntry(rel, blob.link ? "link" : "file");
+    }
+  }
+  root;
+  oids = /* @__PURE__ */ new Map();
+  links = /* @__PURE__ */ new Map();
+  dirs = /* @__PURE__ */ new Map();
+  canonical = /* @__PURE__ */ new Map();
+  contents;
+  /** The one place an answer's origin is decided; every file, dir and realpath answer goes through it. */
+  locate(abs, kind) {
+    return this.classify(this.resolve(path9.resolve(abs), 0), kind);
+  }
+  classify(canonical, kind) {
+    const rel = relativeInside(this.root, canonical);
+    if (rel === null) return { origin: "disk", canonical, rel: null };
+    const tracked = kind === "file" ? this.oids.has(rel) : this.dirs.has(rel);
+    if (tracked) return { origin: "tree", canonical, rel };
+    return { origin: this.ownsBuildOutput(rel, kind === "dir") ? "disk" : "missing", canonical, rel };
+  }
+  /**
+   * Untracked build output a checkout would see on disk: under an excluded dir
+   * whose parent the commit tracks, so `untracked/dist` is as absent as `untracked`.
+   * A tracked symlink only lands here when its chain loops or dangles, and is then absent.
+   */
+  ownsBuildOutput(rel, includeSelf) {
+    const at = firstExcluded(rel, includeSelf);
+    if (at < 0 || this.links.has(rel)) return false;
+    return this.dirs.has(rel.split(path9.sep).slice(0, at).join(path9.sep));
+  }
+  *files() {
+    for (const rel of this.oids.keys()) yield path9.join(this.root, rel);
+  }
+  /** Children of a tracked dir by name, or undefined when the commit has no such dir. */
+  children(rel) {
+    return this.dirs.get(rel);
+  }
+  read(rel) {
+    return this.blob(this.oids.get(rel));
+  }
+  /** Every link target joins the first batch: a checkout resolves links before it reads anything. */
+  blob(oid) {
+    this.contents ??= readBlobs(this.root, [
+      ...[...this.oids].filter(([r]) => READ_BY_INDEX.test(r)).map(([, o]) => o),
+      ...this.links.values()
+    ]);
+    if (!this.contents.has(oid)) this.contents.set(oid, readBlobs(this.root, [oid]).get(oid));
+    return this.contents.get(oid);
+  }
+  tracks(rel) {
+    return rel !== null && (this.oids.has(rel) || this.dirs.has(rel));
+  }
+  resolve(abs, hops) {
+    const parent = path9.dirname(abs);
+    return parent === abs ? abs : this.step(this.resolve(parent, hops), path9.basename(abs), hops);
+  }
+  /**
+   * Every component of every path and link target passes through here, memoized
+   * per path and hop budget: a link named many times in nested targets is followed
+   * once per budget, and a chain cut short by the budget never answers for a shorter one.
+   */
+  step(dir, name, hops) {
+    const key = `${hops}:${path9.join(dir, name)}`;
+    let resolved = this.canonical.get(key);
+    if (resolved === void 0) {
+      resolved = this.stepOnce(dir, name, hops);
+      this.canonical.set(key, resolved);
+    }
+    return resolved;
+  }
+  /** Disk is never consulted for a component the commit tracks, a symlink included. */
+  stepOnce(dir, name, hops) {
+    const next = path9.join(dir, name);
+    const rel = relativeInside(this.root, next);
+    if (this.tracks(rel)) return next;
+    if (hops >= MAX_LINK_HOPS) return next;
+    const linkOid = rel === null ? void 0 : this.links.get(rel);
+    if (linkOid !== void 0) return this.follow(dir, this.blob(linkOid), hops + 1) ?? next;
+    const target = linkTarget(next);
+    return target === null ? next : this.resolve(target, hops + 1);
+  }
+  /**
+   * A tracked link's target walked one component at a time from `dir`, as a
+   * checkout walks it: `..` leaves the dir actually reached, so `gone/..` dangles
+   * (null) when `gone` is absent, where lexical normalisation would drop it.
+   */
+  follow(dir, target, hops) {
+    let at = path9.isAbsolute(target) ? path9.parse(path9.resolve(target)).root : dir;
+    for (const name of target.split("/")) {
+      if (name === "" || name === ".") continue;
+      if (name !== "..") at = this.step(at, name, hops);
+      else if (this.isDir(at)) at = path9.dirname(at);
+      else return null;
+    }
+    return at;
+  }
+  isDir(canonical) {
+    const { origin } = this.classify(canonical, "dir");
+    if (origin !== "disk") return origin === "tree";
+    return statSync(canonical, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  }
+  addEntry(rel, kind) {
+    let child = rel;
+    let childKind = kind;
+    for (let dir = path9.dirname(rel); child !== "."; child = dir, dir = path9.dirname(dir)) {
+      const key = dir === "." ? "" : dir;
+      const known = this.dirs.has(key);
+      const children = this.dirs.get(key) ?? /* @__PURE__ */ new Map();
+      children.set(path9.basename(child), childKind);
+      this.dirs.set(key, children);
+      if (known) return;
+      childKind = "dir";
+    }
+  }
+};
+function* ingestedUnder(tree, rootDir, languages) {
+  for (const abs of tree.files()) {
+    const rel = relativeInside(rootDir, abs);
+    if (rel === null) continue;
+    if (path9.dirname(rel).split(path9.sep).some(isExcludedDir2)) continue;
+    if (shouldIncludeFile2(rel, [...languages])) yield abs;
+  }
+}
+function listTreeFiles(tree, rootDirs, languages) {
   const seen = /* @__PURE__ */ new Set();
-  const out = [];
   for (const rootDir of rootDirs) {
-    await collectFiles(rootDir, rootDir, languages, seen, out);
+    for (const abs of ingestedUnder(tree, rootDir, languages)) seen.add(abs);
   }
-  return out;
+  return [...seen].sort();
 }
-async function collectFiles(dir, rootDir, languages, seen, out) {
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const full = path7.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (isExcludedDir(entry.name)) continue;
-      await collectFiles(full, rootDir, languages, seen, out);
-    } else if (entry.isFile() && !seen.has(full)) {
-      const relative4 = path7.relative(rootDir, full);
-      if (shouldIncludeFile(relative4, [...languages])) {
-        seen.add(full);
-        out.push(full);
-      }
-    }
+function diskBuildDirs(real, canonical) {
+  if (!real.directoryExistsSync(canonical)) return [];
+  return real.readDirSync(canonical).filter((e) => e.isDirectory && isExcludedDir2(path9.basename(e.name)));
+}
+function treeEntry(at, kind, exists) {
+  if (kind !== "link") return { name: at, isFile: kind === "file", isDirectory: kind === "dir", isSymlink: false };
+  return { name: at, isFile: exists.file(at), isDirectory: exists.dir(at), isSymlink: true };
+}
+function readDirAt(tree, real, abs, exists) {
+  const at = tree.locate(abs, "dir");
+  const asAsked = (entry) => ({ ...entry, name: path9.join(path9.resolve(abs), path9.basename(entry.name)) });
+  if (at.origin === "missing") return missing(abs, "dir");
+  if (at.origin === "disk") return real.readDirSync(at.canonical).map(asAsked);
+  const entries = /* @__PURE__ */ new Map();
+  for (const [name, kind] of tree.children(at.rel)) {
+    entries.set(name, treeEntry(path9.join(path9.resolve(abs), name), kind, exists));
+  }
+  for (const entry of diskBuildDirs(real, at.canonical)) {
+    const name = path9.basename(entry.name);
+    if (!entries.has(name)) entries.set(name, asAsked(entry));
   }
+  return [...entries.values()];
+}
+function treeAnswers(tree, real) {
+  const fileExists = (abs) => {
+    const at = tree.locate(abs, "file");
+    return at.origin === "tree" || at.origin === "disk" && real.fileExistsSync(at.canonical);
+  };
+  const directoryExists = (abs) => {
+    const at = tree.locate(abs, "dir");
+    return at.origin === "tree" || at.origin === "disk" && real.directoryExistsSync(at.canonical);
+  };
+  return {
+    fileExists,
+    readFile: (abs) => {
+      const at = tree.locate(abs, "file");
+      if (at.origin === "tree") return tree.read(at.rel);
+      return at.origin === "disk" ? real.readFileSync(at.canonical, "utf-8") : missing(abs, "file");
+    },
+    directoryExists,
+    readDir: (abs) => readDirAt(tree, real, abs, { file: fileExists, dir: directoryExists }),
+    // Like the real host, realpath of an absent path throws.
+    realpath: (abs) => fileExists(abs) || directoryExists(abs) ? tree.locate(abs, "file").canonical : missing(abs, "file")
+  };
+}
+function canonicalToplevel(repoRoot) {
+  const toplevel = detectGitToplevel(path9.resolve(repoRoot));
+  if (toplevel === null) throw new Error(`${repoRoot} is not inside a git repository`);
+  return realpathSync(toplevel);
+}
+function gitTreeSource(repoRoot, rev) {
+  const canonicalRoot = canonicalToplevel(repoRoot);
+  const { commit, commitEpoch } = resolveCommit(canonicalRoot, rev);
+  const tree = new CommitTree(canonicalRoot, commit);
+  const real = workingTreeSource().fileSystem;
+  const answers = treeAnswers(tree, real);
+  let fileSystem;
+  return {
+    listFiles: async (rootDirs, languages) => listTreeFiles(tree, rootDirs, languages),
+    readFile: answers.readFile,
+    // Like `existsSync` in the working-tree source, true for a dir as well as a file.
+    fileExists: (abs) => answers.fileExists(abs) || answers.directoryExists(abs),
+    get fileSystem() {
+      fileSystem ??= overlayHost(answers, real);
+      return fileSystem;
+    },
+    revision: { repoRoot: canonicalRoot, commit, commitEpoch }
+  };
+}
+function rebaseOntoRoot(abs, repoRoot) {
+  const rest = [];
+  for (let at = path9.resolve(abs); path9.dirname(at) !== at; at = path9.dirname(at)) {
+    if (realpathOrNull(at) === repoRoot) return path9.join(repoRoot, ...rest.reverse());
+    rest.push(path9.basename(at));
+  }
+  return canonicalize(abs);
+}
+function realpathOrNull(abs) {
+  try {
+    return realpathSync(abs);
+  } catch {
+    return null;
+  }
+}
+function rootsAtRevision(paths, revision) {
+  const idRoot = realpathSync(revision.repoRoot);
+  return { rootDirs: paths.map((p) => rebaseOntoRoot(p, idRoot)), idRoot };
 }
 
 // src/barrel-resolve.ts
@@ -2026,9 +2534,9 @@ function edgeWeight(e) {
   return typeof w === "number" && w > 0 ? w : 1;
 }
 function pruneDanglingReferences(nodes, edges) {
-  for (const [key, edge] of edges) {
-    const symbolLayer = edge.kind === "references" || edge.kind === "calls";
-    if (symbolLayer && (!nodes.has(edge.dstId) || !nodes.has(edge.srcId))) edges.delete(key);
+  for (const [key, edge2] of edges) {
+    const symbolLayer = edge2.kind === "references" || edge2.kind === "calls";
+    if (symbolLayer && (!nodes.has(edge2.dstId) || !nodes.has(edge2.srcId))) edges.delete(key);
   }
 }
 function resolveBarrelEdges(nodes, edges) {
@@ -2043,7 +2551,7 @@ function resolveBarrelEdges(nodes, edges) {
     forwards.set(e.srcId, arr);
   }
   const cache = /* @__PURE__ */ new Map();
-  function resolve4(id, seen) {
+  function resolve5(id, seen) {
     if (!barrels.has(id)) return /* @__PURE__ */ new Map([[id, 1]]);
     const cached = cache.get(id);
     if (cached) return cached;
@@ -2054,7 +2562,7 @@ function resolveBarrelEdges(nodes, edges) {
     const nextSeen = new Set(seen).add(id);
     for (const t of targets) {
       const share = t.weight / total;
-      for (const [real, frac] of resolve4(t.dst, nextSeen)) {
+      for (const [real, frac] of resolve5(t.dst, nextSeen)) {
         out.set(real, (out.get(real) ?? 0) + share * frac);
       }
     }
@@ -2069,7 +2577,7 @@ function resolveBarrelEdges(nodes, edges) {
       continue;
     }
     const w = edgeWeight(e);
-    for (const [real, frac] of resolve4(e.dstId, /* @__PURE__ */ new Set())) {
+    for (const [real, frac] of resolve5(e.dstId, /* @__PURE__ */ new Set())) {
       if (real === e.srcId) continue;
       resolved.push({
         ...e,
@@ -2083,7 +2591,6 @@ function resolveBarrelEdges(nodes, edges) {
 
 // src/incremental.ts
 import { createHash } from "crypto";
-import * as fs2 from "fs/promises";
 import { getLanguageFromPath as getLanguageFromPath2 } from "@titan-design/code-parser";
 
 // src/analysis/comment-lines.ts
@@ -2314,6 +2821,25 @@ function isLoggingCall(node) {
   return false;
 }
 
+// src/analysis/jsx-metrics.ts
+function rendersElement(node) {
+  if (node.type === "jsx_self_closing_element") return true;
+  if (node.type !== "jsx_element") return false;
+  return node.childForFieldName("open_tag")?.childForFieldName("name") != null;
+}
+function jsxDepthOf(root, opensFunction) {
+  let max = 0;
+  const visit = (node, depth) => {
+    const own = rendersElement(node) ? depth + 1 : depth;
+    if (own > max) max = own;
+    for (const child of node.namedChildren) {
+      if (child && !opensFunction(child)) visit(child, own);
+    }
+  };
+  visit(root, 0);
+  return max;
+}
+
 // src/cognitive-complexity.ts
 function cognitiveComplexityOf(body, language) {
   const handler = language === "python" ? PY_HANDLER : TS_HANDLER;
@@ -2347,9 +2873,8 @@ var TS_NESTING = /* @__PURE__ */ new Set([
   "do_statement",
   "switch_statement",
   "catch_clause",
-  "function_declaration",
-  "method_definition",
-  "arrow_function"
+  ...TS_FUNCTION_DECL_TYPES,
+  ...TS_BOUND_FUNCTION_TYPES
 ]);
 var PY_NESTING = /* @__PURE__ */ new Set([
   "if_statement",
@@ -2441,7 +2966,7 @@ function computeLcomMetrics(file, fileId2) {
   return out;
 }
 function collectClasses(file) {
-  const isClass = file.language === "python" ? (n) => n.type === "class_definition" : (n) => n.type === "class_declaration" || n.type === "class_expression";
+  const isClass = file.language === "python" ? (n) => n.type === "class_definition" : (n) => TS_CLASS_TYPES.has(n.type);
   const out = [];
   const visit = (node) => {
     if (isClass(node)) out.push(node);
@@ -2479,14 +3004,21 @@ function collectPythonMethods(classNode) {
   if (!body) return [];
   const out = [];
   for (const child of body.namedChildren) {
-    if (!child || child.type !== "function_definition") continue;
-    const name = child.childForFieldName("name")?.text;
+    const fn = child ? pythonMethodNode(child) : null;
+    if (!fn) continue;
+    const name = fn.childForFieldName("name")?.text;
     if (!name || name === "__init__") continue;
-    if (isPythonStaticOrClassMethod(child)) continue;
-    out.push({ name, usedNames: thisRefs(child, "self") });
+    out.push({ name, usedNames: thisRefs(fn, "self") });
   }
   return out;
 }
+function pythonMethodNode(stmt) {
+  if (stmt.type === "function_definition") return stmt;
+  if (stmt.type !== "decorated_definition") return null;
+  if (isPythonStaticOrClassMethod(stmt)) return null;
+  const def = stmt.childForFieldName("definition");
+  return def?.type === "function_definition" ? def : null;
+}
 function methodName(methodNode) {
   const nameNode = methodNode.childForFieldName("name");
   return nameNode?.text ?? null;
@@ -2497,16 +3029,10 @@ function hasStaticModifier(methodNode) {
   }
   return false;
 }
-function isPythonStaticOrClassMethod(funcNode) {
-  let prev = funcNode.previousNamedSibling;
-  while (prev && prev.type === "decorator") {
-    const text = prev.text;
-    if (text.includes("@staticmethod") || text.includes("@classmethod")) {
-      return true;
-    }
-    prev = prev.previousNamedSibling;
-  }
-  return false;
+function isPythonStaticOrClassMethod(decorated) {
+  return decorated.namedChildren.some(
+    (c) => c?.type === "decorator" && (c.text === "@staticmethod" || c.text === "@classmethod")
+  );
 }
 function thisRefs(methodNode, selfKeyword) {
   const out = /* @__PURE__ */ new Set();
@@ -2651,6 +3177,7 @@ var SYMBOL_METRICS = [
   { name: "symbol_cyclomatic", stat: "cyclomatic", unit: "count" },
   { name: "symbol_loc", stat: "loc", unit: "lines" },
   { name: "symbol_max_nesting", stat: "nestingDepth", unit: "count" },
+  { name: "symbol_jsx_depth", stat: "jsxDepth", unit: "count", omitZero: true },
   { name: "symbol_comment_lines", stat: "commentLines", unit: "lines" },
   { name: "symbol_docstring_lines", stat: "docstringLines", unit: "lines" },
   { name: "symbol_body_lines", stat: "bodyLines", unit: "lines" },
@@ -2675,6 +3202,7 @@ function symbolMetrics(fileId2, stats, symbolNames) {
   for (const [name, values] of byName) {
     const nodeId = symbolId(fileId2, name);
     for (const m of SYMBOL_METRICS) {
+      if (m.omitZero && values[m.stat] === 0) continue;
       out.push({ nodeId, name: m.name, value: values[m.stat], unit: m.unit });
     }
   }
@@ -2689,10 +3217,6 @@ function functionShapeStats(fn, body, lines) {
 }
 
 // src/source-metrics.ts
-var TS_FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  "function_declaration",
-  "method_definition"
-]);
 var PY_FUNCTION_TYPES = /* @__PURE__ */ new Set(["function_definition"]);
 var TS_NESTING_TYPES = /* @__PURE__ */ new Set([
   "if_statement",
@@ -2735,6 +3259,7 @@ var SOURCE_METRIC_NAMES = /* @__PURE__ */ new Set([
   "cognitive_max",
   "cognitive_sum",
   "max_nesting_depth",
+  "jsx_depth_max",
   "class_count",
   "lcom4_max",
   ...EXCEPTION_METRIC_NAMES,
@@ -2745,10 +3270,10 @@ var SOURCE_METRIC_NAMES = /* @__PURE__ */ new Set([
   ...SYMBOL_METRIC_NAMES
 ]);
 var EMPTY_NAMES = /* @__PURE__ */ new Set();
-function computeSourceMetrics(files, fileIdOf, symbolNamesByFile2 = /* @__PURE__ */ new Map()) {
+function computeSourceMetrics(files, fileIdOf2, symbolNamesByFile2 = /* @__PURE__ */ new Map()) {
   const out = [];
   for (const file of files) {
-    const id = fileIdOf(file.filePath);
+    const id = fileIdOf2(file.filePath);
     out.push(...metricsForFile(id, file, symbolNamesByFile2.get(id) ?? EMPTY_NAMES));
   }
   return out;
@@ -2796,6 +3321,8 @@ function metricsForFile(nodeId, file, symbolNames) {
       unit: "count"
     });
   }
+  const jsxDepthMax = Math.max(jsxDepthIn(file, file.tree.rootNode), ...stats.map((s) => s.jsxDepth));
+  if (jsxDepthMax > 0) out.push({ nodeId, name: "jsx_depth_max", value: jsxDepthMax, unit: "count" });
   out.push(...symbolMetrics(nodeId, stats, symbolNames));
   out.push(...computeLcomMetrics(file, nodeId));
   out.push(...exceptionMetrics(nodeId, file.tree.rootNode, loc));
@@ -2806,7 +3333,7 @@ function countLoc(content) {
 }
 function analyzeFunctions(file) {
   const stats = [];
-  const fnTypes = file.language === "python" ? PY_FUNCTION_TYPES : TS_FUNCTION_TYPES;
+  const fnTypes = file.language === "python" ? PY_FUNCTION_TYPES : TS_FUNCTION_DECL_TYPES;
   const lines = file.content.split("\n");
   walkScopes(file.tree.rootNode, file.language === "python", (node, scope) => {
     const fn = functionAt(node, fnTypes);
@@ -2816,6 +3343,7 @@ function analyzeFunctions(file) {
       cyclomatic: cyclomaticOf(fn.body, file.language),
       cognitive: cognitiveComplexityOf(fn.body, file.language),
       nestingDepth: nestingDepthOf(fn.body, file.language, 0),
+      jsxDepth: jsxDepthIn(file, fn.body),
       loc: fn.node.endPosition.row - fn.node.startPosition.row + 1,
       ...functionShapeStats(fn.node, fn.body, lines)
     });
@@ -2827,13 +3355,17 @@ function functionAt(node, fnTypes) {
     const body = node.childForFieldName("body");
     return body ? { name: node.childForFieldName("name")?.text ?? null, body, node } : null;
   }
-  if ((node.type === "arrow_function" || node.type === "function_expression") && node.parent?.type === "variable_declarator") {
+  if (TS_BOUND_FUNCTION_TYPES.has(node.type) && node.parent?.type === "variable_declarator") {
     const body = node.childForFieldName("body");
     if (!body) return null;
     return { name: node.parent.childForFieldName("name")?.text ?? null, body, node };
   }
   return null;
 }
+function jsxDepthIn(file, root) {
+  if (file.language === "python") return 0;
+  return jsxDepthOf(root, (node) => functionAt(node, TS_FUNCTION_DECL_TYPES) !== null);
+}
 function nestingDepthOf(node, language, depth) {
   const nestingTypes = language === "python" ? PY_NESTING_TYPES : TS_NESTING_TYPES;
   let maxDepth = depth;
@@ -3026,12 +3558,12 @@ var TERMINALS2 = /* @__PURE__ */ new Set([
   "break_statement",
   "continue_statement"
 ]);
-function computeDeadCodeMetrics(files, fileIdOf) {
+function computeDeadCodeMetrics(files, fileIdOf2) {
   const out = [];
   for (const file of files) {
     const counts = deadCodeOf(file);
     if (!counts) continue;
-    const id = fileIdOf(file.filePath);
+    const id = fileIdOf2(file.filePath);
     const { unreachable, locals, params } = counts;
     if (unreachable > 0) {
       out.push({ nodeId: id, name: "unreachable_statements", value: unreachable, unit: "count" });
@@ -3194,12 +3726,12 @@ var SEARCH_METHODS = /* @__PURE__ */ new Set([
   "every",
   "filter"
 ]);
-function computeGrowthRiskMetrics(files, fileIdOf) {
+function computeGrowthRiskMetrics(files, fileIdOf2) {
   const out = [];
   for (const file of files) {
     const loopTypes = file.language === "python" ? PY_LOOP_TYPES : TS_LOOP_TYPES;
     const root = file.tree.rootNode;
-    const id = fileIdOf(file.filePath);
+    const id = fileIdOf2(file.filePath);
     const depth = maxLoopDepth(root, loopTypes, 0);
     if (depth >= 2) {
       out.push({ nodeId: id, name: "loop_depth", value: depth, unit: "count" });
@@ -3270,8 +3802,8 @@ function reconstructFragment(repoRoot, absPath, fileId2, basis) {
   nodes.push(...basis.symbolsByFile.get(fileId2) ?? []);
   const edges = basis.edgesBySrc.get(fileId2) ?? [];
   const seenExternals = /* @__PURE__ */ new Set();
-  for (const edge of edges) {
-    const dst = basis.nodesById.get(edge.dstId);
+  for (const edge2 of edges) {
+    const dst = basis.nodesById.get(edge2.dstId);
     if (dst?.kind === "external" && !seenExternals.has(dst.id)) {
       seenExternals.add(dst.id);
       nodes.push({ id: dst.id, kind: "external", name: dst.name });
@@ -3317,12 +3849,12 @@ function sourceLanguage(filePath) {
   const language = getLanguageFromPath2(filePath);
   return language === "typescript" || language === "python" ? language : null;
 }
-async function readSourceFiles(filePaths) {
+async function readSourceFiles(filePaths, source = workingTreeSource()) {
   const out = [];
   for (const filePath of filePaths) {
     const language = sourceLanguage(filePath);
     if (language === null) continue;
-    const content = await fs2.readFile(filePath, "utf-8");
+    const content = source.readFile(filePath);
     out.push({ filePath, language, content, hash: hashContent(content) });
   }
   return out;
@@ -3472,8 +4004,8 @@ function resolveRelativeId(srcFileId, specifier, fileIds) {
   }
   return null;
 }
-function targetFileId(edge) {
-  return parseSymbolId(edge.dstId)?.fileId ?? edge.dstId;
+function targetFileId(edge2) {
+  return parseSymbolId(edge2.dstId)?.fileId ?? edge2.dstId;
 }
 function computeDeltaAffected(basis, currentFileIds) {
   const affected = /* @__PURE__ */ new Set();
@@ -3485,8 +4017,8 @@ function computeDeltaAffected(basis, currentFileIds) {
   if (!added) return affected;
   for (const [srcId, edges] of basis.edgesBySrc) {
     if (!currentFileIds.has(srcId)) continue;
-    for (const edge of edges) {
-      if (isEdgeAffected(edge, srcId, removed2, currentFileIds)) {
+    for (const edge2 of edges) {
+      if (isEdgeAffected(edge2, srcId, removed2, currentFileIds)) {
         affected.add(srcId);
         break;
       }
@@ -3494,11 +4026,11 @@ function computeDeltaAffected(basis, currentFileIds) {
   }
   return affected;
 }
-function isEdgeAffected(edge, srcId, removed2, currentFileIds) {
-  if (removed2.has(targetFileId(edge))) return true;
-  const specifier = edge.attrs?.specifier;
+function isEdgeAffected(edge2, srcId, removed2, currentFileIds) {
+  if (removed2.has(targetFileId(edge2))) return true;
+  const specifier = edge2.attrs?.specifier;
   if (!specifier || !isRelative(specifier)) return false;
-  return resolveRelativeId(srcId, specifier, currentFileIds) !== targetFileId(edge);
+  return resolveRelativeId(srcId, specifier, currentFileIds) !== targetFileId(edge2);
 }
 
 // src/metrics.ts
@@ -3569,142 +4101,45 @@ function computeCallMetrics(nodes, edges) {
     out.push({ nodeId: node.id, name: "symbol_caller_count", value: callers.size, unit: "count" });
     const single = isPrivateHelper(node) && callers.size === 1 && isSymbolCaller(callers);
     out.push({ nodeId: node.id, name: "symbol_single_caller_helper", value: single ? 1 : 0, unit: "count" });
-    const shape = readParamShape(node.attrs);
-    if (shape && sites.length >= 2) {
-      out.push({ nodeId: node.id, name: "symbol_constant_params", value: constantParams(shape, sites), unit: "count" });
-    }
-  }
-  return out;
-}
-function collectInbound(edges) {
-  const inbound = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    if (edge.kind !== "calls") continue;
-    let entry = inbound.get(edge.dstId);
-    if (!entry) inbound.set(edge.dstId, entry = { callers: /* @__PURE__ */ new Set(), sites: [] });
-    if (edge.srcId !== edge.dstId) entry.callers.add(edge.srcId);
-    entry.sites.push(...edge.attrs?.sites ?? []);
-  }
-  return inbound;
-}
-function isPrivateHelper(node) {
-  const own = node.name.slice(node.name.lastIndexOf(".") + 1);
-  return node.attrs?.exported === false && !(own.startsWith("__") && own.endsWith("__"));
-}
-function isSymbolCaller(callers) {
-  return [...callers].every((id) => parseSymbolId(id) !== null);
-}
-function constantParams(shape, sites) {
-  let count = 0;
-  shape.params.forEach((name, index) => {
-    const values = sites.map((site) => argumentAt(site, name, index < shape.positional ? index : -1));
-    if (values.every((v) => v !== null && v === values[0])) count++;
-  });
-  return count;
-}
-function argumentAt(site, name, position) {
-  if (position >= 0 && position < site.args.length) return site.args[position] ?? null;
-  if (site.kwargs && Object.hasOwn(site.kwargs, name)) return site.kwargs[name] ?? null;
-  if (site.kwSplat) return null;
-  if (position >= 0 && site.spreadFrom !== void 0 && position >= site.spreadFrom) return null;
-  return ABSENT;
-}
-
-// src/analysis/test-linker.ts
-var DEFAULT_MIN_CO_EDIT_COUNT = 2;
-var TEST_INFIX_RE = /\.(?:test|spec)(\.[^./]+)$/;
-var TESTS_DIR_RE = /(^|\/)(?:__tests__|tests?)\//;
-function pathCandidates(testId) {
-  const out = /* @__PURE__ */ new Set();
-  const deInfixed = testId.replace(TEST_INFIX_RE, "$1");
-  if (deInfixed !== testId) out.add(deInfixed);
-  const deDir = deInfixed.replace(TESTS_DIR_RE, "$1");
-  if (deDir !== testId) out.add(deDir);
-  return [...out];
-}
-function splitFileIds(nodes) {
-  const testIds = [];
-  const nonTestIds = /* @__PURE__ */ new Set();
-  for (const n of nodes) {
-    if (n.kind !== "file") continue;
-    if (n.role === "test") testIds.push(n.id);
-    else nonTestIds.add(n.id);
-  }
-  return { testIds, nonTestIds };
-}
-function linkTestsToSources(nodes, coEditPairs, options = {}) {
-  const minCount = options.minCoEditCount ?? DEFAULT_MIN_CO_EDIT_COUNT;
-  const { testIds, nonTestIds } = splitFileIds(nodes);
-  const links = [];
-  for (const testId of testIds) {
-    const matched = pathCandidates(testId).filter((c) => nonTestIds.has(c));
-    if (matched.length > 0) {
-      for (const sourceId of matched) {
-        links.push({ testId, sourceId, method: "path" });
-      }
-      continue;
-    }
-    const partner = couplingFor(coEditPairs, testId).find((p) => p.count >= minCount && nonTestIds.has(p.partner));
-    if (partner) {
-      links.push({ testId, sourceId: partner.partner, method: "coedit" });
-    }
-  }
-  return links;
-}
-function testCoverageCountMetrics(links) {
-  const testsBySource = groupTestsBySource(links);
-  const out = [];
-  for (const [sourceId, tests] of testsBySource) {
-    out.push({
-      nodeId: sourceId,
-      name: "linked_test_count",
-      value: tests.size,
-      unit: "count"
-    });
-  }
-  return out;
-}
-function groupTestsBySource(links) {
-  const out = /* @__PURE__ */ new Map();
-  for (const l of links) {
-    let set = out.get(l.sourceId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      out.set(l.sourceId, set);
-    }
-    set.add(l.testId);
-  }
-  return out;
-}
-
-// src/history-recency.ts
-var DAY_SECONDS = 86400;
-function windowSuffix(window) {
-  return window === "lifetime" ? "lifetime" : `${window}d`;
-}
-function computeRecencyWindows(firstSeen, churnedIdsByWindow, nowEpoch) {
-  const out = [];
-  const ageEmitted = /* @__PURE__ */ new Set();
-  for (const [windowDays, ids] of churnedIdsByWindow) {
-    const suffix = windowSuffix(windowDays);
-    for (const id of ids) {
-      const seen = firstSeen.get(id);
-      let recency = 1;
-      if (seen !== void 0) {
-        const ageDays = Math.max(0, (nowEpoch - seen) / DAY_SECONDS);
-        if (windowDays !== "lifetime") recency = Math.min(1, ageDays / windowDays);
-        if (!ageEmitted.has(id)) {
-          out.push({ nodeId: id, name: "file_age_days", value: Math.round(ageDays), unit: "days" });
-          ageEmitted.add(id);
-        }
-      }
-      out.push({ nodeId: id, name: `recency_${suffix}`, value: round3(recency), unit: "ratio" });
+    const shape = readParamShape(node.attrs);
+    if (shape && sites.length >= 2) {
+      out.push({ nodeId: node.id, name: "symbol_constant_params", value: constantParams(shape, sites), unit: "count" });
     }
   }
   return out;
 }
-function round3(n) {
-  return Math.round(n * 1e3) / 1e3;
+function collectInbound(edges) {
+  const inbound = /* @__PURE__ */ new Map();
+  for (const edge2 of edges) {
+    if (edge2.kind !== "calls") continue;
+    let entry = inbound.get(edge2.dstId);
+    if (!entry) inbound.set(edge2.dstId, entry = { callers: /* @__PURE__ */ new Set(), sites: [] });
+    if (edge2.srcId !== edge2.dstId) entry.callers.add(edge2.srcId);
+    entry.sites.push(...edge2.attrs?.sites ?? []);
+  }
+  return inbound;
+}
+function isPrivateHelper(node) {
+  const own = node.name.slice(node.name.lastIndexOf(".") + 1);
+  return node.attrs?.exported === false && !(own.startsWith("__") && own.endsWith("__"));
+}
+function isSymbolCaller(callers) {
+  return [...callers].every((id) => parseSymbolId(id) !== null);
+}
+function constantParams(shape, sites) {
+  let count = 0;
+  shape.params.forEach((name, index) => {
+    const values = sites.map((site) => argumentAt(site, name, index < shape.positional ? index : -1));
+    if (values.every((v) => v !== null && v === values[0])) count++;
+  });
+  return count;
+}
+function argumentAt(site, name, position) {
+  if (position >= 0 && position < site.args.length) return site.args[position] ?? null;
+  if (site.kwargs && Object.hasOwn(site.kwargs, name)) return site.kwargs[name] ?? null;
+  if (site.kwSplat) return null;
+  if (position >= 0 && site.spreadFrom !== void 0 && position >= site.spreadFrom) return null;
+  return ABSENT;
 }
 
 // src/history-metrics.ts
@@ -3718,7 +4153,12 @@ function loadHistoryMetrics(nodes, idRoot, options = {}) {
   const knownPaths = collectFileIds(nodes);
   const primaryWindow = options.churnWindowDays ?? 30;
   const windows = resolveChurnWindows(options.churnWindows, primaryWindow, options.includeLifetime === true);
-  const wide = loadChurnEntries({ repoRoot: idRoot, windowDays: windows[windows.length - 1] });
+  const wide = loadChurnEntries({
+    repoRoot: idRoot,
+    windowDays: windows[windows.length - 1],
+    rev: options.rev,
+    untilEpoch: options.nowEpoch
+  });
   if (wide === null) return null;
   const nowEpoch = options.nowEpoch ?? Math.floor(Date.now() / 1e3);
   const churnByWindow = aggregateChurnWindows(wide, windows, nowEpoch, knownPaths);
@@ -3726,7 +4166,7 @@ function loadHistoryMetrics(nodes, idRoot, options = {}) {
   const metrics = [
     ...churnMetrics(churnByWindow),
     ...ownershipMetrics(primaryEntries, primaryWindow, knownPaths),
-    ...recencyMetrics(idRoot, churnByWindow, knownPaths, nowEpoch)
+    ...recencyMetrics({ idRoot, rev: options.rev, knownPaths, nowEpoch }, churnByWindow)
   ];
   if (options.includeLifetime === true) metrics.push(...ownershipMetrics(wide, "lifetime", knownPaths));
   return { metrics, primaryEntries };
@@ -3793,14 +4233,14 @@ function mergeAuthorChurn(tests, linesByTest) {
   }
   return byAuthor;
 }
-function recencyMetrics(idRoot, churnByWindow, knownPaths, nowEpoch) {
+function recencyMetrics(at, churnByWindow) {
   const churnedByWindow = /* @__PURE__ */ new Map();
   for (const [window, byPath] of churnByWindow) {
     if (byPath.size > 0) churnedByWindow.set(window, new Set(byPath.keys()));
   }
   if (churnedByWindow.size === 0) return [];
-  const firstSeen = loadFileFirstSeen({ repoRoot: idRoot, knownPaths }) ?? /* @__PURE__ */ new Map();
-  return computeRecencyWindows(firstSeen, churnedByWindow, nowEpoch);
+  const firstSeen = loadFileFirstSeen({ repoRoot: at.idRoot, knownPaths: at.knownPaths, rev: at.rev }) ?? /* @__PURE__ */ new Map();
+  return computeRecencyWindows(firstSeen, churnedByWindow, at.nowEpoch);
 }
 
 // src/index-metrics.ts
@@ -3844,17 +4284,17 @@ function computeTestCoverage(nodes, entries, windowDays) {
 }
 
 // src/merge.ts
-function edgeKey(edge) {
-  return JSON.stringify([edge.srcId, edge.dstId, edge.kind]);
+function edgeKey(edge2) {
+  return JSON.stringify([edge2.srcId, edge2.dstId, edge2.kind]);
 }
 function mergeFragments(fragments) {
   const nodes = /* @__PURE__ */ new Map();
   const edges = /* @__PURE__ */ new Map();
   for (const fragment of fragments) {
     for (const node of fragment.nodes) if (!nodes.has(node.id)) nodes.set(node.id, node);
-    for (const edge of fragment.edges) {
-      const key = edgeKey(edge);
-      if (!edges.has(key)) edges.set(key, edge);
+    for (const edge2 of fragment.edges) {
+      const key = edgeKey(edge2);
+      if (!edges.has(key)) edges.set(key, edge2);
     }
   }
   return { nodes, edges };
@@ -3898,18 +4338,18 @@ function qualifiedByName(file) {
 }
 
 // src/indexer.ts
-var INDEX_VERSION = "0.18.0";
+var INDEX_VERSION = "0.22.0";
 var LANGUAGES = ["typescript", "python"];
 function canonicalizePath(p) {
   try {
-    return realpathSync(p);
+    return realpathSync2(p);
   } catch {
     return p;
   }
 }
 function normalizePaths(paths) {
   if (paths.length === 0) throw new Error("indexPaths requires at least one path");
-  return [...new Set(paths.map((p) => path8.resolve(p)))];
+  return [...new Set(paths.map((p) => path10.resolve(p)))];
 }
 function countByKind(items) {
   const out = {};
@@ -3932,8 +4372,9 @@ function resolveSymbolAliases(store, idRoot, parsedByPath, nodeIds) {
   const files = [...parsedByPath.values()].map((file) => ({ fileId: fileId(idRoot, file.filePath), file }));
   return qualifiedSymbolAliases(files, nodeIds);
 }
-function resolveRoots(paths) {
+function resolveRoots(paths, source) {
   const raw = normalizePaths(paths);
+  if (source.revision) return rootsAtRevision(raw, source.revision);
   const gitToplevel = detectGitToplevel(raw[0]);
   const rootDirs = gitToplevel !== null ? raw.map(canonicalizePath) : raw;
   return { rootDirs, idRoot: gitToplevel ?? rootDirs[0] };
@@ -3945,16 +4386,19 @@ async function parseAll(toParse) {
   }
   return parsed;
 }
-function historyOptions(options) {
+function historyOptions(options, source) {
   return {
     churnWindowDays: options.churnWindowDays,
     churnWindows: options.churnWindows,
-    includeLifetime: options.lifetime === true
+    includeLifetime: options.lifetime === true,
+    rev: source.revision?.commit,
+    nowEpoch: source.revision?.commitEpoch
   };
 }
 async function indexPaths(store, options) {
-  const { rootDirs, idRoot } = resolveRoots(options.paths);
-  const readFiles = await readSourceFiles(await walkSourceFiles(rootDirs, LANGUAGES));
+  const source = options.source ?? workingTreeSource();
+  const { rootDirs, idRoot } = resolveRoots(options.paths, source);
+  const readFiles = await readSourceFiles(await source.listFiles(rootDirs, LANGUAGES), source);
   const reuse = options.incremental !== false ? loadReuseBasis(store, INDEX_VERSION) : null;
   const currentFileIds = new Set(readFiles.map((rf) => fileId(idRoot, rf.filePath)));
   const affected = reuse ? computeDeltaAffected(reuse, currentFileIds) : /* @__PURE__ */ new Set();
@@ -3968,10 +4412,11 @@ async function indexPaths(store, options) {
       parsedByPath,
       reuse,
       cosmeticFileIds: classified.cosmeticFileIds,
-      extractor: new LanguageExtractor({ repoRoot: idRoot, tsConfigPath: options.tsConfig })
+      extractor: new LanguageExtractor({ repoRoot: idRoot, tsConfigPath: options.tsConfig, source })
     })
   );
-  const annotated = annotateRoles([...accumulator.nodes.values()], computeRoleHints(readFiles, idRoot, fileId));
+  const roleHints = computeRoleHints(readFiles, idRoot, fileId, source);
+  const annotated = annotateRoles([...accumulator.nodes.values()], roleHints);
   accumulator.nodes = new Map(annotated.map((n) => [n.id, n]));
   pruneDanglingReferences(accumulator.nodes, accumulator.edges);
   const metrics = options.computeMetrics === false ? [] : buildIndexerMetrics({
@@ -3980,19 +4425,23 @@ async function indexPaths(store, options) {
     parsedFiles: [...parsedByPath.values()],
     reusedSourceMetrics: reuse ? reusedFileIds.flatMap((id) => reuse.sourceMetricsByFile.get(id) ?? []) : [],
     idRoot,
-    history: options.computeChurn === false ? void 0 : historyOptions(options)
+    history: options.computeChurn === false ? void 0 : historyOptions(options, source)
   });
-  const rootDir = rootDirs[0];
+  const rootDir = source.revision ? idRoot : rootDirs[0];
   const ref = options.ref ?? "wd";
-  const bridge = computeAliasBridge(store, { ...options, rootDir, idRoot, ref, nodes: accumulator.nodes });
+  const commitHash = options.commitHash ?? source.revision?.commit ?? detectGitHead(rootDir) ?? void 0;
+  const bridge = computeAliasBridge(store, { ...options, rootDir, idRoot, ref, commitHash, nodes: accumulator.nodes });
   const aliases = [
     ...bridge.aliases,
     ...resolveSymbolAliases(store, idRoot, parsedByPath, new Set(accumulator.nodes.keys()))
   ];
-  const commitHash = options.commitHash ?? detectGitHead(rootDir) ?? void 0;
   const snapshot = { ref, commitHash, aliasBase: bridge.baseSnapshotId };
-  const snapshotId = persist(store, snapshot, accumulator, aliases, metrics);
-  store.insertFingerprints(snapshotId, buildFingerprints(readFiles, idRoot, classified.structuralByFileId));
+  const fingerprints = buildFingerprints(readFiles, idRoot, classified.structuralByFileId);
+  const snapshotId = store.atomically(() => {
+    const id = persist(store, snapshot, accumulator, aliases, metrics);
+    store.insertFingerprints(id, fingerprints);
+    return id;
+  });
   return {
     snapshotId,
     files: readFiles.length,
@@ -4009,14 +4458,14 @@ async function indexPaths(store, options) {
 }
 
 // src/index.ts
-import { getLanguageFromPath as getLanguageFromPath3, getSupportedLanguages, parseFile as parseFile2, shouldIncludeFile as shouldIncludeFile2 } from "@titan-design/code-parser";
+import { getLanguageFromPath as getLanguageFromPath3, getSupportedLanguages, parseFile as parseFile3, shouldIncludeFile as shouldIncludeFile3 } from "@titan-design/code-parser";
 
 // src/extractors/deep-ast.ts
 import { readFileSync as readFileSync2 } from "fs";
-import * as path9 from "path";
+import * as path11 from "path";
 import {
   Node as Node6,
-  Project as Project2,
+  Project as Project4,
   ScriptTarget as ScriptTarget2
 } from "ts-morph";
 function computeDeepAst(input) {
@@ -4028,11 +4477,11 @@ function computeDeepAst(input) {
 function loadSourceFile(absPath) {
   try {
     const text = readFileSync2(absPath, "utf8");
-    const project = new Project2({
+    const project = new Project4({
       useInMemoryFileSystem: true,
       compilerOptions: { target: ScriptTarget2.Latest, allowJs: true }
     });
-    return project.createSourceFile(`f${path9.extname(absPath) || ".ts"}`, text);
+    return project.createSourceFile(`f${path11.extname(absPath) || ".ts"}`, text);
   } catch {
     return null;
   }
@@ -4210,11 +4659,11 @@ function innermostContaining(symbols, line) {
   }
   return best;
 }
-function attributeCoverage(coverage, fileIdOf, symbolsByFile) {
+function attributeCoverage(coverage, fileIdOf2, symbolsByFile) {
   const out = [];
   for (const [absPath, fc] of Object.entries(coverage)) {
     if (!isFileCoverage(fc)) continue;
-    const fileId2 = fileIdOf(absPath);
+    const fileId2 = fileIdOf2(absPath);
     if (!fileId2) continue;
     const fnIds = Object.keys(fc.fnMap);
     if (fnIds.length === 0) continue;
@@ -4245,142 +4694,196 @@ function pctMetric(nodeId, covered, total) {
   };
 }
 
-// src/analysis/pagerank.ts
-var DEFAULT_DAMPING = 0.85;
-var DEFAULT_TOLERANCE = 1e-6;
-var DEFAULT_MAX_ITERS = 100;
-var DEFAULT_EDGE_WEIGHTS = {
-  imports: 1,
-  "re-exports": 0.5,
-  calls: 1.5,
-  extends: 1,
-  implements: 1,
-  references: 1,
-  "depends-on": 1
+// src/analysis/context/minify.ts
+import { parseFile as parseFile2 } from "@titan-design/code-parser";
+var IMPORT_TYPES = {
+  typescript: /* @__PURE__ */ new Set(["import_statement"]),
+  tsx: /* @__PURE__ */ new Set(["import_statement"]),
+  python: /* @__PURE__ */ new Set(["import_statement", "import_from_statement", "future_import_statement"])
 };
-function getEdgeWeight(kind, overrides) {
-  return overrides?.[kind] ?? DEFAULT_EDGE_WEIGHTS[kind] ?? 1;
-}
-function computePageRank(nodes, edges, options = {}) {
-  const n = nodes.length;
-  if (n === 0) return { rows: [], iterations: 0, converged: true };
-  const damping = options.damping ?? DEFAULT_DAMPING;
-  const tolerance = options.tolerance ?? DEFAULT_TOLERANCE;
-  const maxIters = options.maxIterations ?? DEFAULT_MAX_ITERS;
-  const weights = { ...DEFAULT_EDGE_WEIGHTS, ...options.edgeWeights ?? {} };
-  const idx = buildIdIndex(nodes);
-  const adj = buildAdjacency(idx, edges, weights, n);
-  const pers = buildPersonalization(idx, n, options.personalization);
-  const { rank, iterations, converged } = powerIterate(
-    pers,
-    adj,
-    damping,
-    tolerance,
-    maxIters
-  );
-  return { rows: rankToRows(nodes, rank), iterations, converged };
+var DELIMITERS = /* @__PURE__ */ new Set(["(", ")", "[", "]", "{", "}", ",", ";"]);
+var STRING_TYPES = {
+  typescript: ["string", "template_string"],
+  tsx: ["string", "template_string"],
+  python: ["string"]
+};
+function importMarker(count, language) {
+  const prefix = language === "python" ? "#" : "//";
+  return `${prefix} \u2026 ${count} import${count === 1 ? "" : "s"}`;
 }
-function buildIdIndex(nodes) {
-  const idx = /* @__PURE__ */ new Map();
-  for (let i = 0; i < nodes.length; i++) idx.set(nodes[i].id, i);
-  return idx;
+function originalLine(minified, outputLine) {
+  return minified.lineMap[outputLine - 1];
 }
-function buildAdjacency(idx, edges, weights, n) {
-  const outNeighbors = Array.from(
-    { length: n },
-    () => []
-  );
-  const outWeightSum = new Array(n).fill(0);
-  for (const e of edges) {
-    const si = idx.get(e.srcId);
-    const di = idx.get(e.dstId);
-    if (si === void 0 || di === void 0) continue;
-    const w = weights[e.kind] ?? 1;
-    if (w <= 0) continue;
-    outNeighbors[si].push({ to: di, w });
-    outWeightSum[si] += w;
-  }
-  return { outNeighbors, outWeightSum };
-}
-function powerIterate(pers, adj, damping, tolerance, maxIters) {
-  const n = pers.length;
-  let rank = pers.slice();
-  let next = new Array(n).fill(0);
-  let iterations = 0;
-  let converged = false;
-  for (let iter = 0; iter < maxIters; iter++) {
-    iterations = iter + 1;
-    const dangling = sumDangling(rank, adj.outWeightSum);
-    const teleport = 1 - damping + damping * dangling;
-    seedTeleport(next, pers, teleport);
-    distributeRank(next, rank, adj, damping);
-    const diff = l1Diff(rank, next);
-    [rank, next] = [next, rank];
-    next.fill(0);
-    if (diff < tolerance) {
-      converged = true;
-      break;
-    }
-  }
-  return { rank, iterations, converged };
+function isMinifyLanguage(language) {
+  return language === "typescript" || language === "tsx" || language === "python";
 }
-function sumDangling(rank, outWeightSum) {
-  let total = 0;
-  for (let i = 0; i < rank.length; i++) {
-    if (outWeightSum[i] === 0) total += rank[i];
+async function minifySource(text, language) {
+  if (!isMinifyLanguage(language)) return unchanged(text);
+  const { tree } = await parseFile2(text, "source", language);
+  try {
+    return minifyTree(tree.rootNode, text, language);
+  } finally {
+    tree.delete();
   }
-  return total;
 }
-function seedTeleport(next, pers, teleport) {
-  for (let i = 0; i < next.length; i++) next[i] = teleport * pers[i];
-}
-function distributeRank(next, rank, adj, damping) {
-  for (let i = 0; i < rank.length; i++) {
-    const s = adj.outWeightSum[i];
-    if (s === 0 || rank[i] === 0) continue;
-    const factor = damping * rank[i] / s;
-    const list = adj.outNeighbors[i];
-    for (let k = 0; k < list.length; k++) {
-      next[list[k].to] += factor * list[k].w;
+function minifyTree(root, text, language) {
+  const rows = text.split("\n");
+  const cuts = cutsByRow(removedSpans(root, language));
+  const verbatim = verbatimRows(root, language);
+  const block = leadingImportBlock(root, language);
+  const out = [];
+  for (let row = 0; row < rows.length; row++) {
+    if (block && row >= block.startRow && row <= block.endRow) {
+      if (row === block.startRow) out.push({ text: importMarker(block.count, language), line: row + 1, verbatim: false });
+      continue;
     }
+    const kept = keepRow(rows[row] ?? "", cuts.get(row), verbatim.has(row));
+    if (kept !== null) out.push({ text: kept, line: row + 1, verbatim: verbatim.has(row) });
+  }
+  return finish(collapseBlanks(out), text.endsWith("\n"));
+}
+function unchanged(text) {
+  const rows = text.split("\n");
+  const count = text === "" ? 0 : text.endsWith("\n") ? rows.length - 1 : rows.length;
+  return { text, lineMap: Array.from({ length: count }, (_, i) => i + 1) };
+}
+function removedSpans(root, language) {
+  const comments = descendantsOfType(root, "comment");
+  if (language !== "python") {
+    return [
+      ...[...comments, ...descendantsOfType(root, "hash_bang_line")].map(spanOf),
+      ...jsxCommentExpressions(root).map((n) => ({ ...spanOf(n), jsx: true }))
+    ];
   }
+  return [...comments.map(spanOf), ...pythonDocstrings(root).map(docstringSpan)];
 }
-function l1Diff(a, b) {
-  let diff = 0;
-  for (let i = 0; i < a.length; i++) diff += Math.abs(b[i] - a[i]);
-  return diff;
+function spanOf(node) {
+  return { start: node.startPosition, end: node.endPosition };
 }
-function rankToRows(nodes, rank) {
-  return nodes.map((node, i) => ({ nodeId: node.id, score: rank[i] })).sort(compareRows);
+function docstringSpan(docstring) {
+  const semicolon = docstring.nextSibling;
+  const sameRow = semicolon?.type === ";" && semicolon.startPosition.row === docstring.endPosition.row;
+  return { start: docstring.startPosition, end: sameRow ? semicolon.endPosition : docstring.endPosition };
 }
-function compareRows(a, b) {
-  if (b.score !== a.score) return b.score - a.score;
-  return a.nodeId < b.nodeId ? -1 : a.nodeId > b.nodeId ? 1 : 0;
+function jsxCommentExpressions(root) {
+  return descendantsOfType(root, "jsx_expression").filter(
+    (n) => n.namedChildCount > 0 && n.namedChildren.every((c) => c?.type === "comment")
+  );
 }
-function buildPersonalization(idx, n, pers) {
-  if (!pers || pers.size === 0) return uniformVector(n);
-  const out = new Array(n).fill(0);
-  const total = applySeedWeights(out, idx, pers);
-  if (total === 0) return uniformVector(n);
-  for (let i = 0; i < n; i++) out[i] /= total;
-  return out;
+function pythonDocstrings(root) {
+  const bodies = [...descendantsOfType(root, "class_definition"), ...descendantsOfType(root, "function_definition")].map((def) => def.childForFieldName("body")).filter((body) => body !== null);
+  const docstrings = bodies.map((body) => droppableDocstring(body));
+  const module = moduleDocstring(root);
+  return [module && !sharesEndRow(module) ? module : null, ...docstrings].filter((d) => d !== null);
 }
-function uniformVector(n) {
-  return new Array(n).fill(1 / n);
+function droppableDocstring(body) {
+  const docstring = pythonDocstring(body);
+  if (!docstring || bodyStatements(body, docstring).length === 0) return null;
+  return sharesEndRow(docstring) ? null : docstring;
+}
+function sharesEndRow(docstring) {
+  let next = docstring.nextNamedSibling;
+  while (next?.type === "comment") next = next.nextNamedSibling;
+  return next?.startPosition.row === docstring.endPosition.row;
+}
+function moduleDocstring(root) {
+  const first = root.namedChildren.find((c) => c !== null && c.type !== "comment");
+  if (first?.type !== "expression_statement" || first.namedChildCount !== 1) return null;
+  return first.namedChildren[0]?.type === "string" ? first : null;
+}
+function cutsByRow(spans) {
+  const cuts = /* @__PURE__ */ new Map();
+  for (const { start, end, jsx } of spans) {
+    for (let row = start.row; row <= end.row; row++) {
+      const from = row === start.row ? start.column : 0;
+      const to = row === end.row ? end.column : Number.MAX_SAFE_INTEGER;
+      const list = cuts.get(row) ?? [];
+      list.push({ from, to, pad: row !== start.row, jsx: jsx === true });
+      cuts.set(row, list);
+    }
+  }
+  return cuts;
+}
+function verbatimRows(root, language) {
+  const rows = /* @__PURE__ */ new Set();
+  for (const type of STRING_TYPES[language]) {
+    for (const s of descendantsOfType(root, type)) {
+      for (let row = s.startPosition.row; row < s.endPosition.row; row++) rows.add(row);
+    }
+  }
+  return rows;
 }
-function applySeedWeights(out, idx, pers) {
-  let total = 0;
-  for (const [id, w] of pers) {
-    if (!isValidWeight(w)) continue;
-    const i = idx.get(id);
-    if (i === void 0) continue;
-    out[i] = w;
-    total += w;
+function keepRow(row, cuts, verbatim) {
+  if (!cuts) return verbatim ? row : row.trimEnd();
+  let kept = "";
+  let cutSinceKept = false;
+  let onlyJsxCut = true;
+  for (let col = 0; col < row.length; col++) {
+    const hits = cuts.filter((c) => col >= c.from && col < c.to);
+    const char = row[col] ?? "";
+    if (hits.length === 0) {
+      const before = kept.at(-1) ?? " ";
+      if (cutSinceKept && wouldFuse(before, char) && !(onlyJsxCut && isTagEdge(before, char))) kept += " ";
+      kept += char;
+      cutSinceKept = false;
+      onlyJsxCut = true;
+    } else if (hits.every((c) => c.pad)) kept += " ";
+    else {
+      cutSinceKept = true;
+      onlyJsxCut &&= hits.some((c) => c.jsx);
+    }
+  }
+  const trimmed = kept.trimEnd();
+  if (trimmed === "") return null;
+  return verbatim ? kept : trimmed;
+}
+function wouldFuse(before, after) {
+  return /\S/.test(before) && /\S/.test(after) && !DELIMITERS.has(before) && !DELIMITERS.has(after);
+}
+function isTagEdge(before, after) {
+  return before === ">" || after === "<";
+}
+function leadingImportBlock(root, language) {
+  const children = root.namedChildren.filter((c) => c !== null);
+  const docstring = language === "python" ? moduleDocstring(root) : null;
+  let i = 0;
+  while (i < children.length && isPreamble(children[i], docstring)) i++;
+  const imports = [];
+  for (; i < children.length; i++) {
+    const child = children[i];
+    if (child.type === "comment") continue;
+    if (!IMPORT_TYPES[language].has(child.type)) break;
+    imports.push(child);
+  }
+  while (docstring && imports[0]?.startPosition.row === docstring.endPosition.row) imports.shift();
+  const next = children[i];
+  while (next && imports.length > 0 && imports[imports.length - 1]?.endPosition.row === next.startPosition.row) imports.pop();
+  const first = imports[0];
+  const last = imports[imports.length - 1];
+  if (!first || !last) return null;
+  return { startRow: first.startPosition.row, endRow: last.endPosition.row, count: imports.length };
+}
+function isPreamble(node, docstring) {
+  return node.type === "comment" || node.type === "hash_bang_line" || node.id === docstring?.id;
+}
+function collapseBlanks(lines) {
+  const out = [];
+  for (const line of lines) {
+    const blank = line.text === "" && !line.verbatim;
+    const prev = out[out.length - 1];
+    if (blank && (!prev || prev.text === "" && !prev.verbatim)) continue;
+    out.push(line);
   }
-  return total;
+  while (out.length > 0 && out[out.length - 1]?.text === "" && !out[out.length - 1]?.verbatim) out.pop();
+  return out;
 }
-function isValidWeight(w) {
-  return Number.isFinite(w) && w > 0;
+function finish(lines, trailingNewline) {
+  const body = lines.map((l) => l.text).join("\n");
+  return {
+    text: trailingNewline && lines.length > 0 ? `${body}
+` : body,
+    lineMap: lines.map((l) => l.line)
+  };
 }
 
 // src/analysis/relevance.ts
@@ -4406,290 +4909,428 @@ function symmetrize(edges) {
   return out;
 }
 
-// src/analysis/symbol-coupling.ts
-var DEFAULT_MIN_CO_IMPORTS = 2;
-var DEFAULT_LARGE_IMPORTER_THRESHOLD = 40;
-function computeSymbolConsumers(edges) {
-  const bySymbol = /* @__PURE__ */ new Map();
-  for (const e of edges) {
-    let set = bySymbol.get(e.dstId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      bySymbol.set(e.dstId, set);
-    }
-    set.add(e.srcId);
-  }
-  const out = [];
-  for (const [id, consumers] of bySymbol) {
-    const parsed = parseSymbolId(id);
-    if (!parsed) continue;
-    out.push({
-      symbolId: id,
-      fileId: parsed.fileId,
-      name: parsed.name,
-      consumers: [...consumers].sort()
-    });
+// src/analysis/context/signature-tree.ts
+var ELISION_MARKER = "...";
+var TRUNCATION_SUFFIX = "\u2026";
+var DEFAULT_MAX_LINE_CHARS = 120;
+var INDENT = "  ";
+function renderSignatureTree(nodes, options = {}) {
+  const max = options.maxLineChars ?? DEFAULT_MAX_LINE_CHARS;
+  const lines = [];
+  for (const [file, entries] of groupByFile(nodes)) {
+    lines.push(truncate(file, max));
+    for (const line of fileLines(entries)) lines.push(truncate(line, max));
   }
-  return out.sort(compareConsumers);
+  return lines.join("\n");
 }
-function compareConsumers(a, b) {
-  if (b.consumers.length !== a.consumers.length) {
-    return b.consumers.length - a.consumers.length;
+function groupByFile(nodes) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.kind !== "symbol") continue;
+    const parsed = parseSymbolId(node.id);
+    const file = node.parentId ?? parsed?.fileId ?? node.id;
+    const list = byFile.get(file) ?? [];
+    list.push(toEntry(node, parsed?.name ?? node.name));
+    byFile.set(file, list);
   }
-  return a.symbolId < b.symbolId ? -1 : a.symbolId > b.symbolId ? 1 : 0;
+  return [...byFile].sort(([a], [b]) => compare2(a, b));
 }
-function computeSymbolCoupling(edges, options = {}) {
-  const minCoImports = options.minCoImports ?? DEFAULT_MIN_CO_IMPORTS;
-  const largeThreshold = options.largeImporterThreshold ?? DEFAULT_LARGE_IMPORTER_THRESHOLD;
-  const bySource = groupSymbolsBySource(edges);
-  const counts = /* @__PURE__ */ new Map();
-  for (const symbols of bySource.values()) {
-    if (symbols.length < 2 || symbols.length > largeThreshold) continue;
-    accumulateSymbolPairs(symbols, counts);
-  }
-  return finalizePairs(counts, minCoImports);
+function toEntry(node, qualifiedName) {
+  const start = numberAttr(node, "startLine");
+  const end = numberAttr(node, "endLine") ?? start;
+  return { node, start, end, depth: qualifiedName.split(".").length - 1 };
 }
-function groupSymbolsBySource(edges) {
-  const perSource = /* @__PURE__ */ new Map();
-  for (const e of edges) {
-    if (!parseSymbolId(e.dstId)) continue;
-    let set = perSource.get(e.srcId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      perSource.set(e.srcId, set);
-    }
-    set.add(e.dstId);
-  }
-  const out = /* @__PURE__ */ new Map();
-  for (const [src, set] of perSource) out.set(src, [...set].sort());
-  return out;
+function numberAttr(node, key) {
+  const value = node.attrs?.[key];
+  return typeof value === "number" ? value : void 0;
 }
-function accumulateSymbolPairs(symbols, counts) {
-  for (let i = 0; i < symbols.length; i++) {
-    for (let j = i + 1; j < symbols.length; j++) {
-      const key = `${symbols[i]}	${symbols[j]}`;
-      counts.set(key, (counts.get(key) ?? 0) + 1);
+function fileLines(entries) {
+  const ordered = entries.sort(compareEntries);
+  const lines = [];
+  let reach;
+  for (const entry of ordered) {
+    if (reach !== void 0 && entry.start !== void 0 && !adjacent(reach, entry.start)) {
+      lines.push(ELISION_MARKER);
     }
+    lines.push(INDENT.repeat(entry.depth) + symbolText(entry.node));
+    if (entry.end !== void 0) reach = Math.max(reach ?? entry.end, entry.end);
   }
+  return lines;
 }
-function finalizePairs(counts, minCoImports) {
-  const out = [];
-  for (const [key, coImports] of counts) {
-    if (coImports < minCoImports) continue;
-    const [aId, bId] = key.split("	");
-    const a = parseSymbolId(aId);
-    const b = parseSymbolId(bId);
-    out.push({
-      aId,
-      aFile: a.fileId,
-      aName: a.name,
-      bId,
-      bFile: b.fileId,
-      bName: b.name,
-      coImports,
-      crossFile: a.fileId !== b.fileId
-    });
+function adjacent(reach, nextStart) {
+  return nextStart <= reach + 1;
+}
+function symbolText(node) {
+  const signature = node.attrs?.signature;
+  const text = typeof signature === "string" && signature !== "" ? signature : `${node.name} (${node.kind})`;
+  return text.replace(/\s*\n\s*/g, " ");
+}
+function compareEntries(a, b) {
+  if (a.start !== b.start) {
+    if (a.start === void 0) return 1;
+    if (b.start === void 0) return -1;
+    return a.start - b.start;
   }
-  return out.sort(comparePairs);
+  return compare2(a.node.name, b.node.name) || compare2(a.node.id, b.node.id);
+}
+function compare2(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
 }
-function comparePairs(a, b) {
-  if (b.coImports !== a.coImports) return b.coImports - a.coImports;
-  if (a.crossFile !== b.crossFile) return a.crossFile ? -1 : 1;
-  if (a.aId !== b.aId) return a.aId < b.aId ? -1 : 1;
-  return a.bId < b.bId ? -1 : a.bId > b.bId ? 1 : 0;
+function truncate(line, max) {
+  if (line.length <= max) return line;
+  if (max <= TRUNCATION_SUFFIX.length) return TRUNCATION_SUFFIX.slice(0, Math.max(max, 0));
+  return line.slice(0, max - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
 }
 
-// src/analysis/partition-quality.ts
-var FOUNDATION_INSTABILITY_MAX = 0.3;
-var TOP_INSTABILITY_MIN = 0.9;
-var WEAK_COHESION_MAX = 0.5;
-var TIGHT_INTENSITY_MIN = 0.6;
-var MODERATE_INTENSITY_MIN = 0.3;
-function computePartitionQuality(input) {
-  const resolveBarrels = input.resolveBarrels ?? false;
-  const pkgByFile = invertBuckets(input.fileByPackage);
-  const barrelTargets = resolveBarrels ? buildBarrelTargetMap(input.nodes, input.edges) : /* @__PURE__ */ new Map();
-  const resolvedPairs = buildResolvedPairs(
-    input.edges,
-    pkgByFile,
-    barrelTargets,
-    resolveBarrels
-  );
-  const counts = countByPackage(resolvedPairs);
-  const totalEdges = resolvedPairs.length;
-  const filesByPkg = filesPerPackage(input.fileByPackage);
-  const abstractByPkg = countAbstractFiles(input.nodes, pkgByFile);
-  const perPackage = input.packages.map(
-    (p) => buildPackageStats(p.id, counts, filesByPkg, abstractByPkg)
-  );
-  const pairCoupling = buildPairCoupling(resolvedPairs, filesByPkg);
-  const modularityQ = computeModularity(perPackage, totalEdges);
-  const flagsCount = perPackage.reduce((acc, p) => acc + p.flags.length, 0) + pairCoupling.filter((c) => c.flag === "tight").length;
-  return { modularityQ, totalEdges, perPackage, pairCoupling, flagsCount };
+// src/analysis/context/dossier.ts
+var SCHEMA_VERSION2 = "2";
+var CONSUMER_NOTE = "cross-file import resolution only; intra-file and dynamic import() callers are excluded";
+function splitConsumers(files, roleByFile) {
+  const source = [];
+  const test = [];
+  for (const f of files) (roleByFile.get(f) === "test" ? test : source).push(f);
+  return {
+    source,
+    test,
+    counts: { source: source.length, test: test.length, total: files.length },
+    note: CONSUMER_NOTE
+  };
 }
-function invertBuckets(fileByPackage) {
+function consumerCounts(edges) {
   const out = /* @__PURE__ */ new Map();
-  for (const [pkgId, files] of fileByPackage) {
-    if (pkgId === "") continue;
-    for (const f of files) out.set(f, pkgId);
-  }
+  for (const c of computeSymbolConsumers(edges)) out.set(c.symbolId, c.consumers);
   return out;
 }
-function filesPerPackage(fileByPackage) {
-  const out = /* @__PURE__ */ new Map();
-  for (const [pkgId, files] of fileByPackage) {
-    out.set(pkgId, files.length);
+function fileIdOf(symbolId2) {
+  return parseSymbolId(symbolId2)?.fileId ?? null;
+}
+function buildSymbolDossier(input) {
+  const id = input.target.id;
+  const parsed = parseSymbolId(id);
+  const fileId2 = parsed?.fileId ?? "";
+  const m = input.metrics.get(id);
+  const consumers = consumerCounts(input.refEdges).get(id) ?? [];
+  const complexity = m?.cognitiveMax ?? input.metrics.get(fileId2)?.cognitiveMax ?? 0;
+  const churn = input.churnByFile.get(fileId2) ?? 0;
+  const coupledWith = computeSymbolCoupling(input.refEdges).filter((p) => p.aId === id || p.bId === id).map((p) => p.aId === id ? partner(p.bId, p.bName, p.bFile, p.coImports) : partner(p.aId, p.aName, p.aFile, p.coImports)).slice(0, 15);
+  return {
+    exported: input.target.attrs?.exported !== false,
+    signature: attrString(input.target.attrs?.signature),
+    purpose: attrString(input.target.attrs?.purpose),
+    complexity: { cognitive: m?.cognitiveMax, cyclomatic: m?.cyclomaticMax },
+    utilization: m?.utilization ?? 0,
+    consumers: splitConsumers(consumers, input.roleByFile),
+    blastRadius: (m?.utilization ?? 0) * complexity * churn,
+    coupledWith
+  };
+}
+function partner(symbolId2, name, fileId2, coImports) {
+  return { symbolId: symbolId2, name, fileId: fileId2, coImports };
+}
+function attrString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function fileSymbols(fileId2, nodes, metrics, consumers) {
+  const lines = [];
+  for (const n of nodes) {
+    if (n.kind !== "symbol" || n.parentId !== fileId2) continue;
+    const m = metrics.get(n.id);
+    const exported = n.attrs?.exported !== false;
+    lines.push({
+      name: n.name,
+      exported,
+      signature: attrString(n.attrs?.signature) ?? void 0,
+      cognitive: m?.cognitiveMax,
+      cyclomatic: m?.cyclomaticMax,
+      utilization: m?.utilization ?? 0,
+      consumers: (consumers.get(n.id) ?? []).length,
+      rank: exported ? m?.utilization ?? 0 : -(m?.cognitiveMax ?? 0)
+    });
   }
-  return out;
+  return sortSymbols(lines);
 }
-function buildBarrelTargetMap(nodes, edges) {
-  const barrelIds = new Set(
-    nodes.filter((n) => n.role === "barrel").map((n) => n.id)
-  );
-  if (barrelIds.size === 0) return /* @__PURE__ */ new Map();
-  const directReExports = /* @__PURE__ */ new Map();
-  for (const e of edges) {
-    if (!barrelIds.has(e.srcId)) continue;
-    if (e.kind !== "re-exports") continue;
-    let list = directReExports.get(e.srcId);
-    if (!list) {
-      list = [];
-      directReExports.set(e.srcId, list);
-    }
-    list.push(e.dstId);
-  }
-  const resolved = /* @__PURE__ */ new Map();
-  const resolve4 = (barrel, visiting) => {
-    if (resolved.has(barrel)) return resolved.get(barrel);
-    if (visiting.has(barrel)) return [];
-    visiting.add(barrel);
-    const out = [];
-    for (const target of directReExports.get(barrel) ?? []) {
-      if (barrelIds.has(target)) {
-        for (const inner of resolve4(target, visiting)) out.push(inner);
-      } else {
-        out.push(target);
-      }
-    }
-    visiting.delete(barrel);
-    resolved.set(barrel, out);
-    return out;
+function sortSymbols(lines) {
+  const exported = lines.filter((l) => l.exported).sort((a, b) => b.utilization - a.utilization || (b.cognitive ?? 0) - (a.cognitive ?? 0));
+  const internal = lines.filter((l) => !l.exported).sort((a, b) => (b.cognitive ?? 0) - (a.cognitive ?? 0) || a.name.localeCompare(b.name));
+  return [...exported, ...internal].map(({ rank: _rank, ...line }) => line);
+}
+function redistributeImportance(symbols, fileCentrality) {
+  const totalUtil = symbols.reduce((sum, s) => sum + s.utilization, 0);
+  if (totalUtil <= 0 || fileCentrality <= 0) return symbols;
+  return symbols.map((s) => ({
+    ...s,
+    importance: Math.round(fileCentrality * (s.utilization / totalUtil) * 1e6) / 1e6
+  }));
+}
+function fileConsumers(fileId2, refEdges) {
+  const set = /* @__PURE__ */ new Set();
+  for (const e of refEdges) if (fileIdOf(e.dstId) === fileId2) set.add(e.srcId);
+  return [...set].sort();
+}
+function fileDependsOn(fileId2, refEdges, importEdges) {
+  const set = /* @__PURE__ */ new Set();
+  for (const e of refEdges) if (e.srcId === fileId2) {
+    const f = fileIdOf(e.dstId);
+    if (f) set.add(f);
+  }
+  for (const e of importEdges) if (e.srcId === fileId2) set.add(e.dstId);
+  set.delete(fileId2);
+  return [...set].sort();
+}
+function buildFileDossier(input) {
+  const fileId2 = input.target.id;
+  const consumers = consumerCounts(input.refEdges);
+  const symbolUtil = collectSymbolUtil(input.nodes, input.metrics).filter((s) => s.fileId === fileId2);
+  const churnValue = input.churnByFile.get(fileId2);
+  const centrality = input.centrality.get(fileId2) ?? 0;
+  return {
+    metrics: input.metrics.get(fileId2) ?? {},
+    churn: churnValue === void 0 ? null : { windowDays: input.churnWindowDays, value: churnValue },
+    centrality,
+    ownership: input.ownership?.get(fileId2) ?? null,
+    symbols: redistributeImportance(
+      fileSymbols(fileId2, input.nodes, input.metrics, consumers),
+      centrality
+    ),
+    dependsOn: fileDependsOn(fileId2, input.refEdges, input.importEdges),
+    consumers: splitConsumers(fileConsumers(fileId2, input.refEdges), input.roleByFile),
+    blastRadius: buildBlastRadius(symbolUtil, input.metrics, input.churnByFile, 15)
   };
-  for (const id of barrelIds) resolve4(id, /* @__PURE__ */ new Set());
-  return resolved;
 }
-function buildResolvedPairs(edges, pkgByFile, barrelTargets, resolveBarrels) {
-  const out = [];
-  for (const e of edges) {
-    if (resolveBarrels && e.kind === "re-exports") continue;
-    const fromPkg = pkgByFile.get(e.srcId);
-    if (!fromPkg) continue;
-    const targets = barrelTargets.get(e.dstId) ?? [e.dstId];
-    for (const dst of targets) {
-      const toPkg = pkgByFile.get(dst);
-      if (toPkg) out.push({ from: fromPkg, to: toPkg });
-    }
+var SIGNATURE_NOTE = "Type signatures and docstrings are indexed for resolvable TypeScript declarations (C-79); a null signature means it was unannotated or unresolvable \u2014 open target.path at target.span.";
+function buildContextDossier(input) {
+  const { target, kind } = input;
+  const span = readSpan(target);
+  const path14 = kind === "symbol" ? parseSymbolId(target.id)?.fileId ?? target.id : target.id;
+  const notes = [SIGNATURE_NOTE];
+  if (kind === "file" && input.ownership === null) {
+    notes.push("Ownership omitted (git-derived; run without --no-ownership on a repo checkout).");
+  }
+  return {
+    schemaVersion: SCHEMA_VERSION2,
+    target: { id: target.id, kind, name: target.name, path: path14, span },
+    provenance: input.provenance,
+    symbol: kind === "symbol" ? buildSymbolDossier(input) : void 0,
+    file: kind === "file" ? buildFileDossier(input) : void 0,
+    notes
+  };
+}
+function readSpan(node) {
+  const start = node.attrs?.startLine;
+  const end = node.attrs?.endLine;
+  if (typeof start === "number" && typeof end === "number") return { startLine: start, endLine: end };
+  return void 0;
+}
+
+// src/analysis/context/format.ts
+function renderContextMarkdown(d) {
+  const span = d.target.span ? `:${d.target.span.startLine}-${d.target.span.endLine}` : "";
+  const lines = [
+    `# ${d.target.kind === "symbol" ? d.target.name : d.target.path}`,
+    "",
+    `- **kind**: ${d.target.kind}`,
+    `- **path**: \`${d.target.path}${span}\``,
+    `- **snapshot**: ${d.provenance.ref} (${d.provenance.commitHash ?? "\u2014"}) @ ${d.provenance.takenAt}`,
+    ""
+  ];
+  if (d.symbol) lines.push(...renderSymbol(d.symbol));
+  if (d.file) lines.push(...renderFile(d.file));
+  if (d.notes.length) lines.push("## Notes", ...d.notes.map((n) => `- ${n}`), "");
+  return lines.join("\n");
+}
+function renderSymbol(s) {
+  const out = [
+    "## Symbol",
+    `- **exported**: ${s.exported}`,
+    `- **signature**: ${s.signature ? `\`${s.signature}\`` : "\u2014 (not indexed)"}`,
+    `- **purpose**: ${s.purpose ?? "\u2014"}`,
+    `- **complexity**: cognitive ${s.complexity.cognitive ?? "\u2014"}, cyclomatic ${s.complexity.cyclomatic ?? "\u2014"}`,
+    `- **utilization**: ${s.utilization}`,
+    `- **blast radius**: ${round(s.blastRadius)}`,
+    ...renderConsumers(s.consumers)
+  ];
+  if (s.coupledWith.length) {
+    out.push("### Co-imported with");
+    for (const c of s.coupledWith) out.push(`- ${c.name} (\`${c.fileId}\`) \xD7${c.coImports}`);
+    out.push("");
   }
   return out;
 }
-function countByPackage(pairs) {
-  const out = /* @__PURE__ */ new Map();
-  const get = (id) => {
-    let c = out.get(id);
-    if (!c) {
-      c = { internal: 0, outgoing: 0, incoming: 0 };
-      out.set(id, c);
-    }
-    return c;
-  };
-  for (const p of pairs) {
-    if (p.from === p.to) {
-      get(p.from).internal += 1;
-    } else {
-      get(p.from).outgoing += 1;
-      get(p.to).incoming += 1;
+function renderFile(f) {
+  const m = f.metrics;
+  const own = f.ownership ? `${f.ownership.primaryOwner} (bus factor ${f.ownership.busFactor}, ${f.ownership.authorCount} authors)` : "\u2014";
+  const out = [
+    "## File",
+    `- **loc**: ${m.loc ?? "\u2014"} \xB7 **cognitive** ${m.cognitiveMax ?? "\u2014"} \xB7 **cyclomatic** ${m.cyclomaticMax ?? "\u2014"}`,
+    `- **fan-in/out**: ${m.fanIn ?? "\u2014"} / ${m.fanOut ?? "\u2014"} \xB7 **centrality**: ${round(f.centrality)}`,
+    `- **churn**: ${f.churn ? `${f.churn.value} (${f.churn.windowDays}d)` : "\u2014"} \xB7 **role**: ${m.role ?? "\u2014"}`,
+    `- **ownership**: ${own}`,
+    "",
+    ...section(`Depends on (${f.dependsOn.length})`, f.dependsOn),
+    ...renderConsumers(f.consumers)
+  ];
+  if (f.symbols.length) {
+    out.push(`### Symbols (${f.symbols.length})`);
+    for (const s of f.symbols) {
+      const tag = s.exported ? "export" : "internal";
+      const sig = s.signature ? ` \`${s.signature}\`` : "";
+      const imp = s.importance !== void 0 ? `, importance ${s.importance}` : "";
+      out.push(`- \`${s.name}\` (${tag})${sig} \u2014 util ${s.utilization}, cog ${s.cognitive ?? "\u2014"}, consumers ${s.consumers}${imp}`);
     }
+    out.push("");
+  }
+  if (f.blastRadius.length) {
+    out.push("### Blast radius (look here first)");
+    for (const b of f.blastRadius) out.push(`- \`${b.name}\` \u2014 score ${round(b.score)} (util ${b.utilization} \xD7 cog ${b.complexity} \xD7 churn ${b.churn})`);
+    out.push("");
   }
   return out;
 }
-function buildPackageStats(pkgId, counts, filesByPkg, abstractByPkg) {
-  const c = counts.get(pkgId) ?? { internal: 0, outgoing: 0, incoming: 0 };
-  const cohesion = ratioOrZero(c.internal, c.internal + c.outgoing);
-  const instability = ratioOrZero(c.outgoing, c.outgoing + c.incoming);
-  const fileCount = filesByPkg.get(pkgId) ?? 0;
-  const abstractness = ratioOrZero(abstractByPkg.get(pkgId) ?? 0, fileCount);
-  const layer = classifyLayer(instability);
-  const flags = [];
-  if (layer !== "top" && cohesion < WEAK_COHESION_MAX && c.internal + c.outgoing > 0) {
-    flags.push("weak-boundary");
-  }
+function section(title, items) {
+  if (!items.length) return [];
+  return [`### ${title}`, ...items.map((i) => `- \`${i}\``), ""];
+}
+function renderConsumers(c) {
+  const header = `### Consumers \u2014 ${c.counts.source} source, ${c.counts.test} test (${c.counts.total} total)`;
+  const rows = c.source.map((i) => `- \`${i}\``);
+  return [header, ...rows.length ? rows : ["- (no non-test consumers)"], `> ${c.note}`, ""];
+}
+function round(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/analysis/context/bundle.ts
+import { readFileSync as readFileSync3 } from "fs";
+import * as path12 from "path";
+var BUNDLE_SCHEMA_VERSION = "2";
+var EDGE_NOTE = "references resolve cross-file import usage (src = importing file \u2192 dst = symbol); a symbol's dependencies are its declaring file's outbound edges (the graph resolves the source side at file granularity).";
+var COVERAGE_NOTE = "coverage_pct overlay not ingested; run `graph coverage <istanbul-report>` to populate.";
+var SOURCE_READ_NOTE = "source file could not be read from the working tree at this path.";
+function weightOf(e) {
+  const w = e.attrs?.weight;
+  return typeof w === "number" ? w : 1;
+}
+function relevanceCtx(input) {
+  const { relevanceByFile, targetFileId: targetFileId2 } = input;
+  if (!relevanceByFile || relevanceByFile.size === 0 || targetFileId2 === void 0) return null;
+  return { relevanceByFile, targetFileId: targetFileId2 };
+}
+function fileOf(id) {
+  return parseSymbolId(id)?.fileId ?? id;
+}
+function rankEdges(edges, ctx) {
+  if (!ctx) return sortByWeight(edges);
+  const annotated = edges.map((e) => {
+    const neighbor = fileOf(e.from) === ctx.targetFileId ? fileOf(e.to) : fileOf(e.from);
+    return { ...e, relevance: round4(ctx.relevanceByFile.get(neighbor) ?? 0) };
+  });
+  return annotated.sort(
+    (a, b) => (b.relevance ?? 0) - (a.relevance ?? 0) || b.weight - a.weight || a.from.localeCompare(b.from) || a.to.localeCompare(b.to)
+  );
+}
+function sortByWeight(edges) {
+  return edges.sort(
+    (a, b) => b.weight - a.weight || a.from.localeCompare(b.from) || a.to.localeCompare(b.to)
+  );
+}
+function round4(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+function symbolEdges(input) {
+  const id = input.target.id;
+  const fileId2 = parseSymbolId(id)?.fileId ?? "";
+  const ctx = relevanceCtx(input);
+  const callers = input.refEdges.filter((e) => e.dstId === id).map((e) => ({ from: e.srcId, to: id, kind: "references", weight: weightOf(e) }));
+  const dependencies = [
+    ...input.refEdges.filter((e) => e.srcId === fileId2).map((e) => edge(e, "references")),
+    ...input.importEdges.filter((e) => e.srcId === fileId2).map((e) => edge(e, "imports"))
+  ];
+  const coupledWith = (input.dossier.symbol?.coupledWith ?? []).map((c) => ({
+    from: id,
+    to: c.symbolId,
+    kind: "coupled-with",
+    weight: c.coImports
+  }));
   return {
-    pkgId,
-    fileCount,
-    internalEdges: c.internal,
-    outgoingEdges: c.outgoing,
-    incomingEdges: c.incoming,
-    cohesion,
-    instability,
-    abstractness,
-    layer,
-    flags
+    callers: rankEdges(callers, ctx),
+    dependencies: rankEdges(dependencies, ctx),
+    coupledWith: rankEdges(coupledWith, ctx),
+    note: EDGE_NOTE
   };
 }
-function countAbstractFiles(nodes, pkgByFile) {
-  const out = /* @__PURE__ */ new Map();
-  for (const n of nodes) {
-    if (n.kind !== "file" || n.role !== "types") continue;
-    const pkg = pkgByFile.get(n.id);
-    if (pkg) out.set(pkg, (out.get(pkg) ?? 0) + 1);
+function fileEdges(input) {
+  const id = input.target.id;
+  const ctx = relevanceCtx(input);
+  const inbound = (e) => parseSymbolId(e.dstId)?.fileId === id;
+  const callers = [
+    ...input.refEdges.filter(inbound).map((e) => edge(e, "references")),
+    ...input.importEdges.filter((e) => e.dstId === id).map((e) => edge(e, "imports"))
+  ];
+  const dependencies = [
+    ...input.refEdges.filter((e) => e.srcId === id).map((e) => edge(e, "references")),
+    ...input.importEdges.filter((e) => e.srcId === id).map((e) => edge(e, "imports"))
+  ];
+  return {
+    callers: rankEdges(callers, ctx),
+    dependencies: rankEdges(dependencies, ctx),
+    coupledWith: [],
+    note: EDGE_NOTE
+  };
+}
+function edge(e, kind) {
+  return { from: e.srcId, to: e.dstId, kind, weight: weightOf(e) };
+}
+function readSource(input) {
+  const filePath = input.kind === "symbol" ? parseSymbolId(input.target.id)?.fileId ?? input.target.id : input.target.id;
+  const span = input.dossier.target.span ?? null;
+  const abs = input.repoRoot ? path12.join(input.repoRoot, filePath) : filePath;
+  try {
+    const content = readFileSync3(abs, "utf8");
+    const text = span ? sliceSpan(content, span) : content;
+    return { path: filePath, span, text };
+  } catch {
+    return { path: filePath, span, text: null, note: SOURCE_READ_NOTE };
   }
-  return out;
 }
-function ratioOrZero(num, denom) {
-  return denom === 0 ? 0 : num / denom;
+function sliceSpan(content, span) {
+  return content.split("\n").slice(span.startLine - 1, span.endLine).join("\n");
 }
-function classifyLayer(instability) {
-  if (instability <= FOUNDATION_INSTABILITY_MAX) return "foundation";
-  if (instability >= TOP_INSTABILITY_MIN) return "top";
-  return "middle";
+function buildContextBundle(input) {
+  return {
+    schemaVersion: BUNDLE_SCHEMA_VERSION,
+    dossier: input.dossier,
+    source: readSource(input),
+    edges: input.kind === "symbol" ? symbolEdges(input) : fileEdges(input),
+    coverage: {
+      pct: input.coveragePct,
+      note: input.coveragePct === null ? COVERAGE_NOTE : void 0
+    }
+  };
 }
-function buildPairCoupling(pairs, filesByPkg) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const p of pairs) {
-    if (p.from === p.to) continue;
-    const key = JSON.stringify([p.from, p.to]);
-    const entry = counts.get(key);
-    if (entry) entry.edges += 1;
-    else counts.set(key, { from: p.from, to: p.to, edges: 1 });
-  }
-  const out = [];
-  for (const { from, to, edges } of counts.values()) {
-    const filesFrom = filesByPkg.get(from) ?? 0;
-    const intensity = filesFrom === 0 ? 0 : edges / filesFrom;
-    const flag = classifyPairIntensity(intensity);
-    out.push({ from, to, edges, intensity, flag });
-  }
-  return out.sort(comparePairs2);
-}
-function classifyPairIntensity(intensity) {
-  if (intensity >= TIGHT_INTENSITY_MIN) return "tight";
-  if (intensity >= MODERATE_INTENSITY_MIN) return "moderate";
-  return "none";
-}
-function comparePairs2(a, b) {
-  if (a.from !== b.from) return a.from < b.from ? -1 : 1;
-  return a.to < b.to ? -1 : 1;
-}
-function computeModularity(perPackage, totalEdges) {
-  if (totalEdges === 0) return 0;
-  let Q = 0;
-  for (const p of perPackage) {
-    const e_cc = p.internalEdges / totalEdges;
-    const touching = p.internalEdges * 2 + p.outgoingEdges + p.incomingEdges;
-    const a_c = touching / (2 * totalEdges);
-    Q += e_cc - a_c * a_c;
-  }
-  return Q;
+function renderBundleText(bundle) {
+  const cov = bundle.coverage.pct === null ? "\u2014" : `${bundle.coverage.pct}%`;
+  return [
+    renderContextMarkdown(bundle.dossier),
+    "## Coverage",
+    `- **coverage**: ${cov}`,
+    "",
+    ...renderEdgeSection("Callers (inbound)", bundle.edges.callers),
+    ...renderEdgeSection("Dependencies (outbound)", bundle.edges.dependencies),
+    ...renderEdgeSection("Coupled with", bundle.edges.coupledWith),
+    "## Source",
+    "```typescript",
+    bundle.source.text ?? `// ${bundle.source.note ?? "unavailable"}`,
+    "```",
+    ""
+  ].join("\n");
+}
+function renderEdgeSection(title, edges) {
+  if (!edges.length) return [];
+  return [`### ${title}`, ...edges.map(renderEdgeLine), ""];
+}
+function renderEdgeLine(e) {
+  const rel = e.relevance !== void 0 ? `, rel ${e.relevance}` : "";
+  return `- \`${e.from}\` \u2192 \`${e.to}\` (${e.kind} \xD7${e.weight}${rel})`;
 }
 
 // src/analysis/snapshot.ts
@@ -4709,6 +5350,57 @@ function snapshotSymbolCoupling(store, snapshotId, options = {}) {
   return computeSymbolCoupling(snapshotReferenceEdges(store, snapshotId), options);
 }
 
+// src/analysis/dashboard-symbol-coupling.ts
+var MIN_SHARED_CONSUMERS = 2;
+var MAX_PAIRS = 40;
+var MAX_GROUPS = 15;
+var MAX_SYMBOLS_PER_GROUP = 10;
+var CONSUMER_SAMPLE = 12;
+function buildSymbolCouplingPayload(edges) {
+  return {
+    symbolCoupling: buildCouplingRows(edges),
+    symbolConsumers: buildConsumerGroups(edges)
+  };
+}
+function buildCouplingRows(edges) {
+  return computeSymbolCoupling(edges).slice(0, MAX_PAIRS).map((p) => ({
+    aName: p.aName,
+    aFile: p.aFile,
+    bName: p.bName,
+    bFile: p.bFile,
+    coImports: p.coImports,
+    crossFile: p.crossFile
+  }));
+}
+function buildConsumerGroups(edges) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const s of computeSymbolConsumers(edges)) {
+    if (s.consumers.length < MIN_SHARED_CONSUMERS) continue;
+    const bucket = byFile.get(s.fileId) ?? [];
+    bucket.push({
+      name: s.name,
+      consumers: s.consumers.slice(0, CONSUMER_SAMPLE),
+      consumerCount: s.consumers.length
+    });
+    byFile.set(s.fileId, bucket);
+  }
+  return foldGroups(byFile);
+}
+function foldGroups(byFile) {
+  const groups = [];
+  for (const [fileId2, symbols] of byFile) {
+    const kept = symbols.slice(0, MAX_SYMBOLS_PER_GROUP);
+    groups.push({
+      fileId: fileId2,
+      symbols: kept,
+      totalConsumers: kept.reduce((n, s) => n + s.consumerCount, 0)
+    });
+  }
+  return groups.sort(
+    (a, b) => b.symbols.length - a.symbols.length || b.totalConsumers - a.totalConsumers || (a.fileId < b.fileId ? -1 : 1)
+  ).slice(0, MAX_GROUPS);
+}
+
 // src/read.ts
 function listNodes(store, snapshotId, opts) {
   return store.listNodes(snapshotId, opts);
@@ -4804,7 +5496,7 @@ var SOURCE = [
     direction: "higher-worse",
     absent: "exclude",
     source: "source-metrics",
-    description: "Highest cyclomatic complexity of any function in the file."
+    description: "Highest cyclomatic complexity of any function in the file; points attention at branchy code."
   },
   {
     name: "cyclomatic_sum",
@@ -4814,7 +5506,7 @@ var SOURCE = [
     direction: "higher-worse",
     absent: "zero",
     source: "source-metrics",
-    description: "Cyclomatic complexity summed over the file's functions."
+    description: "Cyclomatic complexity summed over the file's functions; points attention at branchy code."
   },
   {
     name: "cognitive_max",
@@ -4824,7 +5516,7 @@ var SOURCE = [
     direction: "higher-worse",
     absent: "exclude",
     source: "source-metrics",
-    description: "Highest cognitive complexity of any function in the file."
+    description: "Highest cognitive complexity of any function in the file, an estimate of comprehension friction."
   },
   {
     name: "cognitive_sum",
@@ -4834,7 +5526,7 @@ var SOURCE = [
     direction: "higher-worse",
     absent: "zero",
     source: "source-metrics",
-    description: "Cognitive complexity summed over the file's functions."
+    description: "Cognitive complexity summed over the file's functions, an estimate of comprehension friction."
   },
   {
     name: "max_nesting_depth",
@@ -4846,6 +5538,16 @@ var SOURCE = [
     source: "source-metrics",
     description: "Deepest block nesting inside any function in the file."
   },
+  {
+    name: "jsx_depth_max",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Deepest JSX element tree in the file: the max of symbol_jsx_depth over its functions and module-scope JSX. Written only when > 0."
+  },
   {
     name: "symbol_cognitive",
     unit: "count",
@@ -4854,7 +5556,7 @@ var SOURCE = [
     direction: "higher-worse",
     absent: "exclude",
     source: "source-metrics",
-    description: "Cognitive complexity of the function a symbol names; the max when several functions share the name."
+    description: "Cognitive complexity (comprehension friction) of the function a symbol names; the max when several functions share the name."
   },
   {
     name: "symbol_cyclomatic",
@@ -4864,7 +5566,7 @@ var SOURCE = [
     direction: "higher-worse",
     absent: "exclude",
     source: "source-metrics",
-    description: "Cyclomatic complexity of the function a symbol names; the max when several functions share the name."
+    description: "Cyclomatic complexity (an attention pointer) of the function a symbol names; the max when several functions share the name."
   },
   {
     name: "symbol_loc",
@@ -4886,6 +5588,16 @@ var SOURCE = [
     source: "source-metrics",
     description: "Deepest block nesting inside the function a symbol names; the max when several share the name."
   },
+  {
+    name: "symbol_jsx_depth",
+    unit: "count",
+    appliesTo: SYMBOL,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Most JSX elements on one ancestor chain in the function, fragments not counted. Walks into {\u2026} and inline callbacks, stops at a nested named function; attribute JSX sits one below its owner. Written only when > 0."
+  },
   {
     name: "symbol_comment_lines",
     unit: "lines",
@@ -5132,7 +5844,7 @@ var HISTORY = [
     absent: "exclude",
     source: "history",
     windowed: true,
-    description: "min(1, file age / window) for a file that churned in the {w} window; 1 for lifetime. A hotspot discount."
+    description: "min(1, file age / window) for a file that churned in the {w} window; 1 for lifetime. Discounts the hotspot score, churn \xD7 complexity after Adam Tornhill and CodeScene."
   },
   {
     name: "file_age_days",
@@ -5275,39 +5987,6 @@ function indexMetrics(metrics) {
   return metricsByNode;
 }
 
-// src/check/patterns.ts
-function patternToRegex(pattern) {
-  if (!pattern.includes("*")) {
-    return new RegExp(escapeRegex(pattern));
-  }
-  let out = "";
-  for (let i = 0; i < pattern.length; i++) {
-    const c = pattern[i];
-    if (c === "*" && pattern[i + 1] === "*") {
-      out += ".*";
-      i++;
-    } else if (c === "*") {
-      out += "[^/]*";
-    } else {
-      out += escapeRegex(c);
-    }
-  }
-  return new RegExp(`^${out}$`);
-}
-function compilePatterns(patterns) {
-  if (!patterns) return [];
-  return patterns.map(patternToRegex);
-}
-function matchesAny(value, patterns) {
-  for (const rx of patterns) {
-    if (rx.test(value)) return true;
-  }
-  return false;
-}
-function escapeRegex(s) {
-  return s.replace(/[.+?(){}|^$\\[\]]/g, "\\$&");
-}
-
 // src/check/rule-helpers.ts
 function severityOf(rule) {
   return rule.severity ?? "error";
@@ -5316,8 +5995,8 @@ function formatNumber(n) {
   if (Number.isInteger(n)) return String(n);
   return n.toFixed(3).replace(/\.?0+$/, "");
 }
-function isImportEdge(edge) {
-  return edge.kind === "imports" || edge.kind === "re-exports";
+function isImportEdge(edge2) {
+  return edge2.kind === "imports" || edge2.kind === "re-exports";
 }
 function longestPrefixMatcher(prefixes) {
   const byLength = [...prefixes].sort((a, b) => b.length - a.length);
@@ -5340,11 +6019,17 @@ function layerIndex(layers) {
 function runLayeredDepsRule(rule, ctx) {
   const packageLayer = layerIndex(rule.layers);
   const packageOf = longestPrefixMatcher([...packageLayer.keys()]);
+  const excludedRoles = new Set(rule.excludeRoles ?? []);
+  const hasExcludedRole = (id) => {
+    const role = ctx.nodesById.get(id)?.role;
+    return role !== void 0 && excludedRoles.has(role);
+  };
   const out = [];
-  for (const edge of ctx.edges) {
-    if (!isImportEdge(edge)) continue;
-    const srcPkg = packageOf(edge.srcId);
-    const dstPkg = packageOf(edge.dstId);
+  for (const edge2 of ctx.edges) {
+    if (!isImportEdge(edge2)) continue;
+    if (hasExcludedRole(edge2.srcId) || hasExcludedRole(edge2.dstId)) continue;
+    const srcPkg = packageOf(edge2.srcId);
+    const dstPkg = packageOf(edge2.dstId);
     if (srcPkg === null || dstPkg === null) continue;
     const srcLayer = packageLayer.get(srcPkg);
     const dstLayer = packageLayer.get(dstPkg);
@@ -5352,9 +6037,9 @@ function runLayeredDepsRule(rule, ctx) {
     out.push({
       ruleId: rule.id,
       severity: severityOf(rule),
-      nodeId: edge.srcId,
-      destinationId: edge.dstId,
-      message: `${srcPkg} (layer ${srcLayer}) imports ${dstPkg} (layer ${dstLayer})`
+      nodeId: edge2.srcId,
+      destinationId: edge2.dstId,
+      message: `${edge2.srcId} (${srcPkg}, layer ${srcLayer}) imports ${edge2.dstId} (${dstPkg}, layer ${dstLayer})`
     });
   }
   return out;
@@ -5362,31 +6047,32 @@ function runLayeredDepsRule(rule, ctx) {
 function runForbidImportRule(rule, ctx) {
   const fromRx = compilePatterns([rule.from]);
   const toRx = compilePatterns([rule.to]);
+  const exceptRx = compilePatterns(rule.except);
   const out = [];
-  for (const edge of ctx.edges) {
-    if (!isImportEdge(edge)) continue;
-    if (!matchesAny(edge.srcId, fromRx)) continue;
-    if (!matchesAny(edge.dstId, toRx)) continue;
+  for (const edge2 of ctx.edges) {
+    if (!isImportEdge(edge2)) continue;
+    if (!matchesAny(edge2.srcId, fromRx)) continue;
+    if (!matchesAny(edge2.dstId, toRx) || matchesAny(edge2.dstId, exceptRx)) continue;
     out.push({
       ruleId: rule.id,
       severity: severityOf(rule),
-      nodeId: edge.srcId,
-      destinationId: edge.dstId,
-      message: `${edge.srcId} imports ${edge.dstId} (forbidden: ${rule.from} \u2192 ${rule.to})`
+      nodeId: edge2.srcId,
+      destinationId: edge2.dstId,
+      message: `${edge2.srcId} imports ${edge2.dstId} (forbidden: ${rule.from} \u2192 ${rule.to})`
     });
   }
   return out;
 }
 function importersByDestination(edges) {
   const importersByDst = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    if (!isImportEdge(edge)) continue;
-    let list = importersByDst.get(edge.dstId);
+  for (const edge2 of edges) {
+    if (!isImportEdge(edge2)) continue;
+    let list = importersByDst.get(edge2.dstId);
     if (!list) {
       list = [];
-      importersByDst.set(edge.dstId, list);
+      importersByDst.set(edge2.dstId, list);
     }
-    list.push(edge.srcId);
+    list.push(edge2.srcId);
   }
   return importersByDst;
 }
@@ -5621,13 +6307,6 @@ function collectBaselineKeys(store, baselineSnapshotId, snapshotId, rules) {
   }
   return keys;
 }
-function violationKey(v) {
-  return v.destinationId ? `${v.ruleId}|${v.nodeId}|${v.destinationId}` : `${v.ruleId}|${v.nodeId}`;
-}
-function rebasedViolationKey(v, resolve4) {
-  const destinationId = v.destinationId ? resolve4(v.destinationId) : v.destinationId;
-  return violationKey({ ...v, nodeId: resolve4(v.nodeId), destinationId });
-}
 function countByOriginAndSeverity(violations) {
   const counts = { newErrors: 0, newWarnings: 0, carryoverErrors: 0, carryoverWarnings: 0 };
   for (const v of violations) {
@@ -5845,7 +6524,7 @@ function validateRule(raw, index, warn) {
     case "forbid-import":
       return assertForbidImport(r);
     case "layered-deps":
-      return assertLayeredDeps(r);
+      return assertLayeredDeps(r, warn);
     case "no-internal-only-barrels":
       return assertNoInternalOnlyBarrels(r);
     default:
@@ -5867,11 +6546,11 @@ function assertNoInternalOnlyBarrels(r) {
     type: "no-internal-only-barrels",
     id: r.id,
     packageRoots: r.packageRoots,
-    severity: r.severity,
-    exclude: parseStringArray(r.exclude)
+    severity: parseSeverity(r),
+    exclude: parseExclude(r)
   };
 }
-function assertLayeredDeps(r) {
+function assertLayeredDeps(r, warn) {
   if (!Array.isArray(r.layers) || r.layers.length < 2) {
     throw new Error(`${r.id}: layers must be an array of 2+ string arrays`);
   }
@@ -5896,7 +6575,8 @@ function assertLayeredDeps(r) {
     type: "layered-deps",
     id: r.id,
     layers: r.layers,
-    severity: r.severity
+    severity: parseSeverity(r),
+    excludeRoles: parseRoleArray(r.id, r.excludeRoles, warn)
   };
 }
 function assertMetricProductMax(r, warn) {
@@ -5915,9 +6595,9 @@ function assertMetricProductMax(r, warn) {
     id: ruleId,
     metrics: r.metrics.map((m) => healMetricName(m, ruleId, warn)),
     max: r.max,
-    kind: r.kind,
-    severity: r.severity,
-    exclude: parseStringArray(r.exclude),
+    kind: parseOptionalKind(r),
+    severity: parseSeverity(r),
+    exclude: parseExclude(r),
     excludeRoles: parseRoleArray(ruleId, r.excludeRoles, warn)
   };
 }
@@ -5930,9 +6610,9 @@ function assertMetricMax(r, warn) {
     id: ruleId,
     metric: healMetricName(r.metric, ruleId, warn),
     max: r.max,
-    kind: r.kind,
-    severity: r.severity,
-    exclude: parseStringArray(r.exclude),
+    kind: parseOptionalKind(r),
+    severity: parseSeverity(r),
+    exclude: parseExclude(r),
     excludeRoles: parseRoleArray(ruleId, r.excludeRoles, warn)
   };
 }
@@ -5945,18 +6625,16 @@ function assertMetricMin(r, warn) {
     id: ruleId,
     metric: healMetricName(r.metric, ruleId, warn),
     min: r.min,
-    kind: r.kind,
-    severity: r.severity,
-    exclude: parseStringArray(r.exclude),
+    kind: parseOptionalKind(r),
+    severity: parseSeverity(r),
+    exclude: parseExclude(r),
     excludeRoles: parseRoleArray(ruleId, r.excludeRoles, warn)
   };
 }
 var NODE_KINDS = /* @__PURE__ */ new Set(["package", "module", "file", "symbol", "external"]);
 function assertMetricOutlier(r, warn) {
   if (typeof r.metric !== "string") throw new Error(`${r.id}: metric must be a string`);
-  if (typeof r.kind !== "string" || !NODE_KINDS.has(r.kind)) {
-    throw new Error(`${r.id}: kind must be one of ${[...NODE_KINDS].join(", ")}`);
-  }
+  if (!isNodeKind(r.kind)) throw kindError(r.id);
   if (typeof r.percentile !== "number" || r.percentile < 50 || r.percentile > 100) {
     throw new Error(`${r.id}: percentile must be a number from 50 to 100`);
   }
@@ -5979,7 +6657,7 @@ function assertMetricOutlier(r, warn) {
     minSample: r.minSample,
     floor: r.floor,
     rankNonZero: r.rankNonZero,
-    severity: r.severity
+    severity: parseSeverity(r)
   };
 }
 function assertForbidImport(r) {
@@ -5990,15 +6668,43 @@ function assertForbidImport(r) {
     id: r.id,
     from: r.from,
     to: r.to,
-    severity: r.severity
+    except: parseStringList(r, "except"),
+    severity: parseSeverity(r)
   };
 }
-function parseStringArray(value) {
-  return Array.isArray(value) ? value : void 0;
+function isNodeKind(value) {
+  return typeof value === "string" && NODE_KINDS.has(value);
+}
+function kindError(ruleId) {
+  return new Error(`${ruleId}: kind must be one of ${[...NODE_KINDS].join(", ")}`);
+}
+function parseOptionalKind(r) {
+  if (r.kind === void 0) return void 0;
+  if (!isNodeKind(r.kind)) throw kindError(r.id);
+  return r.kind;
+}
+function parseSeverity(r) {
+  if (r.severity === void 0 || r.severity === "error" || r.severity === "warning") {
+    return r.severity;
+  }
+  throw new Error(`${r.id}: severity must be "error" or "warning"`);
+}
+function parseExclude(r) {
+  return parseStringList(r, "exclude");
+}
+function parseStringList(r, key) {
+  const value = r[key];
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || !value.every((e) => typeof e === "string")) {
+    throw new Error(`${r.id}: ${key} must be an array of strings`);
+  }
+  return value;
 }
 var ROLE_VALUES = /* @__PURE__ */ new Set([
   "test",
   "fixture",
+  "story",
+  "lab",
   "barrel",
   "types",
   "config",
@@ -6029,7 +6735,7 @@ function healRole(entry, ruleId, warn) {
 }
 
 // src/check/run.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile } from "fs/promises";
 function resolveSnapshot(store, spec) {
   if (typeof spec === "number" || /^\d+$/.test(spec)) {
     const snap2 = store.getSnapshot(Number(spec));
@@ -6050,18 +6756,18 @@ function checkSnapshot(store, options) {
   });
   return { snapshot, baselineSnapshot, result };
 }
-async function loadCheckRules(path11, options = {}) {
+async function loadCheckRules(path14, options = {}) {
   let raw;
   try {
-    raw = await readFile2(path11, "utf8");
+    raw = await readFile(path14, "utf8");
   } catch (err) {
-    throw new Error(`Cannot read rules file at ${path11}: ${errorMessage(err)}`);
+    throw new Error(`Cannot read rules file at ${path14}: ${errorMessage(err)}`);
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    throw new Error(`Invalid JSON in ${path11}: ${errorMessage(err)}`);
+    throw new Error(`Invalid JSON in ${path14}: ${errorMessage(err)}`);
   }
   return validateRules(parsed, options);
 }
@@ -6191,44 +6897,16 @@ function diffCheckResults(store, options) {
     fromSnapshotId: options.fromSnapshotId,
     toSnapshotId: options.toSnapshotId,
     rulesEvaluated: options.rules.length,
-    ...bucketViolations(indexByKey(from.violations, chain.resolve), indexByKey(to.violations))
+    ...bucketViolations(from.violations, to.violations, chain.resolve)
   };
 }
-function bucketViolations(fromByKey, toByKey) {
-  const buckets = { newViolations: [], resolvedViolations: [], unchanged: [], worsened: [], improved: [] };
-  for (const [key, toV] of toByKey) {
-    const fromV = fromByKey.get(key);
-    if (!fromV) {
-      buckets.newViolations.push(toV);
-      continue;
-    }
-    const delta = computeDelta(fromV, toV);
-    const entry = { from: fromV, to: toV, delta };
-    buckets.unchanged.push(entry);
-    if (delta !== null && delta > 0) buckets.worsened.push(entry);
-    else if (delta !== null && delta < 0) buckets.improved.push(entry);
-  }
-  for (const [key, fromV] of fromByKey) {
-    if (!toByKey.has(key)) buckets.resolvedViolations.push(fromV);
-  }
-  return buckets;
-}
-function indexByKey(violations, resolve4) {
-  const out = /* @__PURE__ */ new Map();
-  for (const v of violations) out.set(resolve4 ? rebasedViolationKey(v, resolve4) : violationKey(v), v);
-  return out;
-}
-function computeDelta(from, to) {
-  if (from.value === void 0 || to.value === void 0) return null;
-  return to.value - from.value;
-}
 
 // src/diff/footprint.ts
-var DEFAULT_MIN_CO_IMPORTS2 = 2;
+var DEFAULT_MIN_CO_IMPORTS = 2;
 function computeFootprints(graph, options = {}) {
   const edges = referenceEdges(graph.edges, options.ignoreConsumer);
   const consumers = consumersBySymbol(edges);
-  const partners = partnersBySymbol(edges, options.minCoImports ?? DEFAULT_MIN_CO_IMPORTS2);
+  const partners = partnersBySymbol(edges, options.minCoImports ?? DEFAULT_MIN_CO_IMPORTS);
   const out = /* @__PURE__ */ new Map();
   for (const node of graph.nodes) {
     if (node.kind !== "symbol") continue;
@@ -6284,18 +6962,18 @@ function partnersBySymbol(edges, minCoImports) {
 var PART_REASONS = ["signature", "consumers", "coupling"];
 function diffFootprints(store, options) {
   const { fromSnapshotId, toSnapshotId } = options;
-  const resolve4 = symbolAwareResolver(aliasChain(store, fromSnapshotId, toSnapshotId));
+  const resolve5 = symbolAwareResolver(aliasChain(store, fromSnapshotId, toSnapshotId));
   const fromGraph = loadSymbolLayer(store, fromSnapshotId);
   const toGraph = loadSymbolLayer(store, toSnapshotId);
-  const { previousIds, mergedAway } = mergeSources(fromGraph.nodes, resolve4);
-  const before = computeFootprints(remapGraph(fromGraph, resolve4, new Set(mergedAway)), options);
+  const { previousIds, mergedAway } = mergeSources(fromGraph.nodes, resolve5);
+  const before = computeFootprints(remapGraph(fromGraph, resolve5, new Set(mergedAway)), options);
   const after = computeFootprints(toGraph, options);
   const changes = [
     ...changedOrAdded(after, before, previousIds),
-    ...removed(before, after, previousIds, resolve4),
-    ...mergedAway.map((id) => ({ symbolId: id, status: "removed", reasons: [], fileId: resolve4(declaringFile(id)) }))
-  ].sort((a, b) => compare2(a.symbolId, b.symbolId));
-  const files = [...new Set(changes.map((c) => c.fileId))].sort(compare2);
+    ...removed(before, after, previousIds, resolve5),
+    ...mergedAway.map((id) => ({ symbolId: id, status: "removed", reasons: [], fileId: resolve5(declaringFile(id)) }))
+  ].sort((a, b) => compare3(a.symbolId, b.symbolId));
+  const files = [...new Set(changes.map((c) => c.fileId))].sort(compare3);
   return { fromSnapshotId, toSnapshotId, changes, files };
 }
 function loadSymbolLayer(store, snapshotId) {
@@ -6312,22 +6990,22 @@ function symbolAwareResolver(aliases) {
     return parsed ? symbolId(aliases.resolve(parsed.fileId), parsed.name) : id;
   };
 }
-function remapGraph(graph, resolve4, losers) {
+function remapGraph(graph, resolve5, losers) {
   return {
-    nodes: graph.nodes.filter((n) => !losers.has(n.id)).map((n) => ({ ...n, id: resolve4(n.id) })),
-    edges: graph.edges.filter((e) => !losers.has(e.srcId) && !losers.has(e.dstId)).map((e) => ({ ...e, srcId: resolve4(e.srcId), dstId: resolve4(e.dstId) }))
+    nodes: graph.nodes.filter((n) => !losers.has(n.id)).map((n) => ({ ...n, id: resolve5(n.id) })),
+    edges: graph.edges.filter((e) => !losers.has(e.srcId) && !losers.has(e.dstId)).map((e) => ({ ...e, srcId: resolve5(e.srcId), dstId: resolve5(e.dstId) }))
   };
 }
-function mergeSources(nodes, resolve4) {
+function mergeSources(nodes, resolve5) {
   const groups = /* @__PURE__ */ new Map();
   for (const node of nodes) {
-    const id = resolve4(node.id);
+    const id = resolve5(node.id);
     groups.set(id, [...groups.get(id) ?? [], node.id]);
   }
   const previousIds = /* @__PURE__ */ new Map();
   const mergedAway = [];
   for (const [id, sources] of groups) {
-    const keeper = sources.includes(id) ? id : [...sources].sort(compare2)[0];
+    const keeper = sources.includes(id) ? id : [...sources].sort(compare3)[0];
     if (keeper !== id) previousIds.set(id, keeper);
     mergedAway.push(...sources.filter((source) => source !== keeper));
   }
@@ -6353,19 +7031,19 @@ function reasonsFor(prior, current, renamed) {
   if (renamed) reasons.push("renamed");
   return reasons;
 }
-function removed(before, after, previousIds, resolve4) {
+function removed(before, after, previousIds, resolve5) {
   const out = [];
   for (const id of before.keys()) {
     if (after.has(id)) continue;
     const fromId = previousIds.get(id) ?? id;
-    out.push({ symbolId: fromId, status: "removed", reasons: [], fileId: resolve4(declaringFile(fromId)) });
+    out.push({ symbolId: fromId, status: "removed", reasons: [], fileId: resolve5(declaringFile(fromId)) });
   }
   return out;
 }
 function declaringFile(id) {
   return parseSymbolId(id)?.fileId ?? id;
 }
-function compare2(a, b) {
+function compare3(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
 
@@ -6463,17 +7141,17 @@ function storeVectors(store, model, rows) {
 async function embedTextsCached(store, embedder, texts) {
   const hashes = texts.map((t) => hashEmbedText(t));
   const byHash = loadVectorsByHash(store, embedder.model, hashes);
-  const missing = /* @__PURE__ */ new Map();
+  const missing2 = /* @__PURE__ */ new Map();
   texts.forEach((text, i) => {
-    if (!byHash.has(hashes[i])) missing.set(hashes[i], text);
+    if (!byHash.has(hashes[i])) missing2.set(hashes[i], text);
   });
-  const pending = [...missing.entries()];
+  const pending = [...missing2.entries()];
   for (let i = 0; i < pending.length; i += EMBED_BATCH_SIZE) {
     const rows = await embedBatch(embedder, pending.slice(i, i + EMBED_BATCH_SIZE));
     storeVectors(store, embedder.model, rows);
     for (const r of rows) byHash.set(r.textHash, r.vector);
   }
-  return { byHash, newHashes: new Set(missing.keys()) };
+  return { byHash, newHashes: new Set(missing2.keys()) };
 }
 async function embedBatch(embedder, batch) {
   const vectors = await embedder.embed(batch.map(([, text]) => text), { role: "document" });
@@ -6643,7 +7321,7 @@ function pushMulti(map, key, value) {
 }
 
 // src/conventions/areas.ts
-import * as path10 from "path";
+import * as path13 from "path";
 import { contentHashOf as contentHashOf2 } from "@titan-design/store-sqlite";
 var DEFAULT_MIN_SIZE = 3;
 var PROMPT_FILE_CAP = 30;
@@ -6727,7 +7405,7 @@ function rankByDegree(members, edges) {
 function dominantDirectory(files) {
   const counts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const dir = path10.posix.dirname(f);
+    const dir = path13.posix.dirname(f);
     counts.set(dir, (counts.get(dir) ?? 0) + 1);
   }
   const dirs = [...counts.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1));
@@ -6847,14 +7525,21 @@ function toMatch(area, score) {
 export {
   ALIAS_BASE_ATTR,
   ALL_ROLES,
+  BUNDLE_SCHEMA_VERSION,
   COMMUNITY_SUMMARY_NAMESPACE,
+  SCHEMA_VERSION2 as CONTEXT_SCHEMA_VERSION,
   COVERAGE_METRIC_NAME,
   CodeGraphStore,
   DEAD_CODE_METRIC_NAMES,
   DEFAULT_CHURN_WINDOWS,
+  DEFAULT_HEALTH_WEIGHTS,
+  DEFAULT_MAX_LINE_CHARS,
+  DEFAULT_MAX_PACKAGE_SIZE,
   DEFAULT_OUTLIER_MIN_SAMPLE,
   DOMAIN_DDL,
+  ELISION_MARKER,
   EXCEPTION_METRIC_NAMES,
+  EXTERNAL_BUCKET,
   FINDING_DDL,
   GROWTH_RISK_METRIC_NAMES,
   INDEX_VERSION,
@@ -6869,35 +7554,55 @@ export {
   SYMBOL_EMBEDDING_NAMESPACE,
   SYMBOL_ID_SEP,
   SYMBOL_METRIC_NAMES,
+  TRUNCATION_SUFFIX,
   TsMorphGraphExtractor,
+  UNIMPORTED_ROLES,
+  aggregateEdges,
   aggregateMetrics,
   aliasChain,
   annotateRoles,
   attributeCoverage,
+  bucketFilesByPackage,
+  bucketViolations,
   buildAliases,
+  buildBlastRadius,
+  buildCentralFiles,
+  buildContextBundle,
+  buildContextDossier,
   buildConventionAreas,
   buildEmbedText,
   buildFileModuleNodes,
+  buildHotExports,
   buildIndexerMetrics,
   buildLineage,
+  buildNodeMetrics,
+  buildReportContext,
+  buildSymbolCouplingPayload,
+  busFactorOf,
   canonicalEdgeKind,
   canonicalMetricName,
   canonicalRole,
   carryForwardVerdicts,
   checkSnapshot,
+  classifyCoupling,
   classifyRole,
   collectDeclaredNames,
   collectDeclaredSpans,
+  collectNodeMetrics,
+  collectSymbolUtil,
   compilePatterns,
+  computeArch,
   computeDeadCodeMetrics,
   computeDeepAst,
   computeFootprints,
   computeGrowthRiskMetrics,
+  computeHealth,
   computeMetrics,
   computePageRank,
   computePartitionQuality,
   computeRecencyWindows,
   computeRelevance,
+  computeReportDrift,
   computeRoleHints,
   computeSourceMetrics,
   computeSymbolConsumers,
@@ -6920,6 +7625,7 @@ export {
   externalId,
   externalToFinding,
   fileId,
+  filteredFileIds,
   findConventions,
   findSimilarCapability,
   findingKey,
@@ -6928,15 +7634,20 @@ export {
   getEdgeWeight,
   getLanguageFromPath3 as getLanguageFromPath,
   getSupportedLanguages,
+  gitTreeSource,
   groupTestsBySource,
   hashContent,
   hashEmbedText,
   hashText,
+  hotspotScoreOf,
+  importMarker,
   indexPaths,
   invertBuckets,
   isGeneratedByHeuristic,
   isGeneratedFile,
   isInsideGitRepo,
+  isMinifyLanguage,
+  keepNode,
   keyFindings,
   lineagePath,
   linkTestsToSources,
@@ -6952,21 +7663,32 @@ export {
   loadGeneratedPatterns,
   loadHistoryMetrics,
   loadLineage,
+  loadRoleGlobs,
+  lookupMetric,
   matchesAny,
+  minifySource,
   moduleId,
   normalizeFlaggedText,
   openCodeGraph,
+  originalLine,
   packageId,
+  packagesReferencedByEdges,
+  pairKey,
   parentModuleId,
-  parseFile2 as parseFile,
+  parseFile3 as parseFile,
   parseSymbolId,
   patternToRegex,
   percentileOf,
   planPrune,
   priorSnapshotForRef,
   pruneDanglingReferences,
+  publicApiFiles,
   readSourceFiles,
   rebasedViolationKey,
+  referencedNodes,
+  renderBundleText,
+  renderContextMarkdown,
+  renderSignatureTree,
   resolveAlias,
   resolveBarrelEdges,
   resolveChurnWindows,
@@ -6976,7 +7698,7 @@ export {
   runPrune,
   saveFindings,
   saveVerdicts,
-  shouldIncludeFile2 as shouldIncludeFile,
+  shouldIncludeFile3 as shouldIncludeFile,
   snapshotPageRank,
   snapshotReferenceEdges,
   snapshotRelevance,
@@ -6989,11 +7711,21 @@ export {
   symbolSetHash,
   testCoverageCountMetrics,
   toFindings,
+  toSortedEdges,
+  topBusFactorRisks,
+  topCentralFiles,
+  topDeadModules,
+  topGrowthRisks,
+  topHotspots,
+  topTestCoverageRisks,
+  topUntestedRisks,
+  topUnusedExports,
   tryEmbedSnapshot,
   unitProvenance,
   validateRules,
   violationKey,
   walkSourceFiles,
-  windowSuffix
+  windowSuffix,
+  workingTreeSource
 };
 //# sourceMappingURL=index.js.map