ctxloom-pro 1.7.9 → 1.7.10

package/dist/{chunk-73ZZ6O4B.js → chunk-J3NVYR6J.js}

@@ -2706,7 +2706,7 @@ var CallGraphIndex = class _CallGraphIndex {
 var TS_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".vue"]);
 var PY_EXTENSIONS = /* @__PURE__ */ new Set([".py", ".ipynb"]);
 var AST_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".go", ".rs", ".java", ".cs", ".rb", ".kt", ".kts", ".swift", ".ipynb", ".php", ".dart"]);
-var CTXLOOM_VERSION = "1.7.9".length > 0 ? "1.7.9" : "dev";
+var CTXLOOM_VERSION = "1.7.10".length > 0 ? "1.7.10" : "dev";
 var SNAPSHOT_SCHEMA_VERSION = 2;
 function compareCtxloomVersions(snapshotVer, currentVer) {
   if (snapshotVer === currentVer) return "same";
@@ -4219,8 +4219,8 @@ var CoChangeIndex = class _CoChangeIndex {
     if (event.isBulk || event.isMerge) return;
     const paths = event.files.map((f) => f.path);
     if (paths.length === 0) return;
-    for (const path38 of paths) {
-      this.nodeCounts.set(path38, (this.nodeCounts.get(path38) ?? 0) + 1);
+    for (const path39 of paths) {
+      this.nodeCounts.set(path39, (this.nodeCounts.get(path39) ?? 0) + 1);
     }
     for (let i = 0; i < paths.length; i++) {
       for (let j = i + 1; j < paths.length; j++) {
@@ -4367,8 +4367,8 @@ var ChurnIndex = class _ChurnIndex {
    */
   snapshot() {
     const nodes = {};
-    for (const [path38, raw] of this.nodes) {
-      nodes[path38] = {
+    for (const [path39, raw] of this.nodes) {
+      nodes[path39] = {
         commits: raw.commits,
         churnLines: raw.churnLines,
         bugCommits: raw.bugCommits,
@@ -4383,8 +4383,8 @@ var ChurnIndex = class _ChurnIndex {
    */
   static load(s) {
     const idx = new _ChurnIndex();
-    for (const [path38, raw] of Object.entries(s.nodes)) {
-      idx.nodes.set(path38, {
+    for (const [path39, raw] of Object.entries(s.nodes)) {
+      idx.nodes.set(path39, {
         commits: raw.commits,
         churnLines: raw.churnLines,
         bugCommits: raw.bugCommits,
@@ -4397,8 +4397,8 @@ var ChurnIndex = class _ChurnIndex {
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
-  getOrCreate(path38) {
-    const existing = this.nodes.get(path38);
+  getOrCreate(path39) {
+    const existing = this.nodes.get(path39);
     if (existing !== void 0) return existing;
     const fresh = {
       commits: 0,
@@ -4407,7 +4407,7 @@ var ChurnIndex = class _ChurnIndex {
       authorCounts: {},
       lastTouch: 0
     };
-    this.nodes.set(path38, fresh);
+    this.nodes.set(path39, fresh);
     return fresh;
   }
 };
@@ -4488,12 +4488,12 @@ var OwnershipIndex = class _OwnershipIndex {
    */
   snapshot() {
     const nodes = {};
-    for (const [path38, raw] of this.nodes) {
+    for (const [path39, raw] of this.nodes) {
       const authorWeights = {};
       for (const [email, entry] of Object.entries(raw.authorWeights)) {
         authorWeights[email] = { ...entry };
       }
-      nodes[path38] = { authorWeights, lastTouch: raw.lastTouch };
+      nodes[path39] = { authorWeights, lastTouch: raw.lastTouch };
     }
     return { version: 1, nodes };
   }
@@ -4502,23 +4502,23 @@ var OwnershipIndex = class _OwnershipIndex {
    */
   static load(s) {
     const idx = new _OwnershipIndex();
-    for (const [path38, raw] of Object.entries(s.nodes)) {
+    for (const [path39, raw] of Object.entries(s.nodes)) {
       const authorWeights = {};
       for (const [email, entry] of Object.entries(raw.authorWeights)) {
         authorWeights[email] = { ...entry };
       }
-      idx.nodes.set(path38, { authorWeights, lastTouch: raw.lastTouch });
+      idx.nodes.set(path39, { authorWeights, lastTouch: raw.lastTouch });
     }
     return idx;
   }
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
-  getOrCreate(path38) {
-    const existing = this.nodes.get(path38);
+  getOrCreate(path39) {
+    const existing = this.nodes.get(path39);
     if (existing !== void 0) return existing;
     const fresh = { authorWeights: {}, lastTouch: 0 };
-    this.nodes.set(path38, fresh);
+    this.nodes.set(path39, fresh);
     return fresh;
   }
 };
@@ -7094,7 +7094,8 @@ function registerBlastRadiusTool(registry, ctx) {
         return '<blast_radius changed_files="0">\n  <!-- No changed files detected -->\n</blast_radius>';
       }
       const result = await computeBlastRadius({ changedFiles: files, depth, projectRoot: gitRoot, graph });
-      const report = getImpactRadius({ graph, overlay: ctx.overlay, changedFiles: files, depth });
+      const overlay = await ctx.getOverlay(project_root) ?? void 0;
+      const report = getImpactRadius({ graph, overlay, changedFiles: files, depth });
       return buildBlastRadiusXml(result, depth, detail_level, report.historicalCoupling);
     }
   );
@@ -8731,15 +8732,16 @@ function registerDetectChangesTool(registry, ctx) {
       if (files.length === 0) {
         return '<detect_changes count="0">\n  <!-- No changed files detected -->\n</detect_changes>';
       }
+      const overlay = await ctx.getOverlay(project_root) ?? void 0;
       const { changedFiles: scored, summary } = detectChanges({
         graph,
-        overlay: ctx.overlay,
+        overlay,
         changedFiles: files
       });
       if (detail_level === "minimal") {
         return `<detect_changes count="${scored.length}" critical="${summary.critical}" high="${summary.high}" medium="${summary.medium}" low="${summary.low}" detail_level="minimal" />`;
       }
-      const hasOverlay = ctx.overlay !== void 0;
+      const hasOverlay = overlay !== void 0;
       const xml = [
         `<detect_changes count="${scored.length}" critical="${summary.critical}" high="${summary.high}" medium="${summary.medium}" low="${summary.low}">`
       ];
@@ -9449,6 +9451,28 @@ function registerFindLargeFunctionsTool(registry, ctx) {
 
 // packages/core/src/tools/git-coupling.ts
 import { z as z31 } from "zod";
+
+// packages/core/src/tools/overlayNote.ts
+import fs22 from "fs";
+import path24 from "path";
+async function overlayUnavailableNote(ctx, projectRoot) {
+  let rootDir = "";
+  try {
+    const graph = await ctx.getGraph(projectRoot);
+    rootDir = graph.getRootDir();
+  } catch {
+  }
+  if (rootDir) {
+    const overlayFile = path24.join(rootDir, ".ctxloom", "git-overlay.json");
+    if (fs22.existsSync(overlayFile)) {
+      return `Git overlay exists at ${overlayFile} but could not be loaded into the server. Restart the MCP server (or check its logs for a git/overlay error); a re-index is not required.`;
+    }
+    return `No git overlay for ${rootDir}. Build it by running \`ctxloom index\` in that repo (the git overlay is created automatically when git is enabled). If the server was started with --no-git, restart it without that flag.`;
+  }
+  return "Git overlay not available. Run `ctxloom index` with git enabled to build it.";
+}
+
+// packages/core/src/tools/git-coupling.ts
 var Schema26 = z31.object({
   file: z31.string().describe("File path to look up co-changed siblings for"),
   limit: z31.number().int().min(1).max(50).default(10),
@@ -9456,11 +9480,11 @@ var Schema26 = z31.object({
   half_life_days: z31.number().int().min(1).max(3650).default(90),
   project_root: ProjectRootField
 });
-function overlayUnavailableResponse(file) {
+function overlayUnavailableResponse(file, note) {
   return {
     file,
     coupledFiles: [],
-    note: "Git overlay not available. Re-index with --with-git to enable coupling data."
+    note
   };
 }
 function buildExplanation(sharedCommits, lastSharedDaysAgo) {
@@ -9485,13 +9509,18 @@ function registerGitCouplingTool(registry, ctx) {
       }
     },
     async (args) => {
-      const { file, limit, min_confidence, half_life_days } = Schema26.parse(args);
-      if (!ctx.overlay) {
-        return JSON.stringify(overlayUnavailableResponse(file));
+      const { file, limit, min_confidence, half_life_days, project_root } = Schema26.parse(args);
+      const overlay = await ctx.getOverlay(project_root);
+      if (!overlay) {
+        return JSON.stringify(
+          overlayUnavailableResponse(file, await overlayUnavailableNote(ctx, project_root))
+        );
       }
-      const coChange = ctx.overlay.coChange;
+      const coChange = overlay.coChange;
       if (coChange.size().pairs === 0) {
-        return JSON.stringify(overlayUnavailableResponse(file));
+        return JSON.stringify(
+          overlayUnavailableResponse(file, await overlayUnavailableNote(ctx, project_root))
+        );
       }
       const nowSec = Math.floor(Date.now() / 1e3);
       const pairs = coChange.topFor({
@@ -9556,8 +9585,9 @@ function registerRiskOverlayTool(registry, ctx) {
       }
     },
     async (args) => {
-      const { nodes } = Schema27.parse(args);
-      if (!ctx.overlay) {
+      const { nodes, project_root } = Schema27.parse(args);
+      const overlay = await ctx.getOverlay(project_root);
+      if (!overlay) {
         const response2 = {
           nodes: nodes.map((file) => ({
             file,
@@ -9571,11 +9601,11 @@ function registerRiskOverlayTool(registry, ctx) {
             note: "no git data"
           })),
           overallRiskScore: 0,
-          note: "Git overlay not available. Re-index with --with-git to enable risk data."
+          note: await overlayUnavailableNote(ctx, project_root)
         };
         return JSON.stringify(response2);
       }
-      const { churn, ownership, coChange } = ctx.overlay;
+      const { churn, ownership, coChange } = overlay;
       const nowSec = Math.floor(Date.now() / 1e3);
       const nodeEntries = nodes.map((file) => {
         const churnStats = churn.statsFor(file);
@@ -9640,8 +9670,8 @@ var RulesConfigError = class extends Error {
 };
 
 // packages/core/src/rules/loadConfig.ts
-import fs22 from "fs/promises";
-import path24 from "path";
+import fs23 from "fs/promises";
+import path25 from "path";
 import yaml from "js-yaml";
 import { z as z33 } from "zod";
 var RuleSchema = z33.object({
@@ -9656,10 +9686,10 @@ var RulesConfigSchema = z33.object({
   rules: z33.array(RuleSchema).default([])
 });
 async function loadRulesConfig(rootDir) {
-  const filePath = path24.join(rootDir, ".ctxloom", "rules.yml");
+  const filePath = path25.join(rootDir, ".ctxloom", "rules.yml");
   let raw;
   try {
-    raw = await fs22.readFile(filePath, "utf-8");
+    raw = await fs23.readFile(filePath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw new RulesConfigError(`Failed to read rules config: ${String(err)}`);
@@ -10072,11 +10102,11 @@ function readRecentChanges(projectRoot) {
     return lines.slice(0, 20).map((line) => {
       const x = line[0];
       const y = line[1];
-      const path38 = line.slice(3).trim();
+      const path39 = line.slice(3).trim();
       let status = "?";
       const xy = x === " " ? y : x;
       if (xy === "M" || xy === "A" || xy === "D" || xy === "R") status = xy;
-      return { file: path38, status };
+      return { file: path39, status };
     });
   } catch {
     return [];
@@ -10303,8 +10333,8 @@ function createToolRegistry(ctx) {
 }
 
 // packages/core/src/tools/ruleManager.ts
-import fs23 from "fs";
-import path25 from "path";
+import fs24 from "fs";
+import path26 from "path";
 var RULE_FILES = [
   ".cursorrules",
   "CLAUDE.md",
@@ -10328,30 +10358,30 @@ var RuleManager = class {
     if (this.cachedRules) return this.cachedRules;
     const rules = [];
     for (const ruleFile of RULE_FILES) {
-      const fullPath = path25.join(this.projectRoot, ruleFile);
+      const fullPath = path26.join(this.projectRoot, ruleFile);
       try {
         this.pathValidator.validate(fullPath);
-        if (fs23.existsSync(fullPath)) {
-          const stat = fs23.statSync(fullPath);
+        if (fs24.existsSync(fullPath)) {
+          const stat = fs24.statSync(fullPath);
           if (stat.isFile()) {
-            const content = fs23.readFileSync(fullPath, "utf-8");
+            const content = fs24.readFileSync(fullPath, "utf-8");
             rules.push({
               name: ruleFile,
               path: ruleFile,
               content
             });
           } else if (stat.isDirectory()) {
-            const dirEntries = fs23.readdirSync(fullPath);
+            const dirEntries = fs24.readdirSync(fullPath);
             for (const entry of dirEntries) {
-              const entryPath = path25.join(fullPath, entry);
+              const entryPath = path26.join(fullPath, entry);
               try {
                 this.pathValidator.validate(entryPath);
               } catch {
                 continue;
               }
-              const entryStat = fs23.statSync(entryPath);
+              const entryStat = fs24.statSync(entryPath);
               if (entryStat.isFile()) {
-                const content = fs23.readFileSync(entryPath, "utf-8");
+                const content = fs24.readFileSync(entryPath, "utf-8");
                 rules.push({
                   name: `${ruleFile}/${entry}`,
                   path: `${ruleFile}/${entry}`,
@@ -10394,8 +10424,8 @@ var RuleManager = class {
 };
 
 // packages/core/src/review/AuthorResolver.ts
-import fs24 from "fs/promises";
-import path26 from "path";
+import fs25 from "fs/promises";
+import path27 from "path";
 import yaml2 from "js-yaml";
 var AuthorResolver = class {
   constructor(ctxloomDir) {
@@ -10420,8 +10450,8 @@ var AuthorResolver = class {
   /** Write a new mapping to the cache file. */
   async writeCache(email, handle) {
     this.cache = { ...this.cache, [email]: handle };
-    await fs24.writeFile(
-      path26.join(this.ctxloomDir, "authors-cache.json"),
+    await fs25.writeFile(
+      path27.join(this.ctxloomDir, "authors-cache.json"),
       JSON.stringify(this.cache, null, 2)
     );
   }
@@ -10430,9 +10460,9 @@ var AuthorResolver = class {
     return emails.filter((e) => this.resolve(e) === void 0);
   }
   async loadYml() {
-    const file = path26.join(this.ctxloomDir, "authors.yml");
+    const file = path27.join(this.ctxloomDir, "authors.yml");
     try {
-      const raw = await fs24.readFile(file, "utf8");
+      const raw = await fs25.readFile(file, "utf8");
       const parsed = yaml2.load(raw);
       if (!parsed) return;
       this.mappings = parsed.mappings ?? {};
@@ -10441,9 +10471,9 @@ var AuthorResolver = class {
     }
   }
   async loadCache() {
-    const file = path26.join(this.ctxloomDir, "authors-cache.json");
+    const file = path27.join(this.ctxloomDir, "authors-cache.json");
     try {
-      const raw = await fs24.readFile(file, "utf8");
+      const raw = await fs25.readFile(file, "utf8");
       this.cache = JSON.parse(raw);
     } catch {
     }
@@ -10468,8 +10498,8 @@ async function resolveViaGitHubApi(email, owner, repo, token) {
 }
 
 // packages/core/src/review/CodeownersWriter.ts
-import fs25 from "fs/promises";
-import path27 from "path";
+import fs26 from "fs/promises";
+import path28 from "path";
 var MARKER_START = "# <ctxloom:start> \u2014 managed by ctxloom review-suggest; do not edit between markers";
 var MARKER_START_DETECT = "# <ctxloom:start>";
 var MARKER_END = "# <ctxloom:end>";
@@ -10501,15 +10531,15 @@ ${block}
 async function generateCODEOWNERS(codeownersPath, rules) {
   let existing = "";
   try {
-    existing = await fs25.readFile(codeownersPath, "utf8");
+    existing = await fs26.readFile(codeownersPath, "utf8");
   } catch {
   }
   const block = buildCodeownersBlock(rules);
   return mergeIntoFile(existing, block);
 }
 async function writeCODEOWNERS(codeownersPath, content) {
-  await fs25.mkdir(path27.dirname(codeownersPath), { recursive: true });
-  await fs25.writeFile(codeownersPath, content, "utf8");
+  await fs26.mkdir(path28.dirname(codeownersPath), { recursive: true });
+  await fs26.writeFile(codeownersPath, content, "utf8");
 }
 
 // packages/core/src/review/types.ts
@@ -10694,8 +10724,8 @@ function matchGlob(pattern, value) {
 }
 
 // packages/core/src/review/loadConfig.ts
-import fs26 from "fs/promises";
-import path28 from "path";
+import fs27 from "fs/promises";
+import path29 from "path";
 import yaml3 from "js-yaml";
 function freshDefaults() {
   return {
@@ -10706,9 +10736,9 @@ function freshDefaults() {
   };
 }
 async function loadReviewConfig(root) {
-  const file = path28.join(root, ".ctxloom", "review.yml");
+  const file = path29.join(root, ".ctxloom", "review.yml");
   try {
-    const raw = await fs26.readFile(file, "utf8");
+    const raw = await fs27.readFile(file, "utf8");
     const parsed = yaml3.load(raw);
     if (!parsed) return freshDefaults();
     return {
@@ -10723,13 +10753,13 @@ async function loadReviewConfig(root) {
 }
 
 // packages/core/src/security/PathValidator.ts
-import path29 from "path";
-import fs27 from "fs";
+import path30 from "path";
+import fs28 from "fs";
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var PathValidator = class {
   canonicalRoot;
   constructor(projectRoot) {
-    this.canonicalRoot = fs27.realpathSync(path29.resolve(projectRoot));
+    this.canonicalRoot = fs28.realpathSync(path30.resolve(projectRoot));
   }
   /**
    * Validates that the given input path resolves within the project root.
@@ -10739,14 +10769,14 @@ var PathValidator = class {
    * @throws Error if the path escapes the project root
    */
   validate(inputPath) {
-    const resolved = path29.resolve(this.canonicalRoot, inputPath);
+    const resolved = path30.resolve(this.canonicalRoot, inputPath);
     let canonical;
     try {
-      canonical = fs27.realpathSync(resolved);
+      canonical = fs28.realpathSync(resolved);
     } catch {
       canonical = resolved;
     }
-    if (!canonical.startsWith(this.canonicalRoot + path29.sep) && canonical !== this.canonicalRoot) {
+    if (!canonical.startsWith(this.canonicalRoot + path30.sep) && canonical !== this.canonicalRoot) {
       throw new Error(
         `Path traversal blocked: "${inputPath}" resolves outside of the project root`
       );
@@ -10763,7 +10793,7 @@ var PathValidator = class {
    * Converts an absolute path to a relative path from the project root.
    */
   toRelative(absolutePath) {
-    return path29.relative(this.canonicalRoot, absolutePath);
+    return path30.relative(this.canonicalRoot, absolutePath);
   }
   /**
    * Validates and reads a file, returning its content.
@@ -10771,11 +10801,11 @@ var PathValidator = class {
    */
   readFile(inputPath) {
     const absPath = this.validate(inputPath);
-    const stat = fs27.statSync(absPath);
+    const stat = fs28.statSync(absPath);
     if (stat.size > MAX_FILE_SIZE) {
       throw new Error(`File too large: ${inputPath} (${Math.round(stat.size / 1024)}KB, max ${MAX_FILE_SIZE / 1024 / 1024}MB)`);
     }
-    return fs27.readFileSync(absPath, "utf-8");
+    return fs28.readFileSync(absPath, "utf-8");
   }
   /**
    * Checks if a path exists and is within the project root.
@@ -10926,7 +10956,7 @@ var EmailAlreadyUsedError = class extends Error {
 
 // packages/core/src/license/LicenseStore.ts
 import { readFileSync, writeFileSync, unlinkSync, mkdirSync, chmodSync, existsSync } from "fs";
-import path30 from "path";
+import path31 from "path";
 
 // packages/core/src/license/types.ts
 import { z as z37 } from "zod";
@@ -10947,7 +10977,7 @@ var LicenseFileSchema = z37.object({
 
 // packages/core/src/license/LicenseStore.ts
 function licenseFilePath(home) {
-  return path30.join(home, ".ctxloom", "license.json");
+  return path31.join(home, ".ctxloom", "license.json");
 }
 var LicenseStore = class {
   filePath;
@@ -10970,7 +11000,7 @@ var LicenseStore = class {
     }
   }
   async write(license) {
-    mkdirSync(path30.dirname(this.filePath), { recursive: true });
+    mkdirSync(path31.dirname(this.filePath), { recursive: true });
     writeFileSync(this.filePath, JSON.stringify(license, null, 2), {
       encoding: "utf8",
       mode: 384
@@ -11101,11 +11131,11 @@ import os5 from "os";
 
 // packages/core/src/license/DistinctIdStore.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
-import path31 from "path";
+import path32 from "path";
 import os3 from "os";
 var UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function distinctIdPath(home) {
-  return path31.join(home ?? os3.homedir(), ".ctxloom", "distinct_id");
+  return path32.join(home ?? os3.homedir(), ".ctxloom", "distinct_id");
 }
 function isValidV4(id) {
   return typeof id === "string" && UUID_V4_REGEX.test(id);
@@ -11126,7 +11156,7 @@ function getOrCreateDistinctId(home) {
     id: crypto.randomUUID(),
     alias_pending: os3.hostname()
   };
-  mkdirSync2(path31.dirname(filePath), { recursive: true });
+  mkdirSync2(path32.dirname(filePath), { recursive: true });
   writeFileSync2(filePath, JSON.stringify(record), { mode: 384 });
   return record;
 }
@@ -11155,7 +11185,7 @@ var TELEMETRY_DISABLED = TELEMETRY_LEVEL === "off";
 function getTelemetryLevel() {
   return TELEMETRY_LEVEL;
 }
-var CTXLOOM_VERSION2 = "1.7.9".length > 0 ? "1.7.9" : "dev";
+var CTXLOOM_VERSION2 = "1.7.10".length > 0 ? "1.7.10" : "dev";
 var POSTHOG_HOST = "https://eu.i.posthog.com";
 var POSTHOG_KEY = process.env["POSTHOG_API_KEY"] ?? (true ? "phc_CiDkmFLcZ2K6uCpcoSUQLmFrnnUvsyXGhSxopX5TVKE6" : "");
 var SENTRY_DSN = process.env["SENTRY_DSN"] ?? (true ? "https://81c94a0f04a8e242dee493ac1e17f733@o4508531702497280.ingest.de.sentry.io/4511256875368528" : "");
@@ -11288,17 +11318,17 @@ function parseStack(stack) {
 
 // packages/core/src/license/FunnelMilestones.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import path32 from "path";
+import path33 from "path";
 import os4 from "os";
 var INSTALL_MARKER = "installed_at";
 var FIRST_REVIEW_MARKER = "first_review_at";
 function writeMarker(filePath) {
-  mkdirSync3(path32.dirname(filePath), { recursive: true });
+  mkdirSync3(path33.dirname(filePath), { recursive: true });
   writeFileSync3(filePath, (/* @__PURE__ */ new Date()).toISOString(), { mode: 384 });
 }
 function shouldEmitInstallCompleted(home) {
   const root = home ?? os4.homedir();
-  const marker = path32.join(root, ".ctxloom", INSTALL_MARKER);
+  const marker = path33.join(root, ".ctxloom", INSTALL_MARKER);
   if (existsSync3(marker)) return false;
   try {
     writeMarker(marker);
@@ -11307,7 +11337,7 @@ function shouldEmitInstallCompleted(home) {
   return true;
 }
 function shouldEmitFirstReviewRun(projectRoot) {
-  const marker = path32.join(projectRoot, ".ctxloom", FIRST_REVIEW_MARKER);
+  const marker = path33.join(projectRoot, ".ctxloom", FIRST_REVIEW_MARKER);
   if (existsSync3(marker)) return false;
   try {
     writeMarker(marker);
@@ -11425,16 +11455,16 @@ async function startTrial(email, opts = {}) {
 
 // packages/core/src/license/TelemetryNotice.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import path33 from "path";
+import path34 from "path";
 import os6 from "os";
 function noticePath(home) {
-  return path33.join(home ?? os6.homedir(), ".ctxloom", "telemetry_notice_shown");
+  return path34.join(home ?? os6.homedir(), ".ctxloom", "telemetry_notice_shown");
 }
 function shouldShowTelemetryNotice(home) {
   const filePath = noticePath(home);
   if (existsSync4(filePath)) return false;
   try {
-    mkdirSync4(path33.dirname(filePath), { recursive: true });
+    mkdirSync4(path34.dirname(filePath), { recursive: true });
     writeFileSync4(filePath, (/* @__PURE__ */ new Date()).toISOString(), { mode: 384 });
   } catch {
   }
@@ -11442,13 +11472,13 @@ function shouldShowTelemetryNotice(home) {
 }
 
 // packages/core/src/server/ProjectState.ts
-import path35 from "path";
+import path36 from "path";
 
 // packages/core/src/server/projectId.ts
 import crypto5 from "crypto";
-import path34 from "path";
+import path35 from "path";
 function hashProjectRoot(absPath) {
-  const canonical = path34.resolve(absPath);
+  const canonical = path35.resolve(absPath);
   return crypto5.createHash("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 
@@ -11456,7 +11486,7 @@ function hashProjectRoot(absPath) {
 function createProjectState(projectRoot, opts = {}) {
   return {
     projectRoot,
-    dbPath: path35.join(projectRoot, ".ctxloom", "vectors.lancedb"),
+    dbPath: path36.join(projectRoot, ".ctxloom", "vectors.lancedb"),
     pinned: opts.pinned ?? false,
     lastTouchedAt: Date.now(),
     vectorsInitialized: false,
@@ -11467,6 +11497,7 @@ function createProjectState(projectRoot, opts = {}) {
     skeletonizerPromise: null,
     ruleManager: null,
     overlay: null,
+    overlayPromise: null,
     watcher: null,
     pathValidator: null
   };
@@ -11507,6 +11538,7 @@ async function disposeProjectState(state) {
   state.skeletonizerPromise = null;
   state.ruleManager = null;
   state.overlay = null;
+  state.overlayPromise = null;
   state.pathValidator = null;
   state.graphInitialized = false;
   state.vectorsInitialized = false;
@@ -11613,8 +11645,8 @@ var ProjectStateManager = class {
 };
 
 // packages/core/src/server/resolveProjectRoot.ts
-import fs28 from "fs";
-import path36 from "path";
+import fs29 from "fs";
+import path37 from "path";
 var PATH_SEPARATOR_PATTERN = /[/\\~]|^[A-Za-z]:/;
 function looksLikePath(value) {
   return PATH_SEPARATOR_PATTERN.test(value);
@@ -11639,13 +11671,13 @@ function resolvePathSafely(p, cwd) {
   let expanded = p;
   if (p === "~" || p.startsWith("~/")) {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    expanded = p === "~" ? home : path36.join(home, p.slice(2));
+    expanded = p === "~" ? home : path37.join(home, p.slice(2));
   }
-  return path36.isAbsolute(expanded) ? path36.resolve(expanded) : path36.resolve(cwd, expanded);
+  return path37.isAbsolute(expanded) ? path37.resolve(expanded) : path37.resolve(cwd, expanded);
 }
 function realpathOrSame(p) {
   try {
-    return fs28.realpathSync(p);
+    return fs29.realpathSync(p);
   } catch {
     return p;
   }
@@ -11670,7 +11702,7 @@ function resolveProjectRoot(input) {
       };
     }
     const resolved2 = resolvePathSafely(arg, cwd);
-    if (!fs28.existsSync(resolved2)) {
+    if (!fs29.existsSync(resolved2)) {
       return {
         kind: "project_root_not_found",
         attemptedPath: resolved2,
@@ -11681,7 +11713,7 @@ function resolveProjectRoot(input) {
   }
   if (env !== void 0 && env !== "") {
     const resolved2 = resolvePathSafely(env, cwd);
-    if (!fs28.existsSync(resolved2)) {
+    if (!fs29.existsSync(resolved2)) {
       return {
         kind: "project_root_not_found",
         attemptedPath: resolved2,
@@ -11708,12 +11740,12 @@ var FILESYSTEM_ROOTS = /* @__PURE__ */ new Set(["/", "C:\\", "D:\\", "E:\\", "F:
 function validateDefaultRoot(candidate) {
   if (FILESYSTEM_ROOTS.has(candidate)) return false;
   try {
-    const stat = fs28.statSync(candidate);
+    const stat = fs29.statSync(candidate);
     if (!stat.isDirectory()) return false;
   } catch {
     return false;
   }
-  return PROJECT_MARKERS.some((m) => fs28.existsSync(path36.join(candidate, m)));
+  return PROJECT_MARKERS.some((m) => fs29.existsSync(path37.join(candidate, m)));
 }
 
 // packages/core/src/server/structuredErrors.ts
@@ -11785,8 +11817,8 @@ var EmittedOnceTracker = class {
 };
 
 // packages/core/src/install/installer.ts
-import fs29 from "fs";
-import path37 from "path";
+import fs30 from "fs";
+import path38 from "path";
 
 // packages/core/src/install/templates.ts
 var RULES_BLOCK_NAME = "CTXLOOM-RULES";
@@ -12491,8 +12523,8 @@ function skillFilePath(name) {
 // packages/core/src/install/installer.ts
 function installHarness(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const projectRoot = path37.resolve(cwd);
-  const stat = fs29.statSync(projectRoot);
+  const projectRoot = path38.resolve(cwd);
+  const stat = fs30.statSync(projectRoot);
   if (!stat.isDirectory()) {
     throw new Error(`installHarness: ${projectRoot} is not a directory`);
   }
@@ -12540,20 +12572,20 @@ function resolveExtraHosts(ids, warnings) {
   return HOST_ADAPTERS.filter((a) => requested.has(a.id));
 }
 function safeJoin(root, name) {
-  const target = path37.resolve(root, name);
-  const rootResolved = path37.resolve(root);
+  const target = path38.resolve(root, name);
+  const rootResolved = path38.resolve(root);
   const caseFold = process.platform === "darwin" || process.platform === "win32";
   const t = caseFold ? target.toLowerCase() : target;
   const r = caseFold ? rootResolved.toLowerCase() : rootResolved;
-  if (!t.startsWith(r + path37.sep) && t !== r) {
+  if (!t.startsWith(r + path38.sep) && t !== r) {
     throw new Error(`installHarness: refusing to write outside project root: ${target}`);
   }
   return target;
 }
 function writeRulesBlock(projectRoot, filename, opts) {
   const filePath = safeJoin(projectRoot, filename);
-  const existed = fs29.existsSync(filePath);
-  const existing = existed ? fs29.readFileSync(filePath, "utf-8") : "";
+  const existed = fs30.existsSync(filePath);
+  const existing = existed ? fs30.readFileSync(filePath, "utf-8") : "";
   if (existed) {
     const block = extractBlock(existing, RULES_BLOCK_NAME);
     if (block) {
@@ -12571,7 +12603,7 @@ function writeRulesBlock(projectRoot, filename, opts) {
   }
   const next = upsertBlock(existing, RULES_BLOCK_NAME, RULES_BLOCK_CONTENT);
   if (!opts.dryRun) {
-    fs29.writeFileSync(filePath, next, "utf-8");
+    fs30.writeFileSync(filePath, next, "utf-8");
   }
   return {
     path: filePath,
@@ -12584,15 +12616,15 @@ function writeRulesBlock(projectRoot, filename, opts) {
 function writeHooksJson(projectRoot, opts) {
   const dir = safeJoin(projectRoot, ".claude");
   const filePath = safeJoin(projectRoot, ".claude/hooks.json");
-  const existed = fs29.existsSync(filePath);
+  const existed = fs30.existsSync(filePath);
   let current = {};
   if (existed) {
     try {
-      const text = fs29.readFileSync(filePath, "utf-8");
+      const text = fs30.readFileSync(filePath, "utf-8");
       current = JSON.parse(text);
     } catch (err) {
       opts.warnings.push(
-        `Could not parse existing ${path37.relative(projectRoot, filePath)}; treating as empty. (${err instanceof Error ? err.message : String(err)})`
+        `Could not parse existing ${path38.relative(projectRoot, filePath)}; treating as empty. (${err instanceof Error ? err.message : String(err)})`
       );
       current = {};
     }
@@ -12609,12 +12641,12 @@ function writeHooksJson(projectRoot, opts) {
   const nextJson = JSON.stringify(merged, null, 2) + "\n";
   let alreadyCorrect = false;
   if (existed) {
-    const currentText = fs29.readFileSync(filePath, "utf-8");
+    const currentText = fs30.readFileSync(filePath, "utf-8");
     if (currentText === nextJson) alreadyCorrect = true;
   }
   if (!opts.dryRun && !alreadyCorrect) {
-    fs29.mkdirSync(dir, { recursive: true });
-    fs29.writeFileSync(filePath, nextJson, "utf-8");
+    fs30.mkdirSync(dir, { recursive: true });
+    fs30.writeFileSync(filePath, nextJson, "utf-8");
   }
   return {
     path: filePath,
@@ -12636,19 +12668,19 @@ function isCtxloomEntry(entry, expectedMatcher) {
 }
 function writeHostAdapter(projectRoot, adapter, opts) {
   const filePath = safeJoin(projectRoot, adapter.path);
-  const dir = path37.dirname(filePath);
-  const existed = fs29.existsSync(filePath);
+  const dir = path38.dirname(filePath);
+  const existed = fs30.existsSync(filePath);
   const rendered = adapter.render();
   let alreadyCorrect = false;
   if (existed) {
-    const current = fs29.readFileSync(filePath, "utf-8");
+    const current = fs30.readFileSync(filePath, "utf-8");
     if (adapter.isCanonical(current)) {
       alreadyCorrect = true;
     }
   }
   if (!opts.dryRun && !alreadyCorrect) {
-    fs29.mkdirSync(dir, { recursive: true });
-    fs29.writeFileSync(filePath, rendered, "utf-8");
+    fs30.mkdirSync(dir, { recursive: true });
+    fs30.writeFileSync(filePath, rendered, "utf-8");
   }
   return {
     path: filePath,
@@ -12661,16 +12693,16 @@ function writeHostAdapter(projectRoot, adapter, opts) {
 function writeSkill(projectRoot, skill, opts) {
   const dir = safeJoin(projectRoot, `.claude/skills/${skill.name}`);
   const filePath = safeJoin(projectRoot, skillFilePath(skill.name));
-  const existed = fs29.existsSync(filePath);
+  const existed = fs30.existsSync(filePath);
   let alreadyCorrect = false;
   if (existed) {
-    if (fs29.readFileSync(filePath, "utf-8") === skill.content) {
+    if (fs30.readFileSync(filePath, "utf-8") === skill.content) {
       alreadyCorrect = true;
     }
   }
   if (!opts.dryRun && !alreadyCorrect) {
-    fs29.mkdirSync(dir, { recursive: true });
-    fs29.writeFileSync(filePath, skill.content, "utf-8");
+    fs30.mkdirSync(dir, { recursive: true });
+    fs30.writeFileSync(filePath, skill.content, "utf-8");
   }
   return {
     path: filePath,
@@ -12683,17 +12715,17 @@ function writeSkill(projectRoot, skill, opts) {
 function writeSessionStartScript(projectRoot, opts) {
   const dir = safeJoin(projectRoot, ".claude/hooks");
   const filePath = safeJoin(projectRoot, ".claude/hooks/session-start.sh");
-  const existed = fs29.existsSync(filePath);
+  const existed = fs30.existsSync(filePath);
   let alreadyCorrect = false;
   if (existed) {
-    const current = fs29.readFileSync(filePath, "utf-8");
+    const current = fs30.readFileSync(filePath, "utf-8");
     if (current === SESSION_START_FULL) alreadyCorrect = true;
   }
   if (!opts.dryRun && !alreadyCorrect) {
-    fs29.mkdirSync(dir, { recursive: true });
-    fs29.writeFileSync(filePath, SESSION_START_FULL, "utf-8");
+    fs30.mkdirSync(dir, { recursive: true });
+    fs30.writeFileSync(filePath, SESSION_START_FULL, "utf-8");
     try {
-      fs29.chmodSync(filePath, 493);
+      fs30.chmodSync(filePath, 493);
     } catch {
     }
   }
@@ -12841,4 +12873,4 @@ export {
   skillFilePath,
   installHarness
 };
-//# sourceMappingURL=chunk-73ZZ6O4B.js.map
+//# sourceMappingURL=chunk-J3NVYR6J.js.map