@ctxo/cli 0.13.1 → 0.15.0

package/dist/{chunk-WB7WZKX4.js → chunk-A4URKKPP.js}

@@ -1,40 +1,248 @@
 #!/usr/bin/env node
 import {
-  atomicWrite
-} from "./chunk-RFEXMBTG.js";
+  DATA_EDGE_KINDS,
+  createTestFileClassifier,
+  filesWithTestAnnotations
+} from "./chunk-I7RPXT6L.js";
+import {
+  compareCodepoint
+} from "./chunk-72CEQEQD.js";
 import {
   CoChangeMatrixSchema,
   EDGE_KINDS,
   EdgeKindSchema,
   JsonIndexReader
-} from "./chunk-DT3ZH4AU.js";
+} from "./chunk-EC6INGPV.js";
+import {
+  atomicWrite
+} from "./chunk-RFEXMBTG.js";
 import {
   createLogger
 } from "./chunk-5DSKZJNN.js";
 
+// src/adapters/workspace/single-package-workspace.ts
+import { existsSync, readdirSync } from "fs";
+import { join, resolve } from "path";
+var MANIFEST_CANDIDATES = [
+  "package.json",
+  "pyproject.toml",
+  "setup.py",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "go.mod",
+  "Cargo.toml"
+];
+function findManifest(dir) {
+  for (const name of MANIFEST_CANDIDATES) {
+    const candidate = join(dir, name);
+    if (existsSync(candidate)) return candidate;
+  }
+  const csproj = findFirstByExt(dir, ".csproj") ?? findFirstByExt(dir, ".sln");
+  if (csproj) return csproj;
+  return join(dir, "package.json");
+}
+function findFirstByExt(dir, ext) {
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(ext)) return join(dir, entry.name);
+    }
+  } catch {
+  }
+  return null;
+}
+function detectWorkspace(cwd) {
+  const root = resolve(cwd);
+  const pkg = {
+    root,
+    manifest: findManifest(root)
+  };
+  return {
+    root,
+    packages: [pkg]
+  };
+}
+
+// src/adapters/storage/co-change-reader.ts
+import { readFileSync, statSync } from "fs";
+import { join as join2 } from "path";
+
+// src/core/co-change/co-change-analyzer.ts
+var MIN_FREQUENCY = 0.1;
+function buildCoChangeMatrix(windowed, options) {
+  const commitsPerFile = /* @__PURE__ */ new Map();
+  const sharedPerPair = /* @__PURE__ */ new Map();
+  let commitsUsed = 0;
+  let massSkipped = 0;
+  for (const commit of windowed) {
+    const files = includedFiles(commit, options.isIncluded);
+    if (files.length === 0) continue;
+    if (files.length > options.maxFilesPerCommit) {
+      massSkipped++;
+      continue;
+    }
+    commitsUsed++;
+    for (const file of files) {
+      commitsPerFile.set(file, (commitsPerFile.get(file) ?? 0) + 1);
+    }
+    for (let i = 0; i < files.length - 1; i++) {
+      const file1 = files[i];
+      let partners = sharedPerPair.get(file1);
+      if (!partners) {
+        partners = /* @__PURE__ */ new Map();
+        sharedPerPair.set(file1, partners);
+      }
+      for (let j = i + 1; j < files.length; j++) {
+        const file2 = files[j];
+        partners.set(file2, (partners.get(file2) ?? 0) + 1);
+      }
+    }
+  }
+  const entries = [];
+  for (const [file1, partners] of sharedPerPair) {
+    for (const [file2, sharedCommits] of partners) {
+      if (sharedCommits < options.minShared) continue;
+      const smallerHistory = Math.min(commitsPerFile.get(file1), commitsPerFile.get(file2));
+      const frequency = Math.round(sharedCommits / smallerHistory * 1e3) / 1e3;
+      if (frequency < MIN_FREQUENCY) continue;
+      entries.push({ file1, file2, sharedCommits, frequency });
+    }
+  }
+  entries.sort(compareEntries);
+  const window = {
+    maxCommits: options.maxCommits,
+    ...options.since !== void 0 ? { since: options.since } : {},
+    head: options.head,
+    commitsScanned: windowed.length,
+    commitsUsed,
+    massSkipped,
+    maxFilesPerCommit: options.maxFilesPerCommit,
+    minShared: options.minShared
+  };
+  return { version: 1, timestamp: options.timestamp, window, entries };
+}
+function includedFiles(commit, isIncluded) {
+  const included = /* @__PURE__ */ new Set();
+  for (const file of commit.files) {
+    if (isIncluded(file)) included.add(file);
+  }
+  return [...included].sort(compareCodepoint);
+}
+function compareEntries(a, b) {
+  return b.frequency - a.frequency || b.sharedCommits - a.sharedCommits || compareCodepoint(a.file1, b.file1) || compareCodepoint(a.file2, b.file2);
+}
+function loadCoChangeMap(matrix) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of matrix.entries) {
+    let list1 = map.get(entry.file1);
+    if (!list1) {
+      list1 = [];
+      map.set(entry.file1, list1);
+    }
+    list1.push(entry);
+    let list2 = map.get(entry.file2);
+    if (!list2) {
+      list2 = [];
+      map.set(entry.file2, list2);
+    }
+    list2.push(entry);
+  }
+  return map;
+}
+
+// src/adapters/storage/co-change-reader.ts
+var log = createLogger("ctxo:co-change");
+var UNTIL_REWRITTEN = "co-change is ignored until ctxo index rewrites it";
+var UNTIL_RETRY = "co-change is ignored for now and the next call tries again";
+var CoChangeReader = class {
+  filePath;
+  cached;
+  /** What the last warning was about, so one problem is reported once. */
+  lastWarning;
+  constructor(ctxoRoot) {
+    this.filePath = join2(ctxoRoot, "index", "co-changes.json");
+  }
+  readCoChangeMap() {
+    let stats;
+    try {
+      stats = statSync(this.filePath);
+    } catch (err) {
+      this.cached = void 0;
+      const { code, message } = err;
+      if (code === "ENOENT") {
+        this.lastWarning = void 0;
+      } else {
+        this.warnOnce(`stat ${code ?? message}`, `cannot be inspected (${message})`, UNTIL_RETRY);
+      }
+      return void 0;
+    }
+    const version = `${stats.mtimeMs}:${stats.size}`;
+    if (this.cached?.version === version) return this.cached.map;
+    return this.load(version);
+  }
+  load(version) {
+    let raw;
+    try {
+      raw = readFileSync(this.filePath, "utf-8");
+    } catch (err) {
+      this.cached = void 0;
+      this.warnOnce(`read ${version}`, `cannot be read (${err.message})`, UNTIL_RETRY);
+      return void 0;
+    }
+    const map = this.parse(raw, version);
+    this.cached = { version, map };
+    if (map) this.lastWarning = void 0;
+    return map;
+  }
+  parse(raw, version) {
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch (err) {
+      return this.unusable(version, `is not valid JSON (${err.message})`);
+    }
+    const parsed = CoChangeMatrixSchema.safeParse(data);
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      const where = issue && issue.path.length > 0 ? `${issue.path.map(String).join(".")}: ` : "";
+      return this.unusable(version, `is not a valid co-change matrix (${where}${issue?.message ?? "unknown problem"})`);
+    }
+    return freezeEntries(loadCoChangeMap(parsed.data));
+  }
+  unusable(version, problem) {
+    this.warnOnce(`content ${version}`, problem, UNTIL_REWRITTEN);
+    return void 0;
+  }
+  warnOnce(key, problem, consequence) {
+    if (this.lastWarning === key) return;
+    this.lastWarning = key;
+    log.warn(`${this.filePath} ${problem}; ${consequence}`);
+  }
+};
+function freezeEntries(map) {
+  for (const list of map.values()) {
+    for (const entry of list) Object.freeze(entry);
+    Object.freeze(list);
+  }
+  return map;
+}
+
 // src/adapters/storage/sqlite-storage-adapter.ts
 import initSqlJs from "sql.js";
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2, dirname } from "path";
+import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4, dirname } from "path";
 
 // src/adapters/storage/community-snapshot-writer.ts
 import {
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync,
-  readFileSync,
-  readdirSync,
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
   unlinkSync
 } from "fs";
 import { tmpdir } from "os";
