ctxloom-pro 1.0.21 → 1.0.23

package/dist/{chunk-EHFVPRTN.js → chunk-ZTC3QWIL.js}

@@ -3406,8 +3406,8 @@ var CoChangeIndex = class _CoChangeIndex {
     if (event.isBulk || event.isMerge) return;
     const paths = event.files.map((f) => f.path);
     if (paths.length === 0) return;
-    for (const path29 of paths) {
-      this.nodeCounts.set(path29, (this.nodeCounts.get(path29) ?? 0) + 1);
+    for (const path30 of paths) {
+      this.nodeCounts.set(path30, (this.nodeCounts.get(path30) ?? 0) + 1);
     }
     for (let i = 0; i < paths.length; i++) {
       for (let j = i + 1; j < paths.length; j++) {
@@ -3554,8 +3554,8 @@ var ChurnIndex = class _ChurnIndex {
    */
   snapshot() {
     const nodes = {};
-    for (const [path29, raw] of this.nodes) {
-      nodes[path29] = {
+    for (const [path30, raw] of this.nodes) {
+      nodes[path30] = {
         commits: raw.commits,
         churnLines: raw.churnLines,
         bugCommits: raw.bugCommits,
@@ -3570,8 +3570,8 @@ var ChurnIndex = class _ChurnIndex {
    */
   static load(s) {
     const idx = new _ChurnIndex();
-    for (const [path29, raw] of Object.entries(s.nodes)) {
-      idx.nodes.set(path29, {
+    for (const [path30, raw] of Object.entries(s.nodes)) {
+      idx.nodes.set(path30, {
         commits: raw.commits,
         churnLines: raw.churnLines,
         bugCommits: raw.bugCommits,
@@ -3584,8 +3584,8 @@ var ChurnIndex = class _ChurnIndex {
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
-  getOrCreate(path29) {
-    const existing = this.nodes.get(path29);
+  getOrCreate(path30) {
+    const existing = this.nodes.get(path30);
     if (existing !== void 0) return existing;
     const fresh = {
       commits: 0,
@@ -3594,7 +3594,7 @@ var ChurnIndex = class _ChurnIndex {
       authorCounts: {},
       lastTouch: 0
     };
-    this.nodes.set(path29, fresh);
+    this.nodes.set(path30, fresh);
     return fresh;
   }
 };
@@ -3675,12 +3675,12 @@ var OwnershipIndex = class _OwnershipIndex {
    */
   snapshot() {
     const nodes = {};
-    for (const [path29, raw] of this.nodes) {
+    for (const [path30, raw] of this.nodes) {
       const authorWeights = {};
       for (const [email, entry] of Object.entries(raw.authorWeights)) {
         authorWeights[email] = { ...entry };
       }
-      nodes[path29] = { authorWeights, lastTouch: raw.lastTouch };
+      nodes[path30] = { authorWeights, lastTouch: raw.lastTouch };
     }
     return { version: 1, nodes };
   }
@@ -3689,23 +3689,23 @@ var OwnershipIndex = class _OwnershipIndex {
    */
   static load(s) {
     const idx = new _OwnershipIndex();
-    for (const [path29, raw] of Object.entries(s.nodes)) {
+    for (const [path30, raw] of Object.entries(s.nodes)) {
       const authorWeights = {};
       for (const [email, entry] of Object.entries(raw.authorWeights)) {
         authorWeights[email] = { ...entry };
       }
-      idx.nodes.set(path29, { authorWeights, lastTouch: raw.lastTouch });
+      idx.nodes.set(path30, { authorWeights, lastTouch: raw.lastTouch });
     }
     return idx;
   }
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
-  getOrCreate(path29) {
-    const existing = this.nodes.get(path29);
+  getOrCreate(path30) {
+    const existing = this.nodes.get(path30);
     if (existing !== void 0) return existing;
     const fresh = { authorWeights: {}, lastTouch: 0 };
-    this.nodes.set(path29, fresh);
+    this.nodes.set(path30, fresh);
     return fresh;
   }
 };
@@ -3880,19 +3880,121 @@ function isEnoent(err) {
 // packages/core/src/trends/TrendsRecorder.ts
 import path11 from "path";
 import fs10 from "fs/promises";
+
+// packages/core/src/risk/scoring.ts
+var RISK_WEIGHTS = { churn: 0.4, bug: 0.3, coupling: 0.3 };
+var BAND_PCT = { critical: 0.05, high: 0.15, medium: 0.35 };
+var SCORE_FLOOR = 0.05;
+var SILO_BUS_FACTOR = 1;
+function percentile(values, p) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = Math.min(sorted.length - 1, Math.floor(sorted.length * p));
+  return sorted[idx];
+}
+function computeRiskCaps(samples, p = 0.9) {
+  return {
+    churn: percentile(samples.map((s) => s.churnLines), p),
+    coupling: percentile(samples.map((s) => s.couplingFanOut), p)
+  };
+}
+function computeRiskBreakdown(m, caps) {
+  const churnDenom = Math.max(caps.churn, 1);
+  const couplingDenom = Math.max(caps.coupling, 1);
+  return {
+    churn: Math.min(1, m.churnLines / churnDenom),
+    bugDensity: Math.min(1, m.bugDensity * 2),
+    coupling: Math.min(1, m.couplingFanOut / couplingDenom)
+  };
+}
+function scoreFromBreakdown(b) {
+  return b.churn * RISK_WEIGHTS.churn + b.bugDensity * RISK_WEIGHTS.bug + b.coupling * RISK_WEIGHTS.coupling;
+}
+function isSiloed(m) {
+  return m.busFactor <= SILO_BUS_FACTOR;
+}
+function assignLabelsByPercentile(scores) {
+  const n = scores.length;
+  const bands = { criticalCount: 0, highCount: 0, mediumCount: 0, lowCount: 0, totalRanked: n };
+  if (n === 0) return { labels: [], bands };
+  const ranked = scores.map((s, i) => ({ s, i })).sort((a, b) => b.s - a.s);
+  const criticalCutoff = Math.max(1, Math.ceil(n * BAND_PCT.critical));
+  const highCutoff = Math.max(criticalCutoff + 1, Math.ceil(n * BAND_PCT.high));
+  const mediumCutoff = Math.max(highCutoff + 1, Math.ceil(n * BAND_PCT.medium));
+  const labels = new Array(n).fill("low");
+  for (let rank = 0; rank < n; rank++) {
+    const { s, i } = ranked[rank];
+    if (s < SCORE_FLOOR) {
+      labels[i] = "low";
+      bands.lowCount++;
+      continue;
+    }
+    if (rank < criticalCutoff) {
+      labels[i] = "critical";
+      bands.criticalCount++;
+    } else if (rank < highCutoff) {
+      labels[i] = "high";
+      bands.highCount++;
+    } else if (rank < mediumCutoff) {
+      labels[i] = "medium";
+      bands.mediumCount++;
+    } else {
+      labels[i] = "low";
+      bands.lowCount++;
+    }
+  }
+  return { labels, bands };
+}
+function scoreAll(samples) {
+  const caps = computeRiskCaps(samples);
+  const intermediate = samples.map((raw) => {
+    const breakdown = computeRiskBreakdown(raw, caps);
+    return { raw, breakdown, score: scoreFromBreakdown(breakdown) };
+  });
+  const { labels, bands } = assignLabelsByPercentile(intermediate.map((i) => i.score));
+  const scored = intermediate.map((i, idx) => ({
+    raw: i.raw,
+    breakdown: i.breakdown,
+    score: i.score,
+    label: labels[idx],
+    siloed: isSiloed(i.raw)
+  }));
+  return { scored, caps, bands };
+}
+
+// packages/core/src/trends/TrendsRecorder.ts
 var FILE_SUBPATH = path11.join(".ctxloom", "trends", "snapshots.jsonl");
+var FILE_RISKS_SUBPATH = path11.join(".ctxloom", "trends", "file-risks.jsonl");
 var ENTRY_PATTERN = /(^|\/)(index|main|server|app|cli)\.[^/]+$/;
 var SEVEN_DAYS_SECONDS = 7 * 24 * 3600;
 var COLLAPSE_WINDOW_SECONDS = 300;
 var PERCENT_THRESHOLD = 0.01;
+var FILE_SCORE_DELTA = 0.02;
 var INTEGER_FLOOR_FIELDS = [
   "totalFiles",
   "totalEdges",
   "deadFiles",
   "highRiskFiles"
 ];
-function computeMetrics(opts, unixSeconds) {
-  const { graph, overlay, gitEnabled } = opts;
+function gatherPerFileMetrics(opts) {
+  const { graph, overlay } = opts;
+  return graph.allFiles().map((f) => {
+    const churn = overlay.churn.statsFor(f);
+    const ownership = overlay.ownership.statsFor(f);
+    const coupled = overlay.coChange.topFor({ node: f, limit: 100, minConfidence: 0.1 });
+    return {
+      file: f,
+      raw: {
+        churnLines: churn?.churnLines ?? 0,
+        bugDensity: churn?.bugDensity ?? 0,
+        busFactor: ownership?.busFactor ?? 1,
+        couplingFanOut: coupled.length
+      }
+    };
+  });
+}
+function computeAggregates(opts, unixSeconds) {
+  const { graph, gitEnabled } = opts;
   const files = graph.allFiles();
   let deadFiles = 0;
   for (const f of files) {
@@ -3901,51 +4003,62 @@ function computeMetrics(opts, unixSeconds) {
   }
   if (!gitEnabled) {
     return {
-      totalFiles: files.length,
-      totalEdges: graph.edgeCount(),
-      deadFiles,
-      avgBusFactor: null,
-      highRiskFiles: null,
-      churnLinesLast7d: null
+      metrics: {
+        totalFiles: files.length,
+        totalEdges: graph.edgeCount(),
+        deadFiles,
+        avgBusFactor: null,
+        highRiskFiles: null,
+        churnLinesLast7d: null
+      },
+      perFileScores: []
     };
   }
   let busSum = 0;
   let busCount = 0;
-  for (const f of overlay.ownership.allNodes()) {
-    const stats = overlay.ownership.statsFor(f);
+  for (const f of opts.overlay.ownership.allNodes()) {
+    const stats = opts.overlay.ownership.statsFor(f);
     if (stats !== null) {
       busSum += stats.busFactor;
       busCount++;
     }
   }
   const avgBusFactor = busCount > 0 ? busSum / busCount : 0;
-  let highRiskFiles = 0;
-  let churnLinesLast7d = 0;
   const sevenDaysAgo = unixSeconds - SEVEN_DAYS_SECONDS;
+  let churnLinesLast7d = 0;
   for (const f of files) {
-    const churn = overlay.churn.statsFor(f);
-    const ownership = overlay.ownership.statsFor(f);
-    const coupled = overlay.coChange.topFor({ node: f, limit: 100, minConfidence: 0.1 });
-    const churnLines = churn?.churnLines ?? 0;
-    const bugDensity = churn?.bugDensity ?? 0;
-    const busFactor = ownership?.busFactor ?? 1;
-    const churnPart = Math.min(1, churnLines / 1e3);
-    const bugPart = Math.min(1, bugDensity * 2);
-    const busPart = busFactor <= 1 ? 1 : busFactor <= 2 ? 0.5 : 0;
-    const couplingPart = Math.min(1, coupled.length / 10);
-    const score = churnPart * 0.3 + bugPart * 0.3 + busPart * 0.2 + couplingPart * 0.2;
-    if (score > 0.6) highRiskFiles++;
+    const churn = opts.overlay.churn.statsFor(f);
     if (churn && churn.lastTouch >= sevenDaysAgo) {
       churnLinesLast7d += churn.churnLines;
     }
   }
+  const perFile = gatherPerFileMetrics(opts);
+  const { scored } = scoreAll(perFile.map((p) => p.raw));
+  let highRiskFiles = 0;
+  const perFileScores = [];
+  for (let i = 0; i < scored.length; i++) {
+    const s = scored[i];
+    const file = perFile[i].file;
+    if (s.label === "critical" || s.label === "high") highRiskFiles++;
+    if (s.score >= SCORE_FLOOR) {
+      perFileScores.push({
+        unixSeconds,
+        file,
+        score: Math.round(s.score * 100) / 100,
+        label: s.label
+      });
+    }
+  }
   return {
-    totalFiles: files.length,
-    totalEdges: graph.edgeCount(),
-    deadFiles,
-    avgBusFactor: Math.round(avgBusFactor * 100) / 100,
-    highRiskFiles,
-    churnLinesLast7d
+    metrics: {
+      totalFiles: files.length,
+      totalEdges: graph.edgeCount(),
+      deadFiles,
+      avgBusFactor: Math.round(avgBusFactor * 100) / 100,
+      highRiskFiles,
+      churnLinesLast7d
+    },
+    perFileScores
   };
 }
 async function ensureDir(dir) {
@@ -4016,14 +4129,46 @@ async function overwriteLastLine(filePath, replacement) {
   const head = idx >= 0 ? trimmed.slice(0, idx + 1) : "";
   await fs10.writeFile(filePath, head + replacement + "\n");
 }
+async function loadLastScoresPerFile(filePath) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const raw = await fs10.readFile(filePath, "utf-8");
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const p = JSON.parse(line);
+        if (typeof p?.file === "string" && typeof p.score === "number") {
+          out.set(p.file, p);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+async function appendFilteredPerFileScores(filePath, next, prev) {
+  const lines = [];
+  for (const p of next) {
+    const last = prev.get(p.file);
+    const labelChanged = last?.label !== p.label;
+    const scoreMoved = last === void 0 || Math.abs(p.score - last.score) >= FILE_SCORE_DELTA;
+    if (labelChanged || scoreMoved) lines.push(JSON.stringify(p));
+  }
+  if (lines.length === 0) return 0;
+  await ensureDir(path11.dirname(filePath));
+  await fs10.appendFile(filePath, lines.join("\n") + "\n");
+  return lines.length;
+}
 async function recordTrendSnapshot(opts) {
   const now = opts.now ?? Date.now;
   const ms = now();
   const unixSeconds = Math.floor(ms / 1e3);
   const timestamp = new Date(ms).toISOString();
   const filePath = path11.join(opts.rootDir, FILE_SUBPATH);
+  const fileRisksPath = path11.join(opts.rootDir, FILE_RISKS_SUBPATH);
   try {
-    const metrics = computeMetrics(opts, unixSeconds);
+    const { metrics, perFileScores } = computeAggregates(opts, unixSeconds);
     const snapshot = {
       timestamp,
       unixSeconds,
@@ -4038,6 +4183,10 @@ async function recordTrendSnapshot(opts) {
     } else {
       await fs10.appendFile(filePath, JSON.stringify(snapshot) + "\n");
     }
+    if (perFileScores.length > 0) {
+      const lastScores = await loadLastScoresPerFile(fileRisksPath);
+      await appendFilteredPerFileScores(fileRisksPath, perFileScores, lastScores);
+    }
     return snapshot;
   } catch (err) {
     logger.warn("Failed to record trend snapshot", {
@@ -4099,8 +4248,58 @@ async function loadTrendSeries(opts) {
   return { snapshots: tail, gitEnabled, totalCount };
 }
 
+// packages/core/src/trends/FileRiskStore.ts
+import path13 from "path";
+import fs12 from "fs/promises";
+var FILE_SUBPATH3 = path13.join(".ctxloom", "trends", "file-risks.jsonl");
+var DEFAULT_LIMIT3 = 200;
+var VALID_LABELS = /* @__PURE__ */ new Set(["low", "medium", "high", "critical"]);
+function isValidPoint(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.unixSeconds === "number" && typeof v.file === "string" && typeof v.score === "number" && typeof v.label === "string" && VALID_LABELS.has(v.label);
+}
+async function loadFileRiskHistory(opts) {
+  const filePath = path13.join(opts.rootDir, FILE_SUBPATH3);
+  const limit = opts.limit ?? DEFAULT_LIMIT3;
+  const sinceUnixSeconds = opts.sinceUnixSeconds ?? 0;
+  let raw;
+  try {
+    raw = await fs12.readFile(filePath, "utf-8");
+  } catch {
+    return { file: opts.file, points: [], totalCount: 0 };
+  }
+  const allMatching = [];
+  let totalCount = 0;
+  let malformed = 0;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      malformed++;
+      continue;
+    }
+    if (!isValidPoint(value)) {
+      malformed++;
+      continue;
+    }
+    if (value.file !== opts.file) continue;
+    totalCount++;
+    if (value.unixSeconds < sinceUnixSeconds) continue;
+    allMatching.push(value);
+  }
+  if (malformed > 0) {
+    logger.warn("Skipped malformed file-risk rows", { file: filePath, count: malformed });
+  }
+  allMatching.sort((a, b) => a.unixSeconds - b.unixSeconds);
+  const tail = allMatching.length > limit ? allMatching.slice(allMatching.length - limit) : allMatching;
+  return { file: opts.file, points: tail, totalCount };
+}
+
 // packages/core/src/ast/Skeletonizer.ts
-import fs12 from "fs";
+import fs13 from "fs";
 var Skeletonizer = class {
   parser;
   constructor() {
@@ -4142,7 +4341,7 @@ var Skeletonizer = class {
    * "deliberately skipped" from "skeletonized to empty".
    */
   async skeletonize(filePath) {
-    const fileSource = fs12.readFileSync(filePath, "utf-8");
+    const fileSource = fs13.readFileSync(filePath, "utf-8");
     const fileLines = fileSource.split("\n");
     const MAX_INPUT_BYTES = 256 * 1024;
     if (fileSource.length > MAX_INPUT_BYTES) {
@@ -4206,7 +4405,7 @@ ${methodLines.join("\n")}
    */
   async skeletonizeXML(filePath) {
     const nodes = await this.parser.parse(filePath);
-    const fileLines = fs12.readFileSync(filePath, "utf-8").split("\n");
+    const fileLines = fs13.readFileSync(filePath, "utf-8").split("\n");
     const parts = [`<skeleton file="${filePath}">`];
     for (const node of nodes) {
       switch (node.type) {
@@ -4358,7 +4557,7 @@ function registerFileTool(registry, ctx) {
 
 // packages/core/src/tools/context-packet.ts
 import { z as z3 } from "zod";
-import path13 from "path";
+import path14 from "path";
 var Schema3 = z3.object({
   target_file: z3.string().describe("Relative path to the primary file"),
   mode: z3.enum(["edit", "read"]).optional().default("edit").describe("Context mode")
@@ -4388,7 +4587,7 @@ function registerContextPacketTool(registry, ctx) {
       const skeletons = await Promise.all(
         imports.map(async (dep) => {
           try {
-            const absDep = path13.resolve(ctx.projectRoot, dep);
+            const absDep = path14.resolve(ctx.projectRoot, dep);
             const sk = await skeletonizer.skeletonize(absDep);
             return `
 <!-- ${dep} -->
@@ -4419,7 +4618,7 @@ ${sk}`;
 import { z as z4 } from "zod";
 
 // packages/core/src/tools/findCallers.ts
-import path14 from "path";
+import path15 from "path";
 function escapeXML3(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
@@ -5217,7 +5416,7 @@ function registerArchitectureOverviewTool(registry, ctx) {
 
 // packages/core/src/tools/knowledge-gaps.ts
 import { z as z12 } from "zod";
-import path15 from "path";
+import path16 from "path";
 var Schema12 = z12.object({
   min_importers: z12.number().min(1).max(50).optional().default(3).describe(
     "Minimum importers to qualify as an untested hub (default: 3)"
@@ -5266,7 +5465,7 @@ function registerKnowledgeGapsTool(registry, ctx) {
       const testFiles = new Set(files.filter((f) => TEST_PATTERN2.test(f)));
       const testedBases = /* @__PURE__ */ new Set();
       for (const tf of testFiles) {
-        const base = path15.basename(tf).replace(/\.(test|spec)\.[^.]+$/, "").replace(/\.[^.]+$/, "");
+        const base = path16.basename(tf).replace(/\.(test|spec)\.[^.]+$/, "").replace(/\.[^.]+$/, "");
         if (base) testedBases.add(base);
       }
       const isolated = [];
@@ -5284,7 +5483,7 @@ function registerKnowledgeGapsTool(registry, ctx) {
           deadCode.push(file);
         }
         if (importers >= min_importers) {
-          const base = path15.basename(file).replace(/\.[^.]+$/, "");
+          const base = path16.basename(file).replace(/\.[^.]+$/, "");
           if (!testedBases.has(base)) {
             untestedHubs.push({ file, importers });
           }
@@ -5708,8 +5907,8 @@ function registerGitDiffReviewTool(registry, ctx) {
 
 // packages/core/src/tools/refactor-preview.ts
 import { z as z17 } from "zod";
-import fs13 from "fs";
-import path16 from "path";
+import fs14 from "fs";
+import path17 from "path";
 var Schema17 = z17.object({
   symbol: z17.string().min(1).describe("Symbol name to rename (exact match, case-sensitive)"),
   new_name: z17.string().min(1).describe("New name for the symbol"),
@@ -5723,7 +5922,7 @@ function escapeXML17(text) {
 function scanFile(filePath, symbol, newName) {
   let content;
   try {
-    content = fs13.readFileSync(filePath, "utf-8");
+    content = fs14.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -5786,7 +5985,7 @@ function registerRefactorPreviewTool(registry, ctx) {
       const fileChanges = [];
       let totalOccurrences = 0;
       for (const relPath of candidates) {
-        const absPath = path16.join(ctx.projectRoot, relPath);
+        const absPath = path17.join(ctx.projectRoot, relPath);
         const occurrences = scanFile(absPath, symbol, new_name);
         if (occurrences.length > 0) {
           fileChanges.push({ filePath: relPath, occurrences });
@@ -5953,8 +6152,8 @@ function registerExecutionFlowTool(registry, ctx) {
 
 // packages/core/src/tools/cross-repo-search.ts
 import { z as z19 } from "zod";
-import fs14 from "fs";
-import path17 from "path";
+import fs15 from "fs";
+import path18 from "path";
 var RepoRegistry = class {
   filePath;
   repos;
@@ -5964,16 +6163,16 @@ var RepoRegistry = class {
   }
   load() {
     try {
-      if (!fs14.existsSync(this.filePath)) return [];
-      return JSON.parse(fs14.readFileSync(this.filePath, "utf-8"));
+      if (!fs15.existsSync(this.filePath)) return [];
+      return JSON.parse(fs15.readFileSync(this.filePath, "utf-8"));
     } catch {
       return [];
     }
   }
   save() {
-    const dir = path17.dirname(this.filePath);
-    if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
-    fs14.writeFileSync(this.filePath, JSON.stringify(this.repos, null, 2), "utf-8");
+    const dir = path18.dirname(this.filePath);
+    if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
+    fs15.writeFileSync(this.filePath, JSON.stringify(this.repos, null, 2), "utf-8");
   }
   list() {
     return [...this.repos];
@@ -5983,7 +6182,7 @@ var RepoRegistry = class {
     const entry = {
       root,
       dbPath,
-      name: path17.basename(root),
+      name: path18.basename(root),
       registeredAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (existing >= 0) {
@@ -6011,7 +6210,7 @@ function escapeXML19(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function registerCrossRepoSearchTool(registry, _ctx, registryFilePath) {
-  const repoRegistryPath = registryFilePath ?? path17.join(process.env.HOME ?? process.env.USERPROFILE ?? "", ".ctxloom", "repos.json");
+  const repoRegistryPath = registryFilePath ?? path18.join(process.env.HOME ?? process.env.USERPROFILE ?? "", ".ctxloom", "repos.json");
   registry.register(
     "ctx_cross_repo_search",
     {
@@ -6114,8 +6313,8 @@ function registerCrossRepoSearchTool(registry, _ctx, registryFilePath) {
 
 // packages/core/src/tools/apply-refactor.ts
 import { z as z20 } from "zod";
-import fs15 from "fs";
-import path18 from "path";
+import fs16 from "fs";
+import path19 from "path";
 var Schema20 = z20.object({
   symbol: z20.string().min(1).describe("Symbol name to rename (exact, case-sensitive)"),
   new_name: z20.string().min(1).describe("New name for the symbol"),
@@ -6132,7 +6331,7 @@ function escapeXML20(text) {
 function applyToFile(absPath, symbol, newName, dryRun) {
   let content;
   try {
-    content = fs15.readFileSync(absPath, "utf-8");
+    content = fs16.readFileSync(absPath, "utf-8");
   } catch {
     return 0;
   }
@@ -6141,7 +6340,7 @@ function applyToFile(absPath, symbol, newName, dryRun) {
   const occurrences = (content.match(regex) ?? []).length;
   if (occurrences === 0) return 0;
   if (!dryRun) {
-    fs15.writeFileSync(absPath, content.replace(regex, newName), "utf-8");
+    fs16.writeFileSync(absPath, content.replace(regex, newName), "utf-8");
   }
   return occurrences;
 }
@@ -6181,7 +6380,7 @@ function registerApplyRefactorTool(registry, ctx) {
       const results = [];
       let totalOccurrences = 0;
       for (const relPath of candidates) {
-        const absPath = path18.join(ctx.projectRoot, relPath);
+        const absPath = path19.join(ctx.projectRoot, relPath);
         const count = applyToFile(absPath, symbol, new_name, dry_run);
         if (count > 0) {
           results.push({ filePath: relPath, occurrences: count, written: !dry_run });
@@ -6314,8 +6513,8 @@ function registerDetectChangesTool(registry, ctx) {
 
 // packages/core/src/tools/full-text-search.ts
 import { z as z22 } from "zod";
-import fs16 from "fs";
-import path19 from "path";
+import fs17 from "fs";
+import path20 from "path";
 var Schema22 = z22.object({
   query: z22.string().min(1).describe("Search term \u2014 literal or /regex/"),
   mode: z22.enum(["hybrid", "keyword", "semantic"]).optional().default("hybrid"),
@@ -6340,7 +6539,7 @@ function buildPattern(query, caseSensitive) {
 function scanFile2(absPath, pattern, contextLines) {
   let content;
   try {
-    content = fs16.readFileSync(absPath, "utf-8");
+    content = fs17.readFileSync(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -6406,7 +6605,7 @@ function registerFullTextSearchTool(registry, ctx) {
       const files = graph.allFiles();
       const keywordResults = [];
       for (const relPath of files) {
-        const absPath = path19.join(ctx.projectRoot, relPath);
+        const absPath = path20.join(ctx.projectRoot, relPath);
         const hit = scanFile2(absPath, pattern, context_lines);
         if (hit) {
           keywordResults.push({
@@ -6626,8 +6825,8 @@ function registerGetWorkflowTool(registry, _ctx) {
 }
 
 // packages/core/src/tools/graph-snapshot.ts
-import fs17 from "fs";
-import path20 from "path";
+import fs18 from "fs";
+import path21 from "path";
 import { z as z25 } from "zod";
 var schema = z25.object({
   name: z25.string().min(1).max(64).regex(/^[\w.-]+$/, "Name may only contain letters, digits, dots, underscores, hyphens").describe(
@@ -6638,13 +6837,13 @@ var schema = z25.object({
   )
 });
 function saveNamedSnapshot(graph, name, rootDir, overwrite = false) {
-  const snapshotsDir = path20.resolve(rootDir, ".ctxloom", "snapshots");
-  fs17.mkdirSync(snapshotsDir, { recursive: true });
-  const snapshotPath = path20.resolve(snapshotsDir, `${name}.json`);
-  if (!snapshotPath.startsWith(snapshotsDir + path20.sep)) {
+  const snapshotsDir = path21.resolve(rootDir, ".ctxloom", "snapshots");
+  fs18.mkdirSync(snapshotsDir, { recursive: true });
+  const snapshotPath = path21.resolve(snapshotsDir, `${name}.json`);
+  if (!snapshotPath.startsWith(snapshotsDir + path21.sep)) {
     throw new Error(`Invalid snapshot name: "${name}"`);
   }
-  if (fs17.existsSync(snapshotPath) && !overwrite) {
+  if (fs18.existsSync(snapshotPath) && !overwrite) {
     throw new Error(`Snapshot "${name}" already exists. Pass overwrite: true to replace it.`);
   }
   const files = graph.allFiles();
@@ -6660,13 +6859,13 @@ function saveNamedSnapshot(graph, name, rootDir, overwrite = false) {
     forwardEdges
   };
   const tmp = snapshotPath + ".tmp";
-  fs17.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
-  fs17.renameSync(tmp, snapshotPath);
+  fs18.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+  fs18.renameSync(tmp, snapshotPath);
 }
 function listNamedSnapshots(rootDir) {
-  const snapshotsDir = path20.join(rootDir, ".ctxloom", "snapshots");
-  if (!fs17.existsSync(snapshotsDir)) return [];
-  return fs17.readdirSync(snapshotsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)).sort();
+  const snapshotsDir = path21.join(rootDir, ".ctxloom", "snapshots");
+  if (!fs18.existsSync(snapshotsDir)) return [];
+  return fs18.readdirSync(snapshotsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)).sort();
 }
 function registerGraphSnapshotTool(registry, ctx) {
   registry.register(
@@ -6714,24 +6913,24 @@ function registerGraphSnapshotTool(registry, ctx) {
 }
 
 // packages/core/src/tools/graph-diff.ts
-import fs18 from "fs";
-import path21 from "path";
+import fs19 from "fs";
+import path22 from "path";
 import { z as z26 } from "zod";
 var schema2 = z26.object({
   baseline: z26.string().min(1).describe('Name of the baseline snapshot (the "before" state).'),
   current: z26.string().min(1).describe('Name of the current snapshot (the "after" state).')
 });
 function loadSnapshot(name, rootDir) {
-  const snapshotsDir = path21.resolve(rootDir, ".ctxloom", "snapshots");
-  const snapshotPath = path21.resolve(snapshotsDir, `${name}.json`);
-  if (!snapshotPath.startsWith(snapshotsDir + path21.sep)) {
+  const snapshotsDir = path22.resolve(rootDir, ".ctxloom", "snapshots");
+  const snapshotPath = path22.resolve(snapshotsDir, `${name}.json`);
+  if (!snapshotPath.startsWith(snapshotsDir + path22.sep)) {
     throw new Error(`Invalid snapshot name: "${name}"`);
   }
-  if (!fs18.existsSync(snapshotPath)) {
+  if (!fs19.existsSync(snapshotPath)) {
     throw new Error(`Snapshot "${name}" not found. Run ctx_graph_snapshot first.`);
   }
   try {
-    return JSON.parse(fs18.readFileSync(snapshotPath, "utf-8"));
+    return JSON.parse(fs19.readFileSync(snapshotPath, "utf-8"));
   } catch (e) {
     throw new Error(`Snapshot "${name}" is corrupted: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -7096,8 +7295,8 @@ var RulesConfigError = class extends Error {
 };
 
 // packages/core/src/rules/loadConfig.ts
-import fs19 from "fs/promises";
-import path22 from "path";
+import fs20 from "fs/promises";
+import path23 from "path";
 import yaml from "js-yaml";
 import { z as z30 } from "zod";
 var RuleSchema = z30.object({
@@ -7112,10 +7311,10 @@ var RulesConfigSchema = z30.object({
   rules: z30.array(RuleSchema).default([])
 });
 async function loadRulesConfig(rootDir) {
-  const filePath = path22.join(rootDir, ".ctxloom", "rules.yml");
+  const filePath = path23.join(rootDir, ".ctxloom", "rules.yml");
   let raw;
   try {
-    raw = await fs19.readFile(filePath, "utf-8");
+    raw = await fs20.readFile(filePath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw new RulesConfigError(`Failed to read rules config: ${String(err)}`);
@@ -7480,8 +7679,8 @@ function createToolRegistry(ctx) {
 }
 
 // packages/core/src/tools/ruleManager.ts
-import fs20 from "fs";
-import path23 from "path";
+import fs21 from "fs";
+import path24 from "path";
 var RULE_FILES = [
   ".cursorrules",
   "CLAUDE.md",
@@ -7505,30 +7704,30 @@ var RuleManager = class {
     if (this.cachedRules) return this.cachedRules;
     const rules = [];
     for (const ruleFile of RULE_FILES) {
-      const fullPath = path23.join(this.projectRoot, ruleFile);
+      const fullPath = path24.join(this.projectRoot, ruleFile);
       try {
         this.pathValidator.validate(fullPath);
-        if (fs20.existsSync(fullPath)) {
-          const stat = fs20.statSync(fullPath);
+        if (fs21.existsSync(fullPath)) {
+          const stat = fs21.statSync(fullPath);
           if (stat.isFile()) {
-            const content = fs20.readFileSync(fullPath, "utf-8");
+            const content = fs21.readFileSync(fullPath, "utf-8");
             rules.push({
               name: ruleFile,
               path: ruleFile,
               content
             });
           } else if (stat.isDirectory()) {
-            const dirEntries = fs20.readdirSync(fullPath);
+            const dirEntries = fs21.readdirSync(fullPath);
             for (const entry of dirEntries) {
-              const entryPath = path23.join(fullPath, entry);
+              const entryPath = path24.join(fullPath, entry);
               try {
                 this.pathValidator.validate(entryPath);
               } catch {
                 continue;
               }
-              const entryStat = fs20.statSync(entryPath);
+              const entryStat = fs21.statSync(entryPath);
               if (entryStat.isFile()) {
-                const content = fs20.readFileSync(entryPath, "utf-8");
+                const content = fs21.readFileSync(entryPath, "utf-8");
                 rules.push({
                   name: `${ruleFile}/${entry}`,
                   path: `${ruleFile}/${entry}`,
@@ -7571,8 +7770,8 @@ var RuleManager = class {
 };
 
 // packages/core/src/review/AuthorResolver.ts
-import fs21 from "fs/promises";
-import path24 from "path";
+import fs22 from "fs/promises";
+import path25 from "path";
 import yaml2 from "js-yaml";
 var AuthorResolver = class {
   constructor(ctxloomDir) {
@@ -7597,8 +7796,8 @@ var AuthorResolver = class {
   /** Write a new mapping to the cache file. */
   async writeCache(email, handle) {
     this.cache = { ...this.cache, [email]: handle };
-    await fs21.writeFile(
-      path24.join(this.ctxloomDir, "authors-cache.json"),
+    await fs22.writeFile(
+      path25.join(this.ctxloomDir, "authors-cache.json"),
       JSON.stringify(this.cache, null, 2)
     );
   }
@@ -7607,9 +7806,9 @@ var AuthorResolver = class {
     return emails.filter((e) => this.resolve(e) === void 0);
   }
   async loadYml() {
-    const file = path24.join(this.ctxloomDir, "authors.yml");
+    const file = path25.join(this.ctxloomDir, "authors.yml");
     try {
-      const raw = await fs21.readFile(file, "utf8");
+      const raw = await fs22.readFile(file, "utf8");
       const parsed = yaml2.load(raw);
       if (!parsed) return;
       this.mappings = parsed.mappings ?? {};
@@ -7618,9 +7817,9 @@ var AuthorResolver = class {
     }
   }
   async loadCache() {
-    const file = path24.join(this.ctxloomDir, "authors-cache.json");
+    const file = path25.join(this.ctxloomDir, "authors-cache.json");
     try {
-      const raw = await fs21.readFile(file, "utf8");
+      const raw = await fs22.readFile(file, "utf8");
       this.cache = JSON.parse(raw);
     } catch {
     }
@@ -7645,8 +7844,8 @@ async function resolveViaGitHubApi(email, owner, repo, token) {
 }
 
 // packages/core/src/review/CodeownersWriter.ts
-import fs22 from "fs/promises";
-import path25 from "path";
+import fs23 from "fs/promises";
+import path26 from "path";
 var MARKER_START = "# <ctxloom:start> \u2014 managed by ctxloom review-suggest; do not edit between markers";
 var MARKER_START_DETECT = "# <ctxloom:start>";
 var MARKER_END = "# <ctxloom:end>";
@@ -7678,15 +7877,15 @@ ${block}
 async function generateCODEOWNERS(codeownersPath, rules) {
   let existing = "";
   try {
-    existing = await fs22.readFile(codeownersPath, "utf8");
+    existing = await fs23.readFile(codeownersPath, "utf8");
   } catch {
   }
   const block = buildCodeownersBlock(rules);
   return mergeIntoFile(existing, block);
 }
 async function writeCODEOWNERS(codeownersPath, content) {
-  await fs22.mkdir(path25.dirname(codeownersPath), { recursive: true });
-  await fs22.writeFile(codeownersPath, content, "utf8");
+  await fs23.mkdir(path26.dirname(codeownersPath), { recursive: true });
+  await fs23.writeFile(codeownersPath, content, "utf8");
 }
 
 // packages/core/src/review/types.ts
@@ -7871,8 +8070,8 @@ function matchGlob(pattern, value) {
 }
 
 // packages/core/src/review/loadConfig.ts
-import fs23 from "fs/promises";
-import path26 from "path";
+import fs24 from "fs/promises";
+import path27 from "path";
 import yaml3 from "js-yaml";
 function freshDefaults() {
   return {
@@ -7883,9 +8082,9 @@ function freshDefaults() {
   };
 }
 async function loadReviewConfig(root) {
-  const file = path26.join(root, ".ctxloom", "review.yml");
+  const file = path27.join(root, ".ctxloom", "review.yml");
   try {
-    const raw = await fs23.readFile(file, "utf8");
+    const raw = await fs24.readFile(file, "utf8");
     const parsed = yaml3.load(raw);
     if (!parsed) return freshDefaults();
     return {
@@ -7900,13 +8099,13 @@ async function loadReviewConfig(root) {
 }
 
 // packages/core/src/security/PathValidator.ts
-import path27 from "path";
-import fs24 from "fs";
+import path28 from "path";
+import fs25 from "fs";
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var PathValidator = class {
   canonicalRoot;
   constructor(projectRoot) {
-    this.canonicalRoot = fs24.realpathSync(path27.resolve(projectRoot));
+    this.canonicalRoot = fs25.realpathSync(path28.resolve(projectRoot));
   }
   /**
    * Validates that the given input path resolves within the project root.
@@ -7916,14 +8115,14 @@ var PathValidator = class {
    * @throws Error if the path escapes the project root
    */
   validate(inputPath) {
-    const resolved = path27.resolve(this.canonicalRoot, inputPath);
+    const resolved = path28.resolve(this.canonicalRoot, inputPath);
     let canonical;
     try {
-      canonical = fs24.realpathSync(resolved);
+      canonical = fs25.realpathSync(resolved);
     } catch {
       canonical = resolved;
     }
-    if (!canonical.startsWith(this.canonicalRoot + path27.sep) && canonical !== this.canonicalRoot) {
+    if (!canonical.startsWith(this.canonicalRoot + path28.sep) && canonical !== this.canonicalRoot) {
       throw new Error(
         `Path traversal blocked: "${inputPath}" resolves outside of the project root`
       );
@@ -7940,7 +8139,7 @@ var PathValidator = class {
    * Converts an absolute path to a relative path from the project root.
    */
   toRelative(absolutePath) {
-    return path27.relative(this.canonicalRoot, absolutePath);
+    return path28.relative(this.canonicalRoot, absolutePath);
   }
   /**
    * Validates and reads a file, returning its content.
@@ -7948,11 +8147,11 @@ var PathValidator = class {
    */
   readFile(inputPath) {
     const absPath = this.validate(inputPath);
-    const stat = fs24.statSync(absPath);
+    const stat = fs25.statSync(absPath);
     if (stat.size > MAX_FILE_SIZE) {
       throw new Error(`File too large: ${inputPath} (${Math.round(stat.size / 1024)}KB, max ${MAX_FILE_SIZE / 1024 / 1024}MB)`);
     }
-    return fs24.readFileSync(absPath, "utf-8");
+    return fs25.readFileSync(absPath, "utf-8");
   }
   /**
    * Checks if a path exists and is within the project root.
@@ -8105,7 +8304,7 @@ var EmailAlreadyUsedError = class extends Error {
 
 // packages/core/src/license/LicenseStore.ts
 import { readFileSync, writeFileSync, unlinkSync, mkdirSync, chmodSync, existsSync } from "fs";
-import path28 from "path";
+import path29 from "path";
 
 // packages/core/src/license/types.ts
 import { z as z32 } from "zod";
@@ -8126,7 +8325,7 @@ var LicenseFileSchema = z32.object({
 
 // packages/core/src/license/LicenseStore.ts
 function licenseFilePath(home) {
-  return path28.join(home, ".ctxloom", "license.json");
+  return path29.join(home, ".ctxloom", "license.json");
 }
 var LicenseStore = class {
   filePath;
@@ -8149,7 +8348,7 @@ var LicenseStore = class {
     }
   }
   async write(license) {
-    mkdirSync(path28.dirname(this.filePath), { recursive: true });
+    mkdirSync(path29.dirname(this.filePath), { recursive: true });
     writeFileSync(this.filePath, JSON.stringify(license, null, 2), {
       encoding: "utf8",
       mode: 384
@@ -8481,8 +8680,19 @@ export {
   ChurnIndex,
   OwnershipIndex,
   GitOverlayStore,
+  RISK_WEIGHTS,
+  BAND_PCT,
+  SCORE_FLOOR,
+  SILO_BUS_FACTOR,
+  computeRiskCaps,
+  computeRiskBreakdown,
+  scoreFromBreakdown,
+  isSiloed,
+  assignLabelsByPercentile,
+  scoreAll,
   recordTrendSnapshot,
   loadTrendSeries,
+  loadFileRiskHistory,
   Skeletonizer,
   ToolRegistry,
   detectChanges,
@@ -8531,4 +8741,4 @@ export {
   track,
   captureError
 };
-//# sourceMappingURL=chunk-EHFVPRTN.js.map
+//# sourceMappingURL=chunk-ZTC3QWIL.js.map