@yawlabs/ctxlint 0.25.2 → 0.25.3

package/dist/index.js

@@ -1330,8 +1330,8 @@ var require_semaphore = __commonJS({
         this._waiting = [];
       }
       lock(thunk) {
-        return new Promise((resolve19, reject) => {
-          this._waiting.push({ thunk, resolve: resolve19, reject });
+        return new Promise((resolve22, reject) => {
+          this._waiting.push({ thunk, resolve: resolve22, reject });
           this.runNext();
         });
       }
@@ -2960,9 +2960,9 @@ ${JSON.stringify(message, null, 4)}`);
           if (typeof cancellationStrategy.sender.enableCancellation === "function") {
             cancellationStrategy.sender.enableCancellation(requestMessage);
           }
-          return new Promise(async (resolve19, reject) => {
+          return new Promise(async (resolve22, reject) => {
             const resolveWithCleanup = (r2) => {
-              resolve19(r2);
+              resolve22(r2);
               cancellationStrategy.sender.cleanup(id);
               disposable?.dispose();
             };
@@ -8645,8 +8645,8 @@ var require_server = __commonJS({
         if (value instanceof Promise) {
           return value;
         } else if (Is3.thenable(value)) {
-          return new Promise((resolve19, reject) => {
-            value.then((resolved) => resolve19(resolved), (error52) => reject(error52));
+          return new Promise((resolve22, reject) => {
+            value.then((resolved) => resolve22(resolved), (error52) => reject(error52));
           });
         } else {
           return Promise.resolve(value);
@@ -8928,13 +8928,13 @@ var require_files = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.FileSystem = void 0;
     exports.uriToFilePath = uriToFilePath;
-    exports.resolve = resolve19;
+    exports.resolve = resolve22;
     exports.resolveGlobalNodePath = resolveGlobalNodePath;
     exports.resolveGlobalYarnPath = resolveGlobalYarnPath;
     exports.resolveModulePath = resolveModulePath;
     var url2 = __importStar(__require("url"));
-    var path21 = __importStar(__require("path"));
-    var fs16 = __importStar(__require("fs"));
+    var path23 = __importStar(__require("path"));
+    var fs18 = __importStar(__require("fs"));
     var child_process_1 = __require("child_process");
     function uriToFilePath(uri) {
       const parsed = url2.parse(uri);
@@ -8952,12 +8952,12 @@ var require_files = __commonJS({
           segments.shift();
         }
       }
-      return path21.normalize(segments.join("/"));
+      return path23.normalize(segments.join("/"));
     }
     function isWindows() {
       return process.platform === "win32";
     }
-    function resolve19(moduleName, nodePath, cwd, tracer) {
+    function resolve22(moduleName, nodePath, cwd, tracer) {
       const nodePathKey = "NODE_PATH";
       const app = [
         "var p = process;",
@@ -8976,13 +8976,13 @@ var require_files = __commonJS({
         "}",
         "});"
       ].join("");
-      return new Promise((resolve20, reject) => {
+      return new Promise((resolve23, reject) => {
         const env2 = process.env;
         const newEnv = /* @__PURE__ */ Object.create(null);
         Object.keys(env2).forEach((key) => newEnv[key] = env2[key]);
-        if (nodePath && fs16.existsSync(nodePath)) {
+        if (nodePath && fs18.existsSync(nodePath)) {
           if (newEnv[nodePathKey]) {
-            newEnv[nodePathKey] = nodePath + path21.delimiter + newEnv[nodePathKey];
+            newEnv[nodePathKey] = nodePath + path23.delimiter + newEnv[nodePathKey];
           } else {
             newEnv[nodePathKey] = nodePath;
           }
@@ -9008,7 +9008,7 @@ var require_files = __commonJS({
             if (message2.c === "r") {
               cp.send({ c: "e" });
               if (message2.s) {
-                resolve20(message2.r);
+                resolve23(message2.r);
               } else {
                 reject(new Error(`Failed to resolve module: ${moduleName}`));
               }
@@ -9054,9 +9054,9 @@ var require_files = __commonJS({
         }
         if (prefix.length > 0) {
           if (isWindows()) {
-            return path21.join(prefix, "node_modules");
+            return path23.join(prefix, "node_modules");
           } else {
-            return path21.join(prefix, "lib", "node_modules");
+            return path23.join(prefix, "lib", "node_modules");
           }
         }
         return void 0;
@@ -9095,7 +9095,7 @@ var require_files = __commonJS({
           try {
             const yarn = JSON.parse(line);
             if (yarn.type === "log") {
-              return path21.join(yarn.data, "node_modules");
+              return path23.join(yarn.data, "node_modules");
             }
           } catch (e) {
           }
@@ -9117,36 +9117,36 @@ var require_files = __commonJS({
         if (process.platform === "win32") {
           _isCaseSensitive = false;
         } else {
-          _isCaseSensitive = !fs16.existsSync(__filename.toUpperCase()) || !fs16.existsSync(__filename.toLowerCase());
+          _isCaseSensitive = !fs18.existsSync(__filename.toUpperCase()) || !fs18.existsSync(__filename.toLowerCase());
         }
         return _isCaseSensitive;
       }
       FileSystem2.isCaseSensitive = isCaseSensitive;
       function isParent(parent, child) {
         if (isCaseSensitive()) {
-          return path21.normalize(child).indexOf(path21.normalize(parent)) === 0;
+          return path23.normalize(child).indexOf(path23.normalize(parent)) === 0;
         } else {
-          return path21.normalize(child).toLowerCase().indexOf(path21.normalize(parent).toLowerCase()) === 0;
+          return path23.normalize(child).toLowerCase().indexOf(path23.normalize(parent).toLowerCase()) === 0;
         }
       }
       FileSystem2.isParent = isParent;
     })(FileSystem || (exports.FileSystem = FileSystem = {}));
     function resolveModulePath(workspaceRoot, moduleName, nodePath, tracer) {
       if (nodePath) {
-        if (!path21.isAbsolute(nodePath)) {
-          nodePath = path21.join(workspaceRoot, nodePath);
+        if (!path23.isAbsolute(nodePath)) {
+          nodePath = path23.join(workspaceRoot, nodePath);
         }
-        return resolve19(moduleName, nodePath, nodePath, tracer).then((value) => {
+        return resolve22(moduleName, nodePath, nodePath, tracer).then((value) => {
           if (FileSystem.isParent(nodePath, value)) {
             return value;
           } else {
             return Promise.reject(new Error(`Failed to load ${moduleName} from node path location.`));
           }
         }).then(void 0, (_error) => {
-          return resolve19(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
+          return resolve22(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
         });
       } else {
-        return resolve19(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
+        return resolve22(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
       }
     }
   }
@@ -9229,10 +9229,10 @@ var require_ril = __commonJS({
         return api_1.Disposable.create(() => this.stream.off("end", listener));
       }
       write(data, encoding) {
-        return new Promise((resolve19, reject) => {
+        return new Promise((resolve22, reject) => {
           const callback = (error52) => {
             if (error52 === void 0 || error52 === null) {
-              resolve19();
+              resolve22();
             } else {
               reject(error52);
             }
@@ -9369,9 +9369,9 @@ var require_main = __commonJS({
     exports.createMessageConnection = createMessageConnection;
     var ril_1 = __importDefault(require_ril());
     ril_1.default.install();
-    var path21 = __importStar(__require("path"));
+    var path23 = __importStar(__require("path"));
     var os7 = __importStar(__require("os"));
-    var fs16 = __importStar(__require("fs"));
+    var fs18 = __importStar(__require("fs"));
     var crypto_1 = __require("crypto");
     var net_1 = __require("net");
     var api_1 = require_api();
@@ -9512,7 +9512,7 @@ var require_main = __commonJS({
       }
       let randomLength = 32;
       const fixedLength = "/lsp-.sock".length;
-      const tmpDir = fs16.realpathSync(XDG_RUNTIME_DIR ?? os7.tmpdir());
+      const tmpDir = fs18.realpathSync(XDG_RUNTIME_DIR ?? os7.tmpdir());
       const limit = safeIpcPathLengths.get(process.platform);
       if (limit !== void 0) {
         randomLength = Math.min(limit - tmpDir.length - fixedLength, randomLength);
@@ -9521,14 +9521,14 @@ var require_main = __commonJS({
         throw new Error(`Unable to generate a random pipe name with ${randomLength} characters.`);
       }
       const randomSuffix = (0, crypto_1.randomBytes)(Math.floor(randomLength / 2)).toString("hex");
-      return path21.join(tmpDir, `lsp-${randomSuffix}.sock`);
+      return path23.join(tmpDir, `lsp-${randomSuffix}.sock`);
     }
     function createClientPipeTransport(pipeName, encoding = "utf-8") {
       let connectResolve;
-      const connected = new Promise((resolve19, _reject) => {
-        connectResolve = resolve19;
+      const connected = new Promise((resolve22, _reject) => {
+        connectResolve = resolve22;
       });
-      return new Promise((resolve19, reject) => {
+      return new Promise((resolve22, reject) => {
         const server2 = (0, net_1.createServer)((socket) => {
           server2.close();
           connectResolve([
@@ -9539,7 +9539,7 @@ var require_main = __commonJS({
         server2.on("error", reject);
         server2.listen(pipeName, () => {
           server2.removeListener("error", reject);
-          resolve19({
+          resolve22({
             onConnected: () => {
               return connected;
             }
@@ -9556,10 +9556,10 @@ var require_main = __commonJS({
     }
     function createClientSocketTransport(port, encoding = "utf-8") {
       let connectResolve;
-      const connected = new Promise((resolve19, _reject) => {
-        connectResolve = resolve19;
+      const connected = new Promise((resolve22, _reject) => {
+        connectResolve = resolve22;
       });
-      return new Promise((resolve19, reject) => {
+      return new Promise((resolve22, reject) => {
         const server2 = (0, net_1.createServer)((socket) => {
           server2.close();
           connectResolve([
@@ -9570,7 +9570,7 @@ var require_main = __commonJS({
         server2.on("error", reject);
         server2.listen(port, "127.0.0.1", () => {
           server2.removeListener("error", reject);
-          resolve19({
+          resolve22({
             onConnected: () => {
               return connected;
             }
@@ -13567,8 +13567,8 @@ var require_utils = __commonJS({
       }
       return output;
     };
-    exports.basename = (path21, { windows } = {}) => {
-      const segs = path21.split(windows ? /[\\/]/ : "/");
+    exports.basename = (path23, { windows } = {}) => {
+      const segs = path23.split(windows ? /[\\/]/ : "/");
       const last2 = segs[segs.length - 1];
       if (last2 === "") {
         return segs[segs.length - 2];
@@ -13943,7 +13943,7 @@ var require_parse = __commonJS({
       const parts = [];
       let bracket = 0;
       let paren = 0;
-      let quote = 0;
+      let quote2 = 0;
       let value = "";
       let escaped = false;
       for (const ch of input) {
@@ -13958,11 +13958,11 @@ var require_parse = __commonJS({
           continue;
         }
         if (ch === '"') {
-          quote = quote === 1 ? 0 : 1;
+          quote2 = quote2 === 1 ? 0 : 1;
           value += ch;
           continue;
         }
-        if (quote === 0) {
+        if (quote2 === 0) {
           if (ch === "[") {
             bracket++;
           } else if (ch === "]" && bracket > 0) {
@@ -14039,7 +14039,7 @@ var require_parse = __commonJS({
       }
       let bracket = 0;
       let paren = 0;
-      let quote = 0;
+      let quote2 = 0;
       let escaped = false;
       for (let i2 = 1; i2 < pattern.length; i2++) {
         const ch = pattern[i2];
@@ -14052,10 +14052,10 @@ var require_parse = __commonJS({
           continue;
         }
         if (ch === '"') {
-          quote = quote === 1 ? 0 : 1;
+          quote2 = quote2 === 1 ? 0 : 1;
           continue;
         }
-        if (quote === 1) {
+        if (quote2 === 1) {
           continue;
         }
         if (ch === "[") {
@@ -14432,9 +14432,9 @@ var require_parse = __commonJS({
                 const idx = prev.value.lastIndexOf("[");
                 const pre = prev.value.slice(0, idx);
                 const rest2 = prev.value.slice(idx + 2);
-                const posix2 = POSIX_REGEX_SOURCE[rest2];
-                if (posix2) {
-                  prev.value = pre + posix2;
+                const posix3 = POSIX_REGEX_SOURCE[rest2];
+                if (posix3) {
+                  prev.value = pre + posix3;
                   state.backtrack = true;
                   advance();
                   if (!bos.output && tokens.indexOf(prev) === 1) {
@@ -14951,7 +14951,7 @@ var require_picomatch = __commonJS({
         throw new TypeError("Expected pattern to be a non-empty string");
       }
       const opts = options || {};
-      const posix2 = opts.windows;
+      const posix3 = opts.windows;
       const regex2 = isState ? picomatch2.compileRe(glob, options) : picomatch2.makeRe(glob, options, false, true);
       const state = regex2.state;
       delete regex2.state;
@@ -14961,8 +14961,8 @@ var require_picomatch = __commonJS({
         isIgnored = picomatch2(opts.ignore, ignoreOpts, returnState);
       }
       const matcher = (input, returnObject = false) => {
-        const { isMatch, match, output } = picomatch2.test(input, regex2, options, { glob, posix: posix2 });
-        const result = { glob, state, regex: regex2, posix: posix2, input, output, match, isMatch };
+        const { isMatch, match, output } = picomatch2.test(input, regex2, options, { glob, posix: posix3 });
+        const result = { glob, state, regex: regex2, posix: posix3, input, output, match, isMatch };
         if (typeof opts.onResult === "function") {
           opts.onResult(result);
         }
@@ -14987,7 +14987,7 @@ var require_picomatch = __commonJS({
       }
       return matcher;
     };
-    picomatch2.test = (input, regex2, options, { glob, posix: posix2 } = {}) => {
+    picomatch2.test = (input, regex2, options, { glob, posix: posix3 } = {}) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected input to be a string");
       }
@@ -14995,7 +14995,7 @@ var require_picomatch = __commonJS({
         return { isMatch: false, output: "" };
       }
       const opts = options || {};
-      const format3 = opts.format || (posix2 ? utils.toPosixSlashes : null);
+      const format3 = opts.format || (posix3 ? utils.toPosixSlashes : null);
       let match = input === glob;
       let output = match && format3 ? format3(input) : input;
       if (match === false) {
@@ -15004,16 +15004,16 @@ var require_picomatch = __commonJS({
       }
       if (match === false || opts.capture === true) {
         if (opts.matchBase === true || opts.basename === true) {
-          match = picomatch2.matchBase(input, regex2, options, posix2);
+          match = picomatch2.matchBase(input, regex2, options, posix3);
         } else {
           match = regex2.exec(output);
         }
       }
       return { isMatch: Boolean(match), match, output };
     };
-    picomatch2.matchBase = (input, glob, options, posix2 = options && options.windows) => {
+    picomatch2.matchBase = (input, glob, options, posix3 = options && options.windows) => {
       const regex2 = glob instanceof RegExp ? glob : picomatch2.makeRe(glob, options);
-      return regex2.test(utils.basename(input, { windows: posix2 }));
+      return regex2.test(utils.basename(input, { windows: posix3 }));
     };
     picomatch2.isMatch = (str, patterns, options) => picomatch2(patterns, options)(str);
     picomatch2.parse = (pattern, options) => {
@@ -15723,7 +15723,7 @@ var init_parser = __esm({
       "node_modules"
     ]);
     COMMAND_PREFIXES = /^\s*[\$>]\s+(.+)$/;
-    COMMON_COMMANDS = /^(npm|npx|pnpm|yarn|make|cargo|go\s+(run|build|test)|python|pytest|vitest|jest|mocha|tsc|eslint|prettier|bun|deno)\b/;
+    COMMON_COMMANDS = /^(?:(?:npm|npx|pnpm|yarn|make|cargo|go\s+(?:run|build|test)|python|pytest|vitest|jest|mocha|tsc|eslint|prettier|bun|deno)\b|(?:\.[\\/])?(?:gradlew(?:\.bat)?|mvnw(?:\.cmd)?)(?=\s|$)|(?:gradle|mvn(?:\.cmd)?)(?=\s|$))/;
   }
 });
 
@@ -16528,10 +16528,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check2(path21, isFile, isDirectory2) {
-      log(`checking %s`, path21);
+    function check2(path23, isFile, isDirectory2) {
+      log(`checking %s`, path23);
       try {
-        const stat3 = fs_1.statSync(path21);
+        const stat3 = fs_1.statSync(path23);
         if (stat3.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
@@ -16551,8 +16551,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path21, type = exports.READABLE) {
-      return check2(path21, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path23, type = exports.READABLE) {
+      return check2(path23, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -17150,8 +17150,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path21) {
-  return (0, import_file_exists.exists)(path21, import_file_exists.FOLDER);
+function folderExists(path23) {
+  return (0, import_file_exists.exists)(path23, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -17342,8 +17342,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path21) {
-      return /^\.(git)?$/.test(path21.trim());
+    parser(path23) {
+      return /^\.(git)?$/.test(path23.trim());
     }
   };
 }
@@ -17599,11 +17599,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path21, line, preview] = input.split(NULL);
-    paths.add(path21);
-    (results[path21] = results[path21] || []).push({
+    const [path23, line, preview] = input.split(NULL);
+    paths.add(path23);
+    (results[path23] = results[path23] || []).push({
       line: asNumber(line),
-      path: path21,
+      path: path23,
       preview
     });
   });
@@ -17900,14 +17900,14 @@ function hashObjectTask(filePath, write) {
   }
   return straightThroughStringTask(commands, true);
 }
-function parseInit(bare, path21, text) {
+function parseInit(bare, path23, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path21, false, result[1]);
+    return new InitSummary(bare, path23, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path21, true, result[1]);
+    return new InitSummary(bare, path23, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -17918,12 +17918,12 @@ function parseInit(bare, path21, text) {
       break;
     }
   }
-  return new InitSummary(bare, path21, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path23, /^re/i.test(response), gitDir);
 }
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path21, customArgs) {
+function initTask(bare = false, path23, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -17932,7 +17932,7 @@ function initTask(bare = false, path21, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path21, text);
+      return parseInit(commands.includes("--bare"), path23, text);
     }
   };
 }
@@ -18211,14 +18211,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path21) {
+  function data(index, workingDir, path23) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path21);
+      handler(result, path23);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path21, index, workingDir));
+      result.files.push(new FileStatusSummary(path23, index, workingDir));
     }
   }
 }
@@ -18405,8 +18405,8 @@ function deleteBranchTask(branch, forceDelete = false) {
   return task;
 }
 function toPath(input) {
-  const path21 = input.trim().replace(/^["']|["']$/g, "");
-  return path21 && normalize2(path21);
+  const path23 = input.trim().replace(/^["']|["']$/g, "");
+  return path23 && normalize2(path23);
 }
 function checkIgnoreTask(paths) {
   return {
@@ -18545,8 +18545,8 @@ function stashListTask(opt = {}, customArgs) {
     parser: parser4
   };
 }
-function addSubModuleTask(repo, path21) {
-  return subModuleTask(["add", repo, path21]);
+function addSubModuleTask(repo, path23) {
+  return subModuleTask(["add", repo, path23]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -19809,9 +19809,9 @@ var init_esm = __esm({
       "src/lib/responses/InitSummary.ts"() {
         "use strict";
         InitSummary = class {
-          constructor(bare, path21, existing, gitDir) {
+          constructor(bare, path23, existing, gitDir) {
             this.bare = bare;
-            this.path = path21;
+            this.path = path23;
             this.existing = existing;
             this.gitDir = gitDir;
           }
@@ -20344,12 +20344,12 @@ var init_esm = __esm({
         "use strict";
         fromPathRegex = /^(.+)\0(.+)$/;
         FileStatusSummary = class {
-          constructor(path21, index, working_dir) {
-            this.path = path21;
+          constructor(path23, index, working_dir) {
+            this.path = path23;
             this.index = index;
             this.working_dir = working_dir;
             if (index === "R" || working_dir === "R") {
-              const detail = fromPathRegex.exec(path21) || [null, path21, path21];
+              const detail = fromPathRegex.exec(path23) || [null, path23, path23];
               this.from = detail[2] || "";
               this.path = detail[1] || "";
             }
@@ -20611,9 +20611,9 @@ var init_esm = __esm({
               next
             );
           }
-          hashObject(path21, write) {
+          hashObject(path23, write) {
             return this._runTask(
-              hashObjectTask(path21, write === true),
+              hashObjectTask(path23, write === true),
               trailingFunctionArgument(arguments)
             );
           }
@@ -21250,8 +21250,8 @@ var init_esm = __esm({
           }
           return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
         };
-        Git2.prototype.submoduleAdd = function(repo, path21, then) {
-          return this._runTask(addSubModuleTask2(repo, path21), trailingFunctionArgument2(arguments));
+        Git2.prototype.submoduleAdd = function(repo, path23, then) {
+          return this._runTask(addSubModuleTask2(repo, path23), trailingFunctionArgument2(arguments));
         };
         Git2.prototype.submoduleUpdate = function(args2, then) {
           return this._runTask(
@@ -22212,7 +22212,7 @@ var require_levenshtein = __commonJS({
       } catch (err) {
         console.log("Collator could not be initialized and wouldn't be used");
       }
-      var levenshtein3 = (init_mod(), __toCommonJS(mod_exports));
+      var levenshtein4 = (init_mod(), __toCommonJS(mod_exports));
       var prevRow = [], str2Char = [];
       var Levenshtein = {
         /**
@@ -22257,7 +22257,7 @@ var require_levenshtein = __commonJS({
             }
             return nextCol;
           }
-          return levenshtein3.distance(str1, str2);
+          return levenshtein4.distance(str1, str2);
         }
       };
       if (typeof define !== "undefined" && define !== null && define.amd) {
@@ -23053,12 +23053,12 @@ function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
   }
   return result;
 }
-function findNodeAtLocation(root, path21) {
+function findNodeAtLocation(root, path23) {
   if (!root) {
     return void 0;
   }
   let node = root;
-  for (let segment of path21) {
+  for (let segment of path23) {
     if (typeof segment === "string") {
       if (node.type !== "object" || !Array.isArray(node.children)) {
         return void 0;
@@ -23560,20 +23560,20 @@ function splitSegments(cmd) {
   const out = [];
   let buf = "";
   let op = "";
-  let quote = null;
+  let quote2 = null;
   for (let i2 = 0; i2 < cmd.length; i2++) {
     const ch = cmd[i2];
-    if (quote) {
+    if (quote2) {
       buf += ch;
-      if (ch === "\\" && quote !== "'") {
+      if (ch === "\\" && quote2 !== "'") {
         if (i2 + 1 < cmd.length) buf += cmd[++i2];
         continue;
       }
-      if (ch === quote) quote = null;
+      if (ch === quote2) quote2 = null;
       continue;
     }
     if (ch === '"' || ch === "'" || ch === "`") {
-      quote = ch;
+      quote2 = ch;
       buf += ch;
       continue;
     }
@@ -23609,20 +23609,20 @@ function splitSegments(cmd) {
 function splitPipes(segment) {
   const out = [];
   let buf = "";
-  let quote = null;
+  let quote2 = null;
   for (let i2 = 0; i2 < segment.length; i2++) {
     const ch = segment[i2];
-    if (quote) {
+    if (quote2) {
       buf += ch;
-      if (ch === "\\" && quote !== "'") {
+      if (ch === "\\" && quote2 !== "'") {
         if (i2 + 1 < segment.length) buf += segment[++i2];
         continue;
       }
-      if (ch === quote) quote = null;
+      if (ch === quote2) quote2 = null;
       continue;
     }
     if (ch === '"' || ch === "'" || ch === "`") {
-      quote = ch;
+      quote2 = ch;
       buf += ch;
       continue;
     }
@@ -23840,7 +23840,7 @@ function stripComments2(src) {
       continue;
     }
     if (ch === '"' || ch === "'" || ch === "`") {
-      const quote = ch;
+      const quote2 = ch;
       push(ch, false);
       i2++;
       while (i2 < src.length) {
@@ -23850,7 +23850,7 @@ function stripComments2(src) {
           i2 += 2;
           continue;
         }
-        if (src[i2] === quote) break;
+        if (src[i2] === quote2) break;
         push(src[i2], true);
         i2++;
       }
@@ -24041,6 +24041,1021 @@ var init_cli_subcommands = __esm({
   }
 });
 
+// src/core/checks/gradle-projects.ts
+import * as fs6 from "node:fs";
+import * as path7 from "node:path";
+function findGradleBuildRoot(contextFile, projectRoot, requireWrapper = false) {
+  const root = path7.resolve(projectRoot);
+  let dir = path7.dirname(path7.resolve(contextFile));
+  for (; ; ) {
+    if (SETTINGS_FILES.some((f) => fs6.existsSync(path7.join(dir, f)))) {
+      if (!requireWrapper) return dir;
+      return WRAPPER_FILES.some((f) => fs6.existsSync(path7.join(dir, f))) ? dir : null;
+    }
+    if (dir === root) return null;
+    const parent = path7.dirname(dir);
+    const rel = path7.relative(root, parent);
+    if (parent === dir || rel.startsWith("..") || path7.isAbsolute(rel)) return null;
+    dir = parent;
+  }
+}
+function readGradleProjectSet(buildRoot) {
+  const present = SETTINGS_FILES.filter((f) => fs6.existsSync(path7.join(buildRoot, f)));
+  if (present.length !== 1) return null;
+  const parsed = readSettingsFile(path7.join(buildRoot, present[0]));
+  if (!parsed) return null;
+  if (isValidBuildSrc(path7.join(buildRoot, "buildSrc"))) parsed.builds.add("buildSrc");
+  const visited = /* @__PURE__ */ new Set([path7.resolve(buildRoot)]);
+  const queue = parsed.buildDirs.map((d) => ({ dir: path7.resolve(buildRoot, d), depth: 1 }));
+  while (queue.length > 0) {
+    const { dir, depth } = queue.shift();
+    if (visited.has(dir)) continue;
+    visited.add(dir);
+    if (depth > MAX_INCLUDED_BUILD_DEPTH) return null;
+    const files = SETTINGS_FILES.filter((f) => fs6.existsSync(path7.join(dir, f)));
+    if (files.length === 0) continue;
+    if (files.length > 1) return null;
+    const nested = readSettingsFile(path7.join(dir, files[0]));
+    if (!nested) return null;
+    for (const name of nested.builds) parsed.builds.add(name);
+    for (const d of nested.buildDirs) queue.push({ dir: path7.resolve(dir, d), depth: depth + 1 });
+  }
+  return { paths: parsed.paths, builds: parsed.builds, settingsFile: present[0] };
+}
+function readSettingsFile(file2) {
+  try {
+    const buf = fs6.readFileSync(file2);
+    if (buf.includes(0)) return null;
+    return parseSettings(stripBom(buf.toString("utf-8")));
+  } catch {
+    return null;
+  }
+}
+function isValidBuildSrc(dir) {
+  try {
+    if (!fs6.statSync(dir).isDirectory()) return false;
+  } catch {
+    return false;
+  }
+  const markers = ["settings.gradle", "settings.gradle.kts", "build.gradle", "build.gradle.kts"];
+  if (markers.some((m) => fs6.existsSync(path7.join(dir, m)))) return true;
+  return fs6.existsSync(path7.join(dir, "src"));
+}
+function parseSettings(source) {
+  const tokens = tokenize(source);
+  if (!tokens) return null;
+  const paths = /* @__PURE__ */ new Set();
+  const builds = /* @__PURE__ */ new Set();
+  const buildDirs = [];
+  const renames = [];
+  const blocks = [];
+  let pluginManagementEnd = -1;
+  for (let i2 = 0; i2 < tokens.length; i2++) {
+    const t2 = tokens[i2];
+    if (t2.kind === "punct") {
+      if (t2.text === "{") blocks.push(blockOpener(tokens, i2));
+      else if (t2.text === "}") blocks.pop();
+      continue;
+    }
+    if (t2.kind === "string") {
+      const before = tokens[i2 - 1];
+      if (before?.kind === "punct" && (before.text === "." || before.text === "?.")) return null;
+      if (before?.kind === "punct" && before.text === "[" && (t2.text === "name" || t2.text === "setName")) {
+        return null;
+      }
+      continue;
+    }
+    if (t2.kind !== "ident") continue;
+    if (t2.text === "apply") {
+      if (!appliesBenignPlugin(tokens, i2)) return null;
+      continue;
+    }
+    if (t2.text === "pluginManagement" && tokens[i2 + 1]?.text === "{") {
+      pluginManagementEnd = Math.max(pluginManagementEnd, skipBalanced(tokens, i2 + 1));
+      continue;
+    }
+    const prev = tokens[i2 - 1];
+    const receiverDot = prev?.kind === "punct" && (prev.text === "." || prev.text === "?.");
+    const receiver = receiverDot ? tokens[i2 - 2] : void 0;
+    if (OPEN_IDENTIFIERS.has(t2.text)) {
+      const systemProperty = t2.text === "setProperty" && receiver?.kind === "ident" && receiver.text === "System";
+      if (!systemProperty) return null;
+    }
+    if (t2.text === "include" || t2.text === "includeFlat") {
+      const args2 = literalArguments(tokens, i2 + 1);
+      if (!args2) return null;
+      for (const arg of args2) {
+        if (t2.text === "includeFlat") paths.add(`:${arg}`);
+        else addIncludePath(paths, arg);
+      }
+      continue;
+    }
+    if (t2.text === "includeBuild") {
+      if (receiverDot) return null;
+      const args2 = literalArguments(tokens, i2 + 1, 1);
+      if (!args2 || args2.length !== 1) return null;
+      const base = path7.posix.basename(args2[0].replace(/\\/g, "/").replace(/\/+$/, ""));
+      if (!base || base === "." || base === "..") return null;
+      builds.add(base);
+      buildDirs.push(args2[0]);
+      const override = includeBuildNameOverride(tokens, i2 + 1);
+      if (override === null) return null;
+      if (override) builds.add(override);
+      continue;
+    }
+    if (t2.text === "plugins" && tokens[i2 + 1]?.kind === "punct" && tokens[i2 + 1].text === "{") {
+      if (i2 >= pluginManagementEnd && !pluginsBlockIsBenign(tokens, i2 + 1)) return null;
+      i2 = skipBalanced(tokens, i2 + 1) - 1;
+      continue;
+    }
+    if (t2.text === "name" || t2.text === "setName") {
+      const next = tokens[i2 + 1];
+      const after = tokens[i2 + 2];
+      const isAssign = next?.kind === "punct" && next.text === "=";
+      const isCompound = next?.kind === "punct" && /^[-+*/%]$/.test(next.text) && after?.text === "=";
+      const isSetter = t2.text === "setName" && next !== void 0 && next.line === t2.line;
+      if (!isAssign && !isCompound && !isSetter) continue;
+      const local = prev?.kind === "ident" && ["def", "val", "var"].includes(prev.text);
+      if (local) continue;
+      if (receiverDot) {
+        if (receiver?.kind === "ident" && receiver.text === "rootProject") continue;
+        if (isCompound) return null;
+        const target = literalProjectCall(tokens, i2 - 2);
+        const value = isAssign ? literalValue(tokens, i2 + 2) : literalArguments(tokens, i2 + 1, 1)?.[0];
+        if (!target || !value) return null;
+        renames.push({ from: normalizeProjectPath(target), to: value });
+        continue;
+      }
+      const unsafe = blocks.some((b2) => !NAME_SAFE_BLOCKS.has(b2) && !TRANSPARENT_BLOCKS.has(b2));
+      if (unsafe) return null;
+    }
+  }
+  for (const { from, to } of renames) {
+    const parent = from.slice(0, from.lastIndexOf(":"));
+    const moved = `${parent}:${to}`;
+    for (const p2 of [...paths]) {
+      if (p2 === from) paths.add(moved);
+      else if (p2.startsWith(`${from}:`)) paths.add(moved + p2.slice(from.length));
+    }
+  }
+  return { paths, builds, buildDirs };
+}
+function addIncludePath(paths, arg) {
+  const segments = arg.replace(/^:/, "").split(":");
+  if (segments.some((s) => s.length === 0)) return;
+  let acc = "";
+  for (const s of segments) {
+    acc += `:${s}`;
+    paths.add(acc);
+  }
+}
+function normalizeProjectPath(p2) {
+  return p2.startsWith(":") ? p2 : `:${p2}`;
+}
+function literalArguments(tokens, start, max = Infinity) {
+  const out = [];
+  let i2 = start;
+  const first2 = tokens[i2];
+  if (!first2) return null;
+  const parenthesized = first2.kind === "punct" && first2.text === "(";
+  if (parenthesized) i2++;
+  const line = first2.line;
+  for (; ; ) {
+    let t2 = tokens[i2];
+    if (!t2) return parenthesized ? null : out.length ? out : null;
+    if (parenthesized && t2.kind === "punct" && t2.text === ")") return out;
+    if (t2.kind === "punct" && t2.text === "*") t2 = tokens[++i2];
+    if (t2 && t2.kind === "ident" && ["listOf", "arrayOf", "setOf"].includes(t2.text) && tokens[i2 + 1]?.text === "(") {
+      const inner = literalArguments(tokens, i2 + 1);
+      if (!inner) return null;
+      out.push(...inner);
+      i2 = skipBalanced(tokens, i2 + 1);
+    } else if (t2 && t2.kind === "punct" && t2.text === "[") {
+      const inner = literalList(tokens, i2);
+      if (!inner) return null;
+      out.push(...inner.values);
+      i2 = inner.next;
+    } else if (t2 && t2.kind === "string" && !t2.interpolated) {
+      out.push(t2.text);
+      i2++;
+    } else if (t2 && t2.kind === "ident" && t2.text === "file" && tokens[i2 + 1]?.text === "(" && literalValue(tokens, i2 + 2) !== null && tokens[i2 + 3]?.text === ")") {
+      out.push(literalValue(tokens, i2 + 2));
+      i2 += 4;
+    } else {
+      return null;
+    }
+    if (out.length > max) return null;
+    const sep2 = tokens[i2];
+    if (sep2?.kind === "punct" && sep2.text === ",") {
+      i2++;
+      continue;
+    }
+    if (parenthesized) {
+      return sep2?.kind === "punct" && sep2.text === ")" ? out : null;
+    }
+    if (!sep2 || sep2.line > (tokens[i2 - 1]?.line ?? line) || sep2.text === ";" || sep2.text === "}") {
+      return out;
+    }
+    return null;
+  }
+}
+function literalList(tokens, start) {
+  const values = [];
+  let i2 = start + 1;
+  for (; ; ) {
+    const t2 = tokens[i2];
+    if (!t2) return null;
+    if (t2.kind === "punct" && t2.text === "]") return { values, next: i2 + 1 };
+    if (t2.kind !== "string" || t2.interpolated) return null;
+    values.push(t2.text);
+    i2++;
+    const sep2 = tokens[i2];
+    if (sep2?.kind === "punct" && sep2.text === ",") i2++;
+  }
+}
+function skipBalanced(tokens, start) {
+  const open = tokens[start].text;
+  const close = open === "(" ? ")" : open === "[" ? "]" : "}";
+  let depth = 0;
+  for (let i2 = start; i2 < tokens.length; i2++) {
+    const t2 = tokens[i2];
+    if (t2.kind !== "punct") continue;
+    if (t2.text === open) depth++;
+    else if (t2.text === close && --depth === 0) return i2 + 1;
+  }
+  return tokens.length;
+}
+function literalValue(tokens, i2) {
+  const t2 = tokens[i2];
+  return t2?.kind === "string" && !t2.interpolated ? t2.text : null;
+}
+function literalProjectCall(tokens, end) {
+  let i2 = end;
+  while (tokens[i2]?.kind === "punct" && tokens[i2].text === "!") i2--;
+  if (tokens[i2]?.text !== ")") return null;
+  const lit = tokens[i2 - 1];
+  const open = tokens[i2 - 2];
+  const fn = tokens[i2 - 3];
+  if (lit?.kind !== "string" || lit.interpolated) return null;
+  if (open?.text !== "(" || fn?.kind !== "ident") return null;
+  if (fn.text !== "project" && fn.text !== "findProject") return null;
+  return lit.text;
+}
+function includeBuildNameOverride(tokens, argsStart) {
+  let i2 = argsStart;
+  if (tokens[i2]?.text === "(") i2 = skipBalanced(tokens, i2);
+  else while (tokens[i2]?.kind === "string") i2++;
+  if (tokens[i2]?.text !== "{") return "";
+  const end = skipBalanced(tokens, i2);
+  let found = "";
+  for (let j3 = i2 + 1; j3 < end; j3++) {
+    const t2 = tokens[j3];
+    if (t2.kind !== "ident" || t2.text !== "name" && t2.text !== "setName") continue;
+    let value;
+    if (t2.text === "name" && tokens[j3 + 1]?.text === "=" && tokens[j3 + 2]?.text !== "=") {
+      value = literalValue(tokens, j3 + 2);
+    } else if (t2.text === "setName") {
+      value = literalArguments(tokens, j3 + 1, 1)?.[0] ?? null;
+    } else if (tokens[j3 + 1]?.kind === "punct" && /^[-+*/%]$/.test(tokens[j3 + 1].text)) {
+      return null;
+    } else {
+      continue;
+    }
+    if (value === null) return null;
+    found = value;
+  }
+  return found;
+}
+function pluginsBlockIsBenign(tokens, braceIndex) {
+  const end = skipBalanced(tokens, braceIndex);
+  for (let j3 = braceIndex + 1; j3 < end - 1; j3++) {
+    const t2 = tokens[j3];
+    if (t2.kind !== "ident") continue;
+    if (t2.text === "id") {
+      const id = literalValue(tokens, tokens[j3 + 1]?.text === "(" ? j3 + 2 : j3 + 1);
+      if (!id) return false;
+      let applyFalse = false;
+      for (let k3 = j3 + 1; k3 < end - 1 && tokens[k3].line === t2.line; k3++) {
+        if (tokens[k3].text === ";" || tokens[k3].kind === "ident" && tokens[k3].text === "id")
+          break;
+        if (tokens[k3].kind === "ident" && tokens[k3].text === "apply") {
+          const n7 = tokens[k3 + 1]?.text === "(" ? tokens[k3 + 2] : tokens[k3 + 1];
+          applyFalse = n7?.kind === "ident" && n7.text === "false";
+        }
+      }
+      if (!applyFalse && !BENIGN_SETTINGS_PLUGINS.has(id)) return false;
+    } else if (!["version", "apply", "false"].includes(t2.text)) {
+      return false;
+    }
+  }
+  return true;
+}
+function appliesBenignPlugin(tokens, i2) {
+  let j3 = i2 + 1;
+  if (tokens[j3]?.text === "(") j3++;
+  const key = tokens[j3];
+  const sep2 = tokens[j3 + 1];
+  if (key?.kind !== "ident" || key.text !== "plugin") return false;
+  if (sep2?.text !== ":" && sep2?.text !== "=") return false;
+  const id = literalValue(tokens, j3 + 2);
+  if (tokens[j3 + 3]?.text === ",") return false;
+  return id !== null && BENIGN_SETTINGS_PLUGINS.has(id);
+}
+function blockOpener(tokens, braceIndex) {
+  let j3 = braceIndex - 1;
+  if (tokens[j3]?.text === ")") {
+    let depth = 0;
+    for (; j3 >= 0; j3--) {
+      if (tokens[j3].text === ")") depth++;
+      else if (tokens[j3].text === "(" && --depth === 0) break;
+    }
+    j3--;
+  }
+  const t2 = tokens[j3];
+  return t2?.kind === "ident" ? t2.text : "";
+}
+function tokenize(src) {
+  const tokens = [];
+  let line = 1;
+  let i2 = 0;
+  const n7 = src.length;
+  while (i2 < n7) {
+    const c3 = src[i2];
+    if (c3 === "\n") {
+      line++;
+      i2++;
+      continue;
+    }
+    if (c3 === " " || c3 === "	" || c3 === "\r") {
+      i2++;
+      continue;
+    }
+    if (c3 === "/" && src[i2 + 1] === "/") {
+      while (i2 < n7 && src[i2] !== "\n") i2++;
+      continue;
+    }
+    if (c3 === "/" && src[i2 + 1] === "*") {
+      const end = src.indexOf("*/", i2 + 2);
+      if (end < 0) return null;
+      for (let k3 = i2; k3 < end; k3++) if (src[k3] === "\n") line++;
+      i2 = end + 2;
+      continue;
+    }
+    if (c3 === "/") {
+      const last2 = tokens[tokens.length - 1];
+      const operandPosition = !last2 || last2.kind === "punct" && ["=", "==", "(", ",", "[", "{", ":", "~", "!", ";"].includes(last2.text) || last2.kind === "ident" && last2.text === "return";
+      if (operandPosition) return null;
+    }
+    if (c3 === "$" && src[i2 + 1] === "/") return null;
+    if (c3 === '"' || c3 === "'") {
+      const triple = src.startsWith(c3.repeat(3), i2);
+      const delim = triple ? c3.repeat(3) : c3;
+      const startLine = line;
+      let j3 = i2 + delim.length;
+      let text = "";
+      let interpolated = false;
+      let closed = false;
+      while (j3 < n7) {
+        if (src.startsWith(delim, j3)) {
+          closed = true;
+          j3 += delim.length;
+          break;
+        }
+        const ch = src[j3];
+        if (ch === "\n") {
+          if (!triple) return null;
+          line++;
+        }
+        if (ch === "\\" && j3 + 1 < n7) {
+          text += src[j3 + 1];
+          j3 += 2;
+          continue;
+        }
+        if (ch === "$" && c3 === '"') {
+          interpolated = true;
+          if (src[j3 + 1] === "{") {
+            const end = skipTemplate(src, j3 + 1);
+            if (end < 0) return null;
+            for (let k3 = j3; k3 < end; k3++) if (src[k3] === "\n") line++;
+            j3 = end;
+            continue;
+          }
+        }
+        text += ch;
+        j3++;
+      }
+      if (!closed) return null;
+      tokens.push({ kind: "string", text, interpolated, line: startLine });
+      i2 = j3;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(c3)) {
+      let j3 = i2 + 1;
+      while (j3 < n7 && /[\w$]/.test(src[j3])) j3++;
+      tokens.push({ kind: "ident", text: src.slice(i2, j3), line });
+      i2 = j3;
+      continue;
+    }
+    if (c3 === "`") {
+      const end = src.indexOf("`", i2 + 1);
+      if (end < 0) return null;
+      tokens.push({ kind: "ident", text: src.slice(i2 + 1, end), line });
+      i2 = end + 1;
+      continue;
+    }
+    if (c3 === "?" && src[i2 + 1] === ".") {
+      tokens.push({ kind: "punct", text: "?.", line });
+      i2 += 2;
+      continue;
+    }
+    if (c3 === "=" && src[i2 + 1] === "=") {
+      tokens.push({ kind: "punct", text: "==", line });
+      i2 += 2;
+      continue;
+    }
+    tokens.push({ kind: "punct", text: c3, line });
+    i2++;
+  }
+  return tokens;
+}
+function skipTemplate(src, open) {
+  let depth = 0;
+  for (let j3 = open; j3 < src.length; j3++) {
+    const ch = src[j3];
+    if (ch === "{") depth++;
+    else if (ch === "}" && --depth === 0) return j3 + 1;
+    else if (ch === '"' || ch === "'") {
+      const end = src.indexOf(ch, j3 + 1);
+      if (end < 0) return -1;
+      j3 = end;
+    }
+  }
+  return -1;
+}
+function quote(s) {
+  return s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}
+function patternForName(name, boundary, add) {
+  let out = "";
+  let pos = 0;
+  boundary.lastIndex = 0;
+  for (const m of name.matchAll(boundary)) {
+    const start = m.index ?? 0;
+    if (start > pos) out += quote(name.slice(pos, start));
+    out += add(pos, m[0]);
+    pos = start + m[0].length;
+  }
+  if (pos < name.length) out += quote(name.slice(pos));
+  return out;
+}
+function matchGradleName(pattern, items) {
+  const list = [...items];
+  if (list.includes(pattern)) return pattern;
+  if (!pattern) return null;
+  const camel = patternForName(
+    pattern,
+    CAMEL_BOUNDARY,
+    (_pos, part) => `${quote(part)}[${LOWER}]*`
+  );
+  const kebab = patternForName(
+    pattern,
+    KEBAB_BOUNDARY,
+    (pos, part) => `${pos > 0 ? "-" : ""}${quote(part.toLowerCase())}[${LOWER}0-9]*`
+  );
+  const camelFull = new RegExp(`^(?:${camel})$`, "u");
+  const camelPrefix = new RegExp(`^(?:${camel})`, "u");
+  const camelPrefixCi = new RegExp(`^(?:${camel})`, "iu");
+  const kebabFull = new RegExp(`^(?:${kebab})$`, "u");
+  const kebabPrefix = new RegExp(`^(?:${kebab})[${LOWER}0-9-]*$`, "u");
+  const ci2 = [];
+  const camelMatches = [];
+  const prefixMatches = [];
+  const ciCamel = [];
+  const kebabMatches = [];
+  const kebabPrefixMatches = [];
+  const upper = pattern.toUpperCase();
+  for (const c3 of list) {
+    if (c3.toUpperCase() === upper) ci2.push(c3);
+    if (camelFull.test(c3)) camelMatches.push(c3);
+    if (camelPrefix.test(c3)) prefixMatches.push(c3);
+    if (camelPrefixCi.test(c3)) ciCamel.push(c3);
+    if (kebabFull.test(c3)) kebabMatches.push(c3);
+    if (kebabPrefix.test(c3)) kebabPrefixMatches.push(c3);
+  }
+  const matches = /* @__PURE__ */ new Set();
+  if (ci2.length) ci2.forEach((m) => matches.add(m));
+  else if (camelMatches.length) camelMatches.forEach((m) => matches.add(m));
+  else if (prefixMatches.length) prefixMatches.forEach((m) => matches.add(m));
+  else if (!kebabMatches.length && !kebabPrefixMatches.length)
+    ciCamel.forEach((m) => matches.add(m));
+  if (kebabMatches.length) kebabMatches.forEach((m) => matches.add(m));
+  else kebabPrefixMatches.forEach((m) => matches.add(m));
+  if (matches.size === 1) return [...matches][0];
+  return matches.size > 1 ? "ambiguous" : null;
+}
+function gradleProjectRefs(cmd) {
+  const tokens = shellWords(cmd);
+  if (!tokens || tokens.length === 0 || !GRADLE_HEAD.test(tokens[0])) return null;
+  if (tokens.length > 1 && CONTINUATION.test(tokens[tokens.length - 1])) return null;
+  const refs = [];
+  for (let i2 = 1; i2 < tokens.length; i2++) {
+    const tok = tokens[i2];
+    if (tok.startsWith("-")) {
+      const bare = tok.includes("=") ? tok.slice(0, tok.indexOf("=")) : tok;
+      if (RETARGET_OPTIONS.has(bare)) return null;
+      if (!tok.startsWith("--") && tok.length > 2) {
+        if (RETARGET_OPTIONS.has(tok.slice(0, 2))) return null;
+        continue;
+      }
+      if (tok.includes("=")) continue;
+      if (VALUE_OPTIONS.has(tok)) {
+        i2++;
+        continue;
+      }
+      if (tok.startsWith("--") && !BOOLEAN_LONG_OPTIONS.has(tok)) {
+        if (tokens[i2 + 1] && !tokens[i2 + 1].startsWith("-")) i2++;
+      }
+      continue;
+    }
+    if (!TASK_PATH.test(tok)) continue;
+    const absolute = tok.startsWith(":");
+    const segments = (absolute ? tok.slice(1) : tok).split(":");
+    const projectSegments = segments.slice(0, -1);
+    if (projectSegments.length === 0) continue;
+    if (projectSegments.some((s) => PLACEHOLDER_SEGMENT.test(s))) continue;
+    refs.push({ token: tok, segments: projectSegments, absolute });
+  }
+  return refs;
+}
+function shellWords(cmd) {
+  const words = [];
+  let buf = "";
+  let inWord = false;
+  let quote2 = null;
+  for (let i2 = 0; i2 < cmd.length; i2++) {
+    const ch = cmd[i2];
+    if (quote2) {
+      if (ch === quote2) quote2 = null;
+      else buf += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote2 = ch;
+      inWord = true;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      if (inWord) words.push(buf);
+      buf = "";
+      inWord = false;
+      continue;
+    }
+    if (!inWord && ch === "#") break;
+    if (ch === "<") {
+      const close = cmd.slice(i2).search(/>|\s/);
+      if (close > 1 && cmd[i2 + close] === ">") {
+        buf += cmd.slice(i2, i2 + close + 1);
+        i2 += close;
+        inWord = true;
+        continue;
+      }
+    }
+    if (ch === "&" || ch === "|" || ch === ";" || ch === ">" || ch === "<") break;
+    buf += ch;
+    inWord = true;
+  }
+  if (quote2) return null;
+  if (inWord) words.push(buf);
+  return words;
+}
+function unresolvedGradleProject(ref, set2) {
+  let current = "";
+  for (let depth = 0; depth < ref.segments.length; depth++) {
+    const seg = ref.segments[depth];
+    const children = childNames(set2.paths, current);
+    if (depth === 0) {
+      const match2 = matchGradleName(seg, [...children, ...set2.builds]);
+      if (match2 === null) return `:${seg}`;
+      if (match2 === "ambiguous" || set2.builds.has(match2)) return null;
+      current = `:${match2}`;
+      continue;
+    }
+    const match = matchGradleName(seg, children);
+    if (match === null) return `${current}:${seg}`;
+    if (match === "ambiguous") return null;
+    current = `${current}:${match}`;
+  }
+  return null;
+}
+function childNames(paths, parent) {
+  const out = /* @__PURE__ */ new Set();
+  const prefix = `${parent}:`;
+  for (const p2 of paths) {
+    if (!p2.startsWith(prefix)) continue;
+    const rest = p2.slice(prefix.length);
+    if (rest && !rest.includes(":")) out.add(rest);
+  }
+  return out;
+}
+var SETTINGS_FILES, BENIGN_SETTINGS_PLUGINS, OPEN_IDENTIFIERS, WRAPPER_FILES, MAX_INCLUDED_BUILD_DEPTH, NAME_SAFE_BLOCKS, TRANSPARENT_BLOCKS, PUNCT, LOWER, UPPER, CAMEL_BOUNDARY, KEBAB_BOUNDARY, GRADLE_HEAD, VALUE_OPTIONS, RETARGET_OPTIONS, BOOLEAN_LONG_OPTIONS, CONTINUATION, TASK_PATH, PLACEHOLDER_SEGMENT;
+var init_gradle_projects = __esm({
+  "src/core/checks/gradle-projects.ts"() {
+    "use strict";
+    init_define_WEB_FIRST_SEGMENTS();
+    init_fs();
+    SETTINGS_FILES = ["settings.gradle", "settings.gradle.kts"];
+    BENIGN_SETTINGS_PLUGINS = /* @__PURE__ */ new Set([
+      "com.gradle.develocity",
+      "com.gradle.enterprise",
+      "com.gradle.common-custom-user-data-gradle-plugin",
+      "org.gradle.toolchains.foojay-resolver",
+      "org.gradle.toolchains.foojay-resolver-convention"
+    ]);
+    OPEN_IDENTIFIERS = /* @__PURE__ */ new Set([
+      "pluginManager",
+      "settingsEvaluated",
+      "beforeSettings",
+      "evaluate",
+      "GroovyShell",
+      "Eval",
+      "ScriptEngineManager",
+      "createProjectDescriptor",
+      // A settings `buildscript {}` puts a jar on the settings classpath, which can
+      // contribute extension functions on Settings; `classpath` alone misses
+      // `add('classpath', ...)` and Kotlin `"classpath"(...)`.
+      "buildscript",
+      "classpath",
+      "invokeMethod",
+      "metaClass",
+      "methodMissing",
+      "setProperty"
+    ]);
+    WRAPPER_FILES = ["gradlew", "gradlew.bat"];
+    MAX_INCLUDED_BUILD_DEPTH = 8;
+    NAME_SAFE_BLOCKS = /* @__PURE__ */ new Set([
+      "pluginManagement",
+      "dependencyResolutionManagement",
+      "repositories",
+      "maven",
+      "ivy",
+      "exclusiveContent",
+      "forRepository",
+      "filter",
+      "content",
+      "credentials",
+      "authentication",
+      "versionCatalogs",
+      "create",
+      "register",
+      "develocity",
+      "gradleEnterprise",
+      "buildScan",
+      "buildCache",
+      "local",
+      "remote",
+      "toolchainManagement",
+      "jvm",
+      "javaRepositories",
+      "includeBuild",
+      "dependencySubstitution"
+    ]);
+    TRANSPARENT_BLOCKS = /* @__PURE__ */ new Set([
+      "if",
+      "else",
+      "for",
+      "while",
+      "try",
+      "catch",
+      "finally",
+      "when"
+    ]);
+    PUNCT = "[!\"#$%&'()*+,\\-./:;<=>?@\\[\\\\\\]^_`{|}~]";
+    LOWER = "\\p{Lowercase}";
+    UPPER = "\\p{Uppercase}";
+    CAMEL_BOUNDARY = new RegExp(`((^|${PUNCT})${LOWER}+)|((${UPPER}|[0-9])${LOWER}*)`, "gu");
+    KEBAB_BOUNDARY = new RegExp(`((^|${PUNCT})${LOWER}+)|(${UPPER}${LOWER}*)`, "gu");
+    GRADLE_HEAD = /^(?:\.[\\/])?gradlew(?:\.bat)?$|^gradle$/;
+    VALUE_OPTIONS = /* @__PURE__ */ new Set([
+      "-x",
+      "--exclude-task",
+      "-g",
+      "--gradle-user-home",
+      "--project-cache-dir",
+      "--console",
+      "--console-unicode",
+      "--warning-mode",
+      "--max-workers",
+      "--priority",
+      "--develocity-url",
+      "--develocity-plugin-version",
+      "--write-verification-metadata",
+      "-F",
+      "--dependency-verification",
+      "--update-locks",
+      "--configuration-cache-problems",
+      "-D",
+      "--system-prop",
+      "-P",
+      "--project-prop"
+    ]);
+    RETARGET_OPTIONS = /* @__PURE__ */ new Set([
+      "-p",
+      "--project-dir",
+      "-c",
+      "--settings-file",
+      "-b",
+      "--build-file",
+      "--include-build",
+      "-I",
+      "--init-script"
+    ]);
+    BOOLEAN_LONG_OPTIONS = /* @__PURE__ */ new Set([
+      "--rerun-tasks",
+      "--profile",
+      "--continue",
+      "--no-continue",
+      "--offline",
+      "--refresh-dependencies",
+      "--dry-run",
+      "--continuous",
+      "--no-rebuild",
+      "--configure-on-demand",
+      "--no-configure-on-demand",
+      "--build-cache",
+      "--no-build-cache",
+      "--watch-fs",
+      "--no-watch-fs",
+      "--scan",
+      "--no-scan",
+      "--write-locks",
+      "--refresh-keys",
+      "--export-keys",
+      "--configuration-cache",
+      "--no-configuration-cache",
+      "--property-upgrade-report",
+      "--problems-report",
+      "--no-problems-report",
+      "--task-graph",
+      "--quiet",
+      "--warn",
+      "--info",
+      "--debug",
+      "--stacktrace",
+      "--full-stacktrace",
+      "--non-interactive",
+      "--parallel",
+      "--no-parallel",
+      "--daemon",
+      "--no-daemon",
+      "--foreground",
+      "--stop",
+      "--status",
+      "--help",
+      "--version",
+      "--show-version"
+    ]);
+    CONTINUATION = /^[\\^`]$/;
+    TASK_PATH = /^:?[\w.-]+(?::[\w.-]+)+$|^:[\w.-]+$/;
+    PLACEHOLDER_SEGMENT = /^(?:module|project|subproject|submodule|component|feature)(?:[-_]?(?:name|path|id))?$|^(?:my|your|some|example|sample)[-_]|^(?:foo|bar|baz|xxx|name)$/i;
+  }
+});
+
+// src/core/checks/maven-modules.ts
+import * as fs7 from "node:fs";
+import * as path8 from "node:path";
+function readMavenReactor(baseDir) {
+  const rootPom = path8.join(baseDir, "pom.xml");
+  if (!fs7.existsSync(rootPom)) return null;
+  const projects = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [path8.resolve(rootPom)];
+  while (queue.length > 0) {
+    const pomFile = realPath(queue.shift());
+    if (pomFile === null) return null;
+    if (seen.has(pomFile)) continue;
+    seen.add(pomFile);
+    if (seen.size > MAX_POMS) return null;
+    let xml;
+    try {
+      xml = readXml(pomFile);
+    } catch {
+      return null;
+    }
+    const model = parsePom(xml);
+    if (!model) return null;
+    const basedir = path8.dirname(pomFile);
+    projects.push({ basedir, pomFile, artifactId: model.artifactId, groupId: model.groupId });
+    for (const module of model.modules) {
+      const target = path8.resolve(basedir, module);
+      let childPom = target;
+      try {
+        if (fs7.statSync(target).isDirectory()) childPom = path8.join(target, "pom.xml");
+      } catch {
+        return null;
+      }
+      queue.push(childPom);
+    }
+  }
+  return projects;
+}
+function realPath(p2) {
+  try {
+    return fs7.realpathSync.native(p2);
+  } catch {
+    return null;
+  }
+}
+function readXml(file2) {
+  const buf = fs7.readFileSync(file2);
+  if (buf.includes(0)) throw new Error("not UTF-8");
+  return stripBom(buf.toString("utf-8"));
+}
+function parsePom(xml) {
+  const cleaned = xml.replace(/<!--[\s\S]*?-->/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "");
+  const tagRe = /<(\/?)([A-Za-z_][\w.:-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>/g;
+  const stack = [];
+  const text = {};
+  const modules = [];
+  let hasModuleList = false;
+  let namespaceVersion = null;
+  let lastEnd = 0;
+  for (const m of cleaned.matchAll(tagRe)) {
+    const [whole, closing, rawName, attrs, selfClosing] = m;
+    const name = rawName.includes(":") ? rawName.slice(rawName.indexOf(":") + 1) : rawName;
+    const start = m.index ?? 0;
+    if (closing) {
+      if (stack[stack.length - 1] !== name) return null;
+      const elementPath = stack.join("/");
+      const value2 = cleaned.slice(lastEnd, start).trim();
+      if (/^project\/(?:artifactId|groupId|modelVersion|packaging)$/.test(elementPath)) {
+        text[elementPath] = value2;
+      }
+      if (elementPath === "project/parent/groupId") text[elementPath] = value2;
+      if (/^project\/(?:profiles\/profile\/)?(?:modules\/module|subprojects\/subproject)$/.test(
+        elementPath
+      )) {
+        if (!value2 || value2.includes("${")) return null;
+        modules.push(decodeEntities(value2));
+      }
+      stack.pop();
+    } else {
+      const elementPath = [...stack, name].join("/");
+      if (elementPath === "project") {
+        namespaceVersion = /xmlns\s*=\s*["']http:\/\/maven\.apache\.org\/POM\/(\d+\.\d+\.\d+)["']/.exec(
+          attrs
+        )?.[1] ?? null;
+      }
+      if (elementPath === "project/modules" || elementPath === "project/subprojects") {
+        hasModuleList = true;
+      }
+      if (!selfClosing) stack.push(name);
+    }
+    lastEnd = start + whole.length;
+  }
+  if (stack.length > 0) return null;
+  const modelVersion = text["project/modelVersion"] || namespaceVersion;
+  const packaging = text["project/packaging"] || "jar";
+  const aggregator = packaging === "pom" || packaging.includes("${");
+  if (aggregator && !hasModuleList && modelVersion !== "4.0.0") return null;
+  const value = (v2) => v2 ? decodeEntities(v2) : null;
+  return {
+    artifactId: value(text["project/artifactId"]),
+    groupId: value(text["project/groupId"] ?? text["project/parent/groupId"]),
+    modules
+  };
+}
+function decodeEntities(s) {
+  const codePoint = (n7, raw) => {
+    try {
+      return String.fromCodePoint(n7);
+    } catch {
+      return raw;
+    }
+  };
+  return s.replace(/&#x([0-9a-fA-F]+);/g, (raw, h2) => codePoint(parseInt(h2, 16), raw)).replace(/&#(\d+);/g, (raw, d) => codePoint(Number(d), raw)).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function mavenSelectors(cmd) {
+  const tokens = shellWords(cmd);
+  if (!tokens || tokens.length === 0 || !MAVEN_HEAD.test(tokens[0])) return null;
+  if (tokens.some((t2) => CONTINUATION.test(t2))) return null;
+  const out = [];
+  const addList = (option, value, isList) => {
+    for (const raw of isList ? value.split(",") : [value]) {
+      let sel = raw.trim();
+      if (isList) sel = sel.replace(/^[!+-]/, "");
+      if (!sel || sel.startsWith("?")) continue;
+      const idPart = sel.slice(sel.lastIndexOf(":") + 1);
+      if (PLACEHOLDER.test(sel) || PLACEHOLDER.test(idPart)) continue;
+      out.push({ selector: sel, option });
+    }
+  };
+  for (let i2 = 1; i2 < tokens.length; i2++) {
+    const tok = tokens[i2];
+    if (!tok.startsWith("-")) continue;
+    const eq = tok.indexOf("=");
+    const bare = eq > 0 && tok.startsWith("--") ? tok.slice(0, eq) : tok;
+    if (RETARGET_OPTIONS2.has(bare)) return null;
+    if (/^-f[^\w-]?.+/.test(tok) && !/^-(?:fae|ff|fn|fos)$/.test(tok)) return null;
+    if (bare === "-pl" || bare === "--projects" || bare === "-rf" || bare === "--resume-from") {
+      const isList = bare === "-pl" || bare === "--projects";
+      const option = isList ? "-pl" : "-rf";
+      if (eq > 0 && tok.startsWith("--")) {
+        addList(option, tok.slice(eq + 1), isList);
+      } else if (tokens[i2 + 1] !== void 0) {
+        addList(option, tokens[++i2], isList);
+      }
+      continue;
+    }
+    if (VALUE_OPTIONS2.has(tok)) i2++;
+  }
+  return out;
+}
+function selectorMatches(selector, reactor, baseDir) {
+  if (selector.includes(":")) {
+    if (selector.startsWith(":")) {
+      const artifactId2 = selector.slice(1);
+      return reactor.some((p2) => templateMatches(p2.artifactId, artifactId2));
+    }
+    const [groupId, artifactId, ...rest] = selector.split(":");
+    if (rest.length > 0) return true;
+    return reactor.some(
+      (p2) => templateMatches(p2.artifactId, artifactId) && templateMatches(p2.groupId, groupId)
+    );
+  }
+  const target = realPath(path8.resolve(baseDir, selector));
+  if (target === null) return false;
+  if (fs7.statSync(target).isFile()) return reactor.some((p2) => samePath(p2.pomFile, target));
+  return reactor.some((p2) => samePath(p2.basedir, target));
+}
+function templateMatches(template, value) {
+  if (template === null) return true;
+  if (!template.includes("${")) return template === value;
+  const pattern = template.split(/\$\{[^}]*\}/).map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${pattern}$`).test(value);
+}
+function samePath(a, b2) {
+  return path8.resolve(a) === path8.resolve(b2);
+}
+function mavenBaseDirs(contextFile, projectRoot) {
+  const root = path8.resolve(projectRoot);
+  const dirs = [root];
+  let dir = path8.dirname(path8.resolve(contextFile));
+  for (; ; ) {
+    const rel = path8.relative(root, dir);
+    if (rel === "" || rel.startsWith("..") || path8.isAbsolute(rel)) break;
+    if (fs7.existsSync(path8.join(dir, "pom.xml"))) dirs.push(dir);
+    const parent = path8.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return dirs;
+}
+var MAX_POMS, MAVEN_HEAD, VALUE_OPTIONS2, RETARGET_OPTIONS2, PLACEHOLDER;
+var init_maven_modules = __esm({
+  "src/core/checks/maven-modules.ts"() {
+    "use strict";
+    init_define_WEB_FIRST_SEGMENTS();
+    init_fs();
+    init_gradle_projects();
+    MAX_POMS = 2e4;
+    MAVEN_HEAD = /^(?:\.[\\/])?mvnw(?:\.cmd)?$|^mvn(?:\.cmd)?$/;
+    VALUE_OPTIONS2 = /* @__PURE__ */ new Set([
+      "-D",
+      "--define",
+      "-P",
+      "--activate-profiles",
+      "-s",
+      "--settings",
+      "-gs",
+      "--global-settings",
+      "-t",
+      "--toolchains",
+      "-gt",
+      "--global-toolchains",
+      "-ps",
+      "--project-settings",
+      "-is",
+      "--install-settings",
+      "-it",
+      "--install-toolchains",
+      "-fos",
+      "--fail-on-severity",
+      "-l",
+      "--log-file",
+      "-T",
+      "--threads",
+      "-b",
+      "--builder",
+      "-canf",
+      "--cache-artifact-not-found",
+      "-sadp",
+      "--strict-artifact-descriptor-policy"
+    ]);
+    RETARGET_OPTIONS2 = /* @__PURE__ */ new Set(["-f", "--file", "-N", "--non-recursive", "-af", "--at-file"]);
+    PLACEHOLDER = /[<>{}$*%[\]]|\.\.\.|^path\/to\/|^(?:module|project|submodule|component|feature)(?:[-_]?(?:name|path|id))?$|^(?:my|your|some|example|sample)[-_]|^(?:foo|bar|baz|xxx|name)$/i;
+  }
+});
+
 // src/utils/markdown.ts
 function inlineCodeSpans(line) {
   const spans = [];
@@ -24116,8 +25131,8 @@ var init_markdown = __esm({
 });
 
 // src/core/checks/commands.ts
-import * as fs6 from "node:fs";
-import * as path7 from "node:path";
+import * as fs8 from "node:fs";
+import * as path9 from "node:path";
 function isManagerBuiltin(manager, sub) {
   return PM_MANAGER_BUILTINS[manager]?.has(sub) ?? false;
 }
@@ -24158,7 +25173,7 @@ function loadDeniedCommandPrefixes(projectRoot) {
   for (const rel of ["settings.json", "settings.local.json"]) {
     let content;
     try {
-      content = stripBom(fs6.readFileSync(path7.join(projectRoot, ".claude", rel), "utf-8"));
+      content = stripBom(fs8.readFileSync(path9.join(projectRoot, ".claude", rel), "utf-8"));
     } catch {
       continue;
     }
@@ -24231,6 +25246,7 @@ async function checkCommands(file2, projectRoot) {
     }
   }
   issues.push(...checkUnknownSubcommand(file2, projectRoot, pkgJson, deniedPrefixes, contentLines));
+  const jvmCache = { gradle: /* @__PURE__ */ new Map(), maven: /* @__PURE__ */ new Map() };
   for (const ref of file2.references.commands) {
     if (inHtmlComment(ref.line, ref.column)) continue;
     const cmd = ref.value;
@@ -24247,6 +25263,16 @@ async function checkCommands(file2, projectRoot) {
       });
     }
     if (isDeniedCommand(cmd, deniedPrefixes) || isProhibitedRef(contentLines, ref)) continue;
+    const gradleIssues = checkGradleProjects(file2, ref, projectRoot, jvmCache);
+    if (gradleIssues) {
+      issues.push(...gradleIssues);
+      continue;
+    }
+    const mavenIssues = checkMavenModules(file2, ref, projectRoot, jvmCache);
+    if (mavenIssues) {
+      issues.push(...mavenIssues);
+      continue;
+    }
     const scriptMatch = cmd.match(NPM_SCRIPT_PATTERN);
     if (scriptMatch && pkgJson) {
       const scriptName = scriptNameFromMatch(scriptMatch);
@@ -24289,9 +25315,9 @@ async function checkCommands(file2, projectRoot) {
         ...pkgJson.optionalDependencies
       };
       if (!(pkgName in allDeps)) {
-        const binPath = path7.join(projectRoot, "node_modules", ".bin", pkgName);
+        const binPath = path9.join(projectRoot, "node_modules", ".bin", pkgName);
         try {
-          fs6.accessSync(binPath);
+          fs8.accessSync(binPath);
         } catch {
           issues.push({
             severity: "warning",
@@ -24339,9 +25365,9 @@ async function checkCommands(file2, projectRoot) {
         ...pkgJson.optionalDependencies
       };
       if (!(pkgName in allDeps)) {
-        const binPath = path7.join(projectRoot, "node_modules", ".bin", tool);
+        const binPath = path9.join(projectRoot, "node_modules", ".bin", tool);
         try {
-          fs6.accessSync(binPath);
+          fs8.accessSync(binPath);
         } catch {
           issues.push({
             severity: "warning",
@@ -24385,9 +25411,117 @@ function checkUnknownSubcommand(file2, projectRoot, pkgJson, deniedPrefixes, con
   }
   return issues;
 }
+function checkGradleProjects(file2, ref, projectRoot, cache2) {
+  const refs = gradleProjectRefs(ref.value);
+  if (refs === null) return null;
+  if (refs.length === 0 || cdEarlierInFence(file2.content, ref.line)) return [];
+  const wrapper = !/^gradle(?:\s|$)/.test(ref.value);
+  const buildRoot = findGradleBuildRoot(file2.filePath, projectRoot, wrapper);
+  if (!buildRoot) return [];
+  if (!cache2.gradle.has(buildRoot)) cache2.gradle.set(buildRoot, readGradleProjectSet(buildRoot));
+  const set2 = cache2.gradle.get(buildRoot);
+  if (!set2) return [];
+  const atBuildRoot = path9.resolve(path9.dirname(file2.filePath)) === path9.resolve(buildRoot);
+  const issues = [];
+  for (const projectRef of refs) {
+    if (!projectRef.absolute && !atBuildRoot) continue;
+    const missing = unresolvedGradleProject(projectRef, set2);
+    if (!missing) continue;
+    issues.push({
+      severity: "error",
+      check: "commands",
+      ruleId: "commands/gradle-project-not-found",
+      line: ref.line,
+      message: `"${ref.value}" \u2014 project "${missing}" not found in ${set2.settingsFile}`,
+      suggestion: closestSuggestion(missing, [...set2.paths])
+    });
+  }
+  return issues;
+}
+function checkMavenModules(file2, ref, projectRoot, cache2) {
+  const selectors = mavenSelectors(ref.value);
+  if (selectors === null) return null;
+  if (selectors.length === 0 || cdEarlierInFence(file2.content, ref.line)) return [];
+  const bases = [];
+  for (const dir of mavenBaseDirs(file2.filePath, projectRoot)) {
+    if (!fs8.existsSync(path9.join(dir, "pom.xml"))) continue;
+    if (mavenConfigRetargets(dir)) return [];
+    if (!cache2.maven.has(dir)) cache2.maven.set(dir, readMavenReactor(dir));
+    const reactor = cache2.maven.get(dir);
+    if (!reactor) return [];
+    bases.push({ dir, reactor });
+  }
+  if (bases.length === 0) return [];
+  const issues = [];
+  for (const { selector, option } of selectors) {
+    const allProjects = bases.flatMap((b2) => b2.reactor);
+    if (bases.some((b2) => selectorMatches(selector, allProjects, b2.dir))) continue;
+    if (!selector.includes(":") && bases.every((b2) => outside(projectRoot, b2.dir, selector))) {
+      continue;
+    }
+    const known = bases[0].reactor.flatMap((p2) => [
+      path9.relative(bases[0].dir, p2.basedir).replace(/\\/g, "/"),
+      ...p2.artifactId && !p2.artifactId.includes("${") ? [`:${p2.artifactId}`] : []
+    ]);
+    issues.push({
+      severity: "error",
+      check: "commands",
+      ruleId: "commands/maven-module-not-found",
+      line: ref.line,
+      message: `"${ref.value}" \u2014 ${option} "${selector}" matches no module in the Maven reactor`,
+      suggestion: closestSuggestion(selector, known.filter(Boolean))
+    });
+  }
+  return issues;
+}
+function cdEarlierInFence(content, line) {
+  const lines = content.split("\n");
+  const idx = line - 1;
+  const changesDir = (text) => /(?:^|[\s;&|(])(?:cd|pushd)(?:\s|$)/.test(text);
+  let fenceStart = -1;
+  for (let i2 = 0; i2 < idx && i2 < lines.length; i2++) {
+    if (/^\s*```/.test(lines[i2])) fenceStart = fenceStart < 0 ? i2 + 1 : -1;
+  }
+  if (fenceStart >= 0) {
+    for (let i2 = fenceStart; i2 < idx; i2++) if (changesDir(lines[i2])) return true;
+    return false;
+  }
+  for (let i2 = idx - 1; i2 >= 0 && /^\s*[$>]\s+\S/.test(lines[i2]); i2--) {
+    if (changesDir(lines[i2].replace(/^\s*[$>]\s+/, ""))) return true;
+  }
+  return false;
+}
+function outside(projectRoot, base, selector) {
+  const rel = path9.relative(path9.resolve(projectRoot), path9.resolve(base, selector));
+  return rel.startsWith("..") || path9.isAbsolute(rel);
+}
+function mavenConfigRetargets(dir) {
+  try {
+    const config2 = fs8.readFileSync(path9.join(dir, ".mvn", "maven.config"), "utf-8");
+    return /(?:^|\s)(?:-f(?!(?:ae|f|n|os)(?:\s|$))|--file|-pl|--projects|-N|--non-recursive)/.test(
+      config2
+    );
+  } catch {
+    return false;
+  }
+}
+function closestSuggestion(target, candidates) {
+  let best;
+  let bestDist = Infinity;
+  for (const c3 of candidates) {
+    const d = levenshtein2(target.toLowerCase(), c3.toLowerCase());
+    if (d < bestDist) {
+      bestDist = d;
+      best = c3;
+    }
+  }
+  if (best === void 0 || bestDist > Math.max(2, Math.floor(target.length * 0.3)))
+    return void 0;
+  return `Did you mean "${best}"?`;
+}
 function loadMakefile(projectRoot) {
   try {
-    return stripBom(fs6.readFileSync(path7.join(projectRoot, "Makefile"), "utf-8"));
+    return stripBom(fs8.readFileSync(path9.join(projectRoot, "Makefile"), "utf-8"));
   } catch {
     return null;
   }
@@ -24405,16 +25539,20 @@ function hasMakeTarget(makefile, target) {
   const pattern = new RegExp(`^${escaped}\\s*:(?!:?=)`, "m");
   return pattern.test(makefile);
 }
-var NPM_SCRIPT_PATTERN, MAKE_PATTERN, PM_BUILTIN_SUBCOMMANDS, PM_MANAGER_BUILTINS, PKG_DEPENDENT_TOOL_PATTERN, BIN_TO_PACKAGE, PKG_SHORTHAND_PATTERN, PROHIBITION_TOKEN, CLAUSE_TERMINATOR, RECOMMENDATION_VERB;
+var import_fast_levenshtein2, levenshtein2, NPM_SCRIPT_PATTERN, MAKE_PATTERN, PM_BUILTIN_SUBCOMMANDS, PM_MANAGER_BUILTINS, PKG_DEPENDENT_TOOL_PATTERN, BIN_TO_PACKAGE, PKG_SHORTHAND_PATTERN, PROHIBITION_TOKEN, CLAUSE_TERMINATOR, RECOMMENDATION_VERB;
 var init_commands = __esm({
   "src/core/checks/commands.ts"() {
     "use strict";
     init_define_WEB_FIRST_SEGMENTS();
     init_main3();
+    import_fast_levenshtein2 = __toESM(require_levenshtein(), 1);
     init_fs();
     init_exit_status();
     init_cli_subcommands();
+    init_gradle_projects();
+    init_maven_modules();
     init_markdown();
+    levenshtein2 = import_fast_levenshtein2.default.get;
     NPM_SCRIPT_PATTERN = /^(?:npm\s+run|(pnpm|yarn|bun)(?:\s+(run))?)\s+(\S+)/;
     MAKE_PATTERN = /^make\s+\S/;
     PM_BUILTIN_SUBCOMMANDS = /* @__PURE__ */ new Set([
@@ -24491,13 +25629,13 @@ var init_commands = __esm({
 });
 
 // src/core/checks/staleness.ts
-import * as path8 from "node:path";
+import * as path10 from "node:path";
 async function checkStaleness(file2, projectRoot) {
   const issues = [];
   if (!await isGitRepo(projectRoot)) {
     return issues;
   }
-  const relativePath = path8.relative(projectRoot, file2.filePath).replace(/\\/g, "/");
+  const relativePath = path10.relative(projectRoot, file2.filePath).replace(/\\/g, "/");
   const lastModified = await getFileLastModified(projectRoot, relativePath);
   if (!lastModified || isNaN(lastModified.getTime())) {
     return issues;
@@ -24688,9 +25826,9 @@ var init_tokens2 = __esm({
 });
 
 // src/core/checks/tier-tokens.ts
-import * as fs7 from "node:fs";
+import * as fs9 from "node:fs";
 import * as os2 from "node:os";
-import * as path9 from "node:path";
+import * as path11 from "node:path";
 function hasFrontmatterList(content, field) {
   const lines = content.split("\n");
   if (lines[0]?.trim() !== "---") return false;
@@ -24778,7 +25916,7 @@ function findInviolableCommand(line) {
 function fingerprintFiles(paths) {
   return paths.map((p2) => {
     try {
-      const st2 = fs7.statSync(p2);
+      const st2 = fs9.statSync(p2);
       return `${st2.mtimeMs}:${st2.size}`;
     } catch {
       return "absent";
@@ -24787,11 +25925,11 @@ function fingerprintFiles(paths) {
 }
 function loadSettingsSources(projectRoot, includeGlobal) {
   const candidates = [
-    path9.join(projectRoot, ".claude", "settings.json"),
-    path9.join(projectRoot, ".claude", "settings.local.json")
+    path11.join(projectRoot, ".claude", "settings.json"),
+    path11.join(projectRoot, ".claude", "settings.local.json")
   ];
   if (includeGlobal) {
-    candidates.push(path9.join(os2.homedir(), ".claude", "settings.json"));
+    candidates.push(path11.join(os2.homedir(), ".claude", "settings.json"));
   }
   const fingerprint = fingerprintFiles(candidates);
   if (settingsCache?.root === projectRoot && settingsCache.includeGlobal === includeGlobal && settingsCache.fingerprint === fingerprint) {
@@ -24801,7 +25939,7 @@ function loadSettingsSources(projectRoot, includeGlobal) {
   for (const p2 of candidates) {
     let content;
     try {
-      content = stripBom(fs7.readFileSync(p2, "utf-8"));
+      content = stripBom(fs9.readFileSync(p2, "utf-8"));
     } catch {
       continue;
     }
@@ -24979,7 +26117,7 @@ var init_similarity = __esm({
 });
 
 // src/core/checks/redundancy.ts
-import * as path10 from "node:path";
+import * as path12 from "node:path";
 function compilePatterns(allDeps) {
   const compiled = [];
   for (const [pkg, mentions] of Object.entries(PACKAGE_TECH_MAP)) {
@@ -25059,8 +26197,8 @@ async function checkRedundancy(file2, projectRoot) {
     );
     if (dirMatch) {
       const dir = dirMatch[1].replace(/[`"]/g, "");
-      const baseDir = dir.startsWith("./") || dir.startsWith("../") ? path10.dirname(file2.filePath) : projectRoot;
-      const fullPath = path10.resolve(baseDir, dir);
+      const baseDir = dir.startsWith("./") || dir.startsWith("../") ? path12.dirname(file2.filePath) : projectRoot;
+      const fullPath = path12.resolve(baseDir, dir);
       if (isDirectory(fullPath)) {
         issues.push({
           severity: "info",
@@ -26088,8 +27226,8 @@ var init_security = __esm({
 });
 
 // src/core/checks/mcp/commands.ts
-import * as fs8 from "node:fs";
-import * as path11 from "node:path";
+import * as fs10 from "node:fs";
+import * as path13 from "node:path";
 async function checkMcpCommands(config2, projectRoot) {
   const issues = [];
   if (config2.parseErrors.length > 0) return issues;
@@ -26106,7 +27244,7 @@ async function checkMcpCommands(config2, projectRoot) {
       });
     }
     if (config2.scope === "project" && LOCAL_PATH_PATTERN.test(server2.command)) {
-      const resolved = path11.resolve(projectRoot, server2.command);
+      const resolved = path13.resolve(projectRoot, server2.command);
       if (!fileExistsSafe(resolved)) {
         issues.push({
           severity: "warning",
@@ -26121,8 +27259,8 @@ async function checkMcpCommands(config2, projectRoot) {
       for (const arg of server2.args) {
         if (URL_PREFIX.test(arg)) continue;
         if (!LOCAL_PATH_PATTERN.test(arg) && !FILE_PATH_PATTERN.test(arg)) continue;
-        if (config2.scope !== "project" && !path11.isAbsolute(arg)) continue;
-        const resolved = path11.resolve(projectRoot, arg);
+        if (config2.scope !== "project" && !path13.isAbsolute(arg)) continue;
+        const resolved = path13.resolve(projectRoot, arg);
         if (!fileExistsSafe(resolved)) {
           issues.push({
             severity: "warning",
@@ -26139,7 +27277,7 @@ async function checkMcpCommands(config2, projectRoot) {
 }
 function fileExistsSafe(filePath) {
   try {
-    fs8.accessSync(filePath);
+    fs10.accessSync(filePath);
     return true;
   } catch {
     return false;
@@ -26570,16 +27708,16 @@ var init_redundancy2 = __esm({
 
 // src/core/session-parser.ts
 import { readFile } from "node:fs/promises";
-import { readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname4, resolve as resolve7 } from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname7, resolve as resolve10 } from "node:path";
 import { fileURLToPath } from "node:url";
 function loadWebFirstSegments() {
   if (typeof define_WEB_FIRST_SEGMENTS_default !== "undefined") {
     return new Set(define_WEB_FIRST_SEGMENTS_default);
   }
-  const __dir = dirname4(fileURLToPath(import.meta.url));
-  const fixturePath = resolve7(__dir, "../../tests/fixtures/web-first-segments.json");
-  const raw = JSON.parse(readFileSync5(fixturePath, "utf-8"));
+  const __dir = dirname7(fileURLToPath(import.meta.url));
+  const fixturePath = resolve10(__dir, "../../tests/fixtures/web-first-segments.json");
+  const raw = JSON.parse(readFileSync7(fixturePath, "utf-8"));
   const list = Array.isArray(raw) ? raw : raw.segments;
   return new Set(list);
 }
@@ -26701,14 +27839,14 @@ import { readdir, stat } from "node:fs/promises";
 import { createReadStream } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { createInterface } from "node:readline";
-import { dirname as dirname5, join as join5, resolve as resolve8 } from "node:path";
-import { existsSync } from "node:fs";
+import { dirname as dirname8, join as join7, resolve as resolve11 } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
 function detectProviders() {
   if (!home) return [];
-  return AGENT_DIRS.filter((a) => existsSync(a.dir)).map((a) => a.provider);
+  return AGENT_DIRS.filter((a) => existsSync4(a.dir)).map((a) => a.provider);
 }
 async function parseJsonlFiltered(filePath, filter) {
-  if (!existsSync(filePath)) return [];
+  if (!existsSync4(filePath)) return [];
   const results = [];
   const rl = createInterface({
     input: createReadStream(filePath, { encoding: "utf-8" }),
@@ -26755,7 +27893,7 @@ async function readJsonlHistory(opts) {
 }
 function agentHistoryPath(provider) {
   const agent = AGENT_DIRS.find((a) => a.provider === provider);
-  return agent?.historyFile ? join5(agent.dir, agent.historyFile) : "";
+  return agent?.historyFile ? join7(agent.dir, agent.historyFile) : "";
 }
 async function readClaudeHistory() {
   return readJsonlHistory({
@@ -26776,18 +27914,18 @@ async function readCodexHistory() {
   });
 }
 async function readClaudeMemories() {
-  const projectsDir = join5(home, ".claude", "projects");
-  if (!existsSync(projectsDir)) return [];
+  const projectsDir = join7(home, ".claude", "projects");
+  if (!existsSync4(projectsDir)) return [];
   const memories = [];
   const projectDirs = await readdir(projectsDir).catch(() => []);
   for (const projDir of projectDirs) {
-    const memoryDir = join5(projectsDir, projDir, "memory");
-    if (!existsSync(memoryDir)) continue;
+    const memoryDir = join7(projectsDir, projDir, "memory");
+    if (!existsSync4(memoryDir)) continue;
     const files = await readdir(memoryDir).catch(() => []);
     for (const file2 of files) {
       if (!file2.endsWith(".md") || file2 === "MEMORY.md") continue;
       try {
-        const entry = await parseMemoryFile(join5(memoryDir, file2), projDir);
+        const entry = await parseMemoryFile(join7(memoryDir, file2), projDir);
         memories.push(entry);
       } catch {
       }
@@ -26797,7 +27935,7 @@ async function readClaudeMemories() {
 }
 function detectAiderInSiblings(siblings) {
   for (const sib of siblings) {
-    if (existsSync(join5(sib.path, ".aider.chat.history.md"))) {
+    if (existsSync4(join7(sib.path, ".aider.chat.history.md"))) {
       return "aider";
     }
   }
@@ -26816,7 +27954,7 @@ async function mapWithConcurrency(items, limit, fn) {
   return results;
 }
 async function detectSiblings(projectRoot) {
-  const parentDir = dirname5(resolve8(projectRoot));
+  const parentDir = dirname8(resolve11(projectRoot));
   let entries;
   try {
     entries = await readdir(parentDir);
@@ -26826,16 +27964,16 @@ async function detectSiblings(projectRoot) {
   const candidates = [];
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "node_modules") continue;
-    const fullPath = join5(parentDir, entry);
-    const entryPath = resolve8(fullPath);
-    if (entryPath === resolve8(projectRoot)) continue;
+    const fullPath = join7(parentDir, entry);
+    const entryPath = resolve11(fullPath);
+    if (entryPath === resolve11(projectRoot)) continue;
     try {
       const s = await stat(fullPath);
       if (!s.isDirectory()) continue;
     } catch {
       continue;
     }
-    const isProject = existsSync(join5(fullPath, ".git")) || existsSync(join5(fullPath, "package.json")) || existsSync(join5(fullPath, "Cargo.toml")) || existsSync(join5(fullPath, "go.mod")) || existsSync(join5(fullPath, "pyproject.toml"));
+    const isProject = existsSync4(join7(fullPath, ".git")) || existsSync4(join7(fullPath, "package.json")) || existsSync4(join7(fullPath, "Cargo.toml")) || existsSync4(join7(fullPath, "go.mod")) || existsSync4(join7(fullPath, "pyproject.toml"));
     if (!isProject) continue;
     candidates.push({ fullPath, entryPath, name: entry });
   }
@@ -26863,7 +28001,7 @@ async function detectSiblings(projectRoot) {
 }
 async function resolveSibling(c3) {
   const sibling = { path: c3.entryPath.replace(/\\/g, "/"), name: c3.name };
-  if (!existsSync(join5(c3.fullPath, ".git"))) return sibling;
+  if (!existsSync4(join7(c3.fullPath, ".git"))) return sibling;
   try {
     const git = simpleGit(c3.fullPath);
     const remotes = await git.getRemotes(true);
@@ -26895,7 +28033,7 @@ async function scanSessionData(projectRoot) {
     history: histories,
     memories,
     siblings,
-    currentProject: resolve8(projectRoot).replace(/\\/g, "/"),
+    currentProject: resolve11(projectRoot).replace(/\\/g, "/"),
     providers
   };
 }
@@ -26909,12 +28047,12 @@ var init_session_scanner = __esm({
     init_fs();
     home = process.env.HOME || process.env.USERPROFILE || homedir3();
     AGENT_DIRS = [
-      { provider: "claude-code", dir: join5(home, ".claude"), historyFile: "history.jsonl" },
-      { provider: "codex-cli", dir: join5(home, ".codex"), historyFile: "history.jsonl" },
-      { provider: "vibe-cli", dir: join5(home, ".vibe") },
+      { provider: "claude-code", dir: join7(home, ".claude"), historyFile: "history.jsonl" },
+      { provider: "codex-cli", dir: join7(home, ".codex"), historyFile: "history.jsonl" },
+      { provider: "vibe-cli", dir: join7(home, ".vibe") },
       {
         provider: "amazon-q",
-        dir: join5(home, ".aws", "amazonq")
+        dir: join7(home, ".aws", "amazonq")
       },
       {
         provider: "goose",
@@ -26923,12 +28061,12 @@ var init_session_scanner = __esm({
         // which the HOME guard in `detectProviders` does NOT catch (HOME/USERPROFILE
         // may still be set). Leave the dir empty so `existsSync('')` is always false
         // and we never match a cwd-relative `Block/goose`, mirroring the HOME-guard intent.
-        dir: process.platform === "win32" ? process.env.APPDATA ? join5(process.env.APPDATA, "Block", "goose") : "" : join5(home, ".config", "goose")
+        dir: process.platform === "win32" ? process.env.APPDATA ? join7(process.env.APPDATA, "Block", "goose") : "" : join7(home, ".config", "goose")
       },
-      { provider: "continue", dir: join5(home, ".continue") },
+      { provider: "continue", dir: join7(home, ".continue") },
       {
         provider: "windsurf",
-        dir: join5(home, ".windsurf")
+        dir: join7(home, ".windsurf")
       }
     ];
     SIBLING_RESOLVE_CONCURRENCY = 8;
@@ -26936,9 +28074,9 @@ var init_session_scanner = __esm({
 });
 
 // src/core/checks/session/missing-secret.ts
-import { resolve as resolve9, basename as basename3 } from "node:path";
+import { resolve as resolve12, basename as basename3 } from "node:path";
 function normalizePath2(p2) {
-  return resolve9(p2).replace(/\\/g, "/").toLowerCase();
+  return resolve12(p2).replace(/\\/g, "/").toLowerCase();
 }
 function extractSecretName(display) {
   const prefixMatch = display.match(SECRET_SET_PREFIX);
@@ -26951,9 +28089,9 @@ function extractSecretName(display) {
     if (VALUE_FLAGS.has(tok) && !tok.includes("=")) {
       i2++;
       const val = tokens[i2];
-      const quote = val && (val[0] === '"' || val[0] === "'") ? val[0] : void 0;
-      if (quote && !(val.length > 1 && val.endsWith(quote))) {
-        while (i2 + 1 < tokens.length && !tokens[i2].endsWith(quote)) i2++;
+      const quote2 = val && (val[0] === '"' || val[0] === "'") ? val[0] : void 0;
+      if (quote2 && !(val.length > 1 && val.endsWith(quote2))) {
+        while (i2 + 1 < tokens.length && !tokens[i2].endsWith(quote2)) i2++;
       }
     }
   }
@@ -27056,8 +28194,8 @@ var init_missing_secret = __esm({
 
 // src/core/checks/session/diverged-file.ts
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { join as join6, resolve as resolve10 } from "node:path";
-import { existsSync as existsSync2 } from "node:fs";
+import { join as join8, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
 async function loadLineSet(absPath) {
   let mtimeMs;
   let size;
@@ -27091,14 +28229,14 @@ async function loadLineSet(absPath) {
 async function checkDivergedFile(ctx) {
   const issues = [];
   for (const fileName of CANONICAL_FILES) {
-    const currentPath = join6(ctx.currentProject, fileName);
-    if (!existsSync2(currentPath)) continue;
+    const currentPath = join8(ctx.currentProject, fileName);
+    if (!existsSync5(currentPath)) continue;
     const currentLineSet = await loadLineSet(currentPath);
     if (!currentLineSet) continue;
     const diverged = [];
     for (const sib of ctx.siblings) {
-      const sibPath = join6(sib.path, fileName);
-      if (!existsSync2(sibPath)) continue;
+      const sibPath = join8(sib.path, fileName);
+      if (!existsSync5(sibPath)) continue;
       const sibLineSet = await loadLineSet(sibPath);
       if (!sibLineSet) continue;
       const overlap = jaccardSimilarityFromSets(currentLineSet, sibLineSet, {
@@ -27108,7 +28246,7 @@ async function checkDivergedFile(ctx) {
         diverged.push({
           sibling: sib.name,
           overlap: Math.round(overlap * 100),
-          path: resolve10(sibPath)
+          path: resolve13(sibPath)
         });
       }
     }
@@ -27123,7 +28261,7 @@ async function checkDivergedFile(ctx) {
         line: 0,
         message: `${fileName} has diverged from sibling repos: ${details}`,
         suggestion: `Compare with sibling versions to identify unintentional drift`,
-        detail: `File: ${resolve10(currentPath)}
+        detail: `File: ${resolve13(currentPath)}
 Diverged siblings:
 ${sibPaths}`
       });
@@ -27156,14 +28294,14 @@ var init_diverged_file = __esm({
 
 // src/core/checks/session/missing-workflow.ts
 import { readdir as readdir2 } from "node:fs/promises";
-import { join as join7 } from "node:path";
-import { existsSync as existsSync3 } from "node:fs";
+import { join as join9 } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
 async function checkMissingWorkflow(ctx) {
   const issues = [];
-  const currentWorkflowDir = join7(ctx.currentProject, ".github", "workflows");
-  if (!existsSync3(join7(ctx.currentProject, ".github"))) return issues;
+  const currentWorkflowDir = join9(ctx.currentProject, ".github", "workflows");
+  if (!existsSync6(join9(ctx.currentProject, ".github"))) return issues;
   const currentWorkflows = /* @__PURE__ */ new Set();
-  if (existsSync3(currentWorkflowDir)) {
+  if (existsSync6(currentWorkflowDir)) {
     try {
       const files = await readdir2(currentWorkflowDir);
       for (const f of files) {
@@ -27174,8 +28312,8 @@ async function checkMissingWorkflow(ctx) {
   }
   const workflowMap = /* @__PURE__ */ new Map();
   for (const sib of ctx.siblings) {
-    const sibWorkflowDir = join7(sib.path, ".github", "workflows");
-    if (!existsSync3(sibWorkflowDir)) continue;
+    const sibWorkflowDir = join9(sib.path, ".github", "workflows");
+    if (!existsSync6(sibWorkflowDir)) continue;
     try {
       const files = await readdir2(sibWorkflowDir);
       for (const f of files) {
@@ -27211,17 +28349,17 @@ var init_missing_workflow = __esm({
 });
 
 // src/core/checks/session/stale-memory.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { resolve as resolve11, isAbsolute as isAbsolute5 } from "node:path";
+import { resolve as resolve14, isAbsolute as isAbsolute8 } from "node:path";
 function resolveRef(ref, projectRoot) {
   if (ref.startsWith("~/") || ref === "~") {
     const home2 = process.env.HOME || process.env.USERPROFILE || homedir4();
     if (!home2) return null;
-    return ref === "~" ? home2 : resolve11(home2, ref.slice(2));
+    return ref === "~" ? home2 : resolve14(home2, ref.slice(2));
   }
-  if (isAbsolute5(ref)) return ref;
-  return resolve11(projectRoot, ref);
+  if (isAbsolute8(ref)) return ref;
+  return resolve14(projectRoot, ref);
 }
 async function checkStaleMemory(ctx) {
   const issues = [];
@@ -27233,7 +28371,7 @@ async function checkStaleMemory(ctx) {
     for (const ref of mem.referencedPaths) {
       const fullPath = resolveRef(ref, ctx.currentProject);
       if (!fullPath) continue;
-      if (!existsSync4(fullPath)) {
+      if (!existsSync7(fullPath)) {
         brokenPaths.push(ref);
       }
     }
@@ -27318,9 +28456,9 @@ var init_duplicate_memory = __esm({
 });
 
 // src/core/checks/session/loop-detection.ts
-import { resolve as resolve12 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 function normalizeProject(p2) {
-  return resolve12(p2).replace(/\\/g, "/");
+  return resolve15(p2).replace(/\\/g, "/");
 }
 function findConsecutiveRepeats(displays) {
   const results = [];
@@ -27473,14 +28611,14 @@ var init_loop_detection = __esm({
 // src/core/checks/session/memory-index-overflow.ts
 import { readFile as readFile3 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join10 } from "node:path";
 async function checkMemoryIndexOverflow(ctx) {
   const home2 = process.env.HOME || process.env.USERPROFILE || homedir5();
   if (!home2) return [];
   let content = "";
   let memoryFile = "";
   for (const encoded of projectDirCandidates(ctx.currentProject)) {
-    const candidate = join8(home2, ".claude", "projects", encoded, "memory", "MEMORY.md");
+    const candidate = join10(home2, ".claude", "projects", encoded, "memory", "MEMORY.md");
     try {
       content = stripBom(await readFile3(candidate, "utf-8"));
     } catch {
@@ -27535,10 +28673,10 @@ var init_memory_index_overflow = __esm({
 });
 
 // src/core/transcript.ts
-import { createReadStream as createReadStream2, existsSync as existsSync5, statSync as statSync5 } from "node:fs";
+import { createReadStream as createReadStream2, existsSync as existsSync8, statSync as statSync7 } from "node:fs";
 import { readdir as readdir3 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join11 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 function emptyRead() {
   return {
@@ -27578,8 +28716,8 @@ function clearTranscriptCache() {
   cache.clear();
 }
 function candidateDirs(project, home2) {
-  const root = join9(home2, ".claude", "projects");
-  return projectDirCandidates(project).map((n7) => join9(root, n7)).filter((d) => existsSync5(d));
+  const root = join11(home2, ".claude", "projects");
+  return projectDirCandidates(project).map((n7) => join11(root, n7)).filter((d) => existsSync8(d));
 }
 async function readUncached(project, home2) {
   if (!home2 || !project) return emptyRead();
@@ -27592,9 +28730,9 @@ async function readUncached(project, home2) {
     }
   }
   const files = names.filter(({ name }) => name.endsWith(".jsonl")).map(({ dir, name }) => {
-    const p2 = join9(dir, name);
+    const p2 = join11(dir, name);
     try {
-      return { p: p2, mtime: statSync5(p2).mtimeMs };
+      return { p: p2, mtime: statSync7(p2).mtimeMs };
     } catch {
       return null;
     }
@@ -27674,13 +28812,13 @@ function turnOf(rec, message, st2, sessionId) {
 function isSet(v2) {
   return v2 !== void 0 && v2 !== null && v2 !== "";
 }
-function readResultLines(rec, path21) {
+function readResultLines(rec, path23) {
   const result = rec.toolUseResult;
   if (!result || typeof result !== "object") return void 0;
   const file2 = result.file;
   if (!file2 || typeof file2 !== "object") return void 0;
   const { filePath, numLines } = file2;
-  if (filePath !== path21) return void 0;
+  if (filePath !== path23) return void 0;
   return typeof numLines === "number" ? numLines : void 0;
 }
 function collect(rec, st2) {
@@ -28146,7 +29284,7 @@ var init_unresolvable_sha = __esm({
 });
 
 // src/core/checks/session/large-read.ts
-import { isAbsolute as isAbsolute6, relative as relative6 } from "node:path";
+import { isAbsolute as isAbsolute9, relative as relative9 } from "node:path";
 function qualifies(ev) {
   if (ev.kind !== "file-read" || ev.partial || ev.isError) return false;
   return (ev.outputTokens ?? 0) >= LARGE_READ_TOKENS;
@@ -28154,13 +29292,13 @@ function qualifies(ev) {
 function fmt(n7) {
   return n7.toLocaleString("en-US");
 }
-function displayPath(path21, project) {
-  const rel = relative6(project, path21);
-  if (rel && !rel.startsWith("..") && !isAbsolute6(rel)) return rel.replace(/\\/g, "/");
-  return path21;
+function displayPath(path23, project) {
+  const rel = relative9(project, path23);
+  if (rel && !rel.startsWith("..") && !isAbsolute9(rel)) return rel.replace(/\\/g, "/");
+  return path23;
 }
-function fileKey(path21) {
-  const slashed = path21.replace(/\\/g, "/");
+function fileKey(path23) {
+  const slashed = path23.replace(/\\/g, "/");
   return process.platform === "win32" ? slashed.toLowerCase() : slashed;
 }
 async function checkLargeRead(ctx) {
@@ -28234,11 +29372,11 @@ var init_large_read = __esm({
 
 // src/core/checks/ci-coverage.ts
 import { readdir as readdir4, readFile as readFile4 } from "node:fs/promises";
-import { join as join10 } from "node:path";
-import { existsSync as existsSync6 } from "node:fs";
+import { join as join12 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
 async function findReleaseWorkflows(projectRoot) {
-  const workflowDir = join10(projectRoot, ".github", "workflows");
-  if (!existsSync6(workflowDir)) return [];
+  const workflowDir = join12(projectRoot, ".github", "workflows");
+  if (!existsSync9(workflowDir)) return [];
   let files;
   try {
     files = await readdir4(workflowDir);
@@ -28253,7 +29391,7 @@ async function findReleaseWorkflows(projectRoot) {
       continue;
     }
     try {
-      const content = stripBom(await readFile4(join10(workflowDir, f), "utf-8"));
+      const content = stripBom(await readFile4(join12(workflowDir, f), "utf-8"));
       const nameMatch = content.match(/^\s*name:\s*(.+?)\s*$/m);
       if (nameMatch) {
         const name = nameMatch[1].replace(/^(['"])(.*)\1$/, "$2");
@@ -28313,11 +29451,11 @@ var init_ci_coverage = __esm({
 
 // src/core/checks/ci-secrets.ts
 import { readdir as readdir5, readFile as readFile5 } from "node:fs/promises";
-import { join as join11 } from "node:path";
-import { existsSync as existsSync7 } from "node:fs";
+import { join as join13 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
 async function findSecretUsages(projectRoot) {
-  const workflowDir = join11(projectRoot, ".github", "workflows");
-  if (!existsSync7(workflowDir)) return [];
+  const workflowDir = join13(projectRoot, ".github", "workflows");
+  if (!existsSync10(workflowDir)) return [];
   let files;
   try {
     files = await readdir5(workflowDir);
@@ -28329,7 +29467,7 @@ async function findSecretUsages(projectRoot) {
     if (!(f.endsWith(".yml") || f.endsWith(".yaml"))) continue;
     let content;
     try {
-      content = stripBom(await readFile5(join11(workflowDir, f), "utf-8"));
+      content = stripBom(await readFile5(join13(workflowDir, f), "utf-8"));
     } catch {
       continue;
     }
@@ -28643,26 +29781,26 @@ var init_positions = __esm({
 });
 
 // src/core/checks/hook-coverage.ts
-import * as fs9 from "node:fs";
+import * as fs11 from "node:fs";
 import * as os3 from "node:os";
-import * as path12 from "node:path";
+import * as path14 from "node:path";
 function loadSettingsSources2(projectRoot, homeDir, includeUserGlobal) {
   const home2 = homeDir;
   const candidates = [
     {
-      filePath: path12.join(projectRoot, ".claude", "settings.json"),
-      displayPath: path12.join(".claude", "settings.json"),
+      filePath: path14.join(projectRoot, ".claude", "settings.json"),
+      displayPath: path14.join(".claude", "settings.json"),
       isUserGlobal: false
     },
     {
-      filePath: path12.join(projectRoot, ".claude", "settings.local.json"),
-      displayPath: path12.join(".claude", "settings.local.json"),
+      filePath: path14.join(projectRoot, ".claude", "settings.local.json"),
+      displayPath: path14.join(".claude", "settings.local.json"),
       isUserGlobal: false
     }
   ];
   if (includeUserGlobal) {
     candidates.push({
-      filePath: path12.join(home2, ".claude", "settings.json"),
+      filePath: path14.join(home2, ".claude", "settings.json"),
       displayPath: "~/.claude/settings.json",
       isUserGlobal: true
     });
@@ -28671,7 +29809,7 @@ function loadSettingsSources2(projectRoot, homeDir, includeUserGlobal) {
   for (const c3 of candidates) {
     let content;
     try {
-      content = stripBom(fs9.readFileSync(c3.filePath, "utf-8"));
+      content = stripBom(fs11.readFileSync(c3.filePath, "utf-8"));
     } catch {
       continue;
     }
@@ -28683,11 +29821,11 @@ function loadSettingsSources2(projectRoot, homeDir, includeUserGlobal) {
 function expandPath(raw, projectRoot, homeDir, platform) {
   let s = raw;
   if (s === "~" || s.startsWith("~/") || s.startsWith("~\\")) {
-    s = path12.join(homeDir, s.slice(1));
+    s = path14.join(homeDir, s.slice(1));
   }
   const replacements = {
     CLAUDE_PROJECT_DIR: projectRoot,
-    CLAUDE_CONFIG_DIR: path12.join(homeDir, ".claude"),
+    CLAUDE_CONFIG_DIR: path14.join(homeDir, ".claude"),
     HOME: homeDir,
     USERPROFILE: homeDir
   };
@@ -28702,7 +29840,7 @@ function expandPath(raw, projectRoot, homeDir, platform) {
   if (/\$\{?[A-Za-z_]/.test(s)) return null;
   if (/%[A-Za-z_][A-Za-z0-9_]*%/.test(s)) return null;
   s = translateMsysDrivePath(s, platform);
-  if (!path12.isAbsolute(s)) s = path12.resolve(projectRoot, s);
+  if (!path14.isAbsolute(s)) s = path14.resolve(projectRoot, s);
   return s;
 }
 function looksLikePath(token) {
@@ -28840,19 +29978,19 @@ var init_hook_coverage = __esm({
 });
 
 // src/core/skill-scanner.ts
-import * as fs10 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os4 from "node:os";
-import * as path13 from "node:path";
+import * as path15 from "node:path";
 function defaultHome() {
   return process.env.HOME || process.env.USERPROFILE || os4.homedir();
 }
 function scanSkillFiles(homeDir = defaultHome()) {
   const files = [];
   const orphanedSkillDirs = [];
-  const claudeDir = path13.join(homeDir, ".claude");
-  const skillsRoot = path13.join(claudeDir, "skills");
+  const claudeDir = path15.join(homeDir, ".claude");
+  const skillsRoot = path15.join(claudeDir, "skills");
   for (const name of safeReadDir(skillsRoot, "dir")) {
-    const skillMd = path13.join(skillsRoot, name, "SKILL.md");
+    const skillMd = path15.join(skillsRoot, name, "SKILL.md");
     const content = safeRead(skillMd);
     if (content === null) {
       orphanedSkillDirs.push({ name, displayPath: `~/.claude/skills/${name}/` });
@@ -28866,10 +30004,10 @@ function scanSkillFiles(homeDir = defaultHome()) {
       content
     });
   }
-  const agentsRoot = path13.join(claudeDir, "agents");
+  const agentsRoot = path15.join(claudeDir, "agents");
   for (const fileName of safeReadDir(agentsRoot, "file")) {
     if (!fileName.endsWith(".md")) continue;
-    const agentMd = path13.join(agentsRoot, fileName);
+    const agentMd = path15.join(agentsRoot, fileName);
     const content = safeRead(agentMd);
     if (content === null) continue;
     files.push({
@@ -28885,7 +30023,7 @@ function scanSkillFiles(homeDir = defaultHome()) {
 function safeReadDir(dir, want) {
   let entries;
   try {
-    entries = fs10.readdirSync(dir, { withFileTypes: true });
+    entries = fs12.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -28893,7 +30031,7 @@ function safeReadDir(dir, want) {
     if (want === "dir" ? e.isDirectory() : e.isFile()) return true;
     if (!e.isSymbolicLink()) return false;
     try {
-      const target = fs10.statSync(path13.join(dir, e.name));
+      const target = fs12.statSync(path15.join(dir, e.name));
       return want === "dir" ? target.isDirectory() : target.isFile();
     } catch {
       return false;
@@ -28902,7 +30040,7 @@ function safeReadDir(dir, want) {
 }
 function safeRead(file2) {
   try {
-    return stripBom(fs10.readFileSync(file2, "utf-8"));
+    return stripBom(fs12.readFileSync(file2, "utf-8"));
   } catch {
     return null;
   }
@@ -28916,7 +30054,7 @@ var init_skill_scanner = __esm({
 });
 
 // src/core/checks/skills.ts
-import * as path14 from "node:path";
+import * as path16 from "node:path";
 function parseFrontmatter3(content) {
   const lines = content.split("\n");
   if (lines[0]?.trim() !== "---") {
@@ -28993,7 +30131,7 @@ function checkMissingFrontmatter(file2, fm) {
 }
 function checkBrokenRefs(file2, fmEndLine) {
   const issues = [];
-  const skillDir = path14.dirname(file2.filePath);
+  const skillDir = path16.dirname(file2.filePath);
   const lines = file2.content.split("\n");
   let inCode = false;
   let codeLang = "";
@@ -29013,7 +30151,7 @@ function checkBrokenRefs(file2, fmEndLine) {
       if (PATH_SKIP.test(value)) continue;
       if (!value.startsWith("./") && !value.startsWith("../")) continue;
       while (/[.,;:]$/.test(value)) value = value.slice(0, -1);
-      const resolved = path14.resolve(skillDir, value);
+      const resolved = path16.resolve(skillDir, value);
       if (fileExists(resolved) || isDirectory(resolved)) continue;
       issues.push({
         severity: "warning",
@@ -29278,15 +30416,15 @@ var init_types = __esm({
 });
 
 // src/version.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-import { resolve as resolve15, dirname as dirname7 } from "node:path";
+import { readFileSync as readFileSync10 } from "node:fs";
+import { resolve as resolve18, dirname as dirname10 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function loadVersion() {
-  if (true) return "0.25.2";
+  if (true) return "0.25.3";
   try {
-    const __dir = dirname7(fileURLToPath2(import.meta.url));
-    const pkgPath = resolve15(__dir, "../package.json");
-    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const __dir = dirname10(fileURLToPath2(import.meta.url));
+    const pkgPath = resolve18(__dir, "../package.json");
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0-dev";
   } catch {
     return "0.0.0-dev";
@@ -29302,9 +30440,9 @@ var init_version2 = __esm({
 });
 
 // src/core/audit.ts
-import * as fs11 from "node:fs";
+import * as fs13 from "node:fs";
 import * as os5 from "node:os";
-import * as path15 from "node:path";
+import * as path17 from "node:path";
 function hasMcpChecks(checks) {
   return checks.some((c3) => c3.startsWith("mcp-"));
 }
@@ -29341,7 +30479,7 @@ async function runAudit(projectRoot, activeChecks, options = {}) {
       const absPath = discoveredFile.absolutePath;
       let stat3 = null;
       try {
-        const s = fs11.statSync(absPath);
+        const s = fs13.statSync(absPath);
         stat3 = { mtimeMs: s.mtimeMs, size: s.size };
       } catch {
       }
@@ -29668,12 +30806,12 @@ async function runAudit(projectRoot, activeChecks, options = {}) {
   return result;
 }
 async function runAuditOnContent(filePath, content, projectRoot, options = {}) {
-  const tmpDir = fs11.mkdtempSync(path15.join(os5.tmpdir(), "ctxlint-lsp-"));
-  const ext = path15.extname(filePath) || ".md";
-  const tmpFile = path15.join(tmpDir, "content" + ext);
+  const tmpDir = fs13.mkdtempSync(path17.join(os5.tmpdir(), "ctxlint-lsp-"));
+  const ext = path17.extname(filePath) || ".md";
+  const tmpFile = path17.join(tmpDir, "content" + ext);
   try {
-    fs11.writeFileSync(tmpFile, content, "utf-8");
-    const tmpRelative = path15.relative(tmpDir, tmpFile);
+    fs13.writeFileSync(tmpFile, content, "utf-8");
+    const tmpRelative = path17.relative(tmpDir, tmpFile);
     const rawResult = await runAudit(
       tmpDir,
       options.depth !== void 0 ? ALL_CHECKS : ALL_CHECKS,
@@ -29688,13 +30826,13 @@ async function runAuditOnContent(filePath, content, projectRoot, options = {}) {
       }
     );
     const remapped = rawResult.files.map((fr) => {
-      const isTmp = fr.path === tmpRelative || fr.path === tmpFile || path15.resolve(tmpDir, fr.path) === tmpFile;
+      const isTmp = fr.path === tmpRelative || fr.path === tmpFile || path17.resolve(tmpDir, fr.path) === tmpFile;
       return isTmp ? { ...fr, path: filePath } : fr;
     });
     return { ...rawResult, files: remapped, projectRoot };
   } finally {
     try {
-      fs11.rmSync(tmpDir, { recursive: true, force: true });
+      fs13.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -29802,7 +30940,7 @@ var server_exports = {};
 __export(server_exports, {
   startLspServer: () => startLspServer
 });
-import * as path16 from "node:path";
+import * as path18 from "node:path";
 async function startLspServer() {
   const connection = (0, import_node.createConnection)(import_node.ProposedFeatures.all);
   const documents = new import_node.TextDocuments(TextDocument2);
@@ -29817,7 +30955,7 @@ async function startLspServer() {
     const uri = doc.uri;
     let filePath = uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri;
     filePath = filePath.replace(/^\/([A-Za-z]:)/, "$1");
-    const projectRoot = path16.dirname(filePath);
+    const projectRoot = path18.dirname(filePath);
     try {
       const result = await runAuditOnContent(filePath, doc.getText(), projectRoot, {
         depth: 2
@@ -30269,8 +31407,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path21, errorMaps, issueData } = params;
-      const fullPath = [...path21, ...issueData.path || []];
+      const { data, path: path23, errorMaps, issueData } = params;
+      const fullPath = [...path23, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -30553,11 +31691,11 @@ var init_types2 = __esm({
     init_parseUtil();
     init_util2();
     ParseInputLazyPath = class {
-      constructor(parent, value, path21, key) {
+      constructor(parent, value, path23, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path21;
+        this._path = path23;
         this._key = key;
       }
       get path() {
@@ -34059,10 +35197,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path21) {
-  if (!path21)
+function getElementAtPath(obj, path23) {
+  if (!path23)
     return obj;
-  return path21.reduce((acc, key) => acc?.[key], obj);
+  return path23.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -34390,11 +35528,11 @@ function explicitlyAborted(x3, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path21, issues) {
+function prefixIssues(path23, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path21);
+    iss.path.unshift(path23);
     return iss;
   });
 }
@@ -34612,16 +35750,16 @@ function flattenError(error52, mapper = (issue2) => issue2.message) {
 }
 function formatError(error52, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error53, path21 = []) => {
+  const processError = (error53, path23 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path21, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path23, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
       } else {
-        const fullpath = [...path21, ...issue2.path];
+        const fullpath = [...path23, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -34648,17 +35786,17 @@ function formatError(error52, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error52, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error53, path21 = []) => {
+  const processError = (error53, path23 = []) => {
     var _a4, _b;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path21, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path23, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
       } else {
-        const fullpath = [...path21, ...issue2.path];
+        const fullpath = [...path23, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -34690,8 +35828,8 @@ function treeifyError(error52, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path21 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path21) {
+  const path23 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path23) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -48452,13 +49590,13 @@ function resolveRef2(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path21 = ref.slice(1).split("/").filter(Boolean);
-  if (path21.length === 0) {
+  const path23 = ref.slice(1).split("/").filter(Boolean);
+  if (path23.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path21[0] === defsKey) {
-    const key = path21[1];
+  if (path23[0] === defsKey) {
+    const key = path23[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -52972,7 +54110,7 @@ var init_protocol = __esm({
               return;
             }
             const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-            await new Promise((resolve19) => setTimeout(resolve19, pollInterval));
+            await new Promise((resolve22) => setTimeout(resolve22, pollInterval));
             options?.signal?.throwIfAborted();
           }
         } catch (error52) {
@@ -52989,7 +54127,7 @@ var init_protocol = __esm({
        */
       request(request, resultSchema, options) {
         const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-        return new Promise((resolve19, reject) => {
+        return new Promise((resolve22, reject) => {
           const earlyReject = (error52) => {
             reject(error52);
           };
@@ -53067,7 +54205,7 @@ var init_protocol = __esm({
               if (!parseResult.success) {
                 reject(parseResult.error);
               } else {
-                resolve19(parseResult.data);
+                resolve22(parseResult.data);
               }
             } catch (error52) {
               reject(error52);
@@ -53328,12 +54466,12 @@ var init_protocol = __esm({
           }
         } catch {
         }
-        return new Promise((resolve19, reject) => {
+        return new Promise((resolve22, reject) => {
           if (signal.aborted) {
             reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
             return;
           }
-          const timeoutId = setTimeout(resolve19, interval);
+          const timeoutId = setTimeout(resolve22, interval);
           signal.addEventListener("abort", () => {
             clearTimeout(timeoutId);
             reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -56381,7 +57519,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve19.call(this, root, ref);
+      let _sch = resolve22.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a4 = root.localRefs) === null || _a4 === void 0 ? void 0 : _a4[ref];
         const { schemaId } = this.opts;
@@ -56408,7 +57546,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve19(root, ref) {
+    function resolve22(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -56627,8 +57765,8 @@ var require_utils2 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path21) {
-      let input = path21;
+    function removeDotSegments(path23) {
+      let input = path23;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -56881,8 +58019,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path21, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path21 && path21 !== "/" ? path21 : void 0;
+        const [path23, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path23 && path23 !== "/" ? path23 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -57042,55 +58180,55 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve19(baseURI, relativeURI, options) {
+    function resolve22(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse5(baseURI, schemelessOptions), parse5(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative9, options, skipNormalization) {
+    function resolveComponent(base, relative12, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse5(serialize(base, options), options);
-        relative9 = parse5(serialize(relative9, options), options);
+        relative12 = parse5(serialize(relative12, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative9.scheme) {
-        target.scheme = relative9.scheme;
-        target.userinfo = relative9.userinfo;
-        target.host = relative9.host;
-        target.port = relative9.port;
-        target.path = removeDotSegments(relative9.path || "");
-        target.query = relative9.query;
+      if (!options.tolerant && relative12.scheme) {
+        target.scheme = relative12.scheme;
+        target.userinfo = relative12.userinfo;
+        target.host = relative12.host;
+        target.port = relative12.port;
+        target.path = removeDotSegments(relative12.path || "");
+        target.query = relative12.query;
       } else {
-        if (relative9.userinfo !== void 0 || relative9.host !== void 0 || relative9.port !== void 0) {
-          target.userinfo = relative9.userinfo;
-          target.host = relative9.host;
-          target.port = relative9.port;
-          target.path = removeDotSegments(relative9.path || "");
-          target.query = relative9.query;
+        if (relative12.userinfo !== void 0 || relative12.host !== void 0 || relative12.port !== void 0) {
+          target.userinfo = relative12.userinfo;
+          target.host = relative12.host;
+          target.port = relative12.port;
+          target.path = removeDotSegments(relative12.path || "");
+          target.query = relative12.query;
         } else {
-          if (!relative9.path) {
+          if (!relative12.path) {
             target.path = base.path;
-            if (relative9.query !== void 0) {
-              target.query = relative9.query;
+            if (relative12.query !== void 0) {
+              target.query = relative12.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative9.path[0] === "/") {
-              target.path = removeDotSegments(relative9.path);
+            if (relative12.path[0] === "/") {
+              target.path = removeDotSegments(relative12.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative9.path;
+                target.path = "/" + relative12.path;
               } else if (!base.path) {
-                target.path = relative9.path;
+                target.path = relative12.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative9.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative12.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative9.query;
+            target.query = relative12.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -57098,7 +58236,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative9.fragment;
+      target.fragment = relative12.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -57300,7 +58438,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize4,
-      resolve: resolve19,
+      resolve: resolve22,
       resolveComponent,
       equal,
       serialize,
@@ -60321,12 +61459,12 @@ var require_dist3 = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs16, exportName) {
+    function addFormats(ajv, list, fs18, exportName) {
       var _a4;
       var _b;
       (_a4 = (_b = ajv.opts.code).formats) !== null && _a4 !== void 0 ? _a4 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs16[f]);
+        ajv.addFormat(f, fs18[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -61482,7 +62620,7 @@ var init_mcp = __esm({
         let task = createTaskResult.task;
         const pollInterval = task.pollInterval ?? 5e3;
         while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-          await new Promise((resolve19) => setTimeout(resolve19, pollInterval));
+          await new Promise((resolve22) => setTimeout(resolve22, pollInterval));
           const updatedTask = await extra.taskStore.getTask(taskId);
           if (!updatedTask) {
             throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -62078,12 +63216,12 @@ var init_stdio2 = __esm({
         this.onclose?.();
       }
       send(message) {
-        return new Promise((resolve19) => {
+        return new Promise((resolve22) => {
           const json2 = serializeMessage(message);
           if (this._stdout.write(json2)) {
-            resolve19();
+            resolve22();
           } else {
-            this._stdout.once("drain", resolve19);
+            this._stdout.once("drain", resolve22);
           }
         });
       }
@@ -62634,7 +63772,7 @@ var init_source = __esm({
 });
 
 // src/core/fixer.ts
-import * as fs12 from "node:fs";
+import * as fs14 from "node:fs";
 function applyFixes(result, options = {}) {
   const log = options.quiet ? () => {
   } : console.log.bind(console);
@@ -62672,7 +63810,7 @@ function applyFixes(result, options = {}) {
   for (const [filePath, fixes] of fixesByFile) {
     let content;
     try {
-      content = fs12.readFileSync(filePath, "utf-8");
+      content = fs14.readFileSync(filePath, "utf-8");
     } catch (err) {
       log(source_default.yellow("  Skipped") + ` ${filePath}: ${err.message}`);
       continue;
@@ -62757,7 +63895,7 @@ function applyFixes(result, options = {}) {
       }
       if (!dryRun) {
         try {
-          fs12.writeFileSync(filePath, newContent, "utf-8");
+          fs14.writeFileSync(filePath, newContent, "utf-8");
         } catch (err) {
           log(source_default.yellow("  Skipped") + ` ${filePath}: ${err.message}`);
           continue;
@@ -62779,8 +63917,8 @@ var init_fixer = __esm({
 });
 
 // src/core/config.ts
-import * as fs13 from "node:fs";
-import * as path17 from "node:path";
+import * as fs15 from "node:fs";
+import * as path19 from "node:path";
 function formatJsonError(content, err) {
   const msg = err instanceof Error ? err.message : String(err);
   const posMatch = msg.match(/position (\d+)/);
@@ -62820,7 +63958,7 @@ function suggestKey(unknown2) {
   let best = null;
   let bestDist = Infinity;
   for (const known of KNOWN_CONFIG_KEYS) {
-    const d = levenshtein2(unknown2, known);
+    const d = levenshtein3(unknown2, known);
     if (d < bestDist) {
       bestDist = d;
       best = known;
@@ -62878,10 +64016,10 @@ function warnIgnoreRulePathPatternMisuse(config2, source) {
 }
 function loadConfig(projectRoot) {
   for (const filename of CONFIG_FILENAMES) {
-    const filePath = path17.join(projectRoot, filename);
+    const filePath = path19.join(projectRoot, filename);
     let content;
     try {
-      content = stripBom(fs13.readFileSync(filePath, "utf-8"));
+      content = stripBom(fs15.readFileSync(filePath, "utf-8"));
     } catch {
       continue;
     }
@@ -62892,22 +64030,22 @@ function loadConfig(projectRoot) {
 function loadConfigFromExplicitPath(configPath) {
   let content;
   try {
-    content = stripBom(fs13.readFileSync(configPath, "utf-8"));
+    content = stripBom(fs15.readFileSync(configPath, "utf-8"));
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     throw new Error(`could not load config from ${configPath}: ${detail}`, { cause: err });
   }
   return parseConfigContent(content, configPath);
 }
-var import_fast_levenshtein2, levenshtein2, KNOWN_CONFIG_KEYS, CONFIG_FILENAMES;
+var import_fast_levenshtein3, levenshtein3, KNOWN_CONFIG_KEYS, CONFIG_FILENAMES;
 var init_config2 = __esm({
   "src/core/config.ts"() {
     "use strict";
     init_define_WEB_FIRST_SEGMENTS();
-    import_fast_levenshtein2 = __toESM(require_levenshtein(), 1);
+    import_fast_levenshtein3 = __toESM(require_levenshtein(), 1);
     init_fs();
     init_positions();
-    levenshtein2 = import_fast_levenshtein2.default.get;
+    levenshtein3 = import_fast_levenshtein3.default.get;
     KNOWN_CONFIG_KEYS = [
       "checks",
       "ignore",
@@ -62935,7 +64073,7 @@ __export(server_exports2, {
   server: () => server,
   startServer: () => startServer
 });
-import * as path18 from "node:path";
+import * as path20 from "node:path";
 function describeDisallowed(rawPath) {
   const m = rawPath.match(PATH_DISALLOWED);
   if (!m) return "unknown";
@@ -62948,7 +64086,7 @@ function validateProjectPath(rawPath) {
       `projectPath contains disallowed character ${describeDisallowed(rawPath)} (control chars and shell metacharacters are rejected)`
     );
   }
-  const resolved = path18.resolve(rawPath);
+  const resolved = path20.resolve(rawPath);
   if (!isDirectory(resolved)) {
     throw new Error("projectPath is not an existing directory");
   }
@@ -62972,10 +64110,10 @@ function validateFilePathInput(rawPath) {
   }
 }
 function resolveWithinRoot(filePath, root) {
-  const resolvedRoot = path18.resolve(root);
-  const resolved = path18.resolve(resolvedRoot, filePath);
-  const rel = path18.relative(resolvedRoot, resolved);
-  if (rel.startsWith("..") || path18.isAbsolute(rel)) {
+  const resolvedRoot = path20.resolve(root);
+  const resolved = path20.resolve(resolvedRoot, filePath);
+  const rel = path20.relative(resolvedRoot, resolved);
+  if (rel.startsWith("..") || path20.isAbsolute(rel)) {
     throw new Error("path escapes the project root");
   }
   return resolved;
@@ -63074,7 +64212,7 @@ var init_server4 = __esm({
             exists: fileExists(resolved) || isDirectory(resolved)
           };
           if (!result.exists) {
-            const rename = await findRenames(root, path18.relative(root, resolved));
+            const rename = await findRenames(root, path20.relative(root, resolved));
             if (rename) {
               result.renamed = true;
               result.newPath = rename.newPath;
@@ -64495,8 +65633,8 @@ var init_suggestSimilar = __esm({
 // node_modules/.pnpm/commander@15.0.0/node_modules/commander/lib/command.js
 import { EventEmitter as EventEmitter2 } from "node:events";
 import childProcess from "node:child_process";
-import path19 from "node:path";
-import fs14 from "node:fs";
+import path21 from "node:path";
+import fs16 from "node:fs";
 import process5 from "node:process";
 import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
 function incrementNodeInspectorPort(args2) {
@@ -65534,7 +66672,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs14.existsSync(executableFile)) return;
+        if (fs16.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -65551,11 +66689,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         args2 = args2.slice();
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path19.resolve(baseDir, baseName);
-          if (fs14.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path19.extname(baseName))) return void 0;
+          const localBin = path21.resolve(baseDir, baseName);
+          if (fs16.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path21.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs14.existsSync(`${localBin}${ext}`)
+            (ext) => fs16.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -65567,21 +66705,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs14.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs16.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path19.resolve(
-            path19.dirname(resolvedScriptPath),
+          executableDir = path21.resolve(
+            path21.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path19.basename(
+            const legacyName = path21.basename(
               this._scriptPath,
-              path19.extname(this._scriptPath)
+              path21.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -65592,7 +66730,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        const launchWithNode = sourceExt.includes(path19.extname(executableFile));
+        const launchWithNode = sourceExt.includes(path21.extname(executableFile));
         let proc;
         if (process5.platform !== "win32") {
           if (launchWithNode) {
@@ -66509,7 +67647,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path19.basename(filename, path19.extname(filename));
+        this._name = path21.basename(filename, path21.extname(filename));
         return this;
       }
       /**
@@ -66523,9 +67661,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path21) {
-        if (path21 === void 0) return this._executableDir;
-        this._executableDir = path21;
+      executableDir(path23) {
+        if (path23 === void 0) return this._executableDir;
+        this._executableDir = path23;
         return this;
       }
       /**
@@ -69858,8 +70996,8 @@ var init_ora = __esm({
 });
 
 // src/core/reporter.ts
-import { existsSync as existsSync8, readFileSync as readFileSync11 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
+import { join as join18 } from "node:path";
 function classifyFile(f) {
   if (f.path === "(project)") return "context";
   if (f.path === "(mcp)") return "mcp";
@@ -69883,9 +71021,9 @@ function isSyntheticBucket(p2) {
 }
 function detectVersionSkew(projectRoot, runningVersion) {
   try {
-    const pkgPath = join16(projectRoot, "package.json");
-    if (!existsSync8(pkgPath)) return null;
-    const raw = readFileSync11(pkgPath, "utf8").replace(/^\uFEFF/, "");
+    const pkgPath = join18(projectRoot, "package.json");
+    if (!existsSync11(pkgPath)) return null;
+    const raw = readFileSync13(pkgPath, "utf8").replace(/^\uFEFF/, "");
     const pkg = JSON.parse(raw);
     const name = pkg.name ?? "";
     if (name !== "ctxlint" && name !== "@yawlabs/ctxlint") return null;
@@ -70385,11 +71523,11 @@ __export(cli_exports, {
   promptYesNo: () => promptYesNo,
   runCli: () => runCli
 });
-import * as fs15 from "node:fs";
-import * as path20 from "node:path";
+import * as fs17 from "node:fs";
+import * as path22 from "node:path";
 function existsAsDirectory(p2) {
   try {
-    return fs15.statSync(p2).isDirectory();
+    return fs17.statSync(p2).isDirectory();
   } catch {
     return false;
   }
@@ -70416,7 +71554,7 @@ async function runCli() {
     "Also scan the user-global ~/.claude/settings.json in the dead-hook check (off by default; the standard run only reads project .claude/settings.json[.local])",
     false
   ).option("--no-ignore-file", "Disable .ctxlintignore suppression (see all findings)").option("--watch", "Re-lint on context file changes", false).action(async (projectPath, opts) => {
-    const resolvedPath = path20.resolve(projectPath);
+    const resolvedPath = path22.resolve(projectPath);
     if (!existsAsDirectory(resolvedPath)) {
       console.error(
         `Error: ${resolvedPath} is not an existing directory. Check the path argument.`
@@ -70555,41 +71693,41 @@ Fixed ${applied.totalFixes} issue${applied.totalFixes !== 1 ? "s" : ""} in ${app
       const chalk2 = (await Promise.resolve().then(() => (init_source(), source_exports))).default;
       console.log(chalk2.dim("\nWatching for changes... (Ctrl+C to stop)\n"));
       const watchPaths = [
-        path20.join(resolvedPath, "CLAUDE.md"),
-        path20.join(resolvedPath, "CLAUDE.local.md"),
-        path20.join(resolvedPath, "AGENTS.md"),
-        path20.join(resolvedPath, "AGENT.md"),
-        path20.join(resolvedPath, ".cursorrules"),
-        path20.join(resolvedPath, ".windsurfrules"),
-        path20.join(resolvedPath, ".clinerules"),
-        path20.join(resolvedPath, ".aiderules"),
-        path20.join(resolvedPath, ".continuerules"),
-        path20.join(resolvedPath, ".rules"),
-        path20.join(resolvedPath, ".goosehints"),
-        path20.join(resolvedPath, "GEMINI.md"),
-        path20.join(resolvedPath, "replit.md"),
-        path20.join(resolvedPath, "package.json"),
-        path20.join(resolvedPath, ".mcp.json"),
+        path22.join(resolvedPath, "CLAUDE.md"),
+        path22.join(resolvedPath, "CLAUDE.local.md"),
+        path22.join(resolvedPath, "AGENTS.md"),
+        path22.join(resolvedPath, "AGENT.md"),
+        path22.join(resolvedPath, ".cursorrules"),
+        path22.join(resolvedPath, ".windsurfrules"),
+        path22.join(resolvedPath, ".clinerules"),
+        path22.join(resolvedPath, ".aiderules"),
+        path22.join(resolvedPath, ".continuerules"),
+        path22.join(resolvedPath, ".rules"),
+        path22.join(resolvedPath, ".goosehints"),
+        path22.join(resolvedPath, "GEMINI.md"),
+        path22.join(resolvedPath, "replit.md"),
+        path22.join(resolvedPath, "package.json"),
+        path22.join(resolvedPath, ".mcp.json"),
         // ctxlint config — re-resolve on edit so threshold changes,
         // ignore-list edits, and check-list overrides take effect without
         // restarting the watcher.
-        path20.join(resolvedPath, ".ctxlintrc"),
-        path20.join(resolvedPath, ".ctxlintrc.json"),
+        path22.join(resolvedPath, ".ctxlintrc"),
+        path22.join(resolvedPath, ".ctxlintrc.json"),
         // .ctxlintignore — re-lint when suppression rules change.
-        path20.join(resolvedPath, ".ctxlintignore")
+        path22.join(resolvedPath, ".ctxlintignore")
       ];
       const watchDirs = [
-        path20.join(resolvedPath, ".claude"),
-        path20.join(resolvedPath, ".cursor"),
-        path20.join(resolvedPath, ".github"),
-        path20.join(resolvedPath, ".windsurf"),
-        path20.join(resolvedPath, ".aide"),
-        path20.join(resolvedPath, ".amazonq"),
-        path20.join(resolvedPath, ".goose"),
-        path20.join(resolvedPath, ".junie"),
-        path20.join(resolvedPath, ".aiassistant"),
-        path20.join(resolvedPath, ".continue"),
-        path20.join(resolvedPath, ".vscode")
+        path22.join(resolvedPath, ".claude"),
+        path22.join(resolvedPath, ".cursor"),
+        path22.join(resolvedPath, ".github"),
+        path22.join(resolvedPath, ".windsurf"),
+        path22.join(resolvedPath, ".aide"),
+        path22.join(resolvedPath, ".amazonq"),
+        path22.join(resolvedPath, ".goose"),
+        path22.join(resolvedPath, ".junie"),
+        path22.join(resolvedPath, ".aiassistant"),
+        path22.join(resolvedPath, ".continue"),
+        path22.join(resolvedPath, ".vscode")
       ];
       const watchers = [];
       let debounceTimer = null;
@@ -70653,13 +71791,13 @@ Fixed ${applied.totalFixes} issue${applied.totalFixes !== 1 ? "s" : ""} in ${app
       };
       for (const filePath of watchPaths) {
         try {
-          watchers.push(fs15.watch(filePath, rerun));
+          watchers.push(fs17.watch(filePath, rerun));
         } catch {
         }
       }
       for (const dir of watchDirs) {
         try {
-          watchers.push(fs15.watch(dir, { recursive: true }, rerun));
+          watchers.push(fs17.watch(dir, { recursive: true }, rerun));
         } catch {
         }
       }
@@ -70680,17 +71818,17 @@ Fixed ${applied.totalFixes} issue${applied.totalFixes !== 1 ? "s" : ""} in ${app
     }
   });
   program2.command("init").description("Set up a git pre-commit hook that runs ctxlint --strict").argument("[path]", "Project directory", ".").action(async (projectPath) => {
-    const resolvedRoot = path20.resolve(projectPath);
-    const gitDir = path20.join(resolvedRoot, ".git");
-    const hooksDir = path20.join(gitDir, "hooks");
-    if (!fs15.existsSync(gitDir)) {
+    const resolvedRoot = path22.resolve(projectPath);
+    const gitDir = path22.join(resolvedRoot, ".git");
+    const hooksDir = path22.join(gitDir, "hooks");
+    if (!fs17.existsSync(gitDir)) {
       console.error('Error: not a git repository. Run "git init" first.');
       process.exit(1);
     }
-    if (!fs15.existsSync(hooksDir)) {
-      fs15.mkdirSync(hooksDir, { recursive: true });
+    if (!fs17.existsSync(hooksDir)) {
+      fs17.mkdirSync(hooksDir, { recursive: true });
     }
-    const hookPath = path20.join(hooksDir, "pre-commit");
+    const hookPath = path22.join(hooksDir, "pre-commit");
     const fullHookContent = `#!/bin/sh
 # ctxlint pre-commit hook
 npx @yawlabs/ctxlint@${VERSION} --strict
@@ -70699,15 +71837,15 @@ npx @yawlabs/ctxlint@${VERSION} --strict
 # ctxlint pre-commit hook
 npx @yawlabs/ctxlint@${VERSION} --strict
 `;
-    if (fs15.existsSync(hookPath)) {
-      const existing = fs15.readFileSync(hookPath, "utf-8");
+    if (fs17.existsSync(hookPath)) {
+      const existing = fs17.readFileSync(hookPath, "utf-8");
       const installed = existing.match(
         /^[^#\r\n]*\bnpx\s+(?:-y\s+|--yes\s+)?@yawlabs\/ctxlint(?:@(\d+\.\d+\.\d+))?/m
       );
       if (installed) {
         const pinned = installed[1];
         if (pinned && pinned !== VERSION) {
-          fs15.writeFileSync(
+          fs17.writeFileSync(
             hookPath,
             existing.replace(/(@yawlabs\/ctxlint@)\d+\.\d+\.\d+/g, `$1${VERSION}`)
           );
@@ -70717,10 +71855,10 @@ npx @yawlabs/ctxlint@${VERSION} --strict
         }
         return;
       }
-      fs15.appendFileSync(hookPath, appendHookContent);
+      fs17.appendFileSync(hookPath, appendHookContent);
       console.log("Added ctxlint to existing pre-commit hook.");
     } else {
-      fs15.writeFileSync(hookPath, fullHookContent, { mode: 493 });
+      fs17.writeFileSync(hookPath, fullHookContent, { mode: 493 });
       console.log("Created pre-commit hook at .git/hooks/pre-commit");
     }
     console.log("ctxlint will now run automatically before each commit.");
@@ -70742,7 +71880,7 @@ function resolveDepth(raw) {
   return Number.isNaN(parsed) ? 2 : Math.max(0, Math.min(parsed, 10));
 }
 function resolveSession(resolvedPath, opts, throwOnConfigError = false) {
-  const configPath = opts.config ? path20.resolve(opts.config) : void 0;
+  const configPath = opts.config ? path22.resolve(opts.config) : void 0;
   const config2 = configPath ? loadConfigFromPath(configPath, throwOnConfigError) : loadDiscoveredConfig(resolvedPath, throwOnConfigError);
   const mcpGlobal = opts.mcpGlobal || config2?.mcpGlobal || false;
   const mcpOnly = opts.mcpOnly || config2?.mcpOnly || false;