truecourse 0.4.2 → 0.4.4

package/server.mjs

@@ -17990,17 +17990,17 @@ var require_router = __commonJS({
     var toString = Object.prototype.toString;
     var proto = module.exports = function(options) {
       var opts = options || {};
-      function router9(req, res, next) {
-        router9.handle(req, res, next);
-      }
-      setPrototypeOf(router9, proto);
-      router9.params = {};
-      router9._params = [];
-      router9.caseSensitive = opts.caseSensitive;
-      router9.mergeParams = opts.mergeParams;
-      router9.strict = opts.strict;
-      router9.stack = [];
-      return router9;
+      function router10(req, res, next) {
+        router10.handle(req, res, next);
+      }
+      setPrototypeOf(router10, proto);
+      router10.params = {};
+      router10._params = [];
+      router10.caseSensitive = opts.caseSensitive;
+      router10.mergeParams = opts.mergeParams;
+      router10.strict = opts.strict;
+      router10.stack = [];
+      return router10;
     };
     proto.param = function param(name, fn) {
       if (typeof name === "function") {
@@ -20592,7 +20592,7 @@ var require_application = __commonJS({
   "node_modules/.pnpm/express@4.22.1/node_modules/express/lib/application.js"(exports, module) {
     "use strict";
     var finalhandler = require_finalhandler();
-    var Router9 = require_router();
+    var Router10 = require_router();
     var methods = require_methods();
     var middleware = require_init();
     var query = require_query();
@@ -20657,7 +20657,7 @@ var require_application = __commonJS({
     };
     app.lazyrouter = function lazyrouter() {
       if (!this._router) {
-        this._router = new Router9({
+        this._router = new Router10({
           caseSensitive: this.enabled("case sensitive routing"),
           strict: this.enabled("strict routing")
         });
@@ -20666,17 +20666,17 @@ var require_application = __commonJS({
       }
     };
     app.handle = function handle(req, res, callback) {
-      var router9 = this._router;
+      var router10 = this._router;
       var done = callback || finalhandler(req, res, {
         env: this.get("env"),
         onerror: logerror.bind(this)
       });
-      if (!router9) {
+      if (!router10) {
         debug2("no routes defined on app");
         done();
         return;
       }
-      router9.handle(req, res, done);
+      router10.handle(req, res, done);
     };
     app.use = function use(fn) {
       var offset = 0;
@@ -20696,15 +20696,15 @@ var require_application = __commonJS({
         throw new TypeError("app.use() requires a middleware function");
       }
       this.lazyrouter();
-      var router9 = this._router;
+      var router10 = this._router;
       fns.forEach(function(fn2) {
         if (!fn2 || !fn2.handle || !fn2.set) {
-          return router9.use(path17, fn2);
+          return router10.use(path17, fn2);
         }
         debug2(".use app under %s", path17);
         fn2.mountpath = path17;
         fn2.parent = this;
-        router9.use(path17, function mounted_app(req, res, next) {
+        router10.use(path17, function mounted_app(req, res, next) {
           var orig = req.app;
           fn2.handle(req, res, function(err) {
             setPrototypeOf(req, orig.request);
@@ -22521,7 +22521,7 @@ var require_express = __commonJS({
     var mixin = require_merge_descriptors();
     var proto = require_application();
     var Route = require_route();
-    var Router9 = require_router();
+    var Router10 = require_router();
     var req = require_request();
     var res = require_response();
     exports = module.exports = createApplication;
@@ -22544,7 +22544,7 @@ var require_express = __commonJS({
     exports.request = req;
     exports.response = res;
     exports.Route = Route;
-    exports.Router = Router9;
+    exports.Router = Router10;
     exports.json = bodyParser.json;
     exports.query = require_query();
     exports.raw = bodyParser.raw;
@@ -40157,6 +40157,219 @@ var require_dist4 = __commonJS({
   }
 });
 
+// apps/server/src/lib/atomic-write.ts
+import fs6 from "node:fs";
+import path5 from "node:path";
+function atomicWriteJson(targetPath, data) {
+  fs6.mkdirSync(path5.dirname(targetPath), { recursive: true });
+  const tmp = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
+  fs6.writeFileSync(tmp, JSON.stringify(data, null, 2));
+  fs6.renameSync(tmp, targetPath);
+}
+function lockPath(repoPath) {
+  return path5.join(repoPath, ".truecourse", LOCK_FILENAME);
+}
+function acquireAnalyzeLock(repoPath) {
+  const file = lockPath(repoPath);
+  fs6.mkdirSync(path5.dirname(file), { recursive: true });
+  try {
+    const fd = fs6.openSync(file, "wx");
+    fs6.writeSync(fd, `${process.pid}
+${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+    fs6.closeSync(fd);
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      let owner = null;
+      try {
+        owner = parseInt(fs6.readFileSync(file, "utf-8").split("\n")[0], 10) || null;
+      } catch {
+      }
+      throw new AnalyzeLockError(repoPath, owner);
+    }
+    throw err;
+  }
+}
+function releaseAnalyzeLock(repoPath) {
+  try {
+    fs6.unlinkSync(lockPath(repoPath));
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+var LOCK_FILENAME, AnalyzeLockError;
+var init_atomic_write = __esm({
+  "apps/server/src/lib/atomic-write.ts"() {
+    "use strict";
+    LOCK_FILENAME = ".analyze.lock";
+    AnalyzeLockError = class extends Error {
+      constructor(repoPath, ownerPid) {
+        const who = ownerPid != null ? ` (held by pid ${ownerPid})` : "";
+        super(
+          `Another analyze is already running for ${repoPath}${who}. If you're sure no analyze is in progress, remove ${lockPath(repoPath)} and retry.`
+        );
+        this.name = "AnalyzeLockError";
+      }
+    };
+  }
+});
+
+// apps/server/src/lib/analysis-store.ts
+var analysis_store_exports = {};
+__export(analysis_store_exports, {
+  analysisFilePath: () => analysisFilePath,
+  appendHistory: () => appendHistory,
+  buildAnalysisFilename: () => buildAnalysisFilename,
+  clearLatestCache: () => clearLatestCache,
+  deleteAnalysis: () => deleteAnalysis,
+  deleteDiff: () => deleteDiff,
+  deleteLatest: () => deleteLatest,
+  diffPath: () => diffPath,
+  findAnalysisFilename: () => findAnalysisFilename,
+  historyPath: () => historyPath,
+  latestPath: () => latestPath,
+  listAnalyses: () => listAnalyses,
+  readAnalysis: () => readAnalysis,
+  readDiff: () => readDiff,
+  readHistory: () => readHistory,
+  readLatest: () => readLatest,
+  removeFromHistory: () => removeFromHistory,
+  writeAnalysis: () => writeAnalysis,
+  writeDiff: () => writeDiff,
+  writeLatest: () => writeLatest
+});
+import fs7 from "node:fs";
+import path6 from "node:path";
+function storeDir(repoPath) {
+  return path6.join(repoPath, TRUECOURSE_DIR2);
+}
+function analysesDir(repoPath) {
+  return path6.join(storeDir(repoPath), ANALYSES_DIR);
+}
+function analysisFilePath(repoPath, filename) {
+  return path6.join(analysesDir(repoPath), filename);
+}
+function latestPath(repoPath) {
+  return path6.join(storeDir(repoPath), LATEST_FILE);
+}
+function historyPath(repoPath) {
+  return path6.join(storeDir(repoPath), HISTORY_FILE);
+}
+function diffPath(repoPath) {
+  return path6.join(storeDir(repoPath), DIFF_FILE);
+}
+function buildAnalysisFilename(analysisId, createdAt) {
+  const iso = createdAt.replace(/[:.]/g, "-").replace(/-\d{3}Z$/, "Z");
+  const shortId = analysisId.replace(/-/g, "").slice(0, 8);
+  return `${iso}_${shortId}.json`;
+}
+function readLatest(repoPath) {
+  const file = latestPath(repoPath);
+  let mtime;
+  try {
+    mtime = fs7.statSync(file).mtimeMs;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      latestCache.delete(repoPath);
+      return null;
+    }
+    throw err;
+  }
+  const cached = latestCache.get(repoPath);
+  if (cached && cached.mtime === mtime) return cached.data;
+  const data = JSON.parse(fs7.readFileSync(file, "utf-8"));
+  latestCache.set(repoPath, { mtime, data });
+  return data;
+}
+function writeLatest(repoPath, latest) {
+  atomicWriteJson(latestPath(repoPath), latest);
+  latestCache.delete(repoPath);
+}
+function deleteLatest(repoPath) {
+  try {
+    fs7.unlinkSync(latestPath(repoPath));
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  latestCache.delete(repoPath);
+}
+function writeAnalysis(repoPath, snapshot) {
+  const filename = buildAnalysisFilename(snapshot.id, snapshot.createdAt);
+  atomicWriteJson(analysisFilePath(repoPath, filename), snapshot);
+  return { filename, snapshot };
+}
+function readAnalysis(repoPath, filename) {
+  const file = analysisFilePath(repoPath, filename);
+  if (!fs7.existsSync(file)) return null;
+  return JSON.parse(fs7.readFileSync(file, "utf-8"));
+}
+function listAnalyses(repoPath) {
+  const dir = analysesDir(repoPath);
+  if (!fs7.existsSync(dir)) return [];
+  return fs7.readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
+}
+function findAnalysisFilename(repoPath, analysisId) {
+  for (const name of listAnalyses(repoPath).reverse()) {
+    const snap = readAnalysis(repoPath, name);
+    if (snap?.id === analysisId) return name;
+  }
+  return null;
+}
+function deleteAnalysis(repoPath, filename) {
+  try {
+    fs7.unlinkSync(analysisFilePath(repoPath, filename));
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+function readHistory(repoPath) {
+  const file = historyPath(repoPath);
+  if (!fs7.existsSync(file)) return { analyses: [] };
+  return JSON.parse(fs7.readFileSync(file, "utf-8"));
+}
+function appendHistory(repoPath, entry) {
+  const history = readHistory(repoPath);
+  history.analyses.push(entry);
+  atomicWriteJson(historyPath(repoPath), history);
+}
+function removeFromHistory(repoPath, analysisId) {
+  const history = readHistory(repoPath);
+  const next = history.analyses.filter((a) => a.id !== analysisId);
+  if (next.length === history.analyses.length) return;
+  atomicWriteJson(historyPath(repoPath), { analyses: next });
+}
+function readDiff(repoPath) {
+  const file = diffPath(repoPath);
+  if (!fs7.existsSync(file)) return null;
+  return JSON.parse(fs7.readFileSync(file, "utf-8"));
+}
+function writeDiff(repoPath, diff) {
+  atomicWriteJson(diffPath(repoPath), diff);
+}
+function deleteDiff(repoPath) {
+  try {
+    fs7.unlinkSync(diffPath(repoPath));
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+function clearLatestCache() {
+  latestCache.clear();
+}
+var TRUECOURSE_DIR2, ANALYSES_DIR, LATEST_FILE, HISTORY_FILE, DIFF_FILE, latestCache;
+var init_analysis_store = __esm({
+  "apps/server/src/lib/analysis-store.ts"() {
+    "use strict";
+    init_atomic_write();
+    TRUECOURSE_DIR2 = ".truecourse";
+    ANALYSES_DIR = "analyses";
+    LATEST_FILE = "LATEST.json";
+    HISTORY_FILE = "history.json";
+    DIFF_FILE = "diff.json";
+    latestCache = /* @__PURE__ */ new Map();
+  }
+});
+
 // node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js
 var require_ignore = __commonJS({
   "node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js"(exports, module) {
@@ -45316,7 +45529,7 @@ var init_escape = __esm({
 });
 
 // node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/index.js
-var minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
+var minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path7, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
 var init_esm3 = __esm({
   "node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/index.js"() {
     init_esm2();
@@ -45385,11 +45598,11 @@ var init_esm3 = __esm({
       return (f2) => f2.length === len && f2 !== "." && f2 !== "..";
     };
     defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-    path5 = {
+    path7 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    sep = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
+    sep = defaultPlatform === "win32" ? path7.win32.sep : path7.posix.sep;
     minimatch.sep = sep;
     GLOBSTAR = Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
@@ -47435,7 +47648,7 @@ var init_database_detector = __esm({
 });
 
 // packages/analyzer/dist/module-extractor.js
-import path6 from "path";
+import path8 from "path";
 function extractModulesAndMethods(analyses, layerDetails, fileDependencies) {
   const modules = [];
   const methods = [];
@@ -47582,7 +47795,7 @@ function deriveModuleName(analysis) {
     return localExports[0].name;
   }
   const baseName = fileBaseName(analysis.filePath);
-  const strippedName = stripExtension(path6.basename(analysis.filePath));
+  const strippedName = stripExtension(path8.basename(analysis.filePath));
   if (INDEX_NAMES.has(strippedName)) {
     return baseName;
   }
@@ -47599,10 +47812,10 @@ function deriveModuleName(analysis) {
   return baseName;
 }
 function deriveNextjsRouteName(filePath) {
-  const base = path6.basename(filePath).replace(/\.(ts|tsx|js|jsx)$/, "");
+  const base = path8.basename(filePath).replace(/\.(ts|tsx|js|jsx)$/, "");
   if (base !== "route" && base !== "page")
     return null;
-  const parts = filePath.split(path6.sep);
+  const parts = filePath.split(path8.sep);
   const appIdx = parts.lastIndexOf("app");
   if (appIdx === -1)
     return null;
@@ -47620,9 +47833,9 @@ function stripExtension(filename) {
   return filename;
 }
 function fileBaseName(filePath) {
-  const name = stripExtension(path6.basename(filePath));
+  const name = stripExtension(path8.basename(filePath));
   if (INDEX_NAMES.has(name)) {
-    return path6.basename(path6.dirname(filePath));
+    return path8.basename(path8.dirname(filePath));
   }
   return name;
 }
@@ -74385,10 +74598,10 @@ var init_secret_rules = __esm({
 });
 
 // packages/analyzer/dist/rules/security/secret-scanner.js
-import path7 from "node:path";
+import path9 from "node:path";
 function isSensitiveFile(filePath) {
-  const basename2 = path7.basename(filePath);
-  const ext2 = path7.extname(filePath);
+  const basename2 = path9.basename(filePath);
+  const ext2 = path9.extname(filePath);
   if (basename2.startsWith(".env")) {
     const envVariant = basename2;
     if (SENSITIVE_FILE_EXTENSIONS.has(envVariant)) {
@@ -123988,211 +124201,6 @@ var init_dist2 = __esm({
   }
 });
 
-// apps/server/src/lib/atomic-write.ts
-import fs6 from "node:fs";
-import path9 from "node:path";
-function atomicWriteJson(targetPath, data) {
-  fs6.mkdirSync(path9.dirname(targetPath), { recursive: true });
-  const tmp = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
-  fs6.writeFileSync(tmp, JSON.stringify(data, null, 2));
-  fs6.renameSync(tmp, targetPath);
-}
-function lockPath(repoPath) {
-  return path9.join(repoPath, ".truecourse", LOCK_FILENAME);
-}
-function acquireAnalyzeLock(repoPath) {
-  const file = lockPath(repoPath);
-  fs6.mkdirSync(path9.dirname(file), { recursive: true });
-  try {
-    const fd = fs6.openSync(file, "wx");
-    fs6.writeSync(fd, `${process.pid}
-${(/* @__PURE__ */ new Date()).toISOString()}
-`);
-    fs6.closeSync(fd);
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      let owner = null;
-      try {
-        owner = parseInt(fs6.readFileSync(file, "utf-8").split("\n")[0], 10) || null;
-      } catch {
-      }
-      throw new AnalyzeLockError(repoPath, owner);
-    }
-    throw err;
-  }
-}
-function releaseAnalyzeLock(repoPath) {
-  try {
-    fs6.unlinkSync(lockPath(repoPath));
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-}
-var LOCK_FILENAME, AnalyzeLockError;
-var init_atomic_write = __esm({
-  "apps/server/src/lib/atomic-write.ts"() {
-    "use strict";
-    LOCK_FILENAME = ".analyze.lock";
-    AnalyzeLockError = class extends Error {
-      constructor(repoPath, ownerPid) {
-        const who = ownerPid != null ? ` (held by pid ${ownerPid})` : "";
-        super(
-          `Another analyze is already running for ${repoPath}${who}. If you're sure no analyze is in progress, remove ${lockPath(repoPath)} and retry.`
-        );
-        this.name = "AnalyzeLockError";
-      }
-    };
-  }
-});
-
-// apps/server/src/lib/analysis-store.ts
-var analysis_store_exports = {};
-__export(analysis_store_exports, {
-  analysisFilePath: () => analysisFilePath,
-  appendHistory: () => appendHistory,
-  buildAnalysisFilename: () => buildAnalysisFilename,
-  clearLatestCache: () => clearLatestCache,
-  deleteAnalysis: () => deleteAnalysis,
-  deleteDiff: () => deleteDiff,
-  deleteLatest: () => deleteLatest,
-  diffPath: () => diffPath,
-  historyPath: () => historyPath,
-  latestPath: () => latestPath,
-  listAnalyses: () => listAnalyses,
-  readAnalysis: () => readAnalysis,
-  readDiff: () => readDiff,
-  readHistory: () => readHistory,
-  readLatest: () => readLatest,
-  removeFromHistory: () => removeFromHistory,
-  writeAnalysis: () => writeAnalysis,
-  writeDiff: () => writeDiff,
-  writeLatest: () => writeLatest
-});
-import fs7 from "node:fs";
-import path10 from "node:path";
-function storeDir(repoPath) {
-  return path10.join(repoPath, TRUECOURSE_DIR2);
-}
-function analysesDir(repoPath) {
-  return path10.join(storeDir(repoPath), ANALYSES_DIR);
-}
-function analysisFilePath(repoPath, filename) {
-  return path10.join(analysesDir(repoPath), filename);
-}
-function latestPath(repoPath) {
-  return path10.join(storeDir(repoPath), LATEST_FILE);
-}
-function historyPath(repoPath) {
-  return path10.join(storeDir(repoPath), HISTORY_FILE);
-}
-function diffPath(repoPath) {
-  return path10.join(storeDir(repoPath), DIFF_FILE);
-}
-function buildAnalysisFilename(analysisId, createdAt) {
-  const iso = createdAt.replace(/[:.]/g, "-").replace(/-\d{3}Z$/, "Z");
-  const shortId = analysisId.replace(/-/g, "").slice(0, 8);
-  return `${iso}_${shortId}.json`;
-}
-function readLatest(repoPath) {
-  const file = latestPath(repoPath);
-  let mtime;
-  try {
-    mtime = fs7.statSync(file).mtimeMs;
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      latestCache.delete(repoPath);
-      return null;
-    }
-    throw err;
-  }
-  const cached = latestCache.get(repoPath);
-  if (cached && cached.mtime === mtime) return cached.data;
-  const data = JSON.parse(fs7.readFileSync(file, "utf-8"));
-  latestCache.set(repoPath, { mtime, data });
-  return data;
-}
-function writeLatest(repoPath, latest) {
-  atomicWriteJson(latestPath(repoPath), latest);
-  latestCache.delete(repoPath);
-}
-function deleteLatest(repoPath) {
-  try {
-    fs7.unlinkSync(latestPath(repoPath));
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-  latestCache.delete(repoPath);
-}
-function writeAnalysis(repoPath, snapshot) {
-  const filename = buildAnalysisFilename(snapshot.id, snapshot.createdAt);
-  atomicWriteJson(analysisFilePath(repoPath, filename), snapshot);
-  return { filename, snapshot };
-}
-function readAnalysis(repoPath, filename) {
-  const file = analysisFilePath(repoPath, filename);
-  if (!fs7.existsSync(file)) return null;
-  return JSON.parse(fs7.readFileSync(file, "utf-8"));
-}
-function listAnalyses(repoPath) {
-  const dir = analysesDir(repoPath);
-  if (!fs7.existsSync(dir)) return [];
-  return fs7.readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
-}
-function deleteAnalysis(repoPath, filename) {
-  try {
-    fs7.unlinkSync(analysisFilePath(repoPath, filename));
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-}
-function readHistory(repoPath) {
-  const file = historyPath(repoPath);
-  if (!fs7.existsSync(file)) return { analyses: [] };
-  return JSON.parse(fs7.readFileSync(file, "utf-8"));
-}
-function appendHistory(repoPath, entry) {
-  const history = readHistory(repoPath);
-  history.analyses.push(entry);
-  atomicWriteJson(historyPath(repoPath), history);
-}
-function removeFromHistory(repoPath, analysisId) {
-  const history = readHistory(repoPath);
-  const next = history.analyses.filter((a) => a.id !== analysisId);
-  if (next.length === history.analyses.length) return;
-  atomicWriteJson(historyPath(repoPath), { analyses: next });
-}
-function readDiff(repoPath) {
-  const file = diffPath(repoPath);
-  if (!fs7.existsSync(file)) return null;
-  return JSON.parse(fs7.readFileSync(file, "utf-8"));
-}
-function writeDiff(repoPath, diff) {
-  atomicWriteJson(diffPath(repoPath), diff);
-}
-function deleteDiff(repoPath) {
-  try {
-    fs7.unlinkSync(diffPath(repoPath));
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-}
-function clearLatestCache() {
-  latestCache.clear();
-}
-var TRUECOURSE_DIR2, ANALYSES_DIR, LATEST_FILE, HISTORY_FILE, DIFF_FILE, latestCache;
-var init_analysis_store = __esm({
-  "apps/server/src/lib/analysis-store.ts"() {
-    "use strict";
-    init_atomic_write();
-    TRUECOURSE_DIR2 = ".truecourse";
-    ANALYSES_DIR = "analyses";
-    LATEST_FILE = "LATEST.json";
-    HISTORY_FILE = "history.json";
-    DIFF_FILE = "diff.json";
-    latestCache = /* @__PURE__ */ new Map();
-  }
-});
-
 // apps/server/src/services/analysis-registry.ts
 function registerAnalysis(repoId, analysisId) {
   const existing = activeAnalyses2.get(repoId);
@@ -139790,7 +139798,7 @@ var require_dagre = __commonJS({
 });
 
 // apps/server/src/index.ts
-var import_express9 = __toESM(require_express2(), 1);
+var import_express10 = __toESM(require_express2(), 1);
 var import_cors = __toESM(require_lib3(), 1);
 init_config();
 import fs12 from "node:fs";
@@ -140294,9 +140302,12 @@ var CreateRepoSchema = external_exports.object({
   path: external_exports.string().min(1)
 });
 var AnalyzeRepoSchema = external_exports.object({
-  branch: external_exports.string().optional(),
-  enabledCategories: external_exports.array(external_exports.string()).optional().default([]),
-  enableLlmRules: external_exports.boolean().optional().default(true),
+  /** Which mode to run — full analyze (HEAD committed state) or diff (working tree
+   *  vs LATEST). Required; no silent default. */
+  mode: external_exports.enum(["full", "diff"]),
+  /** Skip git ops (branch detection, commit hash read, pre-parse stash). Useful
+   *  for non-git dirs or test environments. No per-repo-config equivalent —
+   *  only way to opt out for a single run. */
   skipGit: external_exports.boolean().optional().default(false)
 });
 var GenerateViolationsSchema = external_exports.object({
@@ -140426,6 +140437,40 @@ function emitAnalysisCanceled(repoId) {
   const io3 = getIO();
   io3.to(`repo:${repoId}`).emit("analysis:canceled", { repoId });
 }
+function createSocketLlmEstimateHandler(repoId) {
+  return (estimate) => new Promise((resolve7) => {
+    const io3 = getIO();
+    const room = `repo:${repoId}`;
+    io3.to(room).emit("analysis:llm-estimate", {
+      repoId,
+      estimate: {
+        totalEstimatedTokens: estimate.totalEstimatedTokens,
+        tiers: estimate.tiers,
+        uniqueFileCount: estimate.uniqueFileCount,
+        uniqueRuleCount: estimate.uniqueRuleCount
+      }
+    });
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve7(true);
+    }, 6e4);
+    function onProceed(data) {
+      if (data.repoId !== repoId) return;
+      cleanup();
+      io3.to(room).emit("analysis:llm-resolved", { repoId, proceed: data.proceed });
+      resolve7(data.proceed);
+    }
+    function cleanup() {
+      clearTimeout(timeout);
+      for (const [, socket] of io3.sockets.sockets) {
+        socket.removeListener("analysis:llm-proceed", onProceed);
+      }
+    }
+    for (const [, socket] of io3.sockets.sockets) {
+      socket.on("analysis:llm-proceed", onProceed);
+    }
+  });
+}
 
 // apps/server/src/socket/index.ts
 var io2 = null;
@@ -145331,9 +145376,9 @@ router.get("/:id/config", async (req, res, next) => {
 });
 var repos_default = router;
 
-// apps/server/src/routes/analyze.ts
+// apps/server/src/routes/analyses.ts
 var import_express2 = __toESM(require_express2(), 1);
-import path13 from "node:path";
+import path14 from "node:path";
 
 // apps/server/src/config/current-project.ts
 function resolveProjectForRequest(slug) {
@@ -145347,11 +145392,14 @@ function resolveProjectForRequest(slug) {
 }
 
 // apps/server/src/commands/analyze-in-process.ts
+init_analysis_store();
+
+// apps/server/src/commands/analyze-core.ts
 init_logger();
 import { randomUUID as randomUUID6 } from "node:crypto";
 
 // apps/server/src/services/analyzer.service.ts
-import path8 from "node:path";
+import path10 from "node:path";
 init_logger();
 init_dist2();
 function runDeterministicModuleChecks(result, enabledDeterministic) {
@@ -145419,7 +145467,7 @@ async function runAnalysis(repoPath, _branch, onProgress, options) {
     const statusResult = await git.status();
     hasChanges = !statusResult.isClean();
     const gitRoot = (await git.revparse(["--show-toplevel"])).trim();
-    isSubdirectory = path8.resolve(repoPath) !== path8.resolve(gitRoot);
+    isSubdirectory = path10.resolve(repoPath) !== path10.resolve(gitRoot);
   }
   if (hasChanges && !options?.skipStash && !isSubdirectory && git) {
     onProgress({ step: "stash", percent: 2, detail: "Stashing pending changes to analyze committed state..." });
@@ -147808,7 +147856,7 @@ function processLlmCodeViolations(codeResult, validFilePaths, fileContents, allC
   }
 }
 
-// apps/server/src/commands/analyze-in-process.ts
+// apps/server/src/commands/analyze-core.ts
 init_provider();
 
 // apps/server/src/services/usage.service.ts
@@ -147828,10 +147876,10 @@ function toUsageRecords(records) {
   }));
 }
 
-// apps/server/src/commands/analyze-in-process.ts
+// apps/server/src/commands/analyze-core.ts
 init_analysis_store();
 init_atomic_write();
-async function analyzeInProcess(project, options = {}) {
+async function analyzeCore(project, options) {
   try {
     acquireAnalyzeLock(project.path);
   } catch (err) {
@@ -147839,22 +147887,37 @@ async function analyzeInProcess(project, options = {}) {
     throw err;
   }
   try {
-    const start = Date.now();
-    const { skipGit, signal } = options;
+    const { mode, signal } = options;
+    const isDiff2 = mode === "diff";
+    const skipGit = !isDiff2 && !!options.skipGit;
     const projectConfig = readProjectConfig(project.path);
+    const latestBaseline = readLatest(project.path);
+    if (isDiff2 && !latestBaseline) {
+      throw new Error("Run a full analysis first before checking a diff.");
+    }
     let branch = options.branch ?? null;
     let commitHash = options.commitHash ?? null;
-    if (!skipGit && (branch === null || commitHash === null)) {
+    if (isDiff2) {
+      branch = latestBaseline.analysis.branch ?? branch;
+      if (commitHash === null) {
+        try {
+          const git = await getGit(project.path);
+          commitHash = (await git.revparse(["HEAD"])).trim() || null;
+        } catch {
+          commitHash = null;
+        }
+      }
+    } else if (!skipGit && (branch === null || commitHash === null)) {
       const git = await getGit(project.path);
       if (branch === null) branch = (await git.branch()).current || null;
       if (commitHash === null) commitHash = (await git.revparse(["HEAD"])).trim();
     }
     const analysisId = randomUUID6();
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const filename = buildAnalysisFilename(analysisId, now);
+    const start = Date.now();
     const effectiveCategories = options.enabledCategoriesOverride?.length ? options.enabledCategoriesOverride : projectConfig.enabledCategories ?? void 0;
     const effectiveLlmRules = projectConfig.enableLlmRules ?? options.enableLlmRulesOverride ?? true;
-    options.tracker?.start("parse", "Starting analysis...");
+    options.tracker?.start("parse", isDiff2 ? "Analyzing working tree..." : "Starting analysis...");
     const result = await runAnalysis(
       project.path,
       branch ?? void 0,
@@ -147862,68 +147925,86 @@ async function analyzeInProcess(project, options = {}) {
         options.tracker?.detail("parse", progress.detail ?? "Analyzing...");
         options.onProgress?.({ detail: progress.detail });
       },
-      { signal }
+      { signal, skipStash: isDiff2 }
     );
-    if (signal?.aborted) throw new DOMException("Analysis cancelled", "AbortError");
-    const { graph, serviceIdMap, moduleIdMap, methodIdMap, dbIdMap } = buildGraph(result);
-    const previousLatest = readLatest(project.path);
-    const previousAnalysisId = previousLatest?.analysis.id ?? null;
-    const previousActiveViolations = previousLatest ? previousLatest.violations.filter(
-      (v) => branch == null || previousLatest.analysis.branch == null || previousLatest.analysis.branch === branch
-    ) : [];
-    try {
-      graph.flows = detectFlows(result);
-    } catch (flowError) {
-      log.error(`[Flows] Detection failed: ${flowError instanceof Error ? flowError.message : String(flowError)}`);
-      graph.flows = [];
+    if (signal?.aborted) {
+      throw new DOMException(isDiff2 ? "Diff cancelled" : "Analysis cancelled", "AbortError");
     }
-    touchProject(project.slug);
+    const { graph, serviceIdMap, moduleIdMap, methodIdMap, dbIdMap } = buildGraph(result);
+    let changedFiles = [];
     let changedFileSet;
-    if (previousLatest?.analysis.commitHash && !skipGit) {
+    if (isDiff2) {
       try {
         const git = await getGit(project.path);
-        const diffOutput = await git.diff([previousLatest.analysis.commitHash, "HEAD", "--name-only"]);
+        const statusResult = await git.status();
+        for (const f2 of statusResult.not_added) changedFiles.push({ path: f2, status: "new" });
+        for (const f2 of statusResult.created) changedFiles.push({ path: f2, status: "new" });
+        for (const f2 of statusResult.modified) changedFiles.push({ path: f2, status: "modified" });
+        for (const f2 of statusResult.staged) {
+          if (!changedFiles.some((cf) => cf.path === f2)) {
+            changedFiles.push({ path: f2, status: "modified" });
+          }
+        }
+        for (const f2 of statusResult.deleted) changedFiles.push({ path: f2, status: "deleted" });
+      } catch (err) {
+        log.warn(`[Diff] git status failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else if (latestBaseline?.analysis.commitHash && !skipGit) {
+      try {
+        const git = await getGit(project.path);
+        const diffOutput = await git.diff([latestBaseline.analysis.commitHash, "HEAD", "--name-only"]);
         const files = diffOutput.trim().split("\n").filter(Boolean);
         if (files.length > 0) changedFileSet = new Set(files);
       } catch {
       }
     }
+    if (!isDiff2) {
+      try {
+        graph.flows = detectFlows(result);
+      } catch (flowError) {
+        log.error(
+          `[Flows] Detection failed: ${flowError instanceof Error ? flowError.message : String(flowError)}`
+        );
+        graph.flows = [];
+      }
+      touchProject(project.slug);
+    }
     options.tracker?.done(
       "parse",
       `${result.services.length} services, ${result.fileAnalyses?.length ?? 0} files`
     );
+    const previousActiveViolations = latestBaseline ? latestBaseline.violations.filter(
+      (v) => branch == null || latestBaseline.analysis.branch == null || latestBaseline.analysis.branch === branch
+    ) : [];
+    const previousAnalysisId = latestBaseline?.analysis.id ?? null;
     const provider = options.provider ?? (effectiveLlmRules ? createLLMProvider() : void 0);
     if (provider) {
       provider.setAnalysisId(analysisId);
       provider.setRepoPath(project.path);
       if (signal) provider.setAbortSignal(signal);
     }
-    let pipelineResult;
-    try {
-      pipelineResult = await runViolationPipeline({
-        repoPath: project.path,
-        analysisId,
-        now,
-        result,
-        serviceIdMap,
-        moduleIdMap,
-        methodIdMap,
-        dbIdMap,
-        previousActiveViolations,
-        changedFileSet,
-        tracker: options.tracker,
-        enabledCategories: effectiveCategories,
-        enableLlmRules: effectiveLlmRules,
-        provider,
-        signal,
-        onLlmEstimate: options.onLlmEstimate ? async (estimate) => {
-          const proceed = await options.onLlmEstimate(estimate);
-          options.onLlmResolved?.(proceed);
-          return proceed;
-        } : void 0
-      });
-    } finally {
-    }
+    const pipelineResult = await runViolationPipeline({
+      repoPath: project.path,
+      analysisId,
+      now,
+      result,
+      serviceIdMap,
+      moduleIdMap,
+      methodIdMap,
+      dbIdMap,
+      previousActiveViolations,
+      changedFileSet,
+      tracker: options.tracker,
+      enabledCategories: effectiveCategories,
+      enableLlmRules: effectiveLlmRules,
+      provider,
+      signal,
+      onLlmEstimate: options.onLlmEstimate ? async (estimate) => {
+        const proceed = await options.onLlmEstimate(estimate);
+        options.onLlmResolved?.(proceed);
+        return proceed;
+      } : void 0
+    });
     if (pipelineResult.serviceDescriptions.length > 0) {
       for (const desc of pipelineResult.serviceDescriptions) {
         const svc = graph.services.find((s) => s.id === desc.id);
@@ -147934,56 +148015,100 @@ async function analyzeInProcess(project, options = {}) {
     enforceLocationInvariant(pipelineResult.added);
     enforceLocationInvariant(pipelineResult.unchanged);
     enforceLocationInvariant(pipelineResult.resolved);
-    const snapshot = {
-      id: analysisId,
-      createdAt: now,
+    log.info(
+      `[${isDiff2 ? "Diff" : "Analysis"}] core complete in ${Date.now() - start}ms \u2014 ${pipelineResult.added.length} added, ${pipelineResult.unchanged.length} unchanged, ${pipelineResult.resolvedRefs.length} resolved`
+    );
+    return {
+      mode,
+      analysisId,
+      now,
       branch,
       commitHash,
       architecture: result.architecture,
-      status: "completed",
       metadata: result.metadata ?? null,
       graph,
-      violations: {
-        added: pipelineResult.added,
-        resolved: pipelineResult.resolvedRefs,
-        previousAnalysisId
-      },
-      usage
-    };
-    const latest = buildLatestSnapshot(snapshot, filename, pipelineResult.unchanged, pipelineResult.added);
-    const { bySeverity, total } = summarizeActiveViolations(latest.violations);
-    writeAnalysis(project.path, snapshot);
-    writeLatest(project.path, latest);
-    const historyEntry = buildHistoryEntry(snapshot, filename, pipelineResult);
-    appendHistory(project.path, historyEntry);
-    deleteDiff(project.path);
-    setLastAnalyzed(project.slug, now);
-    return {
-      analysisId,
-      filename,
-      serviceCount: result.services.length,
-      fileCount: result.fileAnalyses?.length ?? 0,
-      architecture: result.architecture,
-      durationMs: Date.now() - start,
-      violationsSummary: { total, bySeverity }
+      changedFiles,
+      pipelineResult,
+      usage,
+      latestBaseline,
+      previousAnalysisId,
+      analysisResult: result
     };
   } finally {
     releaseAnalyzeLock(project.path);
   }
 }
+function enforceLocationInvariant(violations) {
+  for (const v of violations) {
+    const hasFile = v.filePath != null;
+    const hasRange = v.lineStart != null && v.lineEnd != null;
+    if (hasFile === hasRange) continue;
+    log.warn(
+      `[Violations] ${v.ruleKey}: partial location (filePath=${v.filePath}, lineStart=${v.lineStart}, lineEnd=${v.lineEnd}) \u2014 dropping to uphold the location invariant`
+    );
+    v.filePath = null;
+    v.lineStart = null;
+    v.lineEnd = null;
+  }
+}
+
+// apps/server/src/commands/analyze-persist.ts
+init_logger();
+import path12 from "node:path";
+init_analysis_store();
+function persistFullAnalysis(project, core, startedAt) {
+  const filename = buildAnalysisFilename(core.analysisId, core.now);
+  const snapshot = {
+    id: core.analysisId,
+    createdAt: core.now,
+    branch: core.branch,
+    commitHash: core.commitHash,
+    architecture: core.architecture,
+    status: "completed",
+    metadata: core.metadata,
+    graph: core.graph,
+    violations: {
+      added: core.pipelineResult.added,
+      resolved: core.pipelineResult.resolvedRefs,
+      previousAnalysisId: core.previousAnalysisId
+    },
+    usage: core.usage
+  };
+  const latest = buildLatestSnapshot(
+    snapshot,
+    filename,
+    core.pipelineResult.unchanged,
+    core.pipelineResult.added
+  );
+  const { bySeverity, total } = summarizeActiveViolations(latest.violations);
+  writeAnalysis(project.path, snapshot);
+  writeLatest(project.path, latest);
+  appendHistory(project.path, buildHistoryEntry(snapshot, filename, core.pipelineResult));
+  deleteDiff(project.path);
+  setLastAnalyzed(project.slug, core.now);
+  return {
+    analysisId: core.analysisId,
+    filename,
+    serviceCount: core.graph.services.length,
+    fileCount: core.analysisResult.fileAnalyses?.length ?? 0,
+    architecture: core.architecture,
+    durationMs: Date.now() - startedAt,
+    violationsSummary: { total, bySeverity }
+  };
+}
+function persistDiffAnalysis(project, core) {
+  if (!core.latestBaseline) {
+    throw new Error("Diff persist requires a latestBaseline \u2014 analyzeCore should have enforced this.");
+  }
+  const diff = buildDiffSnapshot(project.path, core, core.latestBaseline);
+  writeDiff(project.path, diff);
+  log.info(
+    `[Diff] Done \u2014 ${diff.summary.newCount} new, ${diff.summary.unchangedCount} unchanged, ${diff.summary.resolvedCount} resolved across ${diff.changedFiles.length} changed files`
+  );
+  return { diff, isStale: false };
+}
 function buildLatestSnapshot(snapshot, filename, unchanged, added) {
-  const { graph } = snapshot;
-  const serviceById = new Map(graph.services.map((s) => [s.id, s.name]));
-  const moduleById = new Map(graph.modules.map((m) => [m.id, m.name]));
-  const methodById = new Map(graph.methods.map((m) => [m.id, m.name]));
-  const databaseById = new Map(graph.databases.map((d) => [d.id, d.name]));
-  const denormalize = (v) => ({
-    ...v,
-    targetServiceName: v.targetServiceId ? serviceById.get(v.targetServiceId) ?? null : null,
-    targetModuleName: v.targetModuleId ? moduleById.get(v.targetModuleId) ?? null : null,
-    targetMethodName: v.targetMethodId ? methodById.get(v.targetMethodId) ?? null : null,
-    targetDatabaseName: v.targetDatabaseId ? databaseById.get(v.targetDatabaseId) ?? null : null
-  });
+  const denormalize = makeDenormalizer(snapshot.graph);
   return {
     head: filename,
     analysis: {
@@ -147995,7 +148120,7 @@ function buildLatestSnapshot(snapshot, filename, unchanged, added) {
       metadata: snapshot.metadata,
       status: "completed"
     },
-    graph,
+    graph: snapshot.graph,
     violations: [...added.map(denormalize), ...unchanged.map(denormalize)]
   };
 }
@@ -148059,27 +148184,99 @@ function buildHistoryEntry(snapshot, filename, pipeline) {
     }
   };
 }
-function enforceLocationInvariant(violations) {
-  for (const v of violations) {
-    const hasFile = v.filePath != null;
-    const hasRange = v.lineStart != null && v.lineEnd != null;
-    if (hasFile === hasRange) continue;
-    log.warn(
-      `[Violations] ${v.ruleKey}: partial location (filePath=${v.filePath}, lineStart=${v.lineStart}, lineEnd=${v.lineEnd}) \u2014 dropping to uphold the location invariant`
-    );
-    v.filePath = null;
-    v.lineStart = null;
-    v.lineEnd = null;
+function buildDiffSnapshot(repoPath, core, baseline) {
+  const { graph, changedFiles, pipelineResult } = core;
+  const denormalize = makeDenormalizer(graph);
+  const newViolations = pipelineResult.added.map(denormalize);
+  const latestById = new Map(baseline.violations.map((v) => [v.id, v]));
+  const resolvedViolations = pipelineResult.resolvedRefs.map((r) => latestById.get(r.id)).filter((v) => !!v);
+  const changedAbs = new Set(changedFiles.map((c) => path12.resolve(repoPath, c.path)));
+  const matchesChanged = (p) => !!p && (changedAbs.has(p) || changedAbs.has(path12.resolve(repoPath, p)));
+  const affectedModules = graph.modules.filter((m) => matchesChanged(m.filePath));
+  const affectedModuleIdSet = new Set(affectedModules.map((m) => m.id));
+  const serviceNameById = new Map(graph.services.map((s) => [s.id, s.name]));
+  const layerKeyById = new Map(
+    graph.layers.map((l) => [l.id, `${l.serviceName}::${l.layer}`])
+  );
+  const affectedServices = /* @__PURE__ */ new Set();
+  const affectedLayers = /* @__PURE__ */ new Set();
+  const affectedModuleKeys = /* @__PURE__ */ new Set();
+  for (const mod of affectedModules) {
+    const svcName = serviceNameById.get(mod.serviceId);
+    if (svcName) {
+      affectedServices.add(svcName);
+      affectedModuleKeys.add(`${svcName}::${mod.name}`);
+    }
+    const layerKey = layerKeyById.get(mod.layerId);
+    if (layerKey) affectedLayers.add(layerKey);
   }
+  const moduleNameById = new Map(graph.modules.map((m) => [m.id, m.name]));
+  const affectedMethodKeys = [];
+  for (const method of graph.methods) {
+    if (!affectedModuleIdSet.has(method.moduleId)) continue;
+    const modName = moduleNameById.get(method.moduleId);
+    const mod = graph.modules.find((m) => m.id === method.moduleId);
+    const svcName = mod ? serviceNameById.get(mod.serviceId) : void 0;
+    if (svcName && modName) affectedMethodKeys.push(`${svcName}::${modName}::${method.name}`);
+  }
+  return {
+    id: core.analysisId,
+    baseAnalysisId: baseline.analysis.id,
+    createdAt: core.now,
+    branch: core.branch,
+    commitHash: core.commitHash,
+    graph,
+    changedFiles,
+    newViolations,
+    resolvedViolations,
+    affectedNodeIds: {
+      services: [...affectedServices],
+      layers: [...affectedLayers],
+      modules: [...affectedModuleKeys],
+      methods: affectedMethodKeys
+    },
+    summary: {
+      newCount: newViolations.length,
+      unchangedCount: pipelineResult.unchanged.length,
+      resolvedCount: resolvedViolations.length
+    },
+    usage: core.usage
+  };
+}
+function makeDenormalizer(graph) {
+  const serviceById = new Map(graph.services.map((s) => [s.id, s.name]));
+  const moduleById = new Map(graph.modules.map((m) => [m.id, m.name]));
+  const methodById = new Map(graph.methods.map((m) => [m.id, m.name]));
+  const databaseById = new Map(graph.databases.map((d) => [d.id, d.name]));
+  return (v) => ({
+    ...v,
+    targetServiceName: v.targetServiceId ? serviceById.get(v.targetServiceId) ?? null : null,
+    targetModuleName: v.targetModuleId ? moduleById.get(v.targetModuleId) ?? null : null,
+    targetMethodName: v.targetMethodId ? methodById.get(v.targetMethodId) ?? null : null,
+    targetDatabaseName: v.targetDatabaseId ? databaseById.get(v.targetDatabaseId) ?? null : null
+  });
+}
+
+// apps/server/src/commands/analyze-in-process.ts
+async function analyzeInProcess(project, options = {}) {
+  const startedAt = Date.now();
+  const core = await analyzeCore(project, { ...options, mode: "full" });
+  return persistFullAnalysis(project, core, startedAt);
+}
+
+// apps/server/src/commands/diff-in-process.ts
+async function diffInProcess(project, options = {}) {
+  const core = await analyzeCore(project, { ...options, mode: "diff" });
+  return persistDiffAnalysis(project, core);
 }
 
-// apps/server/src/routes/analyze.ts
+// apps/server/src/routes/analyses.ts
 init_analysis_registry();
 init_provider();
 
 // apps/server/src/services/telemetry.service.ts
 import fs9 from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 import os3 from "node:os";
 import crypto from "node:crypto";
 
@@ -151868,7 +152065,7 @@ var DEFAULT_CONFIG = {
 var POSTHOG_API_KEY = "phc_ys9Ykf49KmNqAC3fhq3jugTejc4BDqyKqRS8qRoYZYew";
 var TOOL_VERSION = "0.2.2";
 function getTelemetryConfigPath() {
-  return path12.join(os3.homedir(), ".truecourse", "telemetry.json");
+  return path13.join(os3.homedir(), ".truecourse", "telemetry.json");
 }
 function readTelemetryConfig() {
   const configPath = getTelemetryConfigPath();
@@ -151892,7 +152089,7 @@ function readTelemetryConfig() {
 }
 function writeTelemetryConfig(partial) {
   const configPath = getTelemetryConfigPath();
-  const dir = path12.dirname(configPath);
+  const dir = path13.dirname(configPath);
   fs9.mkdirSync(dir, { recursive: true });
   let current;
   try {
@@ -151960,96 +152157,109 @@ function trackEvent(event, properties) {
   }
 }
 
-// apps/server/src/routes/analyze.ts
+// apps/server/src/services/violation-query.service.ts
+init_analysis_store();
+var SEVERITY_ORDER2 = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3,
+  info: 4
+};
+function listViolations(repoPath, options = {}) {
+  const latest = readLatest(repoPath);
+  if (!latest) return { violations: [], total: 0 };
+  if (options.analysisId && latest.analysis.id !== options.analysisId) {
+    return { violations: [], total: 0 };
+  }
+  const statusMode = options.status ?? "active";
+  let filtered;
+  if (statusMode === "resolved") {
+    filtered = latest.violations.filter((v) => v.status === "resolved");
+  } else if (statusMode === "all") {
+    filtered = latest.violations;
+  } else {
+    const active = ["new", "unchanged"];
+    filtered = latest.violations.filter((v) => active.includes(v.status));
+  }
+  if (options.filePath) {
+    const absPath = options.filePath.startsWith("/") ? options.filePath : `${repoPath}/${options.filePath}`;
+    filtered = filtered.filter(
+      (v) => v.type === "code" && (v.filePath === absPath || v.filePath === options.filePath)
+    );
+  }
+  filtered.sort((a, b) => {
+    const sa = SEVERITY_ORDER2[a.severity] ?? 5;
+    const sb = SEVERITY_ORDER2[b.severity] ?? 5;
+    if (sa !== sb) return sa - sb;
+    return b.createdAt.localeCompare(a.createdAt);
+  });
+  const total = filtered.length;
+  const limit = options.limit ?? 0;
+  const offset = options.offset ?? 0;
+  const paged = limit > 0 ? filtered.slice(offset, offset + limit) : filtered;
+  return { violations: paged, total };
+}
+function getDiffResult(repoPath) {
+  const diff = readDiff(repoPath);
+  if (!diff) return null;
+  const latest = readLatest(repoPath);
+  const isStale = latest ? latest.analysis.id !== diff.baseAnalysisId : false;
+  return { diff, isStale };
+}
+
+// apps/server/src/routes/analyses.ts
+init_analysis_store();
 init_logger();
 var router2 = (0, import_express2.Router)();
-router2.post("/:id/analyze", async (req, res, next) => {
+router2.post("/:id/analyses", async (req, res, next) => {
   try {
     const id = req.params.id;
     const parsed = AnalyzeRepoSchema.safeParse(req.body);
     if (!parsed.success) throw createAppError("Invalid request body", 400);
-    const { enabledCategories: globalEnabledCategories, enableLlmRules, skipGit } = parsed.data;
+    const { mode, skipGit } = parsed.data;
     const repo = resolveProjectForRequest(id);
+    if (mode === "diff" && !readLatest(repo.path)) {
+      throw createAppError("Run a full analysis first before checking a diff.", 400);
+    }
     const projectConfig = readProjectConfig(repo.path);
-    const effectiveCategories = globalEnabledCategories?.length ? globalEnabledCategories : projectConfig.enabledCategories ?? void 0;
-    const effectiveLlmRules = projectConfig.enableLlmRules ?? enableLlmRules;
+    const effectiveCategories = projectConfig.enabledCategories ?? void 0;
+    const effectiveLlmRules = projectConfig.enableLlmRules ?? true;
     const abortController = registerAnalysis(id, "pending");
-    res.status(202).json({
-      message: "Analysis started",
-      repoId: id
-    });
+    res.status(202).json({ message: `${mode === "diff" ? "Diff check" : "Analysis"} started`, repoId: id, mode });
     const trackerSteps = buildAnalysisSteps(effectiveCategories, effectiveLlmRules);
     const tracker = createSocketTracker(id, trackerSteps);
-    const provider = effectiveLlmRules ? createLLMProvider() : void 0;
-    if (provider) {
-      provider.setRepoId(id);
-      provider.setRepoPath(repo.path);
-      provider.setAbortSignal(abortController.signal);
-    }
     pushLogger({
-      filePath: path13.join(repo.path, ".truecourse/logs/analyze.log"),
+      filePath: path14.join(repo.path, ".truecourse/logs/analyze.log"),
       tee: process.env.TRUECOURSE_DEV === "1"
     });
     try {
-      const outcome = await analyzeInProcess(repo, {
-        skipGit,
-        enabledCategoriesOverride: effectiveCategories,
-        enableLlmRulesOverride: effectiveLlmRules,
-        tracker,
-        signal: abortController.signal,
-        provider,
-        onLlmEstimate: (estimate) => new Promise((resolve7) => {
-          const io3 = getIO();
-          const room = `repo:${id}`;
-          io3.to(room).emit("analysis:llm-estimate", {
-            repoId: id,
-            estimate: {
-              totalEstimatedTokens: estimate.totalEstimatedTokens,
-              tiers: estimate.tiers,
-              uniqueFileCount: estimate.uniqueFileCount,
-              uniqueRuleCount: estimate.uniqueRuleCount
-            }
-          });
-          const timeout = setTimeout(() => {
-            cleanup();
-            resolve7(true);
-          }, 6e4);
-          function onProceed(data) {
-            if (data.repoId !== id) return;
-            cleanup();
-            io3.to(room).emit("analysis:llm-resolved", { repoId: id, proceed: data.proceed });
-            resolve7(data.proceed);
-          }
-          function cleanup() {
-            clearTimeout(timeout);
-            for (const [, socket] of io3.sockets.sockets) {
-              socket.removeListener("analysis:llm-proceed", onProceed);
-            }
-          }
-          for (const [, socket] of io3.sockets.sockets) {
-            socket.on("analysis:llm-proceed", onProceed);
-          }
-        })
-      });
-      emitViolationsReady(id, outcome.analysisId);
-      emitAnalysisComplete(id, outcome.analysisId);
-      trackEvent("analyze", {
-        serviceCount: outcome.serviceCount,
-        fileCountRange: bucketFileCount(outcome.fileCount),
-        languages: [],
-        architecture: outcome.architecture,
-        durationRange: bucketDuration(outcome.durationMs)
-      });
+      if (mode === "full") {
+        await runFullAnalyze(id, repo, {
+          skipGit,
+          effectiveCategories,
+          effectiveLlmRules,
+          tracker,
+          signal: abortController.signal
+        });
+      } else {
+        await runDiffAnalyze(id, repo, {
+          tracker,
+          signal: abortController.signal
+        });
+      }
     } catch (error) {
       if (error instanceof DOMException && error.name === "AbortError") {
-        log.info(`[Analysis] Cancelled for repo ${id}`);
+        log.info(`[${mode === "diff" ? "Diff" : "Analysis"}] Cancelled for repo ${id}`);
         emitAnalysisCanceled(id);
       } else {
-        log.error(`[Analysis] Failed for repo ${id}: ${error instanceof Error ? error.message : String(error)}`);
+        log.error(
+          `[${mode === "diff" ? "Diff" : "Analysis"}] Failed for repo ${id}: ${error instanceof Error ? error.message : String(error)}`
+        );
         emitAnalysisProgress(id, {
           step: "error",
           percent: -1,
-          detail: error instanceof Error ? error.message : "Analysis failed"
+          detail: error instanceof Error ? error.message : `${mode === "diff" ? "Diff check" : "Analysis"} failed`
         });
       }
     } finally {
@@ -152060,7 +152270,7 @@ router2.post("/:id/analyze", async (req, res, next) => {
     next(error);
   }
 });
-router2.post("/:id/analyze/cancel", async (req, res, next) => {
+router2.post("/:id/analyses/cancel", async (req, res, next) => {
   try {
     const id = req.params.id;
     const canceled = cancelAnalysis(id);
@@ -152069,159 +152279,187 @@ router2.post("/:id/analyze/cancel", async (req, res, next) => {
     next(error);
   }
 });
-var analyze_default = router2;
-
-// apps/server/src/routes/analysis.ts
-var import_express3 = __toESM(require_express2(), 1);
-import fs11 from "node:fs";
-import path15 from "node:path";
-
-// apps/server/src/commands/diff-in-process.ts
-import path14 from "node:path";
-import { randomUUID as randomUUID7 } from "node:crypto";
-init_logger();
-init_analysis_store();
-async function diffInProcess(project, options = {}) {
-  const latest = readLatest(project.path);
-  if (!latest) {
-    throw new Error("Run a full analysis first before checking a diff.");
-  }
-  const projectConfig = readProjectConfig(project.path);
-  const enabledCategories = options.enabledCategoriesOverride ?? projectConfig.enabledCategories ?? void 0;
-  const enableLlmRules = options.enableLlmRulesOverride ?? projectConfig.enableLlmRules ?? false;
-  const git = await getGit(project.path);
-  const statusResult = await git.status();
-  const changedFiles = [];
-  for (const f2 of statusResult.not_added) changedFiles.push({ path: f2, status: "new" });
-  for (const f2 of statusResult.created) changedFiles.push({ path: f2, status: "new" });
-  for (const f2 of statusResult.modified) changedFiles.push({ path: f2, status: "modified" });
-  for (const f2 of statusResult.staged) {
-    if (!changedFiles.some((cf) => cf.path === f2)) {
-      changedFiles.push({ path: f2, status: "modified" });
-    }
-  }
-  for (const f2 of statusResult.deleted) changedFiles.push({ path: f2, status: "deleted" });
-  const commitHash = (await git.revparse(["HEAD"])).trim() || null;
-  options.tracker?.start("parse", "Analyzing working tree...");
-  const result = await runAnalysis(
-    project.path,
-    latest.analysis.branch ?? void 0,
-    (progress) => {
-      options.tracker?.detail("parse", progress.detail ?? "Analyzing...");
-      options.onProgress?.({ detail: progress.detail });
-    },
-    { signal: options.signal, skipStash: true }
-  );
-  if (options.signal?.aborted) throw new DOMException("Diff cancelled", "AbortError");
-  const { graph, serviceIdMap, moduleIdMap, methodIdMap, dbIdMap } = buildGraph(result);
-  const analysisId = randomUUID7();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  options.tracker?.done(
-    "parse",
-    `${result.services.length} services, ${result.fileAnalyses?.length ?? 0} files`
-  );
-  const pipelineResult = await runViolationPipeline({
-    repoPath: project.path,
-    analysisId,
-    now,
-    result,
-    serviceIdMap,
-    moduleIdMap,
-    methodIdMap,
-    dbIdMap,
-    previousActiveViolations: latest.violations,
-    enabledCategories,
-    enableLlmRules,
-    tracker: options.tracker,
-    signal: options.signal
+router2.get("/:id/analyses", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const repo = resolveProjectForRequest(id);
+    const history = readHistory(repo.path);
+    const entries = history.analyses.filter((e) => !e.metadata?.isDiffAnalysis).slice(-20).reverse();
+    res.json(
+      entries.map((e) => ({
+        id: e.id,
+        status: "completed",
+        branch: e.branch,
+        commitHash: e.commitHash,
+        architecture: null,
+        createdAt: e.createdAt,
+        serviceCount: e.counts.services,
+        violationsBySeverity: e.counts.violations.bySeverity,
+        durationMs: e.usage.durationMs,
+        totalTokens: e.usage.totalTokens,
+        totalCost: e.usage.totalCostUsd,
+        provider: e.usage.provider
+      }))
+    );
+  } catch (error) {
+    next(error);
+  }
+});
+router2.get("/:id/analyses/diff", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const repo = resolveProjectForRequest(id);
+    const result = getDiffResult(repo.path);
+    if (!result) {
+      res.json(null);
+      return;
+    }
+    const { diff, isStale } = result;
+    res.json({
+      resolvedViolations: diff.resolvedViolations,
+      newViolations: diff.newViolations,
+      affectedNodeIds: diff.affectedNodeIds,
+      summary: diff.summary,
+      changedFiles: diff.changedFiles,
+      isStale,
+      diffAnalysisId: diff.id
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+router2.get("/:id/analyses/:analysisId/usage", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const analysisId = req.params.analysisId;
+    const repo = resolveProjectForRequest(id);
+    const latest = readLatest(repo.path);
+    if (latest?.analysis.id === analysisId) {
+      const snap2 = readAnalysis(repo.path, latest.head);
+      res.json(snap2?.usage ?? []);
+      return;
+    }
+    const filename = findAnalysisFilename(repo.path, analysisId);
+    if (!filename) {
+      res.json([]);
+      return;
+    }
+    const snap = readAnalysis(repo.path, filename);
+    res.json(snap?.usage ?? []);
+  } catch (error) {
+    next(error);
+  }
+});
+router2.delete("/:id/analyses/:analysisId", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const analysisId = req.params.analysisId;
+    const repo = resolveProjectForRequest(id);
+    const filename = findAnalysisFilename(repo.path, analysisId);
+    if (!filename) throw createAppError("Analysis not found", 404);
+    deleteAnalysis(repo.path, filename);
+    removeFromHistory(repo.path, analysisId);
+    const latest = readLatest(repo.path);
+    if (latest?.head === filename) {
+      rebuildLatestFromHistory(repo.path);
+      deleteDiff(repo.path);
+    }
+    res.json({ ok: true });
+  } catch (error) {
+    next(error);
+  }
+});
+async function runFullAnalyze(id, repo, opts) {
+  const provider = opts.effectiveLlmRules ? createLLMProvider() : void 0;
+  if (provider) {
+    provider.setRepoId(id);
+    provider.setRepoPath(repo.path);
+    provider.setAbortSignal(opts.signal);
+  }
+  const outcome = await analyzeInProcess(repo, {
+    skipGit: opts.skipGit,
+    enabledCategoriesOverride: opts.effectiveCategories,
+    enableLlmRulesOverride: opts.effectiveLlmRules,
+    tracker: opts.tracker,
+    signal: opts.signal,
+    provider,
+    onLlmEstimate: createSocketLlmEstimateHandler(id)
   });
-  const diff = buildDiffSnapshot({
-    latest,
-    graph,
-    analysisId,
-    now,
-    branch: latest.analysis.branch,
-    commitHash,
-    changedFiles,
-    pipelineResult,
-    repoPath: project.path
+  emitViolationsReady(id, outcome.analysisId);
+  emitAnalysisComplete(id, outcome.analysisId);
+  trackEvent("analyze", {
+    serviceCount: outcome.serviceCount,
+    fileCountRange: bucketFileCount(outcome.fileCount),
+    languages: [],
+    architecture: outcome.architecture,
+    durationRange: bucketDuration(outcome.durationMs)
   });
-  writeDiff(project.path, diff);
-  log.info(
-    `[Diff] Done \u2014 ${diff.summary.newCount} new, ${diff.summary.unchangedCount} unchanged, ${diff.summary.resolvedCount} resolved across ${diff.changedFiles.length} changed files`
-  );
-  return { diff, isStale: false };
 }
-function buildDiffSnapshot(params) {
-  const { latest, graph, analysisId, branch, commitHash, changedFiles, pipelineResult, repoPath } = params;
-  const serviceById = new Map(graph.services.map((s) => [s.id, s.name]));
-  const moduleById = new Map(graph.modules.map((m) => [m.id, m.name]));
-  const methodById = new Map(graph.methods.map((m) => [m.id, m.name]));
-  const databaseById = new Map(graph.databases.map((d) => [d.id, d.name]));
-  const denormalize = (v) => ({
-    ...v,
-    targetServiceName: v.targetServiceId ? serviceById.get(v.targetServiceId) ?? null : null,
-    targetModuleName: v.targetModuleId ? moduleById.get(v.targetModuleId) ?? null : null,
-    targetMethodName: v.targetMethodId ? methodById.get(v.targetMethodId) ?? null : null,
-    targetDatabaseName: v.targetDatabaseId ? databaseById.get(v.targetDatabaseId) ?? null : null
+async function runDiffAnalyze(id, repo, opts) {
+  const { diff } = await diffInProcess(repo, {
+    tracker: opts.tracker,
+    signal: opts.signal,
+    onLlmEstimate: createSocketLlmEstimateHandler(id)
   });
-  const newViolations = pipelineResult.added.map(denormalize);
-  const latestById = new Map(latest.violations.map((v) => [v.id, v]));
-  const resolvedViolations = pipelineResult.resolvedRefs.map((r) => latestById.get(r.id)).filter((v) => !!v);
-  const changedAbs = new Set(
-    changedFiles.map((c) => path14.resolve(repoPath, c.path))
-  );
-  const matchesChanged = (p) => !!p && (changedAbs.has(p) || changedAbs.has(path14.resolve(repoPath, p)));
-  const affectedModules = graph.modules.filter((m) => matchesChanged(m.filePath));
-  const affectedModuleIdSet = new Set(affectedModules.map((m) => m.id));
-  const serviceNameById = new Map(graph.services.map((s) => [s.id, s.name]));
-  const layerKeyById = new Map(
-    graph.layers.map((l) => [l.id, `${l.serviceName}::${l.layer}`])
-  );
-  const affectedServices = /* @__PURE__ */ new Set();
-  const affectedLayers = /* @__PURE__ */ new Set();
-  const affectedModuleKeys = /* @__PURE__ */ new Set();
-  for (const mod of affectedModules) {
-    const svcName = serviceNameById.get(mod.serviceId);
-    if (svcName) {
-      affectedServices.add(svcName);
-      affectedModuleKeys.add(`${svcName}::${mod.name}`);
-    }
-    const layerKey = layerKeyById.get(mod.layerId);
-    if (layerKey) affectedLayers.add(layerKey);
+  emitViolationsReady(id, diff.id);
+  emitAnalysisComplete(id, diff.id);
+}
+function rebuildLatestFromHistory(repoPath) {
+  const files = listAnalyses(repoPath);
+  if (files.length === 0) {
+    deleteLatest(repoPath);
+    return;
   }
-  const moduleNameById = new Map(graph.modules.map((m) => [m.id, m.name]));
-  const affectedMethodKeys = [];
-  for (const method of graph.methods) {
-    if (!affectedModuleIdSet.has(method.moduleId)) continue;
-    const modName = moduleNameById.get(method.moduleId);
-    const mod = graph.modules.find((m) => m.id === method.moduleId);
-    const svcName = mod ? serviceNameById.get(mod.serviceId) : void 0;
-    if (svcName && modName) affectedMethodKeys.push(`${svcName}::${modName}::${method.name}`);
+  const newest = files[files.length - 1];
+  const snap = readAnalysis(repoPath, newest);
+  if (!snap) {
+    deleteLatest(repoPath);
+    return;
   }
-  return {
-    id: analysisId,
-    baseAnalysisId: latest.analysis.id,
-    createdAt: params.now,
-    branch,
-    commitHash,
-    graph,
-    changedFiles,
-    newViolations,
-    resolvedViolations,
-    affectedNodeIds: {
-      services: [...affectedServices],
-      layers: [...affectedLayers],
-      modules: [...affectedModuleKeys],
-      methods: affectedMethodKeys
+  const active = /* @__PURE__ */ new Map();
+  for (const fname of files) {
+    const s = readAnalysis(repoPath, fname);
+    if (!s) continue;
+    for (const r of s.violations.resolved) active.delete(r.id);
+    for (const a of s.violations.added) active.set(a.id, s);
+  }
+  const serviceById = new Map(snap.graph.services.map((s) => [s.id, s.name]));
+  const moduleById = new Map(snap.graph.modules.map((m) => [m.id, m.name]));
+  const methodById = new Map(snap.graph.methods.map((m) => [m.id, m.name]));
+  const databaseById = new Map(snap.graph.databases.map((d) => [d.id, d.name]));
+  const latest = {
+    head: newest,
+    analysis: {
+      id: snap.id,
+      createdAt: snap.createdAt,
+      branch: snap.branch,
+      commitHash: snap.commitHash,
+      architecture: snap.architecture,
+      metadata: snap.metadata,
+      status: "completed"
     },
-    summary: {
-      newCount: newViolations.length,
-      unchangedCount: pipelineResult.unchanged.length,
-      resolvedCount: resolvedViolations.length
-    }
+    graph: snap.graph,
+    violations: []
   };
+  for (const snapshot of new Set(active.values())) {
+    if (!snapshot) continue;
+    for (const v of snapshot.violations.added) {
+      if (!active.has(v.id)) continue;
+      latest.violations.push({
+        ...v,
+        targetServiceName: v.targetServiceId ? serviceById.get(v.targetServiceId) ?? null : null,
+        targetModuleName: v.targetModuleId ? moduleById.get(v.targetModuleId) ?? null : null,
+        targetMethodName: v.targetMethodId ? methodById.get(v.targetMethodId) ?? null : null,
+        targetDatabaseName: v.targetDatabaseId ? databaseById.get(v.targetDatabaseId) ?? null : null
+      });
+    }
+  }
+  writeLatest(repoPath, latest);
 }
+var analyses_default = router2;
+
+// apps/server/src/routes/graph.ts
+var import_express3 = __toESM(require_express2(), 1);
 
 // apps/server/src/config/ui-state.ts
 import fs10 from "node:fs";
@@ -152949,196 +153187,139 @@ function markDependencyViolations(edges, detViolations) {
   }
 }
 
-// apps/server/src/routes/analysis.ts
+// apps/server/src/routes/graph.ts
 init_analysis_store();
 var router3 = (0, import_express3.Router)();
-router3.get(
-  "/:id/analyses",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const repo = resolveProjectForRequest(id);
-      const history = readHistory(repo.path);
-      const entries = history.analyses.filter((e) => !e.metadata?.isDiffAnalysis).slice(-20).reverse();
-      res.json(
-        entries.map((e) => ({
-          id: e.id,
-          status: "completed",
-          branch: e.branch,
-          commitHash: e.commitHash,
-          architecture: null,
-          createdAt: e.createdAt,
-          serviceCount: e.counts.services,
-          violationsBySeverity: e.counts.violations.bySeverity,
-          durationMs: e.usage.durationMs,
-          totalTokens: e.usage.totalTokens,
-          totalCost: e.usage.totalCostUsd,
-          provider: e.usage.provider
-        }))
-      );
-    } catch (error) {
-      next(error);
-    }
-  }
-);
-router3.get(
-  "/:id/analyses/:analysisId/usage",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const analysisId = req.params.analysisId;
-      const repo = resolveProjectForRequest(id);
-      const latest = readLatest(repo.path);
-      if (latest?.analysis.id === analysisId) {
-        const snap2 = readAnalysis(repo.path, latest.head);
-        res.json(snap2?.usage ?? []);
-        return;
-      }
-      const filename = await findAnalysisFilename(repo.path, analysisId);
-      if (!filename) {
-        res.json([]);
-        return;
-      }
-      const snap = readAnalysis(repo.path, filename);
-      res.json(snap?.usage ?? []);
-    } catch (error) {
-      next(error);
-    }
-  }
-);
-router3.get(
-  "/:id/graph",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const repo = resolveProjectForRequest(id);
-      const analysisIdParam = req.query.analysisId;
-      const level = req.query.level || "services";
-      let snapshot = readLatest(repo.path);
-      if (analysisIdParam && (!snapshot || snapshot.analysis.id !== analysisIdParam)) {
-        const diff = readDiff(repo.path);
-        if (diff && diff.id === analysisIdParam) {
-          snapshot = {
-            head: `diff-${diff.id}`,
-            analysis: {
-              id: diff.id,
-              createdAt: diff.createdAt,
-              branch: diff.branch,
-              commitHash: diff.commitHash,
-              architecture: snapshot?.analysis.architecture ?? "monolith",
-              metadata: null,
-              status: "completed"
-            },
-            graph: diff.graph,
-            violations: diff.newViolations
-          };
-        } else {
-          const filename = await findAnalysisFilename(repo.path, analysisIdParam);
-          if (!filename) {
-            res.json({ nodes: [], edges: [] });
-            return;
-          }
-          const snap = readAnalysis(repo.path, filename);
-          if (!snap) {
-            res.json({ nodes: [], edges: [] });
-            return;
-          }
-          snapshot = {
-            head: filename,
-            analysis: {
-              id: snap.id,
-              createdAt: snap.createdAt,
-              branch: snap.branch,
-              commitHash: snap.commitHash,
-              architecture: snap.architecture,
-              metadata: snap.metadata,
-              status: "completed"
-            },
-            graph: snap.graph,
-            violations: []
-          };
+router3.get("/:id/graph", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const repo = resolveProjectForRequest(id);
+    const analysisIdParam = req.query.analysisId;
+    const level = req.query.level || "services";
+    let snapshot = readLatest(repo.path);
+    if (analysisIdParam && (!snapshot || snapshot.analysis.id !== analysisIdParam)) {
+      const diff = readDiff(repo.path);
+      if (diff && diff.id === analysisIdParam) {
+        snapshot = {
+          head: `diff-${diff.id}`,
+          analysis: {
+            id: diff.id,
+            createdAt: diff.createdAt,
+            branch: diff.branch,
+            commitHash: diff.commitHash,
+            architecture: snapshot?.analysis.architecture ?? "monolith",
+            metadata: null,
+            status: "completed"
+          },
+          graph: diff.graph,
+          violations: diff.newViolations
+        };
+      } else {
+        const filename = findAnalysisFilename(repo.path, analysisIdParam);
+        if (!filename) {
+          res.json({ nodes: [], edges: [] });
+          return;
         }
+        const snap = readAnalysis(repo.path, filename);
+        if (!snap) {
+          res.json({ nodes: [], edges: [] });
+          return;
+        }
+        snapshot = {
+          head: filename,
+          analysis: {
+            id: snap.id,
+            createdAt: snap.createdAt,
+            branch: snap.branch,
+            commitHash: snap.commitHash,
+            architecture: snap.architecture,
+            metadata: snap.metadata,
+            status: "completed"
+          },
+          graph: snap.graph,
+          violations: []
+        };
       }
-      if (!snapshot) {
-        res.json({ nodes: [], edges: [] });
-        return;
-      }
-      const graphLevel = level.replace(/s$/, "");
-      const serviceIdToName = new Map(snapshot.graph.services.map((s) => [s.id, s.name]));
-      const moduleIdToName = new Map(snapshot.graph.modules.map((m) => [m.id, m.name]));
-      const dependencyViolations = snapshot.violations.filter((v) => !!(v.relatedServiceId || v.relatedModuleId)).map((v) => ({
-        id: v.id,
-        ruleKey: v.ruleKey,
-        category: v.type === "service" ? "service" : v.type === "function" ? "method" : "module",
-        title: v.title,
-        severity: v.severity,
-        serviceName: v.targetServiceId ? serviceIdToName.get(v.targetServiceId) ?? "" : "",
-        moduleName: v.targetModuleId ? moduleIdToName.get(v.targetModuleId) ?? null : null,
-        targetModuleId: v.targetModuleId ?? null,
-        relatedServiceId: v.relatedServiceId ?? null,
-        relatedModuleId: v.relatedModuleId ?? null,
-        isDependencyViolation: !!(v.relatedServiceId || v.relatedModuleId)
-      }));
-      const unifiedInput = {
-        services: snapshot.graph.services.map((s) => ({
-          ...s,
-          analysisId: snapshot.analysis.id,
-          createdAt: new Date(snapshot.analysis.createdAt)
-        })),
-        serviceDeps: snapshot.graph.serviceDependencies.map((d) => ({
-          ...d,
-          analysisId: snapshot.analysis.id
-        })),
-        layers: snapshot.graph.layers,
-        modules: snapshot.graph.modules.map((m) => ({
-          ...m,
-          analysisId: snapshot.analysis.id
-        })),
-        moduleDeps: snapshot.graph.moduleDeps.map((d) => ({
-          ...d,
-          analysisId: snapshot.analysis.id
-        })),
-        methods: snapshot.graph.methods.map((m) => ({
-          ...m,
-          analysisId: snapshot.analysis.id
-        })),
-        methodDeps: snapshot.graph.methodDeps.map((d) => ({
-          ...d,
-          analysisId: snapshot.analysis.id
-        })),
-        databases: snapshot.graph.databases.map((d) => ({
-          ...d,
-          analysisId: snapshot.analysis.id,
-          createdAt: new Date(snapshot.analysis.createdAt)
-        })),
-        dbConnections: snapshot.graph.databaseConnections.map((c) => ({
-          ...c,
-          analysisId: snapshot.analysis.id
-        })),
-        dependencyViolations
-      };
-      const graphData = buildUnifiedGraph(graphLevel, unifiedInput);
-      const keyMap = buildStableKeyMap({
-        services: snapshot.graph.services,
-        layers: snapshot.graph.layers,
-        modules: snapshot.graph.modules,
-        methods: snapshot.graph.methods
-      });
-      const savedStablePositions = getScopedPositions(repo.path, snapshot.analysis.branch, level);
-      const savedPositions = positionsToUuid(keyMap, savedStablePositions);
-      for (const node2 of graphData.nodes) {
-        const pos = savedPositions[node2.id];
-        if (pos) node2.position = pos;
-      }
-      const savedStableCollapsed = getScopedCollapsed(repo.path, snapshot.analysis.branch, level);
-      const collapsedIds = idsToUuid(keyMap, savedStableCollapsed);
-      res.set("Cache-Control", "no-store");
-      res.json({ ...graphData, collapsedIds });
-    } catch (error) {
-      next(error);
     }
+    if (!snapshot) {
+      res.json({ nodes: [], edges: [] });
+      return;
+    }
+    const graphLevel = level.replace(/s$/, "");
+    const serviceIdToName = new Map(snapshot.graph.services.map((s) => [s.id, s.name]));
+    const moduleIdToName = new Map(snapshot.graph.modules.map((m) => [m.id, m.name]));
+    const dependencyViolations = snapshot.violations.filter((v) => !!(v.relatedServiceId || v.relatedModuleId)).map((v) => ({
+      id: v.id,
+      ruleKey: v.ruleKey,
+      category: v.type === "service" ? "service" : v.type === "function" ? "method" : "module",
+      title: v.title,
+      severity: v.severity,
+      serviceName: v.targetServiceId ? serviceIdToName.get(v.targetServiceId) ?? "" : "",
+      moduleName: v.targetModuleId ? moduleIdToName.get(v.targetModuleId) ?? null : null,
+      targetModuleId: v.targetModuleId ?? null,
+      relatedServiceId: v.relatedServiceId ?? null,
+      relatedModuleId: v.relatedModuleId ?? null,
+      isDependencyViolation: !!(v.relatedServiceId || v.relatedModuleId)
+    }));
+    const unifiedInput = {
+      services: snapshot.graph.services.map((s) => ({
+        ...s,
+        analysisId: snapshot.analysis.id,
+        createdAt: new Date(snapshot.analysis.createdAt)
+      })),
+      serviceDeps: snapshot.graph.serviceDependencies.map((d) => ({
+        ...d,
+        analysisId: snapshot.analysis.id
+      })),
+      layers: snapshot.graph.layers,
+      modules: snapshot.graph.modules.map((m) => ({
+        ...m,
+        analysisId: snapshot.analysis.id
+      })),
+      moduleDeps: snapshot.graph.moduleDeps.map((d) => ({
+        ...d,
+        analysisId: snapshot.analysis.id
+      })),
+      methods: snapshot.graph.methods.map((m) => ({
+        ...m,
+        analysisId: snapshot.analysis.id
+      })),
+      methodDeps: snapshot.graph.methodDeps.map((d) => ({
+        ...d,
+        analysisId: snapshot.analysis.id
+      })),
+      databases: snapshot.graph.databases.map((d) => ({
+        ...d,
+        analysisId: snapshot.analysis.id,
+        createdAt: new Date(snapshot.analysis.createdAt)
+      })),
+      dbConnections: snapshot.graph.databaseConnections.map((c) => ({
+        ...c,
+        analysisId: snapshot.analysis.id
+      })),
+      dependencyViolations
+    };
+    const graphData = buildUnifiedGraph(graphLevel, unifiedInput);
+    const keyMap = buildStableKeyMap({
+      services: snapshot.graph.services,
+      layers: snapshot.graph.layers,
+      modules: snapshot.graph.modules,
+      methods: snapshot.graph.methods
+    });
+    const savedStablePositions = getScopedPositions(repo.path, snapshot.analysis.branch, level);
+    const savedPositions = positionsToUuid(keyMap, savedStablePositions);
+    for (const node2 of graphData.nodes) {
+      const pos = savedPositions[node2.id];
+      if (pos) node2.position = pos;
+    }
+    const savedStableCollapsed = getScopedCollapsed(repo.path, snapshot.analysis.branch, level);
+    const collapsedIds = idsToUuid(keyMap, savedStableCollapsed);
+    res.set("Cache-Control", "no-store");
+    res.json({ ...graphData, collapsedIds });
+  } catch (error) {
+    next(error);
   }
-);
+});
 function keyMapFromLatest(latest) {
   return buildStableKeyMap({
     services: latest.graph.services,
@@ -153147,391 +153328,205 @@ function keyMapFromLatest(latest) {
     methods: latest.graph.methods
   });
 }
-router3.put(
-  "/:id/graph/positions",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const level = req.query.level || "services";
-      const { positions } = req.body;
-      if (!positions || typeof positions !== "object") {
-        throw createAppError("Invalid positions data", 400);
-      }
-      const repo = resolveProjectForRequest(id);
-      const latest = readLatest(repo.path);
-      if (!latest) throw createAppError("No analysis found", 404);
-      const keyMap = keyMapFromLatest(latest);
-      const stablePositions = positionsToStable(keyMap, positions);
-      setPositions(repo.path, latest.analysis.branch, level, stablePositions);
-      res.json({ ok: true });
-    } catch (error) {
-      next(error);
-    }
-  }
-);
-router3.delete(
-  "/:id/graph/positions",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const branch = req.query.branch;
-      const level = req.query.level || "services";
-      const repo = resolveProjectForRequest(id);
-      clearPositions(repo.path, branch ?? null, level);
-      res.json({ ok: true });
-    } catch (error) {
-      next(error);
-    }
-  }
-);
-router3.put(
-  "/:id/graph/collapsed",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const level = req.query.level || "modules";
-      const { collapsedIds: ids } = req.body;
-      if (!Array.isArray(ids)) throw createAppError("Invalid collapsedIds data", 400);
-      const repo = resolveProjectForRequest(id);
-      const latest = readLatest(repo.path);
-      if (!latest) throw createAppError("No analysis found", 404);
-      const keyMap = keyMapFromLatest(latest);
-      const stableIds = idsToStable(keyMap, ids);
-      setCollapsed(repo.path, latest.analysis.branch, level, stableIds);
-      res.json({ ok: true });
-    } catch (error) {
-      next(error);
-    }
-  }
-);
-router3.delete(
-  "/:id/analyses/:analysisId",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const analysisId = req.params.analysisId;
-      const repo = resolveProjectForRequest(id);
-      const filename = await findAnalysisFilename(repo.path, analysisId);
-      if (!filename) throw createAppError("Analysis not found", 404);
-      deleteAnalysis(repo.path, filename);
-      removeFromHistory(repo.path, analysisId);
-      const latest = readLatest(repo.path);
-      if (latest?.head === filename) {
-        await rebuildLatestFromHistory(repo.path);
-        deleteDiff(repo.path);
-      }
-      res.json({ ok: true });
-    } catch (error) {
-      next(error);
+router3.put("/:id/graph/positions", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const level = req.query.level || "services";
+    const { positions } = req.body;
+    if (!positions || typeof positions !== "object") {
+      throw createAppError("Invalid positions data", 400);
     }
+    const repo = resolveProjectForRequest(id);
+    const latest = readLatest(repo.path);
+    if (!latest) throw createAppError("No analysis found", 404);
+    const keyMap = keyMapFromLatest(latest);
+    const stablePositions = positionsToStable(keyMap, positions);
+    setPositions(repo.path, latest.analysis.branch, level, stablePositions);
+    res.json({ ok: true });
+  } catch (error) {
+    next(error);
   }
-);
-async function rebuildLatestFromHistory(repoPath) {
-  const files = listAnalyses(repoPath);
-  if (files.length === 0) {
-    deleteLatest(repoPath);
-    return;
-  }
-  const newest = files[files.length - 1];
-  const snap = readAnalysis(repoPath, newest);
-  if (!snap) {
-    deleteLatest(repoPath);
-    return;
-  }
-  const sorted2 = [...files];
-  const active = /* @__PURE__ */ new Map();
-  for (const fname of sorted2) {
-    const s = readAnalysis(repoPath, fname);
-    if (!s) continue;
-    for (const r of s.violations.resolved) active.delete(r.id);
-    for (const a of s.violations.added) active.set(a.id, s);
+});
+router3.delete("/:id/graph/positions", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const branch = req.query.branch;
+    const level = req.query.level || "services";
+    const repo = resolveProjectForRequest(id);
+    clearPositions(repo.path, branch ?? null, level);
+    res.json({ ok: true });
+  } catch (error) {
+    next(error);
   }
-  const serviceById = new Map(snap.graph.services.map((s) => [s.id, s.name]));
-  const moduleById = new Map(snap.graph.modules.map((m) => [m.id, m.name]));
-  const methodById = new Map(snap.graph.methods.map((m) => [m.id, m.name]));
-  const databaseById = new Map(snap.graph.databases.map((d) => [d.id, d.name]));
-  const latest = {
-    head: newest,
-    analysis: {
-      id: snap.id,
-      createdAt: snap.createdAt,
-      branch: snap.branch,
-      commitHash: snap.commitHash,
-      architecture: snap.architecture,
-      metadata: snap.metadata,
-      status: "completed"
-    },
-    graph: snap.graph,
-    violations: []
-    // Best-effort rebuild — populated from the snapshot that owns each active id.
-  };
-  for (const snapshot of new Set(active.values())) {
-    if (!snapshot) continue;
-    for (const v of snapshot.violations.added) {
-      if (!active.has(v.id)) continue;
-      latest.violations.push({
-        ...v,
-        targetServiceName: v.targetServiceId ? serviceById.get(v.targetServiceId) ?? null : null,
-        targetModuleName: v.targetModuleId ? moduleById.get(v.targetModuleId) ?? null : null,
-        targetMethodName: v.targetMethodId ? methodById.get(v.targetMethodId) ?? null : null,
-        targetDatabaseName: v.targetDatabaseId ? databaseById.get(v.targetDatabaseId) ?? null : null
-      });
-    }
+});
+router3.put("/:id/graph/collapsed", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const level = req.query.level || "modules";
+    const { collapsedIds: ids } = req.body;
+    if (!Array.isArray(ids)) throw createAppError("Invalid collapsedIds data", 400);
+    const repo = resolveProjectForRequest(id);
+    const latest = readLatest(repo.path);
+    if (!latest) throw createAppError("No analysis found", 404);
+    const keyMap = keyMapFromLatest(latest);
+    const stableIds = idsToStable(keyMap, ids);
+    setCollapsed(repo.path, latest.analysis.branch, level, stableIds);
+    res.json({ ok: true });
+  } catch (error) {
+    next(error);
   }
-  writeLatest(repoPath, latest);
-}
-router3.get(
-  "/:id/files",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const ref = req.query.ref;
-      const repo = resolveProjectForRequest(id);
-      const git = await getGit(repo.path);
-      const result = await git.raw(["ls-files"]);
-      const files = result.split("\n").filter((f2) => f2.length > 0);
-      if (ref === "working-tree") {
-        const untrackedResult = await git.raw(["ls-files", "--others", "--exclude-standard"]);
-        const untrackedFiles = untrackedResult.split("\n").filter((f2) => f2.length > 0);
-        for (const f2 of untrackedFiles) {
-          if (!files.includes(f2)) files.push(f2);
-        }
+});
+var graph_default = router3;
+
+// apps/server/src/routes/files.ts
+var import_express4 = __toESM(require_express2(), 1);
+import fs11 from "node:fs";
+import path15 from "node:path";
+init_analysis_store();
+var router4 = (0, import_express4.Router)();
+router4.get("/:id/files", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const ref = req.query.ref;
+    const repo = resolveProjectForRequest(id);
+    const git = await getGit(repo.path);
+    const result = await git.raw(["ls-files"]);
+    const files = result.split("\n").filter((f2) => f2.length > 0);
+    if (ref === "working-tree") {
+      const untrackedResult = await git.raw(["ls-files", "--others", "--exclude-standard"]);
+      const untrackedFiles = untrackedResult.split("\n").filter((f2) => f2.length > 0);
+      for (const f2 of untrackedFiles) {
+        if (!files.includes(f2)) files.push(f2);
       }
-      res.json({ root: repo.path, files });
-    } catch (error) {
-      next(error);
     }
+    res.json({ root: repo.path, files });
+  } catch (error) {
+    next(error);
   }
-);
-router3.get(
-  "/:id/changes",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const repo = resolveProjectForRequest(id);
+});
+router4.get("/:id/file-content", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const filePath = req.query.path;
+    const ref = req.query.ref;
+    if (!filePath) throw createAppError('Missing "path" query parameter', 400);
+    const repo = resolveProjectForRequest(id);
+    const resolved = path15.resolve(repo.path, filePath);
+    if (!resolved.startsWith(path15.resolve(repo.path) + path15.sep) && resolved !== path15.resolve(repo.path)) {
+      throw createAppError("Path traversal not allowed", 403);
+    }
+    let content;
+    if (ref === "working-tree") {
+      if (!fs11.existsSync(resolved)) throw createAppError("File not found", 404);
+      const stat = fs11.statSync(resolved);
+      if (!stat.isFile()) throw createAppError("Path is not a file", 400);
+      content = fs11.readFileSync(resolved, "utf-8");
+    } else {
       const git = await getGit(repo.path);
-      const statusResult = await git.status();
-      const changedFiles = [];
-      for (const f2 of statusResult.not_added) changedFiles.push({ path: f2, status: "new" });
-      for (const f2 of statusResult.created) changedFiles.push({ path: f2, status: "new" });
-      for (const f2 of statusResult.modified) changedFiles.push({ path: f2, status: "modified" });
-      for (const f2 of statusResult.staged) {
-        if (!changedFiles.some((cf) => cf.path === f2)) changedFiles.push({ path: f2, status: "modified" });
-      }
-      for (const f2 of statusResult.deleted) changedFiles.push({ path: f2, status: "deleted" });
-      const latest = readLatest(repo.path);
-      const affectedServices = [];
-      if (latest) {
-        for (const svc of latest.graph.services) {
-          const svcRoot = svc.rootPath;
-          const isAffected = changedFiles.some(
-            (cf) => cf.path.startsWith(svcRoot + "/") || cf.path === svcRoot
-          );
-          if (isAffected) affectedServices.push(svc.id);
-        }
-      }
-      res.json({ changedFiles, affectedServices });
-    } catch (error) {
-      next(error);
-    }
-  }
-);
-router3.post(
-  "/:id/diff-check",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const repo = resolveProjectForRequest(id);
-      const { diff } = await diffInProcess(repo);
-      res.json({
-        resolvedViolations: diff.resolvedViolations,
-        newViolations: diff.newViolations,
-        affectedNodeIds: diff.affectedNodeIds,
-        summary: diff.summary,
-        changedFiles: diff.changedFiles,
-        isStale: false,
-        diffAnalysisId: diff.id
-      });
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Run a full analysis first")) {
-        next(createAppError(error.message, 400));
-        return;
-      }
-      next(error);
-    }
-  }
-);
-router3.get(
-  "/:id/diff-check",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const repo = resolveProjectForRequest(id);
-      const diff = readDiff(repo.path);
-      if (!diff) {
-        res.json(null);
-        return;
-      }
-      const latest = readLatest(repo.path);
-      const isStale = latest ? latest.analysis.id !== diff.baseAnalysisId : false;
-      res.json({
-        resolvedViolations: diff.resolvedViolations,
-        newViolations: diff.newViolations,
-        affectedNodeIds: diff.affectedNodeIds,
-        summary: diff.summary,
-        changedFiles: diff.changedFiles,
-        isStale,
-        diffAnalysisId: diff.id
-      });
-    } catch (error) {
-      next(error);
-    }
-  }
-);
-router3.get(
-  "/:id/file-content",
-  async (req, res, next) => {
-    try {
-      const id = req.params.id;
-      const filePath = req.query.path;
-      const ref = req.query.ref;
-      if (!filePath) throw createAppError('Missing "path" query parameter', 400);
-      const repo = resolveProjectForRequest(id);
-      const resolved = path15.resolve(repo.path, filePath);
-      if (!resolved.startsWith(path15.resolve(repo.path) + path15.sep) && resolved !== path15.resolve(repo.path)) {
-        throw createAppError("Path traversal not allowed", 403);
-      }
-      let content;
-      if (ref === "working-tree") {
+      try {
+        content = await git.show([`HEAD:${filePath}`]);
+      } catch {
         if (!fs11.existsSync(resolved)) throw createAppError("File not found", 404);
         const stat = fs11.statSync(resolved);
         if (!stat.isFile()) throw createAppError("Path is not a file", 400);
         content = fs11.readFileSync(resolved, "utf-8");
-      } else {
-        const git = await getGit(repo.path);
-        try {
-          content = await git.show([`HEAD:${filePath}`]);
-        } catch {
-          if (!fs11.existsSync(resolved)) throw createAppError("File not found", 404);
-          const stat = fs11.statSync(resolved);
-          if (!stat.isFile()) throw createAppError("Path is not a file", 400);
-          content = fs11.readFileSync(resolved, "utf-8");
-        }
-      }
-      const ext2 = path15.extname(resolved).slice(1).toLowerCase();
-      const langMap = {
-        ts: "typescript",
-        tsx: "typescript",
-        js: "javascript",
-        jsx: "javascript",
-        json: "json",
-        md: "markdown",
-        css: "css",
-        html: "html",
-        yaml: "yaml",
-        yml: "yaml",
-        sql: "sql",
-        sh: "shell",
-        py: "python",
-        go: "go",
-        rs: "rust",
-        java: "java",
-        rb: "ruby",
-        php: "php",
-        c: "c",
-        cpp: "cpp",
-        h: "c",
-        hpp: "cpp"
-      };
-      const language = langMap[ext2] || "text";
-      res.json({ content, language });
-    } catch (error) {
-      next(error);
+      }
     }
+    const ext2 = path15.extname(resolved).slice(1).toLowerCase();
+    const langMap = {
+      ts: "typescript",
+      tsx: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      json: "json",
+      md: "markdown",
+      css: "css",
+      html: "html",
+      yaml: "yaml",
+      yml: "yaml",
+      sql: "sql",
+      sh: "shell",
+      py: "python",
+      go: "go",
+      rs: "rust",
+      java: "java",
+      rb: "ruby",
+      php: "php",
+      c: "c",
+      cpp: "cpp",
+      h: "c",
+      hpp: "cpp"
+    };
+    const language = langMap[ext2] || "text";
+    res.json({ content, language });
+  } catch (error) {
+    next(error);
   }
-);
-async function findAnalysisFilename(repoPath, analysisId) {
-  for (const name of listAnalyses(repoPath).reverse()) {
-    const snap = readAnalysis(repoPath, name);
-    if (snap?.id === analysisId) return name;
+});
+router4.get("/:id/changes", async (req, res, next) => {
+  try {
+    const id = req.params.id;
+    const repo = resolveProjectForRequest(id);
+    const git = await getGit(repo.path);
+    const statusResult = await git.status();
+    const changedFiles = [];
+    for (const f2 of statusResult.not_added) changedFiles.push({ path: f2, status: "new" });
+    for (const f2 of statusResult.created) changedFiles.push({ path: f2, status: "new" });
+    for (const f2 of statusResult.modified) changedFiles.push({ path: f2, status: "modified" });
+    for (const f2 of statusResult.staged) {
+      if (!changedFiles.some((cf) => cf.path === f2)) changedFiles.push({ path: f2, status: "modified" });
+    }
+    for (const f2 of statusResult.deleted) changedFiles.push({ path: f2, status: "deleted" });
+    const latest = readLatest(repo.path);
+    const affectedServices = [];
+    if (latest) {
+      for (const svc of latest.graph.services) {
+        const svcRoot = svc.rootPath;
+        const isAffected = changedFiles.some(
+          (cf) => cf.path.startsWith(svcRoot + "/") || cf.path === svcRoot
+        );
+        if (isAffected) affectedServices.push(svc.id);
+      }
+    }
+    res.json({ changedFiles, affectedServices });
+  } catch (error) {
+    next(error);
   }
-  return null;
-}
-var analysis_default = router3;
+});
+var files_default = router4;
 
 // apps/server/src/routes/violations.ts
-var import_express4 = __toESM(require_express2(), 1);
+var import_express5 = __toESM(require_express2(), 1);
 init_analysis_store();
-var router4 = (0, import_express4.Router)();
-var SEVERITY_ORDER2 = {
-  critical: 0,
-  high: 1,
-  medium: 2,
-  low: 3,
-  info: 4
-};
-router4.get(
+var router5 = (0, import_express5.Router)();
+router5.get(
   "/:id/violations",
   async (req, res, next) => {
     try {
       const id = req.params.id;
       const repo = resolveProjectForRequest(id);
-      const analysisIdParam = req.query.analysisId;
-      const fileParam = req.query.file;
-      const statusParam = req.query.status;
       const limitParam = parseInt(req.query.limit) || 0;
       const offsetParam = parseInt(req.query.offset) || 0;
-      let violations;
-      if (analysisIdParam) {
-        const latest = readLatest(repo.path);
-        if (latest && latest.analysis.id === analysisIdParam) {
-          violations = latest.violations;
-        } else {
-          res.json(limitParam > 0 ? { violations: [], total: 0 } : []);
-          return;
-        }
-      } else {
-        const latest = readLatest(repo.path);
-        if (!latest) {
-          res.json(limitParam > 0 ? { violations: [], total: 0 } : []);
-          return;
-        }
-        violations = latest.violations;
-      }
-      let filtered;
-      if (statusParam === "resolved") {
-        filtered = violations.filter((v) => v.status === "resolved");
-      } else if (statusParam === "all") {
-        filtered = violations;
-      } else {
-        const active = ["new", "unchanged"];
-        filtered = violations.filter((v) => active.includes(v.status));
-      }
-      if (fileParam) {
-        const absPath = fileParam.startsWith("/") ? fileParam : `${repo.path}/${fileParam}`;
-        filtered = filtered.filter(
-          (v) => v.type === "code" && (v.filePath === absPath || v.filePath === fileParam)
-        );
-      }
-      filtered.sort((a, b) => {
-        const sa = SEVERITY_ORDER2[a.severity] ?? 5;
-        const sb = SEVERITY_ORDER2[b.severity] ?? 5;
-        if (sa !== sb) return sa - sb;
-        return b.createdAt.localeCompare(a.createdAt);
+      const statusParam = req.query.status;
+      const status = statusParam === "resolved" ? "resolved" : statusParam === "all" ? "all" : "active";
+      const { violations, total } = listViolations(repo.path, {
+        analysisId: req.query.analysisId,
+        filePath: req.query.file,
+        status,
+        limit: limitParam,
+        offset: offsetParam
       });
-      const total = filtered.length;
-      const paged = limitParam > 0 ? filtered.slice(offsetParam, offsetParam + limitParam) : filtered;
       if (limitParam > 0 || offsetParam > 0) {
-        res.json({ violations: paged, total });
+        res.json({ violations, total });
       } else {
-        res.json(paged);
+        res.json(violations);
       }
     } catch (error) {
       next(error);
     }
   }
 );
-router4.get(
+router5.get(
   "/:id/violations/summary",
   async (req, res, next) => {
     try {
@@ -153587,13 +153582,13 @@ async function findAnalysisFilename2(repoPath, analysisId) {
   }
   return null;
 }
-var violations_default = router4;
+var violations_default = router5;
 
 // apps/server/src/routes/databases.ts
-var import_express5 = __toESM(require_express2(), 1);
+var import_express6 = __toESM(require_express2(), 1);
 init_analysis_store();
-var router5 = (0, import_express5.Router)();
-router5.get(
+var router6 = (0, import_express6.Router)();
+router6.get(
   "/:id/databases",
   async (req, res, next) => {
     try {
@@ -153619,7 +153614,7 @@ router5.get(
     }
   }
 );
-router5.get(
+router6.get(
   "/:id/databases/:dbId/schema",
   async (req, res, next) => {
     try {
@@ -153643,21 +153638,21 @@ router5.get(
     }
   }
 );
-var databases_default = router5;
+var databases_default = router6;
 
 // apps/server/src/routes/rules.ts
-var import_express6 = __toESM(require_express2(), 1);
-var router6 = (0, import_express6.Router)();
-router6.get("/", async (_req, res) => {
+var import_express7 = __toESM(require_express2(), 1);
+var router7 = (0, import_express7.Router)();
+router7.get("/", async (_req, res) => {
   res.json(await getRules());
 });
-var rules_default = router6;
+var rules_default = router7;
 
 // apps/server/src/routes/flows.ts
-var import_express7 = __toESM(require_express2(), 1);
+var import_express8 = __toESM(require_express2(), 1);
 init_analysis_store();
-var router7 = (0, import_express7.Router)();
-router7.get(
+var router8 = (0, import_express8.Router)();
+router8.get(
   "/:id/flows",
   async (req, res, next) => {
     try {
@@ -153674,7 +153669,7 @@ router7.get(
     }
   }
 );
-router7.get(
+router8.get(
   "/:id/flows/:flowId",
   async (req, res, next) => {
     try {
@@ -153689,7 +153684,7 @@ router7.get(
     }
   }
 );
-router7.post(
+router8.post(
   "/:id/flows/:flowId/enrich",
   async (req, res, next) => {
     try {
@@ -153706,10 +153701,10 @@ router7.post(
     }
   }
 );
-var flows_default = router7;
+var flows_default = router8;
 
 // apps/server/src/routes/analytics.ts
-var import_express8 = __toESM(require_express2(), 1);
+var import_express9 = __toESM(require_express2(), 1);
 
 // apps/server/src/services/analytics.service.ts
 init_analysis_store();
@@ -153865,8 +153860,8 @@ function loadActiveViolations(repoPath, branch, specificAnalysisId) {
 }
 
 // apps/server/src/routes/analytics.ts
-var router8 = (0, import_express8.Router)();
-router8.get(
+var router9 = (0, import_express9.Router)();
+router9.get(
   "/:id/analytics/trend",
   async (req, res, next) => {
     try {
@@ -153880,7 +153875,7 @@ router8.get(
     }
   }
 );
-router8.get(
+router9.get(
   "/:id/analytics/breakdown",
   async (req, res, next) => {
     try {
@@ -153894,7 +153889,7 @@ router8.get(
     }
   }
 );
-router8.get(
+router9.get(
   "/:id/analytics/top-offenders",
   async (req, res, next) => {
     try {
@@ -153908,7 +153903,7 @@ router8.get(
     }
   }
 );
-router8.get(
+router9.get(
   "/:id/analytics/resolution",
   async (req, res, next) => {
     try {
@@ -153921,7 +153916,7 @@ router8.get(
     }
   }
 );
-var analytics_default = router8;
+var analytics_default = router9;
 
 // apps/server/src/services/watcher.service.ts
 init_logger();
@@ -153958,14 +153953,15 @@ async function main() {
     log.info("[Storage] Legacy Postgres data wiped. Re-analyze to repopulate.");
   }
   log.info(`[LLM] Provider: claude-code, model: ${config.claudeCodeModel || "default"}`);
-  const app = (0, import_express9.default)();
+  const app = (0, import_express10.default)();
   const httpServer = createServer(app);
   setupSocket(httpServer);
   app.use((0, import_cors.default)());
-  app.use(import_express9.default.json());
+  app.use(import_express10.default.json());
   app.use("/api/repos", repos_default);
-  app.use("/api/repos", analyze_default);
-  app.use("/api/repos", projectResolver, analysis_default);
+  app.use("/api/repos", projectResolver, analyses_default);
+  app.use("/api/repos", projectResolver, graph_default);
+  app.use("/api/repos", projectResolver, files_default);
   app.use("/api/repos", projectResolver, violations_default);
   app.use("/api/repos", projectResolver, databases_default);
   app.use("/api/repos", projectResolver, flows_default);
@@ -153977,7 +153973,7 @@ async function main() {
   app.use(errorHandler);
   const staticDir = path16.join(__dirname3, "public");
   if (fs12.existsSync(staticDir)) {
-    app.use(import_express9.default.static(staticDir));
+    app.use(import_express10.default.static(staticDir));
     app.get("*", (_req, res) => {
       res.sendFile(path16.join(staticDir, "index.html"));
     });