@ctxo/cli 0.11.5 → 0.13.0

package/dist/{chunk-HZ4UGA6J.js → chunk-BYX3UFBJ.js}

@@ -3,8 +3,11 @@ import {
   atomicWrite
 } from "./chunk-RFEXMBTG.js";
 import {
+  CoChangeMatrixSchema,
+  EDGE_KINDS,
+  EdgeKindSchema,
   JsonIndexReader
-} from "./chunk-CDGQGCVN.js";
+} from "./chunk-DT3ZH4AU.js";
 import {
   createLogger
 } from "./chunk-5DSKZJNN.js";
@@ -24,11 +27,19 @@ import {
 } 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");
 var DEFAULT_HISTORY_LIMIT = 10;
 var HISTORY_DIR_NAME = "communities.history";
 var CURRENT_FILE_NAME = "communities.json";
 var NOCOMMIT_SHA = "nocommit";
+var COLLISION_COUNTER_RE = /^(.*)\.(\d+)\.json$/;
 var CommunitySnapshotWriter = class {
   indexDir;
   historyDir;
@@ -48,7 +59,8 @@ var CommunitySnapshotWriter = class {
       try {
         const existingRaw = readFileSync(currentPath, "utf-8");
         const existing = JSON.parse(existingRaw);
-        if (existing.commitSha && existing.commitSha !== NOCOMMIT_SHA) {
+        const existingCommit = archivedCommit(existing);
+        if (existingCommit !== void 0 && existingCommit !== snapshot.commitSha) {
           const historyFile = this.historyFilename(existing);
           this.atomicWrite(join(this.historyDir, historyFile), existingRaw);
         }
@@ -65,14 +77,23 @@ var CommunitySnapshotWriter = class {
     if (!existsSync(path)) return void 0;
     return this.safeParse(path);
   }
+  /**
+   * Archived snapshots, newest first, at most one per commit. Where several
+   * files hold the same commitSha (older versions archived once per
+   * `ctxo index --file` run) the newest file wins. `limit` caps the number of
+   * commits returned. Read-only: the duplicates stay on disk until the next
+   * write rotates them out.
+   */
   listHistory(limit) {
     if (!existsSync(this.historyDir)) return [];
-    const entries = readdirSync(this.historyDir).filter((name) => name.endsWith(".json")).sort().reverse();
     const snapshots = [];
-    for (const name of entries) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const name of this.historyNames().reverse()) {
       const snap = this.safeParse(join(this.historyDir, name));
-      if (!snap) continue;
-      if (!snap.commitSha || snap.commitSha === NOCOMMIT_SHA) continue;
+      const commit = archivedCommit(snap);
+      if (!snap || commit === void 0) continue;
+      if (seen.has(commit)) continue;
+      seen.add(commit);
       snapshots.push(snap);
       if (typeof limit === "number" && snapshots.length >= limit) break;
     }
@@ -93,13 +114,39 @@ var CommunitySnapshotWriter = class {
     }
     return candidate.slice(this.historyDir.length + 1);
   }
+  /** The `.json` files in the history folder, oldest first. */
+  historyNames() {
+    return readdirSync(this.historyDir).filter((name) => name.endsWith(".json")).sort(compareHistoryNames);
+  }
+  /**
+   * Rotation in two steps. First the duplicates go: every file that is not
+   * the newest readable file of its commit (the copies older versions left
+   * behind, one per `ctxo index --file` run). Then, by file count, the oldest
+   * files beyond `historyLimit`. Copies therefore never use up slots, history
+   * keeps each commit at most once, and a commit's newest file is removed
+   * only together with its commit, when that is among the oldest beyond the
+   * limit. Files that stand for no commit (unreadable, 'nocommit') are not
+   * duplicates of anything and age out by count like the rest.
+   */
   rotateHistory() {
     if (!existsSync(this.historyDir)) return;
-    const entries = readdirSync(this.historyDir).filter((name) => name.endsWith(".json")).sort();
-    const excess = entries.length - this.historyLimit;
-    if (excess <= 0) return;
-    for (let i = 0; i < excess; i++) {
-      const target = join(this.historyDir, entries[i]);
+    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)));
+      if (commit !== void 0) {
+        if (seen.has(commit)) {
+          doomed.push(name);
+          continue;
+        }
+        seen.add(commit);
+      }
+      unique.push(name);
+    }
+    doomed.push(...unique.slice(this.historyLimit));
+    for (const name of doomed) {
+      const target = join(this.historyDir, name);
       try {
         unlinkSync(target);
       } catch (err) {
@@ -117,6 +164,19 @@ var CommunitySnapshotWriter = class {
     }
   }
 };
+function archivedCommit(snapshot) {
+  const sha = snapshot?.commitSha;
+  return sha && sha !== NOCOMMIT_SHA ? sha : void 0;
+}
+function compareHistoryNames(a, b) {
+  const [baseA, counterA] = splitCollisionCounter(a);
+  const [baseB, counterB] = splitCollisionCounter(b);
+  return compareCodepoint(baseA, baseB) || counterA - counterB;
+}
+function splitCollisionCounter(name) {
+  const match = COLLISION_COUNTER_RE.exec(name);
+  return match ? [`${match[1]}.json`, Number(match[2])] : [name, 0];
+}
 function assertSafeWritePath(ctxoRoot, allowProduction) {
   const resolved = resolve(ctxoRoot);
   const tmpRoot = resolve(tmpdir());
@@ -474,14 +534,593 @@ 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 });
+    }
+  }
+  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 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 {
+  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");
+  }
+  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 = readFileSync3(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;
+    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 log3 = createLogger("ctxo: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);
-    log3.debug("Initialized with root: %s", projectRoot);
+    log5.debug("Initialized with root: %s", projectRoot);
   }
   async isAvailable() {
     try {
@@ -493,97 +1132,311 @@ var SimpleGitAdapter = class {
   }
   async getCommitHistory(filePath, maxCount) {
     try {
-      const log6 = await this.git.log({
+      const log8 = await this.git.log({
         file: filePath,
         "--follow": null,
         ...maxCount ? { maxCount } : {}
       });
-      return log6.all.map((entry) => ({
+      return log8.all.map((entry) => ({
         hash: entry.hash,
         message: entry.message,
         date: entry.date,
         author: entry.author_name
       }));
     } catch (err) {
-      log3.error(` Failed to get history for ${filePath}: ${err.message}`);
+      log5.error(` Failed to get history for ${filePath}: ${err.message}`);
       return [];
     }
   }
-  async getBatchHistory(maxCount = 20) {
+  async getChangedFiles(since) {
     try {
-      const log6 = await this.git.log({ maxCount: maxCount * 50, "--name-only": null });
-      const result = /* @__PURE__ */ new Map();
-      for (const entry of log6.all) {
-        const record = {
-          hash: entry.hash,
-          message: entry.message,
-          date: entry.date,
-          author: entry.author_name
-        };
-        const diff = entry.diff;
-        const files = diff?.files?.map((f) => f.file.replace(/\\/g, "/")) ?? [];
-        for (const file of files) {
-          let list = result.get(file);
-          if (!list) {
-            list = [];
-            result.set(file, list);
-          }
-          if (list.length < maxCount) {
-            list.push(record);
-          }
-        }
+      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)}`);
       }
-      return result;
+      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) {
-      log3.error(` Batch history failed: ${err.message}`);
-      return /* @__PURE__ */ new Map();
+      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 getChangedFiles(since) {
+  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 diff = await this.git.diffSummary([since]);
-      return diff.files.map((f) => f.file.replace(/\\/g, "/"));
+      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) {
-      log3.error(` Failed to get changed files since ${since}: ${err.message}`);
-      return [];
+      log5.error(`Failed to read file changes of ${rev}: ${err.message}`);
+      return void 0;
     }
   }
-  async getFileChurn(filePath) {
+};
+
+// 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 {
-      const log6 = await this.git.log({ file: filePath, "--follow": null });
-      return {
-        filePath,
-        commitCount: log6.total
-      };
+      stats = statSync2(this.filePath);
     } catch (err) {
-      log3.error(` Failed to get churn for ${filePath}: ${err.message}`);
-      return { filePath, commitCount: 0 };
+      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);
   }
-  async getHeadSha() {
+  load(version) {
+    let raw;
     try {
-      const raw = await this.git.revparse(["--short", "HEAD"]);
-      const sha = raw.trim();
-      return sha.length > 0 ? sha : void 0;
+      raw = readFileSync5(this.filePath, "utf-8");
     } catch (err) {
-      log3.error(`Failed to resolve HEAD: ${err.message}`);
+      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;
   }
-  async countCommitsBetween(base) {
+  parse(raw, version) {
+    let data;
     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;
+      data = JSON.parse(raw);
     } catch (err) {
-      log3.error(`Failed to count commits since ${base}: ${err.message}`);
+      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 log4 = createLogger("ctxo:stats");
+var log7 = createLogger("ctxo:stats");
 var SessionRecorderAdapter = class {
   db;
   onWrite;
@@ -629,7 +1482,7 @@ var SessionRecorderAdapter = class {
       );
       this.flushToDisk();
     } catch (err) {
-      log4.error(`Failed to record session event: ${err.message}`);
+      log7.error(`Failed to record session event: ${err.message}`);
     }
   }
   queryStats(days) {
@@ -697,14 +1550,14 @@ var SessionRecorderAdapter = class {
     try {
       this.onWrite?.();
     } catch (err) {
-      log4.error(`Failed to flush stats to disk: ${err.message}`);
+      log7.error(`Failed to flush stats to disk: ${err.message}`);
     }
   }
 };
 
 // src/adapters/workspace/single-package-workspace.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
-import { join as join3, resolve as resolve2 } from "path";
+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",
@@ -717,17 +1570,17 @@ var MANIFEST_CANDIDATES = [
 ];
 function findManifest(dir) {
   for (const name of MANIFEST_CANDIDATES) {
-    const candidate = join3(dir, name);
-    if (existsSync3(candidate)) return candidate;
+    const candidate = join6(dir, name);
+    if (existsSync4(candidate)) return candidate;
   }
   const csproj = findFirstByExt(dir, ".csproj") ?? findFirstByExt(dir, ".sln");
   if (csproj) return csproj;
-  return join3(dir, "package.json");
+  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 join3(dir, entry.name);
+      if (entry.isFile() && entry.name.endsWith(ext)) return join6(dir, entry.name);
     }
   } catch {
   }
@@ -745,154 +1598,90 @@ function detectWorkspace(cwd) {
   };
 }
 
-// src/core/config/load-config.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } 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()
-}).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 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()
-}).passthrough();
-var DEFAULT_WATCH_SNAPSHOT_MIN_FILE_CHANGES = 5;
-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" }
-};
-
-// src/core/config/load-config.ts
-var log5 = 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}`);
-  }
+// 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 loadConfig(ctxoRoot) {
-  const path = join4(ctxoRoot, "config.yaml");
-  const errors = [];
-  const invalidGlobs = [];
-  if (!existsSync4(path)) {
-    return { config: DEFAULT_CONFIG, errors, invalidGlobs, path, exists: false };
-  }
-  let raw;
-  try {
-    raw = readFileSync3(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}`);
-    log5.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}`);
-    }
-    log5.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);
-  for (const pattern of invalidGlobs) {
-    log5.warn(`Invalid glob pattern in config.yaml \u2014 ${pattern}`);
-  }
-  return { config: result.data, errors, invalidGlobs, path, exists: true };
+function dataReferenceKinds(kind) {
+  if (isDataResourceKind(kind)) return DATA_RESOURCE_KINDS2;
+  if (kind === "procedure") return PROCEDURE_KINDS;
+  return void 0;
 }
-function statsEnabled(config) {
-  return config.stats?.enabled !== false;
+
+// 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 indexIgnorePatterns(config) {
-  return (config.index?.ignore ?? []).filter(isValidGlob);
+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 indexIgnoreProjectPatterns(config) {
-  return (config.index?.ignoreProjects ?? []).filter(isValidGlob);
+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);
 }
-function maskingClusterLabelPatterns(config) {
-  return (config.masking?.clusterLabels ?? []).filter(isValidGlob);
+
+// 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 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 isUnderDocumentationFolder(file) {
+  const folders = file.replace(/\\/g, "/").split("/").slice(0, -1);
+  return folders.some((folder) => DOCUMENTATION_FOLDERS.has(asciiLower(folder)));
 }
-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));
-  };
+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);
 }
-
-// src/core/graph/symbol-graph.ts
 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);