-import { basename, join, resolve } from "path";
-
-// src/core/compare-codepoint.ts
-function compareCodepoint(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-
-// src/adapters/storage/community-snapshot-writer.ts
-var log = createLogger("ctxo:community-snapshot");
+import { basename, join as join3, resolve as resolve2 } from "path";
+var log2 = createLogger("ctxo:community-snapshot");
 var DEFAULT_HISTORY_LIMIT = 10;
 var HISTORY_DIR_NAME = "communities.history";
 var CURRENT_FILE_NAME = "communities.json";
@@ -46,26 +254,26 @@ var CommunitySnapshotWriter = class {
   historyLimit;
   constructor(ctxoRoot, historyLimitOrOptions = DEFAULT_HISTORY_LIMIT) {
     const options = typeof historyLimitOrOptions === "number" ? { historyLimit: historyLimitOrOptions } : historyLimitOrOptions;
-    this.indexDir = join(ctxoRoot, "index");
-    this.historyDir = join(this.indexDir, HISTORY_DIR_NAME);
+    this.indexDir = join3(ctxoRoot, "index");
+    this.historyDir = join3(this.indexDir, HISTORY_DIR_NAME);
     this.historyLimit = options.historyLimit ?? DEFAULT_HISTORY_LIMIT;
     assertSafeWritePath(ctxoRoot, options.allowProductionPath ?? false);
   }
   writeSnapshot(snapshot) {
     mkdirSync(this.indexDir, { recursive: true });
     mkdirSync(this.historyDir, { recursive: true });
-    const currentPath = join(this.indexDir, CURRENT_FILE_NAME);
-    if (existsSync(currentPath)) {
+    const currentPath = join3(this.indexDir, CURRENT_FILE_NAME);
+    if (existsSync2(currentPath)) {
       try {
-        const existingRaw = readFileSync(currentPath, "utf-8");
+        const existingRaw = readFileSync2(currentPath, "utf-8");
         const existing = JSON.parse(existingRaw);
         const existingCommit = archivedCommit(existing);
         if (existingCommit !== void 0 && existingCommit !== snapshot.commitSha) {
           const historyFile = this.historyFilename(existing);
-          this.atomicWrite(join(this.historyDir, historyFile), existingRaw);
+          this.atomicWrite(join3(this.historyDir, historyFile), existingRaw);
         }
       } catch (err) {
-        log.error(`failed to archive existing snapshot: ${err.message}`);
+        log2.error(`failed to archive existing snapshot: ${err.message}`);
       }
     }
     const json = JSON.stringify(snapshot, null, 2);
@@ -73,8 +281,8 @@ var CommunitySnapshotWriter = class {
     this.rotateHistory();
   }
   readCurrent() {
-    const path = join(this.indexDir, CURRENT_FILE_NAME);
-    if (!existsSync(path)) return void 0;
+    const path = join3(this.indexDir, CURRENT_FILE_NAME);
+    if (!existsSync2(path)) return void 0;
     return this.safeParse(path);
   }
   /**
@@ -85,11 +293,11 @@ var CommunitySnapshotWriter = class {
    * write rotates them out.
    */
   listHistory(limit) {
-    if (!existsSync(this.historyDir)) return [];
+    if (!existsSync2(this.historyDir)) return [];
     const snapshots = [];
     const seen = /* @__PURE__ */ new Set();
     for (const name of this.historyNames().reverse()) {
-      const snap = this.safeParse(join(this.historyDir, name));
+      const snap = this.safeParse(join3(this.historyDir, name));
       const commit = archivedCommit(snap);
       if (!snap || commit === void 0) continue;
       if (seen.has(commit)) continue;
@@ -105,10 +313,10 @@ var CommunitySnapshotWriter = class {
   historyFilename(snapshot) {
     const ts = snapshot.computedAt.replace(/[:.]/g, "-");
     const sha = snapshot.commitSha || "nocommit";
-    const base = join(this.historyDir, `${ts}-${sha}`);
+    const base = join3(this.historyDir, `${ts}-${sha}`);
     let candidate = `${base}.json`;
     let n = 1;
-    while (existsSync(candidate)) {
+    while (existsSync2(candidate)) {
       candidate = `${base}.${n++}.json`;
       if (n > 1e3) break;
     }
@@ -116,7 +324,7 @@ var CommunitySnapshotWriter = class {
   }
   /** The `.json` files in the history folder, oldest first. */
   historyNames() {
-    return readdirSync(this.historyDir).filter((name) => name.endsWith(".json")).sort(compareHistoryNames);
+    return readdirSync2(this.historyDir).filter((name) => name.endsWith(".json")).sort(compareHistoryNames);
   }
   /**
    * Rotation in two steps. First the duplicates go: every file that is not
@@ -129,12 +337,12 @@ var CommunitySnapshotWriter = class {
    * duplicates of anything and age out by count like the rest.
    */
   rotateHistory() {
-    if (!existsSync(this.historyDir)) return;
+    if (!existsSync2(this.historyDir)) return;
     const seen = /* @__PURE__ */ new Set();
     const unique = [];
     const doomed = [];
     for (const name of this.historyNames().reverse()) {
-      const commit = archivedCommit(this.safeParse(join(this.historyDir, name)));
+      const commit = archivedCommit(this.safeParse(join3(this.historyDir, name)));
       if (commit !== void 0) {
         if (seen.has(commit)) {
           doomed.push(name);
@@ -146,20 +354,20 @@ var CommunitySnapshotWriter = class {
     }
     doomed.push(...unique.slice(this.historyLimit));
     for (const name of doomed) {
-      const target = join(this.historyDir, name);
+      const target = join3(this.historyDir, name);
       try {
         unlinkSync(target);
       } catch (err) {
-        log.error(`failed to rotate ${basename(target)}: ${err.message}`);
+        log2.error(`failed to rotate ${basename(target)}: ${err.message}`);
       }
     }
   }
   safeParse(path) {
     try {
-      const raw = readFileSync(path, "utf-8");
+      const raw = readFileSync2(path, "utf-8");
       return JSON.parse(raw);
     } catch (err) {
-      log.error(`failed to parse ${basename(path)}: ${err.message}`);
+      log2.error(`failed to parse ${basename(path)}: ${err.message}`);
       return void 0;
     }
   }
@@ -178,8 +386,8 @@ function splitCollisionCounter(name) {
   return match ? [`${match[1]}.json`, Number(match[2])] : [name, 0];
 }
 function assertSafeWritePath(ctxoRoot, allowProduction) {
-  const resolved = resolve(ctxoRoot);
-  const tmpRoot = resolve(tmpdir());
+  const resolved = resolve2(ctxoRoot);
+  const tmpRoot = resolve2(tmpdir());
   const inTmp = resolved.startsWith(tmpRoot);
   if (inTmp || allowProduction) return;
   throw new Error(
@@ -188,7 +396,7 @@ function assertSafeWritePath(ctxoRoot, allowProduction) {
 }
 
 // src/adapters/storage/sqlite-storage-adapter.ts
-var log2 = createLogger("ctxo:storage");
+var log3 = createLogger("ctxo:storage");
 var SqliteStorageAdapter = class {
   db;
   dbPath;
@@ -196,20 +404,20 @@ var SqliteStorageAdapter = class {
   communityWriter;
   constructor(ctxoRoot, options = {}) {
     this.ctxoRoot = ctxoRoot;
-    this.dbPath = join2(ctxoRoot, ".cache", "symbols.db");
+    this.dbPath = join4(ctxoRoot, ".cache", "symbols.db");
     this.communityWriter = new CommunitySnapshotWriter(ctxoRoot, {
       allowProductionPath: options.allowProductionPath
     });
   }
   async init() {
     const SQL = await initSqlJs();
-    if (existsSync2(this.dbPath)) {
+    if (existsSync3(this.dbPath)) {
       try {
-        const buffer = readFileSync2(this.dbPath);
+        const buffer = readFileSync3(this.dbPath);
         this.db = new SQL.Database(buffer);
         this.verifyIntegrity();
       } catch {
-        log2.warn("Corrupt DB detected, rebuilding from JSON index");
+        log3.warn("Corrupt DB detected, rebuilding from JSON index");
         this.db = new SQL.Database();
         this.createTables();
       }
@@ -221,9 +429,9 @@ var SqliteStorageAdapter = class {
   }
   async initEmpty() {
     const SQL = await initSqlJs();
-    if (existsSync2(this.dbPath)) {
+    if (existsSync3(this.dbPath)) {
       try {
-        const buffer = readFileSync2(this.dbPath);
+        const buffer = readFileSync3(this.dbPath);
         this.db = new SQL.Database(buffer);
       } catch {
         this.db = new SQL.Database();
@@ -488,7 +696,7 @@ var SqliteStorageAdapter = class {
     try {
       this.persist();
     } catch (err) {
-      log2.error(`Failed to persist DB: ${err.message}`);
+      log3.error(`Failed to persist DB: ${err.message}`);
     }
   }
   deleteFileData(db, filePath) {
@@ -534,1335 +742,301 @@ var SqliteStorageAdapter = class {
   }
 };
 
-// src/adapters/storage/co-change-reader.ts
-import { readFileSync as readFileSync3, statSync } from "fs";
-import { join as join3 } from "path";
-
-// src/core/co-change/co-change-analyzer.ts
-var MIN_FREQUENCY = 0.1;
-function buildCoChangeMatrix(windowed, options) {
-  const commitsPerFile = /* @__PURE__ */ new Map();
-  const sharedPerPair = /* @__PURE__ */ new Map();
-  let commitsUsed = 0;
-  let massSkipped = 0;
-  for (const commit of windowed) {
-    const files = includedFiles(commit, options.isIncluded);
-    if (files.length === 0) continue;
-    if (files.length > options.maxFilesPerCommit) {
-      massSkipped++;
-      continue;
-    }
-    commitsUsed++;
-    for (const file of files) {
-      commitsPerFile.set(file, (commitsPerFile.get(file) ?? 0) + 1);
-    }
-    for (let i = 0; i < files.length - 1; i++) {
-      const file1 = files[i];
-      let partners = sharedPerPair.get(file1);
-      if (!partners) {
-        partners = /* @__PURE__ */ new Map();
-        sharedPerPair.set(file1, partners);
-      }
-      for (let j = i + 1; j < files.length; j++) {
-        const file2 = files[j];
-        partners.set(file2, (partners.get(file2) ?? 0) + 1);
-      }
-    }
-  }
-  const entries = [];
-  for (const [file1, partners] of sharedPerPair) {
-    for (const [file2, sharedCommits] of partners) {
-      if (sharedCommits < options.minShared) continue;
-      const smallerHistory = Math.min(commitsPerFile.get(file1), commitsPerFile.get(file2));
-      const frequency = Math.round(sharedCommits / smallerHistory * 1e3) / 1e3;
-      if (frequency < MIN_FREQUENCY) continue;
-      entries.push({ file1, file2, sharedCommits, frequency });
-    }
+// src/adapters/stats/session-recorder-adapter.ts
+var log4 = createLogger("ctxo:stats");
+var SessionRecorderAdapter = class {
+  db;
+  onWrite;
+  tableCreated = false;
+  constructor(db, onWrite) {
+    this.db = db;
+    this.onWrite = onWrite ?? null;
   }
-  entries.sort(compareEntries);
-  const window = {
-    maxCommits: options.maxCommits,
-    ...options.since !== void 0 ? { since: options.since } : {},
-    head: options.head,
-    commitsScanned: windowed.length,
-    commitsUsed,
-    massSkipped,
-    maxFilesPerCommit: options.maxFilesPerCommit,
-    minShared: options.minShared
-  };
-  return { version: 1, timestamp: options.timestamp, window, entries };
-}
-function includedFiles(commit, isIncluded) {
-  const included = /* @__PURE__ */ new Set();
-  for (const file of commit.files) {
-    if (isIncluded(file)) included.add(file);
+  ensureTable() {
+    if (this.tableCreated) return;
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS session_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp TEXT DEFAULT (datetime('now')),
+        tool TEXT NOT NULL,
+        symbol_id TEXT,
+        detail_level TEXT,
+        response_tokens INTEGER,
+        response_bytes INTEGER,
+        latency_ms REAL,
+        truncated BOOLEAN DEFAULT 0
+      )
+    `);
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_session_timestamp ON session_events(timestamp)");
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_session_tool ON session_events(tool)");
+    this.tableCreated = true;
   }
-  return [...included].sort(compareCodepoint);
-}
-function compareEntries(a, b) {
-  return b.frequency - a.frequency || b.sharedCommits - a.sharedCommits || compareCodepoint(a.file1, b.file1) || compareCodepoint(a.file2, b.file2);
-}
-function loadCoChangeMap(matrix) {
-  const map = /* @__PURE__ */ new Map();
-  for (const entry of matrix.entries) {
-    let list1 = map.get(entry.file1);
-    if (!list1) {
-      list1 = [];
-      map.set(entry.file1, list1);
+  record(event) {
+    try {
+      this.ensureTable();
+      this.db.run(
+        `INSERT INTO session_events (tool, symbol_id, detail_level, response_tokens, response_bytes, latency_ms, truncated)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        [
+          event.tool,
+          event.symbolId,
+          event.detailLevel,
+          event.responseTokens,
+          event.responseBytes,
+          event.latencyMs,
+          event.truncated ? 1 : 0
+        ]
+      );
+      this.flushToDisk();
+    } catch (err) {
+      log4.error(`Failed to record session event: ${err.message}`);
     }
-    list1.push(entry);
-    let list2 = map.get(entry.file2);
-    if (!list2) {
-      list2 = [];
-      map.set(entry.file2, list2);
+  }
+  queryStats(days) {
+    this.ensureTable();
+    const whereClause = days != null && days > 0 ? `WHERE timestamp >= datetime('now', '-${Math.floor(days)} days')` : "";
+    const summaryResult = this.db.exec(
+      `SELECT COUNT(*) as total_calls, COALESCE(SUM(response_tokens), 0) as total_tokens
+       FROM session_events ${whereClause}`
+    );
+    const summaryRow = summaryResult[0]?.values[0];
+    const totalCalls = Number(summaryRow?.[0] ?? 0);
+    const totalTokensServed = Number(summaryRow?.[1] ?? 0);
+    const toolsResult = this.db.exec(
+      `SELECT tool, COUNT(*) as calls, CAST(AVG(response_tokens) AS INTEGER) as avg_tokens
+       FROM session_events ${whereClause}
+       GROUP BY tool ORDER BY calls DESC LIMIT 5`
+    );
+    const topTools = (toolsResult[0]?.values ?? []).map((row) => ({
+      tool: String(row[0]),
+      calls: Number(row[1]),
+      avgTokens: Number(row[2])
+    }));
+    const symbolWherePrefix = whereClause ? whereClause + " AND" : "WHERE";
+    const symbolsResult = this.db.exec(
+      `SELECT symbol_id, COUNT(*) as queries
+       FROM session_events ${symbolWherePrefix} symbol_id IS NOT NULL
+       GROUP BY symbol_id ORDER BY queries DESC LIMIT 5`
+    );
+    const topSymbols = (symbolsResult[0]?.values ?? []).map((row) => {
+      const symbolId = String(row[0]);
+      const parts = symbolId.split("::");
+      const name = parts.length >= 2 ? parts[1] : symbolId;
+      return {
+        symbolId,
+        name,
+        queries: Number(row[1])
+      };
+    });
+    const levelResult = this.db.exec(
+      `SELECT detail_level, COUNT(*) as count
+       FROM session_events ${symbolWherePrefix} detail_level IS NOT NULL
+       GROUP BY detail_level ORDER BY detail_level`
+    );
+    const levelRows = levelResult[0]?.values ?? [];
+    const levelTotal = levelRows.reduce((sum, row) => sum + Number(row[1]), 0);
+    const detailLevelDistribution = levelRows.map((row) => ({
+      level: String(row[0]),
+      count: Number(row[1]),
+      percentage: levelTotal > 0 ? Math.round(Number(row[1]) / levelTotal * 100) : 0
+    }));
+    return {
+      totalCalls,
+      totalTokensServed,
+      topTools,
+      topSymbols,
+      detailLevelDistribution
+    };
+  }
+  clear() {
+    this.ensureTable();
+    this.db.run("DELETE FROM session_events");
+    this.flushToDisk();
+  }
+  flushToDisk() {
+    try {
+      this.onWrite?.();
+    } catch (err) {
+      log4.error(`Failed to flush stats to disk: ${err.message}`);
     }
-    list2.push(entry);
   }
-  return map;
-}
+};
 
-// src/adapters/storage/co-change-reader.ts
-var log3 = createLogger("ctxo:co-change");
-var UNTIL_REWRITTEN = "co-change is ignored until ctxo index rewrites it";
-var UNTIL_RETRY = "co-change is ignored for now and the next call tries again";
-var CoChangeReader = class {
+// src/adapters/storage/contexts-view-reader.ts
+import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { join as join5 } from "path";
+
+// src/core/contexts-view/contexts-view-schema.ts
+import { DATA_RESOURCE_KINDS } from "@ctxo/plugin-api";
+import { z } from "zod";
+var count = z.number().int().nonnegative();
+var SettingsSchema = z.object({
+  // A PR 1A artifact has no data weight; it was 0 then.
+  weights: z.object({ dependency: z.number(), coChange: z.number(), data: z.number().default(0) }),
+  exclude: z.array(z.string()),
+  hubs: z.object({
+    auto: z.boolean(),
+    topPercent: z.number(),
+    minDependents: z.number(),
+    paths: z.array(z.string())
+  }),
+  resolution: z.number(),
+  minCandidateFiles: z.number(),
+  technicalTerms: z.array(z.string())
+});
+var DataAccessSchema = z.object({
+  candidate: z.number().int(),
+  modes: z.array(z.enum(["reads", "writes"]))
+});
+var SharedTableSchema = z.object({
+  name: z.string(),
+  kind: z.enum(DATA_RESOURCE_KINDS).optional(),
+  external: z.boolean(),
+  accesses: z.array(DataAccessSchema),
+  owner: z.number().int().optional()
+});
+var DataResourceSchema = z.object({
+  name: z.string(),
+  kind: z.enum(DATA_RESOURCE_KINDS).optional(),
+  external: z.boolean(),
+  accesses: z.array(DataAccessSchema),
+  writers: z.array(z.number().int()),
+  owner: z.number().int().optional()
+});
+var CandidateSchema = z.object({
+  id: z.number().int(),
+  label: z.string(),
+  fingerprint: z.string(),
+  fileCount: count,
+  files: z.array(z.string()),
+  cohesion: z.number(),
+  topTerms: z.array(z.object({ term: z.string(), files: count })),
+  crossEdges: z.array(
+    z.object({
+      candidate: z.number().int(),
+      total: count,
+      byKind: z.partialRecord(EdgeKindSchema, count)
+    })
+  ),
+  coChangePairs: z.array(
+    z.object({
+      file: z.string(),
+      otherFile: z.string(),
+      otherCandidate: z.number().int(),
+      frequency: z.number(),
+      sharedCommits: count
+    })
+  ),
+  // Absent in a PR 1A artifact.
+  sharedTables: z.array(SharedTableSchema).default([])
+});
+var HubSchema = z.object({
+  file: z.string(),
+  reasons: z.array(z.enum(["configured", "fan-in", "god-node"])),
+  dependents: count,
+  damping: z.number(),
+  candidate: z.number().int().optional()
+});
+var CollisionSchema = z.object({
+  name: z.string(),
+  minJaccard: z.number(),
+  occurrences: z.array(
+    z.object({
+      candidate: z.number().int(),
+      file: z.string(),
+      symbolId: z.string(),
+      members: z.array(z.string())
+    })
+  )
+});
+var ContextsViewSchema = z.object({
+  version: z.literal(1),
+  commitSha: z.string(),
+  settings: SettingsSchema,
+  coverage: z.object({ files: count, covered: count, ratio: z.number() }),
+  candidates: z.array(CandidateSchema),
+  hubs: z.array(HubSchema),
+  unclustered: z.object({ count, files: z.array(z.string()) }),
+  collisions: z.array(CollisionSchema),
+  // Absent in a PR 1A artifact.
+  dataResources: z.array(DataResourceSchema).default([])
+});
+
+// src/adapters/storage/contexts-view-reader.ts
+var log5 = createLogger("ctxo:contexts-view");
+var UNTIL_REWRITTEN2 = "the contexts view is ignored until ctxo index rewrites it";
+var UNTIL_RETRY2 = "the contexts view is ignored for now and the next call tries again";
+function deepFreeze(value) {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) deepFreeze(child);
+  }
+  return value;
+}
+var ContextsViewReader = class {
   filePath;
   cached;
-  /** What the last warning was about, so one problem is reported once. */
   lastWarning;
   constructor(ctxoRoot) {
-    this.filePath = join3(ctxoRoot, "index", "co-changes.json");
+    this.filePath = join5(ctxoRoot, "index", "contexts-view.json");
   }
-  readCoChangeMap() {
+  readContextsView() {
     let stats;
     try {
-      stats = statSync(this.filePath);
+      stats = statSync2(this.filePath);
     } catch (err) {
       this.cached = void 0;
       const { code, message } = err;
       if (code === "ENOENT") {
         this.lastWarning = void 0;
       } else {
-        this.warnOnce(`stat ${code ?? message}`, `cannot be inspected (${message})`, UNTIL_RETRY);
+        this.warnOnce(`stat ${code ?? message}`, `cannot be inspected (${message})`, UNTIL_RETRY2);
       }
       return void 0;
     }
-    const version = `${stats.mtimeMs}:${stats.size}`;
-    if (this.cached?.version === version) return this.cached.map;
+    const version = `${stats.mtimeMs}:${stats.size}:${stats.ino}`;
+    if (this.cached?.version === version) return this.cached.view;
     return this.load(version);
   }
   load(version) {
     let raw;
     try {
-      raw = readFileSync3(this.filePath, "utf-8");
+      raw = readFileSync4(this.filePath, "utf-8");
     } catch (err) {
       this.cached = void 0;
-      this.warnOnce(`read ${version}`, `cannot be read (${err.message})`, UNTIL_RETRY);
+      this.warnOnce(`read ${version}`, `cannot be read (${err.message})`, UNTIL_RETRY2);
       return void 0;
     }
-    const map = this.parse(raw, version);
-    this.cached = { version, map };
-    if (map) this.lastWarning = void 0;
-    return map;
+    const view = this.parse(raw, version);
+    this.cached = { version, view };
+    if (view) this.lastWarning = void 0;
+    return view;
   }
   parse(raw, version) {
     let data;
     try {
       data = JSON.parse(raw);
     } catch (err) {
-      return this.unusable(version, `is not valid JSON (${err.message})`);
+      this.warnOnce(`content ${version}`, `is not valid JSON (${err.message})`, UNTIL_REWRITTEN2);
+      return void 0;
     }
-    const parsed = CoChangeMatrixSchema.safeParse(data);
+    const parsed = ContextsViewSchema.safeParse(data);
     if (!parsed.success) {
       const issue = parsed.error.issues[0];
       const where = issue && issue.path.length > 0 ? `${issue.path.map(String).join(".")}: ` : "";
-      return this.unusable(version, `is not a valid co-change matrix (${where}${issue?.message ?? "unknown problem"})`);
+      this.warnOnce(
+        `content ${version}`,
+        `is not a valid contexts view (${where}${issue?.message ?? "unknown problem"})`,
+        UNTIL_REWRITTEN2
+      );
+      return void 0;
     }
-    return freezeEntries(loadCoChangeMap(parsed.data));
-  }
-  unusable(version, problem) {
-    this.warnOnce(`content ${version}`, problem, UNTIL_REWRITTEN);
-    return void 0;
+    return deepFreeze(parsed.data);
   }
   warnOnce(key, problem, consequence) {
     if (this.lastWarning === key) return;
     this.lastWarning = key;
-    log3.warn(`${this.filePath} ${problem}; ${consequence}`);
-  }
-};
-function freezeEntries(map) {
-  for (const list of map.values()) {
-    for (const entry of list) Object.freeze(entry);
-    Object.freeze(list);
-  }
-  return map;
-}
-
-// src/core/co-change/co-change-window.ts
-var SINCE_PATTERN = /^(\d+)([dwmy])$/;
-var SECONDS_PER_DAY = 86400;
-function parseCoChangeSince(value) {
-  const match = SINCE_PATTERN.exec(value);
-  if (!match) return void 0;
-  const amount = Number.parseInt(match[1], 10);
-  if (!Number.isSafeInteger(amount)) return void 0;
-  return { amount, unit: match[2] };
-}
-function sinceCutoff(headCommittedAt, since) {
-  const cutoff = subtractSince(headCommittedAt, since);
-  return Number.isFinite(cutoff) ? cutoff : Number.NEGATIVE_INFINITY;
-}
-function subtractSince(headCommittedAt, since) {
-  switch (since.unit) {
-    case "d":
-      return headCommittedAt - since.amount * SECONDS_PER_DAY;
-    case "w":
-      return headCommittedAt - since.amount * 7 * SECONDS_PER_DAY;
-    case "m":
-      return subtractUtcMonths(headCommittedAt, since.amount);
-    case "y":
-      return subtractUtcMonths(headCommittedAt, since.amount * 12);
-  }
-}
-function subtractUtcMonths(epochSeconds, months) {
-  const date = new Date(epochSeconds * 1e3);
-  const dayOfMonth = date.getUTCDate();
-  date.setUTCDate(1);
-  date.setUTCMonth(date.getUTCMonth() - months);
-  date.setUTCDate(Math.min(dayOfMonth, daysInUtcMonth(date)));
-  return date.getTime() / 1e3;
-}
-function daysInUtcMonth(date) {
-  const lastDay = new Date(date.getTime());
-  lastDay.setUTCMonth(lastDay.getUTCMonth() + 1, 0);
-  return lastDay.getUTCDate();
-}
-function selectWindow(commits, maxCommits, cutoff) {
-  const newest = maxCommits === "all" ? [...commits] : commits.slice(0, wholeCommitCount(maxCommits));
-  return cutoff === void 0 ? newest : newest.filter((commit) => commit.committedAt >= cutoff);
-}
-function wholeCommitCount(maxCommits) {
-  return maxCommits >= 1 ? Math.floor(maxCommits) : 0;
-}
-
-// src/core/config/load-config.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
-import { parse as parseYaml } from "yaml";
-import picomatch from "picomatch";
-
-// src/core/config/config-schema.ts
-import { z } from "zod";
-var StatsConfigSchema = z.object({
-  enabled: z.boolean().optional()
-}).strict();
-var IndexConfigSchema = z.object({
-  ignore: z.array(z.string().min(1)).optional(),
-  ignoreProjects: z.array(z.string().min(1)).optional(),
-  facts: z.boolean().optional(),
-  tests: z.array(z.string().min(1)).optional()
-}).strict();
-var MaskingConfigSchema = z.object({
-  /**
-   * Glob patterns matched against community cluster labels. Matching labels
-   * are replaced with `[masked-cluster-N]` in MCP tool responses so
-   * org-sensitive folder names (e.g. `src/payment-vault`, `internal-*`)
-   * never surface to AI agents over the stdio channel.
-   */
-  clusterLabels: z.array(z.string().min(1)).optional()
-}).strict();
-var WatchConfigSchema = z.object({
-  /**
-   * Minimum number of files that must be re-indexed since the last
-   * community snapshot before `ctxo watch` recomputes one. Default: 5.
-   * On large monorepos Louvain + PageRank cost ~1 s of blocking CPU;
-   * bumping this (e.g. 25) avoids recomputing on every save.
-   */
-  snapshotMinFileChanges: z.number().int().min(1).optional()
-}).strict();
-var GateConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  sensitivity: z.enum(["strict", "balanced", "lenient"]).optional(),
-  /** Absolute floor: minimum confirmed+likely dependents before the gate can fire. */
-  minDependents: z.number().int().min(0).optional(),
-  /** Repo-relative significance: symbol must be in the top `percentile`% by PageRank. */
-  percentile: z.number().int().min(1).max(100).optional()
-}).strict();
-var CoChangeConfigSchema = z.object({
-  /**
-   * Size of the co-change window: the last N non-merge commits from HEAD, or "all".
-   * Default: 2000. Independent of `ctxo index --max-history`, which only sets how much
-   * per-file commit history is kept.
-   */
-  maxCommits: z.union([z.number().int().min(1), z.literal("all")], { error: 'must be a positive integer or "all"' }).optional(),
-  /**
-   * Narrows the window to a duration counted back from HEAD's committer date (never the wall
-   * clock): `30d`, `2w`, `12m` or `1y`. Applies together with `maxCommits`.
-   */
-  since: z.string().refine((value) => parseCoChangeSince(value) !== void 0, {
-    error: "must be a duration such as 30d, 2w, 12m or 1y"
-  }).optional(),
-  /** Commits touching more analysed files than this are skipped as mass changes. Default: 30. */
-  maxFilesPerCommit: z.number().int().min(1).optional(),
-  /** A file pair becomes an entry only after this many shared commits. Default: 2. */
-  minShared: z.number().int().min(1).optional(),
-  /** Extra tracked files to analyse that no language plugin indexes, such as SQL scripts (globs). */
-  include: z.array(z.string().min(1)).optional(),
-  /** Indexed files to leave out of the analysis (globs). */
-  exclude: z.array(z.string().min(1)).optional()
-}).strict();
-var CommunitiesConfigSchema = z.object({
-  /** Louvain resolution: higher gives more, smaller communities. Default: 1.0. */
-  resolution: z.number().positive().optional(),
-  /** Minimum number of communities a symbol must bridge to count as a god node. Default: 3. */
-  godNodeMinBridged: z.number().int().min(1).optional(),
-  /** Maximum number of god nodes reported. Default: 25. */
-  godNodeMaxResults: z.number().int().min(0).optional()
-}).strict();
-var ContextsViewConfigSchema = z.object({
-  /** Blend of the file-edge signals. Defaults: dependency 1.0, coChange 1.0, data 0 (shared tables are a finding, not a clustering weight). */
-  weights: z.object({
-    dependency: z.number().min(0).optional(),
-    coChange: z.number().min(0).optional(),
-    data: z.number().min(0).optional()
-  }).strict().optional(),
-  /** Files to leave out of the file graph (globs). */
-  exclude: z.array(z.string().min(1)).optional(),
-  hubs: z.object({
-    /** Detect hubs automatically (fan-in and god nodes). Default: true. */
-    auto: z.boolean().optional(),
-    /** A file is a fan-in hub when it is in the top `topPercent`% by dependents. Default: 1. */
-    topPercent: z.number().positive().max(100).optional(),
-    /** Minimum distinct dependent files for a fan-in hub. Default: 10. */
-    minDependents: z.number().int().min(1).optional(),
-    /** Files that lose all their edges (globs). */
-    paths: z.array(z.string().min(1)).optional()
-  }).strict().optional(),
-  /** Louvain resolution for the file graph. Default: 1.0. */
-  resolution: z.number().positive().optional(),
-  /** Candidates with fewer files fold into a neighbour. Default: 3. */
-  minCandidateFiles: z.number().int().min(1).optional(),
-  /** Words dropped from candidate terms; replaces the default list. */
-  technicalTerms: z.array(z.string().min(1)).optional()
-}).strict();
-var CtxoConfigSchema = z.object({
-  version: z.union([z.string(), z.number()]).optional(),
-  stats: StatsConfigSchema.optional(),
-  index: IndexConfigSchema.optional(),
-  masking: MaskingConfigSchema.optional(),
-  watch: WatchConfigSchema.optional(),
-  gate: GateConfigSchema.optional(),
-  cochange: CoChangeConfigSchema.optional(),
-  communities: CommunitiesConfigSchema.optional(),
-  contextsView: ContextsViewConfigSchema.optional()
-}).passthrough();
-var DEFAULT_WATCH_SNAPSHOT_MIN_FILE_CHANGES = 5;
-var DEFAULT_COCHANGE_MAX_COMMITS = 2e3;
-var DEFAULT_COCHANGE_MAX_FILES_PER_COMMIT = 30;
-var DEFAULT_COCHANGE_MIN_SHARED = 2;
-var DEFAULT_TECHNICAL_TERMS = [
-  "Service",
-  "Repository",
-  "Controller",
-  "Handler",
-  "Manager",
-  "Dto",
-  "Impl",
-  "Async"
-];
-var DEFAULT_CONFIG = {
-  version: "1.0",
-  stats: { enabled: true },
-  index: { ignore: [], ignoreProjects: [] },
-  masking: { clusterLabels: [] },
-  watch: { snapshotMinFileChanges: DEFAULT_WATCH_SNAPSHOT_MIN_FILE_CHANGES },
-  gate: { enabled: true, sensitivity: "balanced" },
-  cochange: {
-    maxCommits: DEFAULT_COCHANGE_MAX_COMMITS,
-    maxFilesPerCommit: DEFAULT_COCHANGE_MAX_FILES_PER_COMMIT,
-    minShared: DEFAULT_COCHANGE_MIN_SHARED,
-    include: [],
-    exclude: []
-  }
-};
-
-// src/core/config/load-config.ts
-var log4 = createLogger("ctxo:config");
-function isValidGlob(pattern) {
-  try {
-    picomatch(pattern);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function validateGlobs(patterns, field, invalid) {
-  if (!patterns) return;
-  for (const p of patterns) {
-    if (!isValidGlob(p)) invalid.push(`${field}: ${p}`);
-  }
-}
-function loadConfig(ctxoRoot) {
-  const path = join4(ctxoRoot, "config.yaml");
-  const errors = [];
-  const invalidGlobs = [];
-  if (!existsSync3(path)) {
-    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: false };
-  }
-  let raw;
-  try {
-    raw = readFileSync4(path, "utf-8");
-  } catch (err) {
-    errors.push(`Cannot read ${path}: ${err.message}`);
-    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: true };
-  }
-  let parsed;
-  try {
-    parsed = parseYaml(raw);
-  } catch (err) {
-    errors.push(`Invalid YAML in ${path}: ${err.message}`);
-    log4.warn(`Invalid YAML in config.yaml, falling back to defaults: ${err.message}`);
-    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: true };
-  }
-  if (parsed === null || parsed === void 0) {
-    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: true };
-  }
-  const result = CtxoConfigSchema.safeParse(parsed);
-  if (!result.success) {
-    for (const issue of result.error.issues) {
-      errors.push(`${issue.path.join(".") || "<root>"}: ${issue.message}`);
-    }
-    log4.warn(`Invalid config.yaml (${errors.length} issue(s)), falling back to defaults`);
-    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: true };
-  }
-  validateGlobs(result.data.index?.ignore, "index.ignore", invalidGlobs);
-  validateGlobs(result.data.index?.ignoreProjects, "index.ignoreProjects", invalidGlobs);
-  validateGlobs(result.data.index?.tests, "index.tests", invalidGlobs);
-  validateGlobs(result.data.cochange?.include, "cochange.include", invalidGlobs);
-  validateGlobs(result.data.cochange?.exclude, "cochange.exclude", invalidGlobs);
-  validateGlobs(result.data.contextsView?.exclude, "contextsView.exclude", invalidGlobs);
-  validateGlobs(result.data.contextsView?.hubs?.paths, "contextsView.hubs.paths", invalidGlobs);
-  for (const pattern of invalidGlobs) {
-    log4.warn(`Invalid glob pattern in config.yaml \u2014 ${pattern}`);
-  }
-  return { config: result.data, errors, invalidGlobs, path, exists: true };
-}
-function statsEnabled(config) {
-  return config.stats?.enabled !== false;
-}
-function indexIgnorePatterns(config) {
-  return (config.index?.ignore ?? []).filter(isValidGlob);
-}
-function indexIgnoreProjectPatterns(config) {
-  return (config.index?.ignoreProjects ?? []).filter(isValidGlob);
-}
-function factsRequested(config) {
-  return config.index?.facts === true;
-}
-function indexTestPatterns(config) {
-  return (config.index?.tests ?? []).filter(isValidGlob);
-}
-function communityDetectorOptions(config) {
-  const section = config.communities;
-  const resolution = section?.resolution;
-  const minBridged = section?.godNodeMinBridged;
-  const maxResults = section?.godNodeMaxResults;
-  return {
-    ...typeof resolution === "number" && Number.isFinite(resolution) && resolution > 0 ? { resolution } : {},
-    ...typeof minBridged === "number" && Number.isInteger(minBridged) && minBridged >= 1 ? { godNodeMinBridged: minBridged } : {},
-    ...typeof maxResults === "number" && Number.isInteger(maxResults) && maxResults >= 0 ? { godNodeMaxResults: maxResults } : {}
-  };
-}
-function maskingClusterLabelPatterns(config) {
-  return (config.masking?.clusterLabels ?? []).filter(isValidGlob);
-}
-function watchSnapshotMinFileChanges(config) {
-  const value = config.watch?.snapshotMinFileChanges;
-  if (typeof value === "number" && Number.isFinite(value) && value >= 1) return value;
-  return DEFAULT_WATCH_SNAPSHOT_MIN_FILE_CHANGES;
-}
-function isPositiveInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 1;
-}
-function positiveIntegerOr(value, fallback) {
-  return isPositiveInteger(value) ? value : fallback;
-}
-function validMaxCommits(value) {
-  if (value === "all") return "all";
-  return isPositiveInteger(value) ? value : void 0;
-}
-function validSince(value) {
-  return typeof value === "string" && parseCoChangeSince(value) !== void 0 ? value : void 0;
-}
-function resolveCoChangeConfig(config, overrides = {}) {
-  const section = config.cochange;
-  const since = validSince(overrides.since) ?? validSince(section?.since);
-  return {
-    maxCommits: validMaxCommits(overrides.maxCommits) ?? validMaxCommits(section?.maxCommits) ?? DEFAULT_COCHANGE_MAX_COMMITS,
-    ...since !== void 0 ? { since } : {},
-    maxFilesPerCommit: positiveIntegerOr(section?.maxFilesPerCommit, DEFAULT_COCHANGE_MAX_FILES_PER_COMMIT),
-    minShared: positiveIntegerOr(section?.minShared, DEFAULT_COCHANGE_MIN_SHARED),
-    include: (section?.include ?? []).filter(isValidGlob),
-    exclude: (section?.exclude ?? []).filter(isValidGlob)
-  };
-}
-function nonNegativeOr(value, fallback) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
-}
-function positiveOr(value, fallback) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
-}
-function resolveContextsViewConfig(config) {
-  const section = config.contextsView;
-  const hubs = section?.hubs;
-  const topPercent = hubs?.topPercent;
-  return {
-    weights: {
-      dependency: nonNegativeOr(section?.weights?.dependency, 1),
-      coChange: nonNegativeOr(section?.weights?.coChange, 1),
-      data: nonNegativeOr(section?.weights?.data, 0)
-    },
-    exclude: (section?.exclude ?? []).filter(isValidGlob),
-    hubs: {
-      auto: hubs?.auto !== false,
-      topPercent: typeof topPercent === "number" && topPercent > 0 && topPercent <= 100 ? topPercent : 1,
-      minDependents: positiveIntegerOr(hubs?.minDependents, 10),
-      paths: (hubs?.paths ?? []).filter(isValidGlob)
-    },
-    resolution: positiveOr(section?.resolution, 1),
-    minCandidateFiles: positiveIntegerOr(section?.minCandidateFiles, 3),
-    technicalTerms: section?.technicalTerms ? [...section.technicalTerms] : [...DEFAULT_TECHNICAL_TERMS]
-  };
-}
-function makeGlobMatcher(patterns) {
-  if (patterns.length === 0) return () => false;
-  const matchers = patterns.map((p) => picomatch(p, { dot: true }));
-  return (input) => {
-    const normalised = input.replace(/\\/g, "/");
-    return matchers.some((m) => m(normalised));
-  };
-}
-
-// src/adapters/git/simple-git-adapter.ts
-import { spawnSync } from "child_process";
-import { simpleGit } from "simple-git";
-var log5 = createLogger("ctxo:git");
-var NUL = "\0";
-var RECORD_SEPARATOR = "";
-var FIELD_SEPARATOR = "";
-var CHANGE_LOG_FORMAT = "--format=%x1e%H%x1f%aI%x1f%ct%x1f%an%x1f%s";
-var STABLE_OUTPUT_CONFIG = [
-  "-c",
-  "core.quotepath=off",
-  "-c",
-  "log.showSignature=false"
-];
-function toForwardSlashes(path) {
-  return path.replace(/\\/g, "/");
-}
-function isFileChangeStatus(value) {
-  return value === "A" || value === "M" || value === "D" || value === "R" || value === "C" || value === "T";
-}
-function parseNameStatus(tokens) {
-  const changes = [];
-  let i = 0;
-  while (i < tokens.length) {
-    const kind = (tokens[i] ?? "").trim().charAt(0);
-    if (kind === "") {
-      i += 1;
-    } else if (kind === "R" || kind === "C") {
-      const oldPath = tokens[i + 1];
-      const path = tokens[i + 2];
-      i += 3;
-      if (oldPath !== void 0 && path !== void 0) {
-        changes.push({ status: kind, path: toForwardSlashes(path), oldPath: toForwardSlashes(oldPath) });
-      }
-    } else {
-      const path = tokens[i + 1];
-      i += 2;
-      if (path !== void 0 && isFileChangeStatus(kind)) {
-        changes.push({ status: kind, path: toForwardSlashes(path) });
-      }
-    }
-  }
-  return changes;
-}
-function parseSkipWorktree(raw) {
-  const paths = /* @__PURE__ */ new Set();
-  for (const record of raw.split(NUL)) {
-    if (record.length > 2 && record.charAt(0) === "S" && record.charAt(1) === " ") {
-      paths.add(toForwardSlashes(record.slice(2)));
-    }
-  }
-  return paths;
-}
-function parseChangeLog(raw) {
-  const commits = [];
-  for (const record of raw.split(RECORD_SEPARATOR)) {
-    const [header = "", ...tokens] = record.split(NUL);
-    const [hash, date, time, author, ...subject] = header.split(FIELD_SEPARATOR);
-    const committedAt = Number.parseInt(time ?? "", 10);
-    if (!hash || date === void 0 || author === void 0 || Number.isNaN(committedAt)) continue;
-    commits.push({
-      hash,
-      message: subject.join(FIELD_SEPARATOR).trim(),
-      date,
-      author,
-      committedAt,
-      changes: parseNameStatus(tokens)
-    });
-  }
-  return commits;
-}
-var SimpleGitAdapter = class {
-  git;
-  projectRoot;
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-    this.git = simpleGit(projectRoot);
-    log5.debug("Initialized with root: %s", projectRoot);
-  }
-  async isAvailable() {
-    try {
-      await this.git.version();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async getCommitHistory(filePath, maxCount) {
-    try {
-      const log8 = await this.git.log({
-        file: filePath,
-        "--follow": null,
-        ...maxCount ? { maxCount } : {}
-      });
-      return log8.all.map((entry) => ({
-        hash: entry.hash,
-        message: entry.message,
-        date: entry.date,
-        author: entry.author_name
-      }));
-    } catch (err) {
-      log5.error(` Failed to get history for ${filePath}: ${err.message}`);
-      return [];
-    }
-  }
-  async getChangedFiles(since) {
-    try {
-      const diff = await this.git.diffSummary([since]);
-      return diff.files.map((f) => f.file.replace(/\\/g, "/"));
-    } catch (err) {
-      log5.error(` Failed to get changed files since ${since}: ${err.message}`);
-      return [];
-    }
-  }
-  async getFileChurn(filePath) {
-    try {
-      const log8 = await this.git.log({ file: filePath, "--follow": null });
-      return {
-        filePath,
-        commitCount: log8.total
-      };
-    } catch (err) {
-      log5.error(` Failed to get churn for ${filePath}: ${err.message}`);
-      return { filePath, commitCount: 0 };
-    }
-  }
-  async getHeadSha() {
-    try {
-      const raw = await this.git.revparse(["--short", "HEAD"]);
-      const sha = raw.trim();
-      return sha.length > 0 ? sha : void 0;
-    } catch (err) {
-      log5.error(`Failed to resolve HEAD: ${err.message}`);
-      return void 0;
-    }
-  }
-  async countCommitsBetween(base) {
-    try {
-      const raw = await this.git.raw(["rev-list", "--count", `${base}..HEAD`]);
-      const n = parseInt(raw.trim(), 10);
-      return Number.isFinite(n) && n >= 0 ? n : void 0;
-    } catch (err) {
-      log5.error(`Failed to count commits since ${base}: ${err.message}`);
-      return void 0;
-    }
-  }
-  async getChangeLog(maxCommits) {
-    try {
-      const headRaw = await this.git.raw([...STABLE_OUTPUT_CONFIG, "log", "-1", "--format=%h%x1f%ct", "HEAD"]);
-      const [head, headTime] = headRaw.trim().split(FIELD_SEPARATOR);
-      const headCommittedAt = Number.parseInt(headTime ?? "", 10);
-      if (!head || Number.isNaN(headCommittedAt)) {
-        throw new Error(`unexpected HEAD description ${JSON.stringify(headRaw)}`);
-      }
-      const args = [...STABLE_OUTPUT_CONFIG, "log", "--no-merges", "-M", "--name-status", "-z", CHANGE_LOG_FORMAT];
-      if (maxCommits !== "all") args.push(`--max-count=${maxCommits}`);
-      args.push("HEAD");
-      return { head, headCommittedAt, commits: parseChangeLog(await this.git.raw(args)) };
-    } catch (err) {
-      log5.error(`Failed to read change log: ${err.message}`);
-      return void 0;
-    }
-  }
-  async getSkipWorktreePaths() {
-    try {
-      return parseSkipWorktree(await this.git.raw([...STABLE_OUTPUT_CONFIG, "ls-files", "-t", "-z"]));
-    } catch (err) {
-      log5.error(`Failed to list skip-worktree paths: ${err.message}`);
-      return void 0;
-    }
-  }
-  async getIgnoredPaths(paths) {
-    if (paths.length === 0) return /* @__PURE__ */ new Set();
-    const result = spawnSync("git", [...STABLE_OUTPUT_CONFIG, "check-ignore", "-z", "--stdin"], {
-      cwd: this.projectRoot,
-      input: paths.map((path) => `${path}${NUL}`).join(""),
-      encoding: "utf-8",
-      maxBuffer: 64 * 1024 * 1024
-    });
-    if (result.error === void 0 && result.status === 1) return /* @__PURE__ */ new Set();
-    if (result.error !== void 0 || result.status !== 0) {
-      const reason = (result.error?.message ?? result.stderr ?? "").replace(/\s+/g, " ").trim();
-      log5.error(`Failed to check ignored paths: ${reason}`);
-      return void 0;
-    }
-    return new Set(
-      result.stdout.split(NUL).filter((path) => path.length > 0).map(toForwardSlashes)
-    );
-  }
-  async getCommitFileChanges(rev) {
-    if (rev.startsWith("-")) {
-      log5.error(`Refusing to read file changes for option-like revision ${rev}`);
-      return void 0;
-    }
-    try {
-      const raw = await this.git.raw([
-        ...STABLE_OUTPUT_CONFIG,
-        "diff-tree",
-        "--root",
-        "--no-commit-id",
-        "-r",
-        "-M",
-        "--name-status",
-        "-z",
-        rev
-      ]);
-      return parseNameStatus(raw.split(NUL));
-    } catch (err) {
-      log5.error(`Failed to read file changes of ${rev}: ${err.message}`);
-      return void 0;
-    }
-  }
-};
-
-// src/adapters/storage/contexts-view-reader.ts
-import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import { join as join5 } from "path";
-
-// src/core/contexts-view/contexts-view-schema.ts
-import { DATA_RESOURCE_KINDS } from "@ctxo/plugin-api";
-import { z as z2 } from "zod";
-var count = z2.number().int().nonnegative();
-var SettingsSchema = z2.object({
-  // A PR 1A artifact has no data weight; it was 0 then.
-  weights: z2.object({ dependency: z2.number(), coChange: z2.number(), data: z2.number().default(0) }),
-  exclude: z2.array(z2.string()),
-  hubs: z2.object({
-    auto: z2.boolean(),
-    topPercent: z2.number(),
-    minDependents: z2.number(),
-    paths: z2.array(z2.string())
-  }),
-  resolution: z2.number(),
-  minCandidateFiles: z2.number(),
-  technicalTerms: z2.array(z2.string())
-});
-var DataAccessSchema = z2.object({
-  candidate: z2.number().int(),
-  modes: z2.array(z2.enum(["reads", "writes"]))
-});
-var SharedTableSchema = z2.object({
-  name: z2.string(),
-  kind: z2.enum(DATA_RESOURCE_KINDS).optional(),
-  external: z2.boolean(),
-  accesses: z2.array(DataAccessSchema),
-  owner: z2.number().int().optional()
-});
-var DataResourceSchema = z2.object({
-  name: z2.string(),
-  kind: z2.enum(DATA_RESOURCE_KINDS).optional(),
-  external: z2.boolean(),
-  accesses: z2.array(DataAccessSchema),
-  writers: z2.array(z2.number().int()),
-  owner: z2.number().int().optional()
-});
-var CandidateSchema = z2.object({
-  id: z2.number().int(),
-  label: z2.string(),
-  fingerprint: z2.string(),
-  fileCount: count,
-  files: z2.array(z2.string()),
-  cohesion: z2.number(),
-  topTerms: z2.array(z2.object({ term: z2.string(), files: count })),
-  crossEdges: z2.array(
-    z2.object({
-      candidate: z2.number().int(),
-      total: count,
-      byKind: z2.partialRecord(EdgeKindSchema, count)
-    })
-  ),
-  coChangePairs: z2.array(
-    z2.object({
-      file: z2.string(),
-      otherFile: z2.string(),
-      otherCandidate: z2.number().int(),
-      frequency: z2.number(),
-      sharedCommits: count
-    })
-  ),
-  // Absent in a PR 1A artifact.
-  sharedTables: z2.array(SharedTableSchema).default([])
-});
-var HubSchema = z2.object({
-  file: z2.string(),
-  reasons: z2.array(z2.enum(["configured", "fan-in", "god-node"])),
-  dependents: count,
-  damping: z2.number(),
-  candidate: z2.number().int().optional()
-});
-var CollisionSchema = z2.object({
-  name: z2.string(),
-  minJaccard: z2.number(),
-  occurrences: z2.array(
-    z2.object({
-      candidate: z2.number().int(),
-      file: z2.string(),
-      symbolId: z2.string(),
-      members: z2.array(z2.string())
-    })
-  )
-});
-var ContextsViewSchema = z2.object({
-  version: z2.literal(1),
-  commitSha: z2.string(),
-  settings: SettingsSchema,
-  coverage: z2.object({ files: count, covered: count, ratio: z2.number() }),
-  candidates: z2.array(CandidateSchema),
-  hubs: z2.array(HubSchema),
-  unclustered: z2.object({ count, files: z2.array(z2.string()) }),
-  collisions: z2.array(CollisionSchema),
-  // Absent in a PR 1A artifact.
-  dataResources: z2.array(DataResourceSchema).default([])
-});
-
-// src/adapters/storage/contexts-view-reader.ts
-var log6 = createLogger("ctxo:contexts-view");
-var UNTIL_REWRITTEN2 = "the contexts view is ignored until ctxo index rewrites it";
-var UNTIL_RETRY2 = "the contexts view is ignored for now and the next call tries again";
-function deepFreeze(value) {
-  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
-    Object.freeze(value);
-    for (const child of Object.values(value)) deepFreeze(child);
-  }
-  return value;
-}
-var ContextsViewReader = class {
-  filePath;
-  cached;
-  lastWarning;
-  constructor(ctxoRoot) {
-    this.filePath = join5(ctxoRoot, "index", "contexts-view.json");
-  }
-  readContextsView() {
-    let stats;
-    try {
-      stats = statSync2(this.filePath);
-    } catch (err) {
-      this.cached = void 0;
-      const { code, message } = err;
-      if (code === "ENOENT") {
-        this.lastWarning = void 0;
-      } else {
-        this.warnOnce(`stat ${code ?? message}`, `cannot be inspected (${message})`, UNTIL_RETRY2);
-      }
-      return void 0;
-    }
-    const version = `${stats.mtimeMs}:${stats.size}:${stats.ino}`;
-    if (this.cached?.version === version) return this.cached.view;
-    return this.load(version);
-  }
-  load(version) {
-    let raw;
-    try {
-      raw = readFileSync5(this.filePath, "utf-8");
-    } catch (err) {
-      this.cached = void 0;
-      this.warnOnce(`read ${version}`, `cannot be read (${err.message})`, UNTIL_RETRY2);
-      return void 0;
-    }
-    const view = this.parse(raw, version);
-    this.cached = { version, view };
-    if (view) this.lastWarning = void 0;
-    return view;
-  }
-  parse(raw, version) {
-    let data;
-    try {
-      data = JSON.parse(raw);
-    } catch (err) {
-      this.warnOnce(`content ${version}`, `is not valid JSON (${err.message})`, UNTIL_REWRITTEN2);
-      return void 0;
-    }
-    const parsed = ContextsViewSchema.safeParse(data);
-    if (!parsed.success) {
-      const issue = parsed.error.issues[0];
-      const where = issue && issue.path.length > 0 ? `${issue.path.map(String).join(".")}: ` : "";
-      this.warnOnce(
-        `content ${version}`,
-        `is not a valid contexts view (${where}${issue?.message ?? "unknown problem"})`,
-        UNTIL_REWRITTEN2
-      );
-      return void 0;
-    }
-    return deepFreeze(parsed.data);
-  }
-  warnOnce(key, problem, consequence) {
-    if (this.lastWarning === key) return;
-    this.lastWarning = key;
-    log6.warn(`${this.filePath} ${problem}; ${consequence}`);
-  }
-};
-
-// src/adapters/stats/session-recorder-adapter.ts
-var log7 = createLogger("ctxo:stats");
-var SessionRecorderAdapter = class {
-  db;
-  onWrite;
-  tableCreated = false;
-  constructor(db, onWrite) {
-    this.db = db;
-    this.onWrite = onWrite ?? null;
-  }
-  ensureTable() {
-    if (this.tableCreated) return;
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS session_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        timestamp TEXT DEFAULT (datetime('now')),
-        tool TEXT NOT NULL,
-        symbol_id TEXT,
-        detail_level TEXT,
-        response_tokens INTEGER,
-        response_bytes INTEGER,
-        latency_ms REAL,
-        truncated BOOLEAN DEFAULT 0
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_session_timestamp ON session_events(timestamp)");
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_session_tool ON session_events(tool)");
-    this.tableCreated = true;
-  }
-  record(event) {
-    try {
-      this.ensureTable();
-      this.db.run(
-        `INSERT INTO session_events (tool, symbol_id, detail_level, response_tokens, response_bytes, latency_ms, truncated)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`,
-        [
-          event.tool,
-          event.symbolId,
-          event.detailLevel,
-          event.responseTokens,
-          event.responseBytes,
-          event.latencyMs,
-          event.truncated ? 1 : 0
-        ]
-      );
-      this.flushToDisk();
-    } catch (err) {
-      log7.error(`Failed to record session event: ${err.message}`);
-    }
-  }
-  queryStats(days) {
-    this.ensureTable();
-    const whereClause = days != null && days > 0 ? `WHERE timestamp >= datetime('now', '-${Math.floor(days)} days')` : "";
-    const summaryResult = this.db.exec(
-      `SELECT COUNT(*) as total_calls, COALESCE(SUM(response_tokens), 0) as total_tokens
-       FROM session_events ${whereClause}`
-    );
-    const summaryRow = summaryResult[0]?.values[0];
-    const totalCalls = Number(summaryRow?.[0] ?? 0);
-    const totalTokensServed = Number(summaryRow?.[1] ?? 0);
-    const toolsResult = this.db.exec(
-      `SELECT tool, COUNT(*) as calls, CAST(AVG(response_tokens) AS INTEGER) as avg_tokens
-       FROM session_events ${whereClause}
-       GROUP BY tool ORDER BY calls DESC LIMIT 5`
-    );
-    const topTools = (toolsResult[0]?.values ?? []).map((row) => ({
-      tool: String(row[0]),
-      calls: Number(row[1]),
-      avgTokens: Number(row[2])
-    }));
-    const symbolWherePrefix = whereClause ? whereClause + " AND" : "WHERE";
-    const symbolsResult = this.db.exec(
-      `SELECT symbol_id, COUNT(*) as queries
-       FROM session_events ${symbolWherePrefix} symbol_id IS NOT NULL
-       GROUP BY symbol_id ORDER BY queries DESC LIMIT 5`
-    );
-    const topSymbols = (symbolsResult[0]?.values ?? []).map((row) => {
-      const symbolId = String(row[0]);
-      const parts = symbolId.split("::");
-      const name = parts.length >= 2 ? parts[1] : symbolId;
-      return {
-        symbolId,
-        name,
-        queries: Number(row[1])
-      };
-    });
-    const levelResult = this.db.exec(
-      `SELECT detail_level, COUNT(*) as count
-       FROM session_events ${symbolWherePrefix} detail_level IS NOT NULL
-       GROUP BY detail_level ORDER BY detail_level`
-    );
-    const levelRows = levelResult[0]?.values ?? [];
-    const levelTotal = levelRows.reduce((sum, row) => sum + Number(row[1]), 0);
-    const detailLevelDistribution = levelRows.map((row) => ({
-      level: String(row[0]),
-      count: Number(row[1]),
-      percentage: levelTotal > 0 ? Math.round(Number(row[1]) / levelTotal * 100) : 0
-    }));
-    return {
-      totalCalls,
-      totalTokensServed,
-      topTools,
-      topSymbols,
-      detailLevelDistribution
-    };
-  }
-  clear() {
-    this.ensureTable();
-    this.db.run("DELETE FROM session_events");
-    this.flushToDisk();
-  }
-  flushToDisk() {
-    try {
-      this.onWrite?.();
-    } catch (err) {
-      log7.error(`Failed to flush stats to disk: ${err.message}`);
-    }
-  }
-};
-
-// src/adapters/workspace/single-package-workspace.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2 } from "fs";
-import { join as join6, resolve as resolve2 } from "path";
-var MANIFEST_CANDIDATES = [
-  "package.json",
-  "pyproject.toml",
-  "setup.py",
-  "pom.xml",
-  "build.gradle",
-  "build.gradle.kts",
-  "go.mod",
-  "Cargo.toml"
-];
-function findManifest(dir) {
-  for (const name of MANIFEST_CANDIDATES) {
-    const candidate = join6(dir, name);
-    if (existsSync4(candidate)) return candidate;
-  }
-  const csproj = findFirstByExt(dir, ".csproj") ?? findFirstByExt(dir, ".sln");
-  if (csproj) return csproj;
-  return join6(dir, "package.json");
-}
-function findFirstByExt(dir, ext) {
-  try {
-    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-      if (entry.isFile() && entry.name.endsWith(ext)) return join6(dir, entry.name);
-    }
-  } catch {
-  }
-  return null;
-}
-function detectWorkspace(cwd) {
-  const root = resolve2(cwd);
-  const pkg = {
-    root,
-    manifest: findManifest(root)
-  };
-  return {
-    root,
-    packages: [pkg]
-  };
-}
-
-// src/core/data-coupling/data-kinds.ts
-import { DATA_RESOURCE_KINDS as DATA_RESOURCE_KINDS2 } from "@ctxo/plugin-api";
-var DATA_EDGE_KINDS = /* @__PURE__ */ new Set(["reads", "writes", "executes"]);
-var PROCEDURE_KINDS = ["procedure"];
-function isDataResourceKind(kind) {
-  return DATA_RESOURCE_KINDS2.includes(kind);
-}
-function dataReferenceKinds(kind) {
-  if (isDataResourceKind(kind)) return DATA_RESOURCE_KINDS2;
-  if (kind === "procedure") return PROCEDURE_KINDS;
-  return void 0;
-}
-
-// src/core/test-files/test-file-classifier.ts
-var DEFAULT_TEST_GLOBS = [
-  "**/__tests__/**",
-  "**/*.test.*",
-  "**/*.spec.*",
-  "**/test/**",
-  "**/tests/**",
-  "**/*_test.go",
-  "**/src/test/**",
-  "**/*.Tests/**",
-  "**/*.Test/**",
-  "**/*Tests.cs",
-  "**/*Test.cs",
-  "**/test_*.py",
-  "**/*_test.py"
-];
-var NAME_ONLY_TEST_GLOBS = ["**/*Tests.cs", "**/*Test.cs"];
-var TEST_FRAMEWORK_ANNOTATIONS = [
-  "Fact",
-  "Theory",
-  "SkippableFact",
-  "SkippableTheory",
-  "Test",
-  "TestCase",
-  "TestCaseSource",
-  "TestFixture",
-  "TestMethod",
-  "DataTestMethod",
-  "TestClass"
-];
-function normalisePath(path) {
-  return path.replace(/\\/g, "/");
-}
-function filesWithTestAnnotations(indices) {
-  const names = new Set(TEST_FRAMEWORK_ANNOTATIONS);
-  const files = /* @__PURE__ */ new Set();
-  for (const index of indices) {
-    const marked = index.symbols.some((symbol) => symbol.annotations?.some((annotation) => names.has(annotation.name)));
-    if (marked) files.add(normalisePath(index.file));
-  }
-  return files;
-}
-function createTestFileClassifier(extraGlobs = [], annotatedFiles, options = {}) {
-  const nameOnly = new Set(NAME_ONLY_TEST_GLOBS);
-  const defaults = options.annotationAware === true ? DEFAULT_TEST_GLOBS.filter((glob) => !nameOnly.has(glob)) : DEFAULT_TEST_GLOBS;
-  const matchesGlob = makeGlobMatcher([...defaults, ...extraGlobs]);
-  return (path) => annotatedFiles?.has(normalisePath(path)) === true || matchesGlob(path);
-}
-
-// src/core/graph/symbol-graph.ts
-var isDefaultTestFile = createTestFileClassifier();
-var DOCUMENTATION_FOLDERS = /* @__PURE__ */ new Set(["docs", "doc", "documentation"]);
-function asciiLower(text) {
-  return text.replace(/[A-Z]/g, (c) => String.fromCharCode(c.charCodeAt(0) + 32));
-}
-function isUnderDocumentationFolder(file) {
-  const folders = file.replace(/\\/g, "/").split("/").slice(0, -1);
-  return folders.some((folder) => DOCUMENTATION_FOLDERS.has(asciiLower(folder)));
-}
-function definitionRank(symbolId) {
-  const at = symbolId.indexOf("::");
-  const file = at < 0 ? symbolId : symbolId.slice(0, at);
-  return (isDefaultTestFile(file) ? 2 : 0) + (isUnderDocumentationFolder(file) ? 1 : 0);
-}
-var SymbolGraph = class {
-  nodes = /* @__PURE__ */ new Map();
-  nodesByFileAndName = /* @__PURE__ */ new Map();
-  nodesByNameAndKind = /* @__PURE__ */ new Map();
-  forwardEdges = /* @__PURE__ */ new Map();
-  reverseEdges = /* @__PURE__ */ new Map();
-  definitionRanks = /* @__PURE__ */ new Map();
-  edgeSet = /* @__PURE__ */ new Set();
-  addNode(node) {
-    this.nodes.set(node.symbolId, node);
-    const parts = node.symbolId.split("::");
-    const [p0, p1] = parts;
-    if (p0 !== void 0 && p1 !== void 0) {
-      this.nodesByFileAndName.set(`${p0}::${p1}`, node);
-    }
-    if (parts.length === 3) {
-      const nk = `${parts[1]}::${parts[2]}`;
-      const list = this.nodesByNameAndKind.get(nk);
-      if (list) list.push(node);
-      else this.nodesByNameAndKind.set(nk, [node]);
-    }
-  }
-  addEdge(edge) {
-    const resolvedFrom = this.resolveNodeId(edge.from);
-    const resolvedTo = this.resolveNodeId(edge.to);
-    const resolvedEdge = { from: resolvedFrom, to: resolvedTo, kind: edge.kind };
-    const edgeKey = `${resolvedEdge.from}|${resolvedEdge.to}|${resolvedEdge.kind}`;
-    if (this.edgeSet.has(edgeKey)) return;
-    this.edgeSet.add(edgeKey);
-    const forward = this.forwardEdges.get(resolvedEdge.from) ?? [];
-    forward.push(resolvedEdge);
-    this.forwardEdges.set(resolvedEdge.from, forward);
-    const reverse = this.reverseEdges.get(resolvedEdge.to) ?? [];
-    reverse.push(resolvedEdge);
-    this.reverseEdges.set(resolvedEdge.to, reverse);
-  }
-  getNode(symbolId) {
-    return this.nodes.get(symbolId) ?? this.resolveNodeFuzzy(symbolId);
-  }
-  resolveNodeId(id) {
-    if (this.nodes.has(id)) return id;
-    const segs = id.split("::");
-    const [p0, p1] = segs;
-    if (p0 !== void 0 && p1 !== void 0) {
-      const fuzzyKey = `${p0}::${p1}`;
-      const match = this.nodesByFileAndName.get(fuzzyKey);
-      if (match) return match.symbolId;
-      const jsToTs = p0.replace(/\.js$/, ".ts");
-      if (jsToTs !== p0) {
-        const altKey = `${jsToTs}::${p1}`;
-        const altMatch = this.nodesByFileAndName.get(altKey);
-        if (altMatch) return altMatch.symbolId;
-      }
-    }
-    const dataMatch = this.resolveDataReference(segs);
-    if (dataMatch) return dataMatch.symbolId;
-    const nameKind = this.extractNameKind(segs);
-    if (nameKind) {
-      const candidates = this.nodesByNameAndKind.get(nameKind);
-      if (candidates && candidates.length === 1) return candidates[0].symbolId;
-    }
-    return id;
-  }
-  resolveNodeFuzzy(id) {
-    const segs = id.split("::");
-    const [p0, p1] = segs;
-    if (p0 !== void 0 && p1 !== void 0) {
-      const match = this.nodesByFileAndName.get(`${p0}::${p1}`);
-      if (match) return match;
-      const jsToTs = p0.replace(/\.js$/, ".ts");
-      if (jsToTs !== p0) {
-        const tsMatch = this.nodesByFileAndName.get(`${jsToTs}::${p1}`);
-        if (tsMatch) return tsMatch;
-      }
-    }
-    const dataMatch = this.resolveDataReference(segs);
-    if (dataMatch) return dataMatch;
-    const nameKind = this.extractNameKind(segs);
-    if (nameKind) {
-      const candidates = this.nodesByNameAndKind.get(nameKind);
-      if (candidates && candidates.length === 1) return candidates[0];
-    }
-    return void 0;
-  }
-  /**
-   * Resolves a 2-part data reference (`dbo.loans::table`). A table or view reference is kind-agnostic
-   * across data resource kinds, a procedure reference matches procedures only. Several definitions
-   * resolve by `definitionRank` (a production copy before a documentation copy before a test copy), then
-   * to the codepoint-smallest symbolId, which is the first file in sorted path order. The result does
-   * not depend on insertion order.
-   */
-  resolveDataReference(segs) {
-    if (segs.length !== 2) return void 0;
-    const [name, kind] = segs;
-    const kinds = dataReferenceKinds(kind);
-    if (!kinds) return void 0;
-    let best;
-    for (const k of kinds) {
-      for (const node of this.nodesByNameAndKind.get(`${name}::${k}`) ?? []) {
-        if (!best || this.compareDefinitions(node, best) < 0) best = node;
-      }
-    }
-    return best;
-  }
-  /** The tie-break order of same-name definitions: `definitionRank`, then the codepoint-smaller symbolId. */
-  compareDefinitions = (a, b) => this.definitionRankOf(a.symbolId) - this.definitionRankOf(b.symbolId) || compareCodepoint(a.symbolId, b.symbolId);
-  /**
-   * The identity of the table, view or procedure that `id` names: a full id of any of its definitions, or a
-   * 2-part reference such as `dbo.loans::table`. Undefined when `id` names no node, or a node of another
-   * kind. A table or view identity spans both kinds, as a 2-part `::table` reference does.
-   */
-  dataResourceIdentity(id) {
-    const node = this.getNode(id);
-    return node ? this.identityOf(node) : void 0;
-  }
-  identityOf(node) {
-    const segs = node.symbolId.split("::");
-    if (segs.length !== 3) return void 0;
-    const [, name, kind] = segs;
-    const kinds = dataReferenceKinds(kind);
-    if (!kinds) return void 0;
-    const byId = /* @__PURE__ */ new Map();
-    for (const k of kinds) {
-      for (const definition of this.nodesByNameAndKind.get(`${name}::${k}`) ?? []) {
-        byId.set(definition.symbolId, this.nodes.get(definition.symbolId) ?? definition);
-      }
-    }
-    const definitions = [...byId.values()].sort(this.compareDefinitions);
-    const winner = definitions[0] ?? node;
-    const production = definitions.filter((definition) => this.definitionRankOf(definition.symbolId) === 0);
-    return { canonicalId: `${name}::${winner.kind}`, winner, definitions, production };
-  }
-  /** `definitionRank`, cached per symbolId (the glob match runs once per definition). */
-  definitionRankOf(symbolId) {
-    let rank = this.definitionRanks.get(symbolId);
-    if (rank === void 0) {
-      rank = definitionRank(symbolId);
-      this.definitionRanks.set(symbolId, rank);
-    }
-    return rank;
-  }
-  /**
-   * Extracts a `name::kind` key from the segments of a reference ID, supporting:
-   *   - 2-part: `Bar::class`                  → `Bar::class`
-   *   - 3-part: `pkg.Bar::helper::method`      → `helper::method`
-   * Returns undefined for 1-part IDs (no kind information available).
-   */
-  extractNameKind(segs) {
-    if (segs.length === 3) return `${segs[1]}::${segs[2]}`;
-    if (segs.length === 2) return `${segs[0]}::${segs[1]}`;
-    return void 0;
-  }
-  getForwardEdges(symbolId) {
-    return this.forwardEdges.get(symbolId) ?? [];
-  }
-  getReverseEdges(symbolId) {
-    return this.reverseEdges.get(symbolId) ?? [];
-  }
-  /**
-   * The dependents of a resolved symbolId, as the impact tools read them. For a definition of a table, view
-   * or procedure these are the incoming edges of every same-name definition, which in practice are the
-   * winner's: any copy then reports the dependents of the resource. For every other id they are its own
-   * incoming edges, as `getReverseEdges` gives them.
-   */
-  getDependentEdges(symbolId) {
-    const node = this.nodes.get(symbolId);
-    const definitions = node ? this.identityOf(node)?.definitions : void 0;
-    if (!definitions || definitions.length < 2) return this.getReverseEdges(symbolId);
-    return definitions.flatMap((definition) => this.getReverseEdges(definition.symbolId));
-  }
-  hasNode(symbolId) {
-    return this.nodes.has(symbolId) || this.resolveNodeFuzzy(symbolId) !== void 0;
-  }
-  get nodeCount() {
-    return this.nodes.size;
-  }
-  get edgeCount() {
-    return this.edgeSet.size;
-  }
-  allNodes() {
-    return [...this.nodes.values()];
-  }
-  allEdges() {
-    const edges = [];
-    for (const list of this.forwardEdges.values()) {
-      edges.push(...list);
-    }
-    return edges;
+    log5.warn(`${this.filePath} ${problem}; ${consequence}`);
   }
 };
 
@@ -2021,26 +1195,128 @@ var DriftDetector = class {
         mapping.set(prevId, bestCurrentId);
       }
     }
-    return mapping;
+    return mapping;
+  }
+};
+function indexByCommunityId(entries) {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const bucket = index.get(entry.communityId) ?? /* @__PURE__ */ new Set();
+    bucket.add(entry.symbolId);
+    index.set(entry.communityId, bucket);
+  }
+  return index;
+}
+function assignmentMap(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    map.set(entry.symbolId, entry.communityId);
+  }
+  return map;
+}
+function labelMap(entries) {
+  const labels = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!labels.has(entry.communityId)) {
+      labels.set(entry.communityId, entry.communityLabel);
+    }
+  }
+  return labels;
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 1;
+  let intersection = 0;
+  for (const x of a) if (b.has(x)) intersection++;
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function confidenceFor(distinctCommits) {
+  if (distinctCommits >= 7) return "high";
+  if (distinctCommits >= 3) return "medium";
+  return "low";
+}
+function hintFor(distinctCommits) {
+  if (distinctCommits >= 3) return void 0;
+  return "Install the post-commit hook (`ctxo init`) or run `ctxo index` after commits to build history; `ctxo index --check` does not record snapshots.";
+}
+
+// src/core/overlay/boundary-violation-detector.ts
+var HIGH_SEVERITY_THRESHOLD = 0;
+var MEDIUM_SEVERITY_THRESHOLD = 2;
+var MIN_DISTINCT_COMMITS_FOR_CONFIDENCE = 2;
+var BoundaryViolationDetector = class {
+  detect(graph, current, history) {
+    const snapshotsAvailable = history.length;
+    const distinctCommits = distinctCommitCount(history, current.commitSha);
+    const currentAssignments = assignmentMap2(current.communities);
+    const currentLabels = labelMap2(current.communities);
+    const earlierCommits = priorCommitSnapshots(history, current.commitSha);
+    const historicalAssignments = earlierCommits.map((snapshot) => ({
+      snapshot,
+      assignments: assignmentMap2(snapshot.communities),
+      labels: labelMap2(snapshot.communities)
+    }));
+    const violations = [];
+    for (const edge of graph.allEdges()) {
+      if (edge.from === edge.to) continue;
+      if (DATA_EDGE_KINDS.has(edge.kind)) continue;
+      const fromCommunity = currentAssignments.get(edge.from);
+      const toCommunity = currentAssignments.get(edge.to);
+      if (fromCommunity === void 0 || toCommunity === void 0) continue;
+      if (fromCommunity === toCommunity) continue;
+      const fromLabel = currentLabels.get(fromCommunity) ?? `community-${fromCommunity}`;
+      const toLabel = currentLabels.get(toCommunity) ?? `community-${toCommunity}`;
+      const historicalCount = distinctCommits < MIN_DISTINCT_COMMITS_FOR_CONFIDENCE ? -1 : countHistoricalCrossCluster(historicalAssignments, edge.from, edge.to);
+      if (historicalCount === -1 || historicalCount <= MEDIUM_SEVERITY_THRESHOLD) {
+        violations.push({
+          from: {
+            symbolId: edge.from,
+            communityId: fromCommunity,
+            label: fromLabel
+          },
+          to: {
+            symbolId: edge.to,
+            communityId: toCommunity,
+            label: toLabel
+          },
+          edgeKind: edge.kind,
+          historicalEdgesBetweenClusters: historicalCount,
+          severity: historicalCount === HIGH_SEVERITY_THRESHOLD ? "high" : "medium"
+        });
+      }
+    }
+    violations.sort((a, b) => {
+      if (a.severity !== b.severity) return a.severity === "high" ? -1 : 1;
+      const cmp = compareCodepoint(a.from.symbolId, b.from.symbolId);
+      return cmp !== 0 ? cmp : compareCodepoint(a.to.symbolId, b.to.symbolId);
+    });
+    return {
+      violations,
+      confidence: confidenceFor2(distinctCommits),
+      snapshotsAvailable,
+      distinctCommits,
+      hint: hintFor2(distinctCommits)
+    };
   }
 };
-function indexByCommunityId(entries) {
-  const index = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const bucket = index.get(entry.communityId) ?? /* @__PURE__ */ new Set();
-    bucket.add(entry.symbolId);
-    index.set(entry.communityId, bucket);
+function countHistoricalCrossCluster(history, fromSymbol, toSymbol) {
+  let count2 = 0;
+  for (const snap of history) {
+    const fromId = snap.assignments.get(fromSymbol);
+    const toId = snap.assignments.get(toSymbol);
+    if (fromId === void 0 || toId === void 0) continue;
+    if (fromId !== toId) count2++;
   }
-  return index;
+  return count2;
 }
-function assignmentMap(entries) {
+function assignmentMap2(entries) {
   const map = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     map.set(entry.symbolId, entry.communityId);
   }
   return map;
 }
-function labelMap(entries) {
+function labelMap2(entries) {
   const labels = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!labels.has(entry.communityId)) {
@@ -2049,200 +1325,96 @@ function labelMap(entries) {
   }
   return labels;
 }
-function jaccard(a, b) {
-  if (a.size === 0 && b.size === 0) return 1;
-  let intersection = 0;
-  for (const x of a) if (b.has(x)) intersection++;
-  const union = a.size + b.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-function confidenceFor(distinctCommits) {
+function confidenceFor2(distinctCommits) {
   if (distinctCommits >= 7) return "high";
   if (distinctCommits >= 3) return "medium";
   return "low";
 }
-function hintFor(distinctCommits) {
-  if (distinctCommits >= 3) return void 0;
+function hintFor2(distinctCommits) {
+  if (distinctCommits >= MIN_DISTINCT_COMMITS_FOR_CONFIDENCE) return void 0;
   return "Install the post-commit hook (`ctxo init`) or run `ctxo index` after commits to build history; `ctxo index --check` does not record snapshots.";
 }
 
-// src/core/blast-radius/blast-radius-calculator.ts
-var EDGE_KIND_CONFIDENCE = {
-  calls: "confirmed",
-  extends: "confirmed",
-  implements: "confirmed",
-  reads: "confirmed",
-  writes: "confirmed",
-  executes: "confirmed",
-  uses: "likely",
-  imports: "potential"
-};
-var CONFIDENCE_RANK = {
-  confirmed: 2,
-  likely: 1,
-  potential: 0
-};
-function edgeKindToConfidence(kind) {
-  return EDGE_KINDS.includes(kind) ? EDGE_KIND_CONFIDENCE[kind] : "potential";
-}
-var BlastRadiusCalculator = class {
-  /**
-   * `symbolId` may be any id `SymbolGraph.getNode` resolves, a 2-part data id included. The root is the
-   * node it names, and the root's own file is the one co-change is matched against. Dependents come from
-   * `getDependentEdges`, so every copy of a table, view or procedure, and its 2-part id, has the dependents
-   * of the resource, and no definition of the resource counts as a dependent of another.
-   */
-  calculate(graph, symbolId, coChangeMap) {
-    const root = graph.getNode(symbolId);
-    if (!root) {
-      return { impactedSymbols: [], directDependentsCount: 0, confirmedCount: 0, likelyCount: 0, potentialCount: 0, overallRiskScore: 0 };
+// src/core/importance/pagerank-calculator.ts
+var DEFAULT_DAMPING = 0.85;
+var DEFAULT_MAX_ITERATIONS = 100;
+var DEFAULT_TOLERANCE = 1e-6;
+var DEFAULT_LIMIT = 25;
+var PageRankCalculator = class {
+  calculate(graph, options = {}) {
+    const damping = options.damping ?? DEFAULT_DAMPING;
+    const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    const tolerance = options.tolerance ?? DEFAULT_TOLERANCE;
+    const limit = options.limit ?? DEFAULT_LIMIT;
+    const nodes = graph.allNodes();
+    const n = nodes.length;
+    if (n === 0) {
+      return { rankings: [], totalSymbols: 0, iterations: 0, converged: true };
     }
-    const rootId = root.symbolId;
-    const sourceFile = rootId.split("::")[0];
-    const definitions = graph.dataResourceIdentity(rootId)?.definitions.map((definition) => definition.symbolId) ?? [];
-    const visited = /* @__PURE__ */ new Set([rootId, ...definitions]);
-    const rawEntries = [];
-    const queue = [{ id: rootId, depth: 0 }];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      const reverseEdges = graph.getDependentEdges(current.id);
-      const bestByNode = /* @__PURE__ */ new Map();
-      for (const edge of reverseEdges) {
-        if (visited.has(edge.from)) continue;
-        const conf = edgeKindToConfidence(edge.kind);
-        const existing = bestByNode.get(edge.from);
-        if (!existing) {
-          bestByNode.set(edge.from, { confidence: conf, kinds: /* @__PURE__ */ new Set([edge.kind]) });
-        } else {
-          existing.kinds.add(edge.kind);
-          if (CONFIDENCE_RANK[conf] > CONFIDENCE_RANK[existing.confidence]) {
-            existing.confidence = conf;
-          }
-        }
-      }
-      for (const [nodeId, info] of bestByNode) {
-        visited.add(nodeId);
-        const depth = current.depth + 1;
-        const riskScore = 1 / Math.pow(depth, 0.7);
-        let confidence = info.confidence;
-        let coChangeFrequency;
-        if (coChangeMap) {
-          const nodeFile = nodeId.split("::")[0];
-          const coEntries = coChangeMap.get(sourceFile);
-          if (coEntries) {
-            const match = coEntries.find((e) => (e.file1 === sourceFile ? e.file2 : e.file1) === nodeFile);
-            if (match) {
-              coChangeFrequency = match.frequency;
-              if (confidence === "potential" && match.frequency > 0.5) {
-                confidence = "likely";
-              }
-            }
-          }
-        }
-        rawEntries.push({
-          symbolId: nodeId,
-          depth,
-          riskScore: Math.round(riskScore * 1e3) / 1e3,
-          confidence,
-          edgeKinds: [...info.kinds],
-          coChangeFrequency
-        });
-        queue.push({ id: nodeId, depth });
-      }
+    const scores = /* @__PURE__ */ new Map();
+    const initialScore = 1 / n;
+    for (const node of nodes) {
+      scores.set(node.symbolId, initialScore);
     }
-    const blastSet = /* @__PURE__ */ new Set([rootId, ...definitions, ...rawEntries.map((e) => e.symbolId)]);
-    const entries = rawEntries.map((e) => ({
-      ...e,
-      dependentCount: graph.getDependentEdges(e.symbolId).filter((re) => blastSet.has(re.from)).length
-    }));
-    entries.sort((a, b) => a.depth - b.depth);
-    const directDependentsCount = entries.filter((e) => e.depth === 1).length;
-    const totalRisk = entries.reduce((sum, e) => sum + e.riskScore, 0);
-    const overallRiskScore = Math.round(Math.min(totalRisk / Math.max(directDependentsCount, 1), 1) * 1e3) / 1e3;
-    const confirmedCount = entries.filter((e) => e.confidence === "confirmed").length;
-    const likelyCount = entries.filter((e) => e.confidence === "likely").length;
-    const potentialCount = entries.filter((e) => e.confidence === "potential").length;
-    return { impactedSymbols: entries, directDependentsCount, confirmedCount, likelyCount, potentialCount, overallRiskScore };
-  }
-};
-
-// src/core/blast-radius/co-changed-files.ts
-var DEFAULT_LIMIT = 10;
-var DEFAULT_MIN_FREQUENCY = 0.5;
-function findCoChangedFiles(coChangeMap, rootFile, impactedFiles, options = {}) {
-  const limit = options.limit ?? DEFAULT_LIMIT;
-  const minFrequency = options.minFrequency ?? DEFAULT_MIN_FREQUENCY;
-  const strongestByFile = /* @__PURE__ */ new Map();
-  for (const entry of coChangeMap.get(rootFile) ?? []) {
-    const file = entry.file1 === rootFile ? entry.file2 : entry.file1;
-    if (file === rootFile || impactedFiles.has(file) || entry.frequency < minFrequency) continue;
-    const candidate = { file, frequency: entry.frequency, sharedCommits: entry.sharedCommits };
-    const known = strongestByFile.get(file);
-    if (!known || compareStrongestFirst(candidate, known) < 0) strongestByFile.set(file, candidate);
-  }
-  return [...strongestByFile.values()].sort(compareStrongestFirst).slice(0, Math.max(0, limit));
-}
-function compareStrongestFirst(a, b) {
-  return b.frequency - a.frequency || b.sharedCommits - a.sharedCommits || compareCodepoint(a.file, b.file);
-}
-function findCoChangedFilesForBlastRadius(coChangeMap, rootSymbolId, impactedSymbols) {
-  if (!coChangeMap) return [];
-  const rootFile = fileOf(rootSymbolId);
-  const impactedFiles = /* @__PURE__ */ new Set([rootFile]);
-  for (const { symbolId } of impactedSymbols) impactedFiles.add(fileOf(symbolId));
-  return findCoChangedFiles(coChangeMap, rootFile, impactedFiles);
-}
-function fileOf(symbolId) {
-  return symbolId.split("::")[0];
-}
-
-// src/core/overlay/architectural-overlay.ts
-var DEFAULT_RULES = [
-  // Test layer (matched first — __tests__, .test.ts, tests/, fixtures)
-  { pattern: /__tests__/, layer: "Test" },
-  { pattern: /\.test\.ts$/, layer: "Test" },
-  { pattern: /\btests\b/, layer: "Test" },
-  { pattern: /\bfixtures?\b/, layer: "Test" },
-  // Composition root
-  { pattern: /src\/index\.ts$/, layer: "Composition" },
-  // Domain
-  { pattern: /\bcore\b/, layer: "Domain" },
-  { pattern: /\bports?\b/, layer: "Domain" },
-  // Adapter
-  { pattern: /\badapters?\b/, layer: "Adapter" },
-  { pattern: /\bcli\b/, layer: "Adapter" },
-  // Infrastructure
-  { pattern: /\binfra\b/, layer: "Infrastructure" },
-  { pattern: /\bdb\b/, layer: "Infrastructure" },
-  { pattern: /\bqueue\b/, layer: "Infrastructure" },
-  // Config files
-  { pattern: /\.(config|rc)\.(ts|js|json)$/, layer: "Configuration" }
-];
-var ArchitecturalOverlay = class {
-  rules;
-  constructor(customRules) {
-    this.rules = (customRules ?? DEFAULT_RULES).map(({ pattern, layer }) => ({
-      pattern: new RegExp(pattern.source, pattern.flags),
-      layer
-    }));
-  }
-  classify(filePaths) {
-    const layers = {};
-    for (const filePath of filePaths) {
-      const layer = this.matchLayer(filePath);
-      const list = layers[layer] ?? [];
-      list.push(filePath);
-      layers[layer] = list;
+    const outDegree = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      outDegree.set(node.symbolId, graph.getForwardEdges(node.symbolId).length);
     }
-    return { layers };
-  }
-  matchLayer(filePath) {
-    for (const rule of this.rules) {
-      if (rule.pattern.test(filePath)) {
-        return rule.layer;
+    let iterations = 0;
+    let converged = false;
+    while (iterations < maxIterations) {
+      const newScores = /* @__PURE__ */ new Map();
+      const base = (1 - damping) / n;
+      let danglingSum = 0;
+      for (const node of nodes) {
+        if ((outDegree.get(node.symbolId) ?? 0) === 0) {
+          danglingSum += scores.get(node.symbolId) ?? 0;
+        }
+      }
+      const danglingContrib = damping * danglingSum / n;
+      for (const node of nodes) {
+        let incomingScore = 0;
+        const reverseEdges = graph.getReverseEdges(node.symbolId);
+        const contributors = /* @__PURE__ */ new Set();
+        for (const edge of reverseEdges) {
+          if (contributors.has(edge.from)) continue;
+          contributors.add(edge.from);
+          const fromScore = scores.get(edge.from) ?? 0;
+          const fromOut = outDegree.get(edge.from) ?? 1;
+          incomingScore += fromScore / fromOut;
+        }
+        newScores.set(node.symbolId, base + damping * incomingScore + danglingContrib);
+      }
+      let maxDelta = 0;
+      for (const node of nodes) {
+        const delta = Math.abs((newScores.get(node.symbolId) ?? 0) - (scores.get(node.symbolId) ?? 0));
+        if (delta > maxDelta) maxDelta = delta;
+      }
+      for (const [id, score] of newScores) {
+        scores.set(id, score);
+      }
+      iterations++;
+      if (maxDelta < tolerance) {
+        converged = true;
+        break;
       }
     }
-    return "Unknown";
+    const entries = nodes.map((node) => ({
+      symbolId: node.symbolId,
+      name: node.name,
+      kind: node.kind,
+      file: node.symbolId.split("::")[0] ?? "",
+      score: Math.round((scores.get(node.symbolId) ?? 0) * 1e6) / 1e6,
+      inDegree: graph.getReverseEdges(node.symbolId).length,
+      outDegree: outDegree.get(node.symbolId) ?? 0
+    }));
+    entries.sort((a, b) => b.score - a.score);
+    return {
+      rankings: entries.slice(0, limit),
+      totalSymbols: n,
+      iterations,
+      converged
+    };
   }
 };
 
@@ -2403,456 +1575,262 @@ var DeadCodeDetector = class {
         return "Zero importers \u2014 no code references this symbol";
       case 0.9:
         return "Only referenced from test/config files";
-      case 0.7:
-        return "All importers are themselves dead (cascading)";
-    }
-  }
-  isFrameworkSymbol(name) {
-    return FRAMEWORK_PATTERNS.some((p) => p.test(name));
-  }
-  computeCascadeDepths(graph, deadIds, candidateIds) {
-    const depths = /* @__PURE__ */ new Map();
-    const rootDead = /* @__PURE__ */ new Set();
-    for (const id of deadIds) {
-      const reverseEdges = graph.getReverseEdges(id);
-      const deadImporters = reverseEdges.filter((e) => deadIds.has(e.from) && e.from !== id);
-      if (deadImporters.length === 0) {
-        rootDead.add(id);
-        depths.set(id, 0);
-      }
-    }
-    const queue = [...rootDead].map((id) => ({ id, depth: 0 }));
-    const visited = new Set(rootDead);
-    while (queue.length > 0) {
-      const current = queue.shift();
-      for (const edge of graph.getForwardEdges(current.id)) {
-        if (deadIds.has(edge.to) && !visited.has(edge.to) && candidateIds.has(edge.to)) {
-          const newDepth = current.depth + 1;
-          depths.set(edge.to, newDepth);
-          visited.add(edge.to);
-          queue.push({ id: edge.to, depth: newDepth });
-        }
-      }
-    }
-    return depths;
-  }
-  detectScaffolding(isExcluded, sourceContents) {
-    if (!sourceContents || sourceContents.size === 0) return [];
-    const results = [];
-    for (const [file, content] of sourceContents) {
-      if (isExcluded(file)) continue;
-      const lines = content.split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        for (const { regex, pattern } of SCAFFOLDING_PATTERNS) {
-          if (regex.test(line)) {
-            results.push({
-              file,
-              line: i + 1,
-              pattern,
-              text: line.trim().slice(0, 120)
-            });
-            break;
-          }
-        }
-      }
-    }
-    return results;
-  }
-  matchesAny(value, patterns) {
-    return patterns.some((p) => p.test(value));
-  }
-};
-
-// src/core/importance/pagerank-calculator.ts
-var DEFAULT_DAMPING = 0.85;
-var DEFAULT_MAX_ITERATIONS = 100;
-var DEFAULT_TOLERANCE = 1e-6;
-var DEFAULT_LIMIT2 = 25;
-var PageRankCalculator = class {
-  calculate(graph, options = {}) {
-    const damping = options.damping ?? DEFAULT_DAMPING;
-    const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-    const tolerance = options.tolerance ?? DEFAULT_TOLERANCE;
-    const limit = options.limit ?? DEFAULT_LIMIT2;
-    const nodes = graph.allNodes();
-    const n = nodes.length;
-    if (n === 0) {
-      return { rankings: [], totalSymbols: 0, iterations: 0, converged: true };
-    }
-    const scores = /* @__PURE__ */ new Map();
-    const initialScore = 1 / n;
-    for (const node of nodes) {
-      scores.set(node.symbolId, initialScore);
-    }
-    const outDegree = /* @__PURE__ */ new Map();
-    for (const node of nodes) {
-      outDegree.set(node.symbolId, graph.getForwardEdges(node.symbolId).length);
-    }
-    let iterations = 0;
-    let converged = false;
-    while (iterations < maxIterations) {
-      const newScores = /* @__PURE__ */ new Map();
-      const base = (1 - damping) / n;
-      let danglingSum = 0;
-      for (const node of nodes) {
-        if ((outDegree.get(node.symbolId) ?? 0) === 0) {
-          danglingSum += scores.get(node.symbolId) ?? 0;
-        }
-      }
-      const danglingContrib = damping * danglingSum / n;
-      for (const node of nodes) {
-        let incomingScore = 0;
-        const reverseEdges = graph.getReverseEdges(node.symbolId);
-        const contributors = /* @__PURE__ */ new Set();
-        for (const edge of reverseEdges) {
-          if (contributors.has(edge.from)) continue;
-          contributors.add(edge.from);
-          const fromScore = scores.get(edge.from) ?? 0;
-          const fromOut = outDegree.get(edge.from) ?? 1;
-          incomingScore += fromScore / fromOut;
-        }
-        newScores.set(node.symbolId, base + damping * incomingScore + danglingContrib);
-      }
-      let maxDelta = 0;
-      for (const node of nodes) {
-        const delta = Math.abs((newScores.get(node.symbolId) ?? 0) - (scores.get(node.symbolId) ?? 0));
-        if (delta > maxDelta) maxDelta = delta;
-      }
-      for (const [id, score] of newScores) {
-        scores.set(id, score);
-      }
-      iterations++;
-      if (maxDelta < tolerance) {
-        converged = true;
-        break;
-      }
-    }
-    const entries = nodes.map((node) => ({
-      symbolId: node.symbolId,
-      name: node.name,
-      kind: node.kind,
-      file: node.symbolId.split("::")[0] ?? "",
-      score: Math.round((scores.get(node.symbolId) ?? 0) * 1e6) / 1e6,
-      inDegree: graph.getReverseEdges(node.symbolId).length,
-      outDegree: outDegree.get(node.symbolId) ?? 0
-    }));
-    entries.sort((a, b) => b.score - a.score);
-    return {
-      rankings: entries.slice(0, limit),
-      totalSymbols: n,
-      iterations,
-      converged
-    };
-  }
-};
-
-// src/core/overlay/boundary-violation-detector.ts
-var HIGH_SEVERITY_THRESHOLD = 0;
-var MEDIUM_SEVERITY_THRESHOLD = 2;
-var MIN_DISTINCT_COMMITS_FOR_CONFIDENCE = 2;
-var BoundaryViolationDetector = class {
-  detect(graph, current, history) {
-    const snapshotsAvailable = history.length;
-    const distinctCommits = distinctCommitCount(history, current.commitSha);
-    const currentAssignments = assignmentMap2(current.communities);
-    const currentLabels = labelMap2(current.communities);
-    const earlierCommits = priorCommitSnapshots(history, current.commitSha);
-    const historicalAssignments = earlierCommits.map((snapshot) => ({
-      snapshot,
-      assignments: assignmentMap2(snapshot.communities),
-      labels: labelMap2(snapshot.communities)
-    }));
-    const violations = [];
-    for (const edge of graph.allEdges()) {
-      if (edge.from === edge.to) continue;
-      if (DATA_EDGE_KINDS.has(edge.kind)) continue;
-      const fromCommunity = currentAssignments.get(edge.from);
-      const toCommunity = currentAssignments.get(edge.to);
-      if (fromCommunity === void 0 || toCommunity === void 0) continue;
-      if (fromCommunity === toCommunity) continue;
-      const fromLabel = currentLabels.get(fromCommunity) ?? `community-${fromCommunity}`;
-      const toLabel = currentLabels.get(toCommunity) ?? `community-${toCommunity}`;
-      const historicalCount = distinctCommits < MIN_DISTINCT_COMMITS_FOR_CONFIDENCE ? -1 : countHistoricalCrossCluster(historicalAssignments, edge.from, edge.to);
-      if (historicalCount === -1 || historicalCount <= MEDIUM_SEVERITY_THRESHOLD) {
-        violations.push({
-          from: {
-            symbolId: edge.from,
-            communityId: fromCommunity,
-            label: fromLabel
-          },
-          to: {
-            symbolId: edge.to,
-            communityId: toCommunity,
-            label: toLabel
-          },
-          edgeKind: edge.kind,
-          historicalEdgesBetweenClusters: historicalCount,
-          severity: historicalCount === HIGH_SEVERITY_THRESHOLD ? "high" : "medium"
-        });
-      }
-    }
-    violations.sort((a, b) => {
-      if (a.severity !== b.severity) return a.severity === "high" ? -1 : 1;
-      const cmp = compareCodepoint(a.from.symbolId, b.from.symbolId);
-      return cmp !== 0 ? cmp : compareCodepoint(a.to.symbolId, b.to.symbolId);
-    });
-    return {
-      violations,
-      confidence: confidenceFor2(distinctCommits),
-      snapshotsAvailable,
-      distinctCommits,
-      hint: hintFor2(distinctCommits)
-    };
-  }
-};
-function countHistoricalCrossCluster(history, fromSymbol, toSymbol) {
-  let count2 = 0;
-  for (const snap of history) {
-    const fromId = snap.assignments.get(fromSymbol);
-    const toId = snap.assignments.get(toSymbol);
-    if (fromId === void 0 || toId === void 0) continue;
-    if (fromId !== toId) count2++;
-  }
-  return count2;
-}
-function assignmentMap2(entries) {
-  const map = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    map.set(entry.symbolId, entry.communityId);
-  }
-  return map;
-}
-function labelMap2(entries) {
-  const labels = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    if (!labels.has(entry.communityId)) {
-      labels.set(entry.communityId, entry.communityLabel);
+      case 0.7:
+        return "All importers are themselves dead (cascading)";
     }
   }
-  return labels;
-}
-function confidenceFor2(distinctCommits) {
-  if (distinctCommits >= 7) return "high";
-  if (distinctCommits >= 3) return "medium";
-  return "low";
-}
-function hintFor2(distinctCommits) {
-  if (distinctCommits >= MIN_DISTINCT_COMMITS_FOR_CONFIDENCE) return void 0;
-  return "Install the post-commit hook (`ctxo init`) or run `ctxo index` after commits to build history; `ctxo index --check` does not record snapshots.";
-}
-
-// src/core/search/symbol-tokenizer.ts
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "get",
-  "set",
-  "is",
-  "has",
-  "can",
-  "do",
-  "the",
-  "a",
-  "an",
-  "of",
-  "to",
-  "in",
-  "for",
-  "on",
-  "with",
-  "at",
-  "by",
-  "from",
-  "as",
-  "into",
-  "not",
-  "no",
-  "or"
-]);
-var DEFAULT_OPTIONS = {
-  includeStopWords: false,
-  includeOriginal: true,
-  includeFilePath: false
-};
-var SymbolTokenizer = class _SymbolTokenizer {
-  options;
-  constructor(options) {
-    this.options = { ...DEFAULT_OPTIONS, ...options };
+  isFrameworkSymbol(name) {
+    return FRAMEWORK_PATTERNS.some((p) => p.test(name));
   }
-  /**
-   * Tokenize a symbol name into searchable tokens.
-   *
-   * Examples:
-   *   "getCoChangeMetrics"    → ["get", "co", "change", "metrics"]  (or without stop words: ["co", "change", "metrics"])
-   *   "SqliteStorageAdapter"  → ["sqlite", "storage", "adapter"]
-   *   "i_storage_port"        → ["i", "storage", "port"]
-   *   "BM25Scorer"            → ["bm", "25", "scorer"]
-   *   "DB_PASSWORD"           → ["db", "password"]
-   */
-  tokenize(symbolName, filePath) {
-    const splitTokens = _SymbolTokenizer.splitName(symbolName);
-    const lowered = splitTokens.map((t) => t.toLowerCase());
-    const tokens = this.options.includeStopWords ? lowered : lowered.filter((t) => !STOP_WORDS.has(t));
-    if (this.options.includeOriginal) {
-      const original = symbolName.toLowerCase();
-      if (!tokens.includes(original)) {
-        tokens.unshift(original);
+  computeCascadeDepths(graph, deadIds, candidateIds) {
+    const depths = /* @__PURE__ */ new Map();
+    const rootDead = /* @__PURE__ */ new Set();
+    for (const id of deadIds) {
+      const reverseEdges = graph.getReverseEdges(id);
+      const deadImporters = reverseEdges.filter((e) => deadIds.has(e.from) && e.from !== id);
+      if (deadImporters.length === 0) {
+        rootDead.add(id);
+        depths.set(id, 0);
       }
     }
-    if (this.options.includeFilePath && filePath) {
-      const pathTokens = _SymbolTokenizer.tokenizeFilePath(filePath);
-      for (const pt of pathTokens) {
-        if (!tokens.includes(pt)) {
-          tokens.push(pt);
+    const queue = [...rootDead].map((id) => ({ id, depth: 0 }));
+    const visited = new Set(rootDead);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      for (const edge of graph.getForwardEdges(current.id)) {
+        if (deadIds.has(edge.to) && !visited.has(edge.to) && candidateIds.has(edge.to)) {
+          const newDepth = current.depth + 1;
+          depths.set(edge.to, newDepth);
+          visited.add(edge.to);
+          queue.push({ id: edge.to, depth: newDepth });
         }
       }
     }
-    return tokens;
+    return depths;
   }
-  /**
-   * Tokenize a search query. Queries use stop words and don't include originals.
-   */
-  tokenizeQuery(query) {
-    const words = query.trim().split(/\s+/);
-    const tokens = [];
-    for (const word of words) {
-      const split = _SymbolTokenizer.splitName(word);
-      for (const t of split) {
-        const lowered = t.toLowerCase();
-        if (lowered.length > 0 && !tokens.includes(lowered)) {
-          tokens.push(lowered);
+  detectScaffolding(isExcluded, sourceContents) {
+    if (!sourceContents || sourceContents.size === 0) return [];
+    const results = [];
+    for (const [file, content] of sourceContents) {
+      if (isExcluded(file)) continue;
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const { regex, pattern } of SCAFFOLDING_PATTERNS) {
+          if (regex.test(line)) {
+            results.push({
+              file,
+              line: i + 1,
+              pattern,
+              text: line.trim().slice(0, 120)
+            });
+            break;
+          }
         }
       }
     }
-    return tokens;
+    return results;
   }
-  /**
-   * Split a name into constituent words based on naming convention boundaries.
-   *
-   * Rules:
-   *  1. Split on underscores and hyphens (snake_case, kebab-case)
-   *  2. Split on camelCase/PascalCase boundaries (uppercase after lowercase)
-   *  3. Split acronym boundaries (e.g., "HTMLParser" → ["HTML", "Parser"])
-   *  4. Split on digit ↔ letter boundaries
-   */
-  static splitName(name) {
-    if (!name || name.length === 0) return [];
-    const segments = name.split(/[_\-./\\]+/).filter((s) => s.length > 0);
-    const tokens = [];
-    for (const segment of segments) {
-      tokens.push(..._SymbolTokenizer.splitCamelCase(segment));
+  matchesAny(value, patterns) {
+    return patterns.some((p) => p.test(value));
+  }
+};
+
+// src/core/overlay/architectural-overlay.ts
+var DEFAULT_RULES = [
+  // Test layer (matched first — __tests__, .test.ts, tests/, fixtures)
+  { pattern: /__tests__/, layer: "Test" },
+  { pattern: /\.test\.ts$/, layer: "Test" },
+  { pattern: /\btests\b/, layer: "Test" },
+  { pattern: /\bfixtures?\b/, layer: "Test" },
+  // Composition root
+  { pattern: /src\/index\.ts$/, layer: "Composition" },
+  // Domain
+  { pattern: /\bcore\b/, layer: "Domain" },
+  { pattern: /\bports?\b/, layer: "Domain" },
+  // Adapter
+  { pattern: /\badapters?\b/, layer: "Adapter" },
+  { pattern: /\bcli\b/, layer: "Adapter" },
+  // Infrastructure
+  { pattern: /\binfra\b/, layer: "Infrastructure" },
+  { pattern: /\bdb\b/, layer: "Infrastructure" },
+  { pattern: /\bqueue\b/, layer: "Infrastructure" },
+  // Config files
+  { pattern: /\.(config|rc)\.(ts|js|json)$/, layer: "Configuration" }
+];
+var ArchitecturalOverlay = class {
+  rules;
+  constructor(customRules) {
+    this.rules = (customRules ?? DEFAULT_RULES).map(({ pattern, layer }) => ({
+      pattern: new RegExp(pattern.source, pattern.flags),
+      layer
+    }));
+  }
+  classify(filePaths) {
+    const layers = {};
+    for (const filePath of filePaths) {
+      const layer = this.matchLayer(filePath);
+      const list = layers[layer] ?? [];
+      list.push(filePath);
+      layers[layer] = list;
     }
-    return tokens.filter((t) => t.length > 0);
+    return { layers };
   }
-  /**
-   * Split a single segment on camelCase/PascalCase/digit boundaries.
-   */
-  static splitCamelCase(segment) {
-    const tokens = [];
-    let current = "";
-    for (let i = 0; i < segment.length; i++) {
-      const ch = segment[i];
-      const prev = i > 0 ? segment[i - 1] : "";
-      if (current.length > 0) {
-        const prevIsDigit = isDigit(prev);
-        const currIsDigit = isDigit(ch);
-        if (prevIsDigit !== currIsDigit) {
-          tokens.push(current);
-          current = ch;
-          continue;
-        }
-      }
-      if (current.length > 0 && isLower(prev) && isUpper(ch)) {
-        tokens.push(current);
-        current = ch;
-        continue;
-      }
-      if (current.length > 1 && isUpper(ch) === false && isUpper(prev) && !isDigit(ch)) {
-        const lastChar = current[current.length - 1];
-        if (isUpper(lastChar)) {
-          tokens.push(current.slice(0, -1));
-          current = lastChar + ch;
-          continue;
-        }
+  matchLayer(filePath) {
+    for (const rule of this.rules) {
+      if (rule.pattern.test(filePath)) {
+        return rule.layer;
       }
-      current += ch;
     }
-    if (current.length > 0) {
-      tokens.push(current);
-    }
-    return tokens;
+    return "Unknown";
   }
+};
+
+// src/core/blast-radius/blast-radius-calculator.ts
+var EDGE_KIND_CONFIDENCE = {
+  calls: "confirmed",
+  extends: "confirmed",
+  implements: "confirmed",
+  reads: "confirmed",
+  writes: "confirmed",
+  executes: "confirmed",
+  uses: "likely",
+  imports: "potential"
+};
+var CONFIDENCE_RANK = {
+  confirmed: 2,
+  likely: 1,
+  potential: 0
+};
+function edgeKindToConfidence(kind) {
+  return EDGE_KINDS.includes(kind) ? EDGE_KIND_CONFIDENCE[kind] : "potential";
+}
+var BlastRadiusCalculator = class {
   /**
-   * Extract searchable tokens from a file path.
-   * "src/core/search/symbol-tokenizer.ts" → ["src", "core", "search", "symbol", "tokenizer", "ts"]
+   * `symbolId` may be any id `SymbolGraph.getNode` resolves, a 2-part data id included. The root is the
+   * node it names, and the root's own file is the one co-change is matched against. Dependents come from
+   * `getDependentEdges`, so every copy of a table, view or procedure, and its 2-part id, has the dependents
+   * of the resource, and no definition of the resource counts as a dependent of another.
    */
-  static tokenizeFilePath(filePath) {
-    const withoutExt = filePath.replace(/\.[^.]+$/, "");
-    const segments = withoutExt.split(/[/\\]+/);
-    const tokens = [];
-    for (const seg of segments) {
-      const parts = seg.split(/[_\-.]+/).filter((s) => s.length > 0);
-      for (const p of parts) {
-        const lowered = p.toLowerCase();
-        if (lowered.length > 0 && !tokens.includes(lowered)) {
-          tokens.push(lowered);
+  calculate(graph, symbolId, coChangeMap) {
+    const root = graph.getNode(symbolId);
+    if (!root) {
+      return { impactedSymbols: [], directDependentsCount: 0, confirmedCount: 0, likelyCount: 0, potentialCount: 0, overallRiskScore: 0 };
+    }
+    const rootId = root.symbolId;
+    const sourceFile = rootId.split("::")[0];
+    const definitions = graph.dataResourceIdentity(rootId)?.definitions.map((definition) => definition.symbolId) ?? [];
+    const visited = /* @__PURE__ */ new Set([rootId, ...definitions]);
+    const rawEntries = [];
+    const queue = [{ id: rootId, depth: 0 }];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const reverseEdges = graph.getDependentEdges(current.id);
+      const bestByNode = /* @__PURE__ */ new Map();
+      for (const edge of reverseEdges) {
+        if (visited.has(edge.from)) continue;
+        const conf = edgeKindToConfidence(edge.kind);
+        const existing = bestByNode.get(edge.from);
+        if (!existing) {
+          bestByNode.set(edge.from, { confidence: conf, kinds: /* @__PURE__ */ new Set([edge.kind]) });
+        } else {
+          existing.kinds.add(edge.kind);
+          if (CONFIDENCE_RANK[conf] > CONFIDENCE_RANK[existing.confidence]) {
+            existing.confidence = conf;
+          }
+        }
+      }
+      for (const [nodeId, info] of bestByNode) {
+        visited.add(nodeId);
+        const depth = current.depth + 1;
+        const riskScore = 1 / Math.pow(depth, 0.7);
+        let confidence = info.confidence;
+        let coChangeFrequency;
+        if (coChangeMap) {
+          const nodeFile = nodeId.split("::")[0];
+          const coEntries = coChangeMap.get(sourceFile);
+          if (coEntries) {
+            const match = coEntries.find((e) => (e.file1 === sourceFile ? e.file2 : e.file1) === nodeFile);
+            if (match) {
+              coChangeFrequency = match.frequency;
+              if (confidence === "potential" && match.frequency > 0.5) {
+                confidence = "likely";
+              }
+            }
+          }
         }
+        rawEntries.push({
+          symbolId: nodeId,
+          depth,
+          riskScore: Math.round(riskScore * 1e3) / 1e3,
+          confidence,
+          edgeKinds: [...info.kinds],
+          coChangeFrequency
+        });
+        queue.push({ id: nodeId, depth });
       }
     }
-    return tokens;
-  }
-  /** Check if a token is a stop word */
-  static isStopWord(token) {
-    return STOP_WORDS.has(token.toLowerCase());
+    const blastSet = /* @__PURE__ */ new Set([rootId, ...definitions, ...rawEntries.map((e) => e.symbolId)]);
+    const entries = rawEntries.map((e) => ({
+      ...e,
+      dependentCount: graph.getDependentEdges(e.symbolId).filter((re) => blastSet.has(re.from)).length
+    }));
+    entries.sort((a, b) => a.depth - b.depth);
+    const directDependentsCount = entries.filter((e) => e.depth === 1).length;
+    const totalRisk = entries.reduce((sum, e) => sum + e.riskScore, 0);
+    const overallRiskScore = Math.round(Math.min(totalRisk / Math.max(directDependentsCount, 1), 1) * 1e3) / 1e3;
+    const confirmedCount = entries.filter((e) => e.confidence === "confirmed").length;
+    const likelyCount = entries.filter((e) => e.confidence === "likely").length;
+    const potentialCount = entries.filter((e) => e.confidence === "potential").length;
+    return { impactedSymbols: entries, directDependentsCount, confirmedCount, likelyCount, potentialCount, overallRiskScore };
   }
 };
-function isUpper(ch) {
-  return ch >= "A" && ch <= "Z";
+
+// src/core/blast-radius/co-changed-files.ts
+var DEFAULT_LIMIT2 = 10;
+var DEFAULT_MIN_FREQUENCY = 0.5;
+function findCoChangedFiles(coChangeMap, rootFile, impactedFiles, options = {}) {
+  const limit = options.limit ?? DEFAULT_LIMIT2;
+  const minFrequency = options.minFrequency ?? DEFAULT_MIN_FREQUENCY;
+  const strongestByFile = /* @__PURE__ */ new Map();
+  for (const entry of coChangeMap.get(rootFile) ?? []) {
+    const file = entry.file1 === rootFile ? entry.file2 : entry.file1;
+    if (file === rootFile || impactedFiles.has(file) || entry.frequency < minFrequency) continue;
+    const candidate = { file, frequency: entry.frequency, sharedCommits: entry.sharedCommits };
+    const known = strongestByFile.get(file);
+    if (!known || compareStrongestFirst(candidate, known) < 0) strongestByFile.set(file, candidate);
+  }
+  return [...strongestByFile.values()].sort(compareStrongestFirst).slice(0, Math.max(0, limit));
+}
+function compareStrongestFirst(a, b) {
+  return b.frequency - a.frequency || b.sharedCommits - a.sharedCommits || compareCodepoint(a.file, b.file);
 }
-function isLower(ch) {
-  return ch >= "a" && ch <= "z";
+function findCoChangedFilesForBlastRadius(coChangeMap, rootSymbolId, impactedSymbols) {
+  if (!coChangeMap) return [];
+  const rootFile = fileOf(rootSymbolId);
+  const impactedFiles = /* @__PURE__ */ new Set([rootFile]);
+  for (const { symbolId } of impactedSymbols) impactedFiles.add(fileOf(symbolId));
+  return findCoChangedFiles(coChangeMap, rootFile, impactedFiles);
 }
-function isDigit(ch) {
-  return ch >= "0" && ch <= "9";
+function fileOf(symbolId) {
+  return symbolId.split("::")[0];
 }
 
 export {
-  compareCodepoint,
-  CommunitySnapshotWriter,
-  SqliteStorageAdapter,
+  detectWorkspace,
   buildCoChangeMatrix,
   CoChangeReader,
-  DATA_EDGE_KINDS,
-  isDataResourceKind,
-  parseCoChangeSince,
-  sinceCutoff,
-  selectWindow,
-  loadConfig,
-  statsEnabled,
-  indexIgnorePatterns,
-  indexIgnoreProjectPatterns,
-  factsRequested,
-  indexTestPatterns,
-  communityDetectorOptions,
-  maskingClusterLabelPatterns,
-  watchSnapshotMinFileChanges,
-  resolveCoChangeConfig,
-  resolveContextsViewConfig,
-  makeGlobMatcher,
-  filesWithTestAnnotations,
-  createTestFileClassifier,
-  SymbolGraph,
+  CommunitySnapshotWriter,
+  SqliteStorageAdapter,
   RevertDetector,
   DriftDetector,
-  SimpleGitAdapter,
-  BlastRadiusCalculator,
-  findCoChangedFilesForBlastRadius,
-  ArchitecturalOverlay,
-  ContextsViewReader,
-  DeadCodeDetector,
-  SymbolTokenizer,
-  PageRankCalculator,
   BoundaryViolationDetector,
+  PageRankCalculator,
   SessionRecorderAdapter,
-  detectWorkspace
+  DeadCodeDetector,
+  ArchitecturalOverlay,
+  BlastRadiusCalculator,
+  findCoChangedFilesForBlastRadius,
+  ContextsViewReader
 };
-//# sourceMappingURL=chunk-WB7WZKX4.js.map
+//# sourceMappingURL=chunk-A4URKKPP.js.map