ctxloom-pro 1.0.21 → 1.0.23

package/apps/dashboard/dist/server/index.js

@@ -148,8 +148,8 @@ var init_embedder = __esm({
 // ../../packages/core/src/db/VectorStore.ts
 import lancedb from "@lancedb/lancedb";
 import { makeArrowTable } from "@lancedb/lancedb";
-import path14 from "path";
-import fs14 from "fs";
+import path15 from "path";
+import fs15 from "fs";
 var init_VectorStore = __esm({
   "../../packages/core/src/db/VectorStore.ts"() {
     "use strict";
@@ -160,12 +160,12 @@ var init_VectorStore = __esm({
 // server/index.ts
 import express from "express";
 import cors from "cors";
-import path37 from "path";
-import fs29 from "fs";
+import path38 from "path";
+import fs30 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // server/loader.ts
-import path31 from "path";
+import path32 from "path";
 
 // ../../packages/core/src/graph/DependencyGraph.ts
 import fs7 from "fs";
@@ -3124,8 +3124,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 path38 of paths) {
-      this.nodeCounts.set(path38, (this.nodeCounts.get(path38) ?? 0) + 1);
+    for (const path39 of paths) {
+      this.nodeCounts.set(path39, (this.nodeCounts.get(path39) ?? 0) + 1);
     }
     for (let i = 0; i < paths.length; i++) {
       for (let j = i + 1; j < paths.length; j++) {
@@ -3272,8 +3272,8 @@ var ChurnIndex = class _ChurnIndex {
    */
   snapshot() {
     const nodes = {};
-    for (const [path38, raw] of this.nodes) {
-      nodes[path38] = {
+    for (const [path39, raw] of this.nodes) {
+      nodes[path39] = {
         commits: raw.commits,
         churnLines: raw.churnLines,
         bugCommits: raw.bugCommits,
@@ -3288,8 +3288,8 @@ var ChurnIndex = class _ChurnIndex {
    */
   static load(s) {
     const idx = new _ChurnIndex();
-    for (const [path38, raw] of Object.entries(s.nodes)) {
-      idx.nodes.set(path38, {
+    for (const [path39, raw] of Object.entries(s.nodes)) {
+      idx.nodes.set(path39, {
         commits: raw.commits,
         churnLines: raw.churnLines,
         bugCommits: raw.bugCommits,
@@ -3302,8 +3302,8 @@ var ChurnIndex = class _ChurnIndex {
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
-  getOrCreate(path38) {
-    const existing = this.nodes.get(path38);
+  getOrCreate(path39) {
+    const existing = this.nodes.get(path39);
     if (existing !== void 0) return existing;
     const fresh = {
       commits: 0,
@@ -3312,7 +3312,7 @@ var ChurnIndex = class _ChurnIndex {
       authorCounts: {},
       lastTouch: 0
     };
-    this.nodes.set(path38, fresh);
+    this.nodes.set(path39, fresh);
     return fresh;
   }
 };
@@ -3393,12 +3393,12 @@ var OwnershipIndex = class _OwnershipIndex {
    */
   snapshot() {
     const nodes = {};
-    for (const [path38, raw] of this.nodes) {
+    for (const [path39, raw] of this.nodes) {
       const authorWeights = {};
       for (const [email, entry] of Object.entries(raw.authorWeights)) {
         authorWeights[email] = { ...entry };
       }
-      nodes[path38] = { authorWeights, lastTouch: raw.lastTouch };
+      nodes[path39] = { authorWeights, lastTouch: raw.lastTouch };
     }
     return { version: 1, nodes };
   }
@@ -3407,23 +3407,23 @@ var OwnershipIndex = class _OwnershipIndex {
    */
   static load(s) {
     const idx = new _OwnershipIndex();
-    for (const [path38, raw] of Object.entries(s.nodes)) {
+    for (const [path39, raw] of Object.entries(s.nodes)) {
       const authorWeights = {};
       for (const [email, entry] of Object.entries(raw.authorWeights)) {
         authorWeights[email] = { ...entry };
       }
-      idx.nodes.set(path38, { authorWeights, lastTouch: raw.lastTouch });
+      idx.nodes.set(path39, { authorWeights, lastTouch: raw.lastTouch });
     }
     return idx;
   }
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
-  getOrCreate(path38) {
-    const existing = this.nodes.get(path38);
+  getOrCreate(path39) {
+    const existing = this.nodes.get(path39);
     if (existing !== void 0) return existing;
     const fresh = { authorWeights: {}, lastTouch: 0 };
-    this.nodes.set(path38, fresh);
+    this.nodes.set(path39, fresh);
     return fresh;
   }
 };
@@ -3599,19 +3599,121 @@ function isEnoent(err) {
 init_logger();
 import path12 from "path";
 import fs11 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 = path12.join(".ctxloom", "trends", "snapshots.jsonl");
+var FILE_RISKS_SUBPATH = path12.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) {
@@ -3620,51 +3722,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) {
@@ -3735,14 +3848,46 @@ async function overwriteLastLine(filePath, replacement) {
   const head = idx >= 0 ? trimmed.slice(0, idx + 1) : "";
   await fs11.writeFile(filePath, head + replacement + "\n");
 }
+async function loadLastScoresPerFile(filePath) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const raw = await fs11.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(path12.dirname(filePath));
+  await fs11.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 timestamp2 = new Date(ms).toISOString();
   const filePath = path12.join(opts.rootDir, FILE_SUBPATH);
+  const fileRisksPath = path12.join(opts.rootDir, FILE_RISKS_SUBPATH);
   try {
-    const metrics = computeMetrics(opts, unixSeconds);
+    const { metrics, perFileScores } = computeAggregates(opts, unixSeconds);
     const snapshot = {
       timestamp: timestamp2,
       unixSeconds,
@@ -3757,6 +3902,10 @@ async function recordTrendSnapshot(opts) {
     } else {
       await fs11.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", {
@@ -3819,8 +3968,59 @@ async function loadTrendSeries(opts) {
   return { snapshots: tail, gitEnabled, totalCount };
 }
 
+// ../../packages/core/src/trends/FileRiskStore.ts
+init_logger();
+import path14 from "path";
+import fs13 from "fs/promises";
+var FILE_SUBPATH3 = path14.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 = path14.join(opts.rootDir, FILE_SUBPATH3);
+  const limit = opts.limit ?? DEFAULT_LIMIT3;
+  const sinceUnixSeconds = opts.sinceUnixSeconds ?? 0;
+  let raw;
+  try {
+    raw = await fs13.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 fs13 from "fs";
+import fs14 from "fs";
 var Skeletonizer = class {
   parser;
   constructor() {
@@ -3862,7 +4062,7 @@ var Skeletonizer = class {
    * "deliberately skipped" from "skeletonized to empty".
    */
   async skeletonize(filePath) {
-    const fileSource = fs13.readFileSync(filePath, "utf-8");
+    const fileSource = fs14.readFileSync(filePath, "utf-8");
     const fileLines = fileSource.split("\n");
     const MAX_INPUT_BYTES = 256 * 1024;
     if (fileSource.length > MAX_INPUT_BYTES) {
@@ -3926,7 +4126,7 @@ ${methodLines.join("\n")}
    */
   async skeletonizeXML(filePath) {
     const nodes = await this.parser.parse(filePath);
-    const fileLines = fs13.readFileSync(filePath, "utf-8").split("\n");
+    const fileLines = fs14.readFileSync(filePath, "utf-8").split("\n");
     const parts = [`<skeleton file="${filePath}">`];
     for (const node of nodes) {
       switch (node.type) {
@@ -4461,8 +4661,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path38, errorMaps, issueData } = params;
-  const fullPath = [...path38, ...issueData.path || []];
+  const { data, path: path39, errorMaps, issueData } = params;
+  const fullPath = [...path39, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -4578,11 +4778,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path38, key) {
+  constructor(parent, value, path39, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path38;
+    this._path = path39;
     this._key = key;
   }
   get path() {
@@ -8035,14 +8235,14 @@ var Schema = external_exports.object({
 var Schema2 = external_exports.object({ path: external_exports.string().describe("Relative path to the file") });
 
 // ../../packages/core/src/tools/context-packet.ts
-import path15 from "path";
+import path16 from "path";
 var Schema3 = external_exports.object({
   target_file: external_exports.string().describe("Relative path to the primary file"),
   mode: external_exports.enum(["edit", "read"]).optional().default("edit").describe("Context mode")
 });
 
 // ../../packages/core/src/tools/findCallers.ts
-import path16 from "path";
+import path17 from "path";
 
 // ../../packages/core/src/tools/call-graph.ts
 var Schema4 = external_exports.object({
@@ -8114,7 +8314,7 @@ var Schema11 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/knowledge-gaps.ts
-import path17 from "path";
+import path18 from "path";
 var Schema12 = external_exports.object({
   min_importers: external_exports.number().min(1).max(50).optional().default(3).describe(
     "Minimum importers to qualify as an untested hub (default: 3)"
@@ -8174,8 +8374,8 @@ var Schema16 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/refactor-preview.ts
-import fs15 from "fs";
-import path18 from "path";
+import fs16 from "fs";
+import path19 from "path";
 var Schema17 = external_exports.object({
   symbol: external_exports.string().min(1).describe("Symbol name to rename (exact match, case-sensitive)"),
   new_name: external_exports.string().min(1).describe("New name for the symbol"),
@@ -8200,8 +8400,8 @@ var Schema18 = external_exports.object({
 init_embedder();
 init_VectorStore();
 init_logger();
-import fs16 from "fs";
-import path19 from "path";
+import fs17 from "fs";
+import path20 from "path";
 var Schema19 = external_exports.object({
   query: external_exports.string().min(1).describe("Search query \u2014 natural language or code fragment"),
   limit: external_exports.number().min(1).max(100).optional().default(10).describe(
@@ -8213,8 +8413,8 @@ var Schema19 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/apply-refactor.ts
-import fs17 from "fs";
-import path20 from "path";
+import fs18 from "fs";
+import path21 from "path";
 var Schema20 = external_exports.object({
   symbol: external_exports.string().min(1).describe("Symbol name to rename (exact, case-sensitive)"),
   new_name: external_exports.string().min(1).describe("New name for the symbol"),
@@ -8241,8 +8441,8 @@ var Schema21 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/full-text-search.ts
-import fs18 from "fs";
-import path21 from "path";
+import fs19 from "fs";
+import path22 from "path";
 var Schema22 = external_exports.object({
   query: external_exports.string().min(1).describe("Search term \u2014 literal or /regex/"),
   mode: external_exports.enum(["hybrid", "keyword", "semantic"]).optional().default("hybrid"),
@@ -8267,8 +8467,8 @@ var Schema24 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/graph-snapshot.ts
-import fs19 from "fs";
-import path22 from "path";
+import fs20 from "fs";
+import path23 from "path";
 var schema = external_exports.object({
   name: external_exports.string().min(1).max(64).regex(/^[\w.-]+$/, "Name may only contain letters, digits, dots, underscores, hyphens").describe(
     'Snapshot name (e.g. "before-refactor", "v1.0"). Used as the filename.'
@@ -8279,8 +8479,8 @@ var schema = external_exports.object({
 });
 
 // ../../packages/core/src/tools/graph-diff.ts
-import fs20 from "fs";
-import path23 from "path";
+import fs21 from "fs";
+import path24 from "path";
 var schema2 = external_exports.object({
   baseline: external_exports.string().min(1).describe('Name of the baseline snapshot (the "before" state).'),
   current: external_exports.string().min(1).describe('Name of the current snapshot (the "after" state).')
@@ -8313,8 +8513,8 @@ var Schema26 = external_exports.object({
 });
 
 // ../../packages/core/src/rules/loadConfig.ts
-import fs21 from "fs/promises";
-import path24 from "path";
+import fs22 from "fs/promises";
+import path25 from "path";
 
 // ../../node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
@@ -10939,24 +11139,24 @@ var Schema27 = external_exports.object({
 });
 
 // ../../packages/core/src/tools/ruleManager.ts
-import fs22 from "fs";
-import path25 from "path";
-
-// ../../packages/core/src/review/AuthorResolver.ts
-import fs23 from "fs/promises";
+import fs23 from "fs";
 import path26 from "path";
 
-// ../../packages/core/src/review/CodeownersWriter.ts
+// ../../packages/core/src/review/AuthorResolver.ts
 import fs24 from "fs/promises";
 import path27 from "path";
 
-// ../../packages/core/src/review/loadConfig.ts
+// ../../packages/core/src/review/CodeownersWriter.ts
 import fs25 from "fs/promises";
 import path28 from "path";
 
-// ../../packages/core/src/security/PathValidator.ts
+// ../../packages/core/src/review/loadConfig.ts
+import fs26 from "fs/promises";
 import path29 from "path";
-import fs26 from "fs";
+
+// ../../packages/core/src/security/PathValidator.ts
+import path30 from "path";
+import fs27 from "fs";
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 
 // ../../packages/core/src/index.ts
@@ -10967,7 +11167,7 @@ init_logger();
 
 // ../../packages/core/src/license/LicenseStore.ts
 import { readFileSync, writeFileSync, unlinkSync, mkdirSync, chmodSync, existsSync } from "fs";
-import path30 from "path";
+import path31 from "path";
 
 // ../../packages/core/src/license/types.ts
 var FINGERPRINT_RE = /^sha256:[0-9a-f]{64}$/;
@@ -11003,7 +11203,7 @@ var SENTRY_DSN = process.env["SENTRY_DSN"] ?? (typeof __TELEMETRY_SENTRY_DSN__ =
 
 // server/loader.ts
 async function loadContext(root) {
-  const absRoot = path31.resolve(root);
+  const absRoot = path32.resolve(root);
   const overlay = new GitOverlayStore(absRoot);
   const gitEnabled = await overlay.loadSnapshot();
   const graph = new DependencyGraph();
@@ -11038,42 +11238,6 @@ async function switchContext(ctx, newRoot) {
 
 // server/routes/overview.ts
 import { Router } from "express";
-
-// server/lib/risk.ts
-var RISK_WEIGHTS = { churn: 0.2, bug: 0.2, bus: 0.4, coupling: 0.2 };
-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),
-    busFactor: Math.min(1, 1 / Math.max(1, m.busFactor)),
-    coupling: Math.min(1, m.couplingFanOut / couplingDenom)
-  };
-}
-function scoreFromBreakdown(b) {
-  return b.churn * RISK_WEIGHTS.churn + b.bugDensity * RISK_WEIGHTS.bug + b.busFactor * RISK_WEIGHTS.bus + b.coupling * RISK_WEIGHTS.coupling;
-}
-function riskLabel(score) {
-  if (score > 0.8) return "critical";
-  if (score > 0.6) return "high";
-  if (score > 0.3) return "medium";
-  return "low";
-}
-
-// server/routes/overview.ts
 function buildOverviewRouter(ctx) {
   const router = Router();
   router.get("/", (_req, res) => {
@@ -11101,10 +11265,9 @@ function buildOverviewRouter(ctx) {
         };
       });
       const caps = computeRiskCaps(raw);
-      for (const m of raw) {
-        const score = scoreFromBreakdown(computeRiskBreakdown(m, caps));
-        risk[riskLabel(score)]++;
-      }
+      const scores = raw.map((m) => scoreFromBreakdown(computeRiskBreakdown(m, caps)));
+      const { labels } = assignLabelsByPercentile(scores);
+      for (const label of labels) risk[label]++;
     }
     const body = {
       totalFiles: files.length,
@@ -11170,7 +11333,12 @@ function buildRiskRouter(ctx) {
   router.get("/", (_req, res) => {
     const { graph, overlay, gitEnabled } = ctx;
     if (!gitEnabled) {
-      const body = { entries: [], overallRiskScore: 0, caps: { churn: 0, coupling: 0 } };
+      const body = {
+        entries: [],
+        overallRiskScore: 0,
+        caps: { churn: 0, coupling: 0 },
+        bands: { criticalCount: 0, highCount: 0, mediumCount: 0, lowCount: 0, totalRanked: 0 }
+      };
       return res.json(body);
     }
     const files = graph.allFiles();
@@ -11188,24 +11356,26 @@ function buildRiskRouter(ctx) {
       };
     });
     const caps = computeRiskCaps(raw);
-    const entries = raw.map((m) => {
+    const scored = raw.map((m) => {
       const breakdown = computeRiskBreakdown(m, caps);
-      const score = scoreFromBreakdown(breakdown);
-      return {
-        file: m.file,
-        riskScore: Math.round(score * 100) / 100,
-        riskLabel: riskLabel(score),
-        churnLines: m.churnLines,
-        bugDensity: m.bugDensity,
-        busFactor: m.busFactor,
-        topOwner: m.topOwner,
-        couplingFanOut: m.couplingFanOut,
-        breakdown
-      };
+      return { m, breakdown, score: scoreFromBreakdown(breakdown) };
     });
+    const { labels, bands } = assignLabelsByPercentile(scored.map((s) => s.score));
+    const entries = scored.map(({ m, breakdown, score }, idx) => ({
+      file: m.file,
+      riskScore: Math.round(score * 100) / 100,
+      riskLabel: labels[idx],
+      churnLines: m.churnLines,
+      bugDensity: m.bugDensity,
+      busFactor: m.busFactor,
+      topOwner: m.topOwner,
+      couplingFanOut: m.couplingFanOut,
+      breakdown,
+      siloed: isSiloed(m)
+    }));
     entries.sort((a, b) => b.riskScore - a.riskScore);
     const overallRiskScore = entries.length > 0 ? Math.round(entries.reduce((s, e) => s + e.riskScore, 0) / entries.length * 100) / 100 : 0;
-    res.json({ entries, overallRiskScore, caps });
+    res.json({ entries, overallRiskScore, caps, bands });
   });
   return router;
 }
@@ -11286,21 +11456,21 @@ function buildOwnershipRouter(ctx) {
 
 // server/routes/file.ts
 import { Router as Router7 } from "express";
-import fs27 from "fs/promises";
-import path32 from "path";
+import fs28 from "fs/promises";
+import path33 from "path";
 function buildFileRouter(ctx) {
   const router = Router7();
   router.get("/", async (req, res) => {
     const rel = req.query.path;
     if (!rel) return res.status(400).json({ error: "missing path" });
-    const abs = path32.resolve(ctx.root, rel);
-    const rootBoundary = ctx.root.endsWith(path32.sep) ? ctx.root : ctx.root + path32.sep;
+    const abs = path33.resolve(ctx.root, rel);
+    const rootBoundary = ctx.root.endsWith(path33.sep) ? ctx.root : ctx.root + path33.sep;
     if (abs !== ctx.root && !abs.startsWith(rootBoundary)) {
       return res.status(403).json({ error: "forbidden" });
     }
     try {
-      const content = await fs27.readFile(abs, "utf-8");
-      const ext = path32.extname(abs).slice(1);
+      const content = await fs28.readFile(abs, "utf-8");
+      const ext = path33.extname(abs).slice(1);
       res.json({ content, lines: content.split("\n").length, ext });
     } catch {
       res.status(404).json({ error: "not found" });
@@ -11312,7 +11482,7 @@ function buildFileRouter(ctx) {
 // server/routes/open.ts
 import { Router as Router8 } from "express";
 import { execFile as execFile2 } from "child_process";
-import path33 from "path";
+import path34 from "path";
 function tryOpen(bin, abs) {
   return new Promise((resolve) => {
     execFile2(bin, [abs], { timeout: 5e3 }, (err) => resolve(!err));
@@ -11323,8 +11493,8 @@ function buildOpenRouter(ctx) {
   router.post("/", async (req, res) => {
     const rel = req.body?.path;
     if (!rel || typeof rel !== "string") return res.status(400).json({ error: "missing path" });
-    const abs = path33.resolve(ctx.root, rel);
-    const rootBoundary = ctx.root.endsWith(path33.sep) ? ctx.root : ctx.root + path33.sep;
+    const abs = path34.resolve(ctx.root, rel);
+    const rootBoundary = ctx.root.endsWith(path34.sep) ? ctx.root : ctx.root + path34.sep;
     if (abs !== ctx.root && !abs.startsWith(rootBoundary)) {
       return res.status(403).json({ error: "forbidden" });
     }
@@ -11336,8 +11506,8 @@ function buildOpenRouter(ctx) {
 
 // server/routes/tokens.ts
 import { Router as Router9 } from "express";
-import path34 from "path";
-import fs28 from "fs";
+import path35 from "path";
+import fs29 from "fs";
 var CHARS_PER_TOKEN = 4;
 var cache = null;
 function buildTokensRouter(ctx) {
@@ -11352,9 +11522,9 @@ function buildTokensRouter(ctx) {
     let fullChars = 0;
     let skeletonChars = 0;
     for (const file of files) {
-      const absPath = path34.join(ctx.root, file);
+      const absPath = path35.join(ctx.root, file);
       try {
-        const content = fs28.readFileSync(absPath, "utf-8");
+        const content = fs29.readFileSync(absPath, "utf-8");
         fullChars += content.length;
         const skeleton = await skeletonizer.skeletonize(absPath);
         skeletonChars += skeleton.length;
@@ -11406,19 +11576,66 @@ function buildTrendsRouter(ctx) {
   return router;
 }
 
-// server/routes/projects.ts
+// server/routes/file-trends.ts
 import { Router as Router11 } from "express";
-import path36 from "path";
+var RANGE_TO_SECONDS2 = {
+  "7d": 7 * 24 * 3600,
+  "30d": 30 * 24 * 3600,
+  "90d": 90 * 24 * 3600
+};
+function parseRange2(raw) {
+  if (raw === "7d" || raw === "30d" || raw === "90d" || raw === "all") return raw;
+  return "90d";
+}
+function parseLimit2(raw) {
+  const n = typeof raw === "string" ? Number.parseInt(raw, 10) : NaN;
+  if (!Number.isFinite(n) || n < 1) return 200;
+  return Math.min(n, 2e3);
+}
+function buildFileTrendsRouter(ctx) {
+  const router = Router11();
+  router.get("/file", async (req, res) => {
+    const filePath = typeof req.query.path === "string" ? req.query.path : "";
+    if (!filePath) {
+      return res.status(400).json({ error: "missing required query param 'path'" });
+    }
+    const range = parseRange2(req.query.range);
+    const limit = parseLimit2(req.query.limit);
+    const sinceUnixSeconds = range === "all" ? 0 : Math.floor(Date.now() / 1e3) - RANGE_TO_SECONDS2[range];
+    const history = await loadFileRiskHistory({
+      rootDir: ctx.root,
+      file: filePath,
+      sinceUnixSeconds,
+      limit
+    });
+    const body = {
+      file: history.file,
+      points: history.points.map((p) => ({
+        unixSeconds: p.unixSeconds,
+        score: p.score,
+        label: p.label
+      })),
+      totalCount: history.totalCount,
+      gitEnabled: ctx.gitEnabled
+    };
+    res.json(body);
+  });
+  return router;
+}
+
+// server/routes/projects.ts
+import { Router as Router12 } from "express";
+import path37 from "path";
 
 // server/projects.ts
 import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import os4 from "os";
-import path35 from "path";
+import path36 from "path";
 import crypto5 from "crypto";
 var HOME = os4.homedir();
-var REGISTRY_PATH = path35.join(HOME, ".ctxloom", "repos.json");
+var REGISTRY_PATH = path36.join(HOME, ".ctxloom", "repos.json");
 function slugFor(root) {
-  const abs = path35.resolve(root);
+  const abs = path36.resolve(root);
   return crypto5.createHash("sha1").update(abs).digest("hex").slice(0, 12);
 }
 function readRegistry() {
@@ -11433,27 +11650,27 @@ function readRegistry() {
   }
 }
 function listProjects(defaultRoot) {
-  const absDefault = path35.resolve(defaultRoot);
+  const absDefault = path36.resolve(defaultRoot);
   const out = [
     {
       slug: slugFor(absDefault),
-      name: path35.basename(absDefault) || absDefault,
+      name: path36.basename(absDefault) || absDefault,
       root: absDefault,
       isDefault: true,
-      hasSnapshot: existsSync2(path35.join(absDefault, ".ctxloom"))
+      hasSnapshot: existsSync2(path36.join(absDefault, ".ctxloom"))
     }
   ];
   const seen = /* @__PURE__ */ new Set([absDefault]);
   for (const entry of readRegistry()) {
-    const abs = path35.resolve(entry.root);
+    const abs = path36.resolve(entry.root);
     if (seen.has(abs)) continue;
     seen.add(abs);
     out.push({
       slug: slugFor(abs),
-      name: entry.name ?? (path35.basename(abs) || abs),
+      name: entry.name ?? (path36.basename(abs) || abs),
       root: abs,
       isDefault: false,
-      hasSnapshot: existsSync2(path35.join(abs, ".ctxloom"))
+      hasSnapshot: existsSync2(path36.join(abs, ".ctxloom"))
     });
   }
   return out;
@@ -11462,7 +11679,7 @@ function listProjects(defaultRoot) {
 // server/routes/projects.ts
 function buildProjectsRouter(deps) {
   const { ctx, defaultRoot, onActiveChanged } = deps;
-  const router = Router11();
+  const router = Router12();
   function annotated() {
     const activeSlug = slugFor(ctx.root);
     return listProjects(defaultRoot).map((p) => ({
@@ -11504,7 +11721,7 @@ function buildProjectsRouter(deps) {
     } catch (err) {
       const detail = err instanceof Error ? err.message : String(err);
       res.status(500).json({
-        error: `failed to switch to ${path36.basename(target.root)}: ${detail}`
+        error: `failed to switch to ${path37.basename(target.root)}: ${detail}`
       });
     }
   });
@@ -11512,7 +11729,7 @@ function buildProjectsRouter(deps) {
 }
 
 // server/index.ts
-var __dirname2 = path37.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path38.dirname(fileURLToPath2(import.meta.url));
 async function startDashboard(options) {
   const { root, port, open } = options;
   console.log(`ctxloom dashboard \u2014 loading context from ${root}...`);
@@ -11541,6 +11758,7 @@ async function startDashboard(options) {
   app.use("/api/open", buildOpenRouter(ctx));
   app.use("/api/tokens", buildTokensRouter(ctx));
   app.use("/api/trends", buildTrendsRouter(ctx));
+  app.use("/api/trends", buildFileTrendsRouter(ctx));
   app.get("/api/health", (_req, res) => res.json({ ok: true, gitEnabled: ctx.gitEnabled }));
   app.get("/api/status", (_req, res) => res.json({
     lastIndexed: ctx.lastIndexed.toISOString(),
@@ -11570,9 +11788,9 @@ async function startDashboard(options) {
       }
       activeWatcher = null;
     }
-    const snapshotDir = path37.join(targetRoot, ".ctxloom");
+    const snapshotDir = path38.join(targetRoot, ".ctxloom");
     try {
-      activeWatcher = fs29.watch(snapshotDir, (_event, filename) => {
+      activeWatcher = fs30.watch(snapshotDir, (_event, filename) => {
         if (!filename || !filename.includes("snapshot")) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(async () => {
@@ -11600,11 +11818,20 @@ async function startDashboard(options) {
       attachSnapshotWatcher(newRoot);
     }
   }));
-  const clientDist = path37.join(__dirname2, "../dashboard/client");
-  app.use(express.static(clientDist, { dotfiles: "allow" }));
-  app.get(/.*/, (_req, res) => {
-    res.sendFile(path37.join(clientDist, "index.html"), { dotfiles: "allow" });
-  });
+  const clientDist = path38.join(__dirname2, "../dashboard/client");
+  const clientDistExists = fs30.existsSync(path38.join(clientDist, "index.html"));
+  if (clientDistExists) {
+    app.use(express.static(clientDist, { dotfiles: "allow" }));
+    app.get(/.*/, (_req, res) => {
+      res.sendFile(path38.join(clientDist, "index.html"), { dotfiles: "allow" });
+    });
+  } else {
+    app.get(/^\/(?!api\/).*/, (_req, res) => {
+      res.status(404).type("text/plain").send(
+        "Dashboard client bundle not found. In dev: open http://localhost:5173. For a production preview from this port, run `npm run build:client -w @ctxloom/dashboard`."
+      );
+    });
+  }
   app.listen(port, () => {
     const url = `http://localhost:${port}`;
     console.log(`