@@ -940,6 +1729,8 @@ var SymbolGraph = class {
         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);
@@ -959,6 +1750,8 @@ var SymbolGraph = class {
         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);
@@ -966,6 +1759,63 @@ var SymbolGraph = class {
     }
     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`
@@ -983,6 +1833,18 @@ var SymbolGraph = class {
   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;
   }
@@ -1043,6 +1905,21 @@ var RevertDetector = class {
   }
 };
 
+// src/core/overlay/snapshot-history.ts
+function priorCommitSnapshots(history, currentSha) {
+  const seen = /* @__PURE__ */ new Set();
+  const prior = [];
+  for (const snapshot of history) {
+    if (snapshot.commitSha === currentSha || seen.has(snapshot.commitSha)) continue;
+    seen.add(snapshot.commitSha);
+    prior.push(snapshot);
+  }
+  return prior;
+}
+function distinctCommitCount(history, currentSha) {
+  return priorCommitSnapshots(history, currentSha).length;
+}
+
 // src/core/overlay/drift-detector.ts
 var DEFAULT_JACCARD_THRESHOLD = 0.3;
 var DriftDetector = class {
@@ -1054,15 +1931,18 @@ var DriftDetector = class {
   }
   detect(current, history) {
     const snapshotsAvailable = history.length;
-    const previous = history[0];
-    const anchor = history[1];
+    const distinctCommits = distinctCommitCount(history, current.commitSha);
+    const confidence = confidenceFor(distinctCommits);
+    const hint = hintFor(distinctCommits);
+    const [previous, anchor] = priorCommitSnapshots(history, current.commitSha);
     if (!previous) {
       return {
         events: [],
-        confidence: "low",
+        confidence,
         snapshotsAvailable,
+        distinctCommits,
         stability: { stable: 0, transient: 0, unverified: 0 },
-        hint: "No prior snapshot available \u2014 install the post-commit hook (`ctxo init`), run `ctxo watch`, or add `ctxo index --check` to CI so the drift history accumulates."
+        hint
       };
     }
     const currentByCommunityId = indexByCommunityId(current.communities);
@@ -1115,13 +1995,14 @@ var DriftDetector = class {
         stability: classification
       });
     }
-    const events = (this.suppressTransient ? rawEvents.filter((e) => e.stability !== "transient") : rawEvents).sort((a, b) => a.symbolId.localeCompare(b.symbolId));
+    const events = (this.suppressTransient ? rawEvents.filter((e) => e.stability !== "transient") : rawEvents).sort((a, b) => compareCodepoint(a.symbolId, b.symbolId));
     return {
       events,
-      confidence: confidenceFor(snapshotsAvailable),
+      confidence,
       snapshotsAvailable,
+      distinctCommits,
       stability,
-      hint: hintFor(snapshotsAvailable)
+      hint
     };
   }
   mapCommunities(current, previous) {
@@ -1175,41 +2056,56 @@ function jaccard(a, b) {
   const union = a.size + b.size - intersection;
   return union === 0 ? 0 : intersection / union;
 }
-function confidenceFor(snapshots) {
-  if (snapshots >= 7) return "high";
-  if (snapshots >= 3) return "medium";
+function confidenceFor(distinctCommits) {
+  if (distinctCommits >= 7) return "high";
+  if (distinctCommits >= 3) return "medium";
   return "low";
 }
-function hintFor(snapshots) {
-  if (snapshots >= 3) return void 0;
-  return "Install post-commit hook or run `ctxo index` more often to build a richer drift history.";
+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/blast-radius/blast-radius-calculator.ts
-var CONFIRMED_KINDS = /* @__PURE__ */ new Set(["calls", "extends", "implements"]);
-var LIKELY_KINDS = /* @__PURE__ */ new Set(["uses"]);
+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) {
-  if (CONFIRMED_KINDS.has(kind)) return "confirmed";
-  if (LIKELY_KINDS.has(kind)) return "likely";
-  return "potential";
+  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) {
-    if (!graph.hasNode(symbolId)) {
+    const root = graph.getNode(symbolId);
+    if (!root) {
       return { impactedSymbols: [], directDependentsCount: 0, confirmedCount: 0, likelyCount: 0, potentialCount: 0, overallRiskScore: 0 };
     }
-    const sourceFile = symbolId.split("::")[0];
-    const visited = /* @__PURE__ */ new Set([symbolId]);
+    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: symbolId, depth: 0 }];
+    const queue = [{ id: rootId, depth: 0 }];
     while (queue.length > 0) {
       const current = queue.shift();
-      const reverseEdges = graph.getReverseEdges(current.id);
+      const reverseEdges = graph.getDependentEdges(current.id);
       const bestByNode = /* @__PURE__ */ new Map();
       for (const edge of reverseEdges) {
         if (visited.has(edge.from)) continue;
@@ -1234,7 +2130,7 @@ var BlastRadiusCalculator = class {
           const nodeFile = nodeId.split("::")[0];
           const coEntries = coChangeMap.get(sourceFile);
           if (coEntries) {
-            const match = coEntries.find((e) => e.file1 === nodeFile || e.file2 === nodeFile);
+            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) {
@@ -1254,11 +2150,10 @@ var BlastRadiusCalculator = class {
         queue.push({ id: nodeId, depth });
       }
     }
-    const blastSet = new Set(rawEntries.map((e) => e.symbolId));
-    blastSet.add(symbolId);
+    const blastSet = /* @__PURE__ */ new Set([rootId, ...definitions, ...rawEntries.map((e) => e.symbolId)]);
     const entries = rawEntries.map((e) => ({
       ...e,
-      dependentCount: graph.getReverseEdges(e.symbolId).filter((re) => blastSet.has(re.from)).length
+      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;
@@ -1271,6 +2166,36 @@ var BlastRadiusCalculator = class {
   }
 };
 
+// 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)
@@ -1324,6 +2249,7 @@ var ArchitecturalOverlay = class {
 // src/core/dead-code/dead-code-detector.ts
 var TEST_PATTERNS = [/__tests__/, /\.test\.ts$/, /\.spec\.ts$/, /\btests\//, /\bfixtures?\//];
 var CONFIG_PATTERNS = [/\.(config|rc)\.(ts|js|json)$/, /tsconfig/, /eslint/, /\.d\.ts$/];
+var SQL_PATTERN = /\.sql$/i;
 var FRAMEWORK_PATTERNS = [
   // Vitest
   /^(describe|it|expect|beforeAll|beforeEach|afterAll|afterEach|vi)$/,
@@ -1347,8 +2273,10 @@ var SCAFFOLDING_PATTERNS = [
 var DeadCodeDetector = class {
   detect(graph, options = {}) {
     const allNodes = graph.allNodes();
-    const candidates = options.includeTests ? allNodes : allNodes.filter((n) => {
+    const candidates = allNodes.filter((n) => {
       const file = n.symbolId.split("::")[0] ?? "";
+      if (SQL_PATTERN.test(file)) return false;
+      if (options.includeTests) return true;
       return !this.matchesAny(file, TEST_PATTERNS) && !this.matchesAny(file, CONFIG_PATTERNS);
     });
     if (candidates.length === 0) {
@@ -1365,7 +2293,7 @@ var DeadCodeDetector = class {
       const forwardEdges = graph.getForwardEdges(node.symbolId);
       const incomingFromCandidates = reverseEdges.filter((e) => candidateIds.has(e.from) && e.from !== node.symbolId);
       if (incomingFromCandidates.length === 0) {
-        const hasOutgoing = forwardEdges.some((e) => candidateIds.has(e.to));
+        const hasOutgoing = forwardEdges.some((e) => candidateIds.has(e.to) || DATA_EDGE_KINDS.has(e.kind));
         if (hasOutgoing || reverseEdges.length > 0) {
           entryPoints.add(node.symbolId);
         }
@@ -1531,13 +2459,13 @@ var DeadCodeDetector = class {
 var DEFAULT_DAMPING = 0.85;
 var DEFAULT_MAX_ITERATIONS = 100;
 var DEFAULT_TOLERANCE = 1e-6;
-var DEFAULT_LIMIT = 25;
+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_LIMIT;
+    const limit = options.limit ?? DEFAULT_LIMIT2;
     const nodes = graph.allNodes();
     const n = nodes.length;
     if (n === 0) {
@@ -1613,13 +2541,15 @@ var PageRankCalculator = class {
 // src/core/overlay/boundary-violation-detector.ts
 var HIGH_SEVERITY_THRESHOLD = 0;
 var MEDIUM_SEVERITY_THRESHOLD = 2;
-var MIN_SNAPSHOTS_FOR_CONFIDENCE = 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 historicalAssignments = history.map((snapshot) => ({
+    const earlierCommits = priorCommitSnapshots(history, current.commitSha);
+    const historicalAssignments = earlierCommits.map((snapshot) => ({
       snapshot,
       assignments: assignmentMap2(snapshot.communities),
       labels: labelMap2(snapshot.communities)
@@ -1627,13 +2557,14 @@ var BoundaryViolationDetector = class {
     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 = snapshotsAvailable < MIN_SNAPSHOTS_FOR_CONFIDENCE ? -1 : countHistoricalCrossCluster(historicalAssignments, edge.from, edge.to);
+      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: {
@@ -1654,26 +2585,27 @@ var BoundaryViolationDetector = class {
     }
     violations.sort((a, b) => {
       if (a.severity !== b.severity) return a.severity === "high" ? -1 : 1;
-      const cmp = a.from.symbolId.localeCompare(b.from.symbolId);
-      return cmp !== 0 ? cmp : a.to.symbolId.localeCompare(b.to.symbolId);
+      const cmp = compareCodepoint(a.from.symbolId, b.from.symbolId);
+      return cmp !== 0 ? cmp : compareCodepoint(a.to.symbolId, b.to.symbolId);
     });
     return {
       violations,
-      confidence: confidenceFor2(snapshotsAvailable),
+      confidence: confidenceFor2(distinctCommits),
       snapshotsAvailable,
-      hint: hintFor2(snapshotsAvailable)
+      distinctCommits,
+      hint: hintFor2(distinctCommits)
     };
   }
 };
 function countHistoricalCrossCluster(history, fromSymbol, toSymbol) {
-  let count = 0;
+  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) count++;
+    if (fromId !== toId) count2++;
   }
-  return count;
+  return count2;
 }
 function assignmentMap2(entries) {
   const map = /* @__PURE__ */ new Map();
@@ -1691,109 +2623,227 @@ function labelMap2(entries) {
   }
   return labels;
 }
-function confidenceFor2(snapshots) {
-  if (snapshots >= 7) return "high";
-  if (snapshots >= 3) return "medium";
+function confidenceFor2(distinctCommits) {
+  if (distinctCommits >= 7) return "high";
+  if (distinctCommits >= 3) return "medium";
   return "low";
 }
-function hintFor2(snapshots) {
-  if (snapshots >= MIN_SNAPSHOTS_FOR_CONFIDENCE) return void 0;
-  return "Insufficient snapshot history \u2014 enable `ctxo init` hook or add `ctxo index --check` to CI for boundary-violation signal.";
+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/co-change/co-change-analyzer.ts
-var MIN_SHARED_COMMITS = 2;
-var MIN_FREQUENCY = 0.1;
-function aggregateCoChanges(indices) {
-  const commitToFiles = /* @__PURE__ */ new Map();
-  const fileCommitCounts = /* @__PURE__ */ new Map();
-  for (const idx of indices) {
-    const file = idx.file;
-    let count = 0;
-    for (const intent of idx.intent) {
-      count++;
-      let files = commitToFiles.get(intent.hash);
-      if (!files) {
-        files = /* @__PURE__ */ new Set();
-        commitToFiles.set(intent.hash, files);
+// 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 };
+  }
+  /**
+   * 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);
       }
-      files.add(file);
     }
-    if (count > 0) {
-      fileCommitCounts.set(file, count);
+    if (this.options.includeFilePath && filePath) {
+      const pathTokens = _SymbolTokenizer.tokenizeFilePath(filePath);
+      for (const pt of pathTokens) {
+        if (!tokens.includes(pt)) {
+          tokens.push(pt);
+        }
+      }
     }
+    return tokens;
   }
-  const pairCounts = /* @__PURE__ */ new Map();
-  for (const files of commitToFiles.values()) {
-    if (files.size < 2) continue;
-    const sorted = [...files].sort();
-    for (let i = 0; i < sorted.length; i++) {
-      for (let j = i + 1; j < sorted.length; j++) {
-        const key = `${sorted[i]}|${sorted[j]}`;
-        pairCounts.set(key, (pairCounts.get(key) ?? 0) + 1);
+  /**
+   * 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);
+        }
       }
     }
+    return tokens;
   }
-  const entries = [];
-  for (const [key, sharedCommits] of pairCounts) {
-    if (sharedCommits < MIN_SHARED_COMMITS) continue;
-    const [file1, file2] = key.split("|");
-    const count1 = fileCommitCounts.get(file1) ?? 0;
-    const count2 = fileCommitCounts.get(file2) ?? 0;
-    const minCount = Math.min(count1, count2);
-    if (minCount === 0) continue;
-    const frequency = Math.round(sharedCommits / minCount * 1e3) / 1e3;
-    if (frequency < MIN_FREQUENCY) continue;
-    entries.push({ file1, file2, sharedCommits, frequency });
-  }
-  entries.sort((a, b) => b.frequency - a.frequency || b.sharedCommits - a.sharedCommits);
-  return {
-    version: 1,
-    timestamp: Math.floor(Date.now() / 1e3),
-    entries
-  };
-}
-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);
+  /**
+   * 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));
     }
-    list1.push(entry);
-    let list2 = map.get(entry.file2);
-    if (!list2) {
-      list2 = [];
-      map.set(entry.file2, list2);
+    return tokens.filter((t) => t.length > 0);
+  }
+  /**
+   * 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;
+        }
+      }
+      current += ch;
     }
-    list2.push(entry);
+    if (current.length > 0) {
+      tokens.push(current);
+    }
+    return tokens;
   }
-  return map;
+  /**
+   * Extract searchable tokens from a file path.
+   * "src/core/search/symbol-tokenizer.ts" → ["src", "core", "search", "symbol", "tokenizer", "ts"]
+   */
+  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);
+        }
+      }
+    }
+    return tokens;
+  }
+  /** Check if a token is a stop word */
+  static isStopWord(token) {
+    return STOP_WORDS.has(token.toLowerCase());
+  }
+};
+function isUpper(ch) {
+  return ch >= "A" && ch <= "Z";
+}
+function isLower(ch) {
+  return ch >= "a" && ch <= "z";
+}
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
 }
 
 export {
+  compareCodepoint,
   CommunitySnapshotWriter,
   SqliteStorageAdapter,
+  buildCoChangeMatrix,
+  CoChangeReader,
+  DATA_EDGE_KINDS,
+  isDataResourceKind,
+  parseCoChangeSince,
+  sinceCutoff,
+  selectWindow,
+  loadConfig,
+  statsEnabled,
+  indexIgnorePatterns,
+  indexIgnoreProjectPatterns,
+  factsRequested,
+  indexTestPatterns,
+  communityDetectorOptions,
+  maskingClusterLabelPatterns,
+  watchSnapshotMinFileChanges,
+  resolveCoChangeConfig,
+  resolveContextsViewConfig,
+  makeGlobMatcher,
+  filesWithTestAnnotations,
+  createTestFileClassifier,
   SymbolGraph,
   RevertDetector,
   DriftDetector,
   SimpleGitAdapter,
   BlastRadiusCalculator,
+  findCoChangedFilesForBlastRadius,
   ArchitecturalOverlay,
+  ContextsViewReader,
   DeadCodeDetector,
+  SymbolTokenizer,
   PageRankCalculator,
   BoundaryViolationDetector,
-  aggregateCoChanges,
-  loadCoChangeMap,
   SessionRecorderAdapter,
-  detectWorkspace,
-  loadConfig,
-  statsEnabled,
-  indexIgnorePatterns,
-  indexIgnoreProjectPatterns,
-  maskingClusterLabelPatterns,
-  watchSnapshotMinFileChanges,
-  makeGlobMatcher
+  detectWorkspace
 };
-//# sourceMappingURL=chunk-HZ4UGA6J.js.map
+//# sourceMappingURL=chunk-BYX3UFBJ.js.map