@yawlabs/ctxlint 0.12.3 → 0.13.1

package/dist/index.js

@@ -461,8 +461,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path14, errorMaps, issueData } = params;
-      const fullPath = [...path14, ...issueData.path || []];
+      const { data, path: path17, errorMaps, issueData } = params;
+      const fullPath = [...path17, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -745,11 +745,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path14, key) {
+      constructor(parent, value, path17, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path14;
+        this._path = path17;
         this._key = key;
       }
       get path() {
@@ -4257,10 +4257,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path14) {
-  if (!path14)
+function getElementAtPath(obj, path17) {
+  if (!path17)
     return obj;
-  return path14.reduce((acc, key) => acc?.[key], obj);
+  return path17.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4572,11 +4572,11 @@ function aborted(x3, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path14, issues) {
+function prefixIssues(path17, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path14);
+    iss.path.unshift(path17);
     return iss;
   });
 }
@@ -4819,7 +4819,7 @@ function formatError(error49, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error49, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error50, path14 = []) => {
+  const processError = (error50, path17 = []) => {
     var _a3, _b;
     for (const issue2 of error50.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -4829,7 +4829,7 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path17, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4861,8 +4861,8 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path14) {
+  const path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path17) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17890,13 +17890,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path14 = ref.slice(1).split("/").filter(Boolean);
-  if (path14.length === 0) {
+  const path17 = ref.slice(1).split("/").filter(Boolean);
+  if (path17.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path14[0] === defsKey) {
-    const key = path14[1];
+  if (path17[0] === defsKey) {
+    const key = path17[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -22404,7 +22404,7 @@ var init_protocol = __esm({
               return;
             }
             const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-            await new Promise((resolve12) => setTimeout(resolve12, pollInterval));
+            await new Promise((resolve14) => setTimeout(resolve14, pollInterval));
             options?.signal?.throwIfAborted();
           }
         } catch (error49) {
@@ -22421,7 +22421,7 @@ var init_protocol = __esm({
        */
       request(request, resultSchema, options) {
         const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve14, reject) => {
           const earlyReject = (error49) => {
             reject(error49);
           };
@@ -22499,7 +22499,7 @@ var init_protocol = __esm({
               if (!parseResult.success) {
                 reject(parseResult.error);
               } else {
-                resolve12(parseResult.data);
+                resolve14(parseResult.data);
               }
             } catch (error49) {
               reject(error49);
@@ -22760,12 +22760,12 @@ var init_protocol = __esm({
           }
         } catch {
         }
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve14, reject) => {
           if (signal.aborted) {
             reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
             return;
           }
-          const timeoutId = setTimeout(resolve12, interval);
+          const timeoutId = setTimeout(resolve14, interval);
           signal.addEventListener("abort", () => {
             clearTimeout(timeoutId);
             reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -25813,7 +25813,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve12.call(this, root, ref);
+      let _sch = resolve14.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -25840,7 +25840,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve12(root, ref) {
+    function resolve14(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -26056,8 +26056,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path14) {
-      let input = path14;
+    function removeDotSegments(path17) {
+      let input = path17;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -26257,8 +26257,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path14, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path14 && path14 !== "/" ? path14 : void 0;
+        const [path17, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path17 && path17 !== "/" ? path17 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -26418,7 +26418,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve12(baseURI, relativeURI, options) {
+    function resolve14(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -26645,7 +26645,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize3,
-      resolve: resolve12,
+      resolve: resolve14,
       resolveComponent,
       equal,
       serialize,
@@ -29666,12 +29666,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs10, exportName) {
+    function addFormats(ajv, list, fs12, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs10[f]);
+        ajv.addFormat(f, fs12[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -30827,7 +30827,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((resolve12) => setTimeout(resolve12, pollInterval));
+          await new Promise((resolve14) => setTimeout(resolve14, pollInterval));
           const updatedTask = await extra.taskStore.getTask(taskId);
           if (!updatedTask) {
             throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -31423,12 +31423,12 @@ var init_stdio2 = __esm({
         this.onclose?.();
       }
       send(message) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve14) => {
           const json2 = serializeMessage(message);
           if (this._stdout.write(json2)) {
-            resolve12();
+            resolve14();
           } else {
-            this._stdout.once("drain", resolve12);
+            this._stdout.once("drain", resolve14);
           }
         });
       }
@@ -35539,7 +35539,7 @@ var require_supports_color = __commonJS({
   "node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module) {
     "use strict";
     init_define_WEB_FIRST_SEGMENTS();
-    var os3 = __require("os");
+    var os5 = __require("os");
     var tty3 = __require("tty");
     var hasFlag2 = require_has_flag();
     var { env: env2 } = process;
@@ -35587,7 +35587,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os3.release().split(".");
+        const osRelease = os5.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -35836,10 +35836,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(path14, isFile, isDirectory2) {
-      log(`checking %s`, path14);
+    function check2(path17, isFile, isDirectory2) {
+      log(`checking %s`, path17);
       try {
-        const stat3 = fs_1.statSync(path14);
+        const stat3 = fs_1.statSync(path17);
         if (stat3.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
@@ -35859,8 +35859,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path14, type = exports.READABLE) {
-      return check2(path14, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path17, type = exports.READABLE) {
+      return check2(path17, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -36453,8 +36453,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path14) {
-  return (0, import_file_exists.exists)(path14, import_file_exists.FOLDER);
+function folderExists(path17) {
+  return (0, import_file_exists.exists)(path17, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -36645,8 +36645,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path14) {
-      return /^\.(git)?$/.test(path14.trim());
+    parser(path17) {
+      return /^\.(git)?$/.test(path17.trim());
     }
   };
 }
@@ -36902,11 +36902,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path14, line, preview] = input.split(NULL);
-    paths.add(path14);
-    (results[path14] = results[path14] || []).push({
+    const [path17, line, preview] = input.split(NULL);
+    paths.add(path17);
+    (results[path17] = results[path17] || []).push({
       line: asNumber(line),
-      path: path14,
+      path: path17,
       preview
     });
   });
@@ -37203,14 +37203,14 @@ function hashObjectTask(filePath, write) {
   }
   return straightThroughStringTask(commands, true);
 }
-function parseInit(bare, path14, text) {
+function parseInit(bare, path17, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path14, false, result[1]);
+    return new InitSummary(bare, path17, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path14, true, result[1]);
+    return new InitSummary(bare, path17, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -37221,12 +37221,12 @@ function parseInit(bare, path14, text) {
       break;
     }
   }
-  return new InitSummary(bare, path14, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path17, /^re/i.test(response), gitDir);
 }
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path14, customArgs) {
+function initTask(bare = false, path17, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -37235,7 +37235,7 @@ function initTask(bare = false, path14, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path14, text);
+      return parseInit(commands.includes("--bare"), path17, text);
     }
   };
 }
@@ -37514,14 +37514,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path14) {
+  function data(index, workingDir, path17) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path14);
+      handler(result, path17);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path14, index, workingDir));
+      result.files.push(new FileStatusSummary(path17, index, workingDir));
     }
   }
 }
@@ -37708,8 +37708,8 @@ function deleteBranchTask(branch, forceDelete = false) {
   return task;
 }
 function toPath(input) {
-  const path14 = input.trim().replace(/^["']|["']$/g, "");
-  return path14 && normalize2(path14);
+  const path17 = input.trim().replace(/^["']|["']$/g, "");
+  return path17 && normalize2(path17);
 }
 function checkIgnoreTask(paths) {
   return {
@@ -37848,8 +37848,8 @@ function stashListTask(opt = {}, customArgs) {
     parser: parser4
   };
 }
-function addSubModuleTask(repo, path14) {
-  return subModuleTask(["add", repo, path14]);
+function addSubModuleTask(repo, path17) {
+  return subModuleTask(["add", repo, path17]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -39112,9 +39112,9 @@ var init_esm2 = __esm({
       "src/lib/responses/InitSummary.ts"() {
         "use strict";
         InitSummary = class {
-          constructor(bare, path14, existing, gitDir) {
+          constructor(bare, path17, existing, gitDir) {
             this.bare = bare;
-            this.path = path14;
+            this.path = path17;
             this.existing = existing;
             this.gitDir = gitDir;
           }
@@ -39647,12 +39647,12 @@ var init_esm2 = __esm({
         "use strict";
         fromPathRegex = /^(.+)\0(.+)$/;
         FileStatusSummary = class {
-          constructor(path14, index, working_dir) {
-            this.path = path14;
+          constructor(path17, index, working_dir) {
+            this.path = path17;
             this.index = index;
             this.working_dir = working_dir;
             if (index === "R" || working_dir === "R") {
-              const detail = fromPathRegex.exec(path14) || [null, path14, path14];
+              const detail = fromPathRegex.exec(path17) || [null, path17, path17];
               this.from = detail[2] || "";
               this.path = detail[1] || "";
             }
@@ -39914,9 +39914,9 @@ var init_esm2 = __esm({
               next
             );
           }
-          hashObject(path14, write) {
+          hashObject(path17, write) {
             return this._runTask(
-              hashObjectTask(path14, write === true),
+              hashObjectTask(path17, write === true),
               trailingFunctionArgument(arguments)
             );
           }
@@ -40553,8 +40553,8 @@ var init_esm2 = __esm({
           }
           return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
         };
-        Git2.prototype.submoduleAdd = function(repo, path14, then) {
-          return this._runTask(addSubModuleTask2(repo, path14), trailingFunctionArgument2(arguments));
+        Git2.prototype.submoduleAdd = function(repo, path17, then) {
+          return this._runTask(addSubModuleTask2(repo, path17), trailingFunctionArgument2(arguments));
         };
         Git2.prototype.submoduleUpdate = function(args2, then) {
           return this._runTask(
@@ -40905,6 +40905,45 @@ async function getCommitsSinceBatch(projectRoot, paths, since) {
   }
   return out;
 }
+function normalizeRenamePath(p2) {
+  return p2.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function parseRenameLog(result, targetPath) {
+  if (!result.trim()) return null;
+  const want = targetPath ? normalizeRenamePath(targetPath) : void 0;
+  const wantBase = want ? want.split("/").pop() ?? want : void 0;
+  let currentHash = "unknown";
+  let currentDateStr;
+  let basenameFallback = null;
+  const lines = result.trim().split("\n");
+  for (const line of lines) {
+    const headerMatch = line.match(/^([a-f0-9]{7,40})\s+(.+)$/);
+    if (headerMatch) {
+      currentHash = headerMatch[1].substring(0, 7);
+      currentDateStr = headerMatch[2];
+      continue;
+    }
+    if (line.startsWith("R")) {
+      const parts = line.split("	");
+      if (parts.length >= 3) {
+        const daysAgo = currentDateStr ? Math.floor((Date.now() - new Date(currentDateStr).getTime()) / (1e3 * 60 * 60 * 24)) : 0;
+        const info2 = {
+          oldPath: parts[1],
+          newPath: parts[2],
+          commitHash: currentHash,
+          daysAgo
+        };
+        if (!want) return info2;
+        const oldNorm = normalizeRenamePath(info2.oldPath);
+        if (oldNorm === want) return info2;
+        if (!basenameFallback && wantBase && (oldNorm.split("/").pop() ?? oldNorm) === wantBase) {
+          basenameFallback = info2;
+        }
+      }
+    }
+  }
+  return basenameFallback;
+}
 async function findRenames(projectRoot, filePath) {
   try {
     const git = getGit(projectRoot);
@@ -40914,35 +40953,9 @@ async function findRenames(projectRoot, filePath) {
       "--find-renames",
       "--name-status",
       "--format=%H %ai",
-      "-10",
-      "--",
-      filePath
+      "-50"
     ]);
-    if (!result.trim()) return null;
-    let currentHash = "unknown";
-    let currentDateStr;
-    const lines = result.trim().split("\n");
-    for (const line of lines) {
-      const headerMatch = line.match(/^([a-f0-9]{7,40})\s+(.+)$/);
-      if (headerMatch) {
-        currentHash = headerMatch[1].substring(0, 7);
-        currentDateStr = headerMatch[2];
-        continue;
-      }
-      if (line.startsWith("R")) {
-        const parts = line.split("	");
-        if (parts.length >= 3) {
-          const daysAgo = currentDateStr ? Math.floor((Date.now() - new Date(currentDateStr).getTime()) / (1e3 * 60 * 60 * 24)) : 0;
-          return {
-            oldPath: parts[1],
-            newPath: parts[2],
-            commitHash: currentHash,
-            daysAgo
-          };
-        }
-      }
-    }
-    return null;
+    return parseRenameLog(result, filePath);
   } catch {
     return null;
   }
@@ -41629,6 +41642,37 @@ function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
   }
   return result;
 }
+function findNodeAtLocation(root, path17) {
+  if (!root) {
+    return void 0;
+  }
+  let node = root;
+  for (let segment of path17) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return void 0;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return void 0;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return void 0;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
 function getNodeValue(node) {
   switch (node.type) {
     case "array":
@@ -42001,7 +42045,7 @@ var init_edit = __esm({
 });
 
 // node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
-var ScanError, SyntaxKind, parseTree2, getNodeValue2, ParseErrorCode;
+var ScanError, SyntaxKind, parseTree2, findNodeAtLocation2, getNodeValue2, ParseErrorCode;
 var init_main = __esm({
   "node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js"() {
     "use strict";
@@ -42039,6 +42083,7 @@ var init_main = __esm({
       SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
     })(SyntaxKind || (SyntaxKind = {}));
     parseTree2 = parseTree;
+    findNodeAtLocation2 = findNodeAtLocation;
     getNodeValue2 = getNodeValue;
     (function(ParseErrorCode2) {
       ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
@@ -45978,6 +46023,487 @@ var init_content_secrets = __esm({
   }
 });
 
+// src/core/checks/hook-coverage.ts
+import * as fs7 from "node:fs";
+import * as os2 from "node:os";
+import * as path11 from "node:path";
+function loadSettingsSources2(projectRoot, homeDir, includeUserGlobal) {
+  const home2 = homeDir;
+  const candidates = [
+    {
+      filePath: path11.join(projectRoot, ".claude", "settings.json"),
+      displayPath: path11.join(".claude", "settings.json"),
+      isUserGlobal: false
+    },
+    {
+      filePath: path11.join(projectRoot, ".claude", "settings.local.json"),
+      displayPath: path11.join(".claude", "settings.local.json"),
+      isUserGlobal: false
+    }
+  ];
+  if (includeUserGlobal) {
+    candidates.push({
+      filePath: path11.join(home2, ".claude", "settings.json"),
+      displayPath: "~/.claude/settings.json",
+      isUserGlobal: true
+    });
+  }
+  const sources = [];
+  for (const c3 of candidates) {
+    let content;
+    try {
+      content = stripBom(fs7.readFileSync(c3.filePath, "utf-8"));
+    } catch {
+      continue;
+    }
+    const tree = parseTree2(content, [], { allowTrailingComma: true });
+    sources.push({ ...c3, content, tree });
+  }
+  return sources;
+}
+function expandPath(raw, projectRoot, homeDir) {
+  let s = raw;
+  if (s === "~" || s.startsWith("~/") || s.startsWith("~\\")) {
+    s = path11.join(homeDir, s.slice(1));
+  }
+  const replacements = {
+    CLAUDE_PROJECT_DIR: projectRoot,
+    CLAUDE_CONFIG_DIR: path11.join(homeDir, ".claude"),
+    HOME: homeDir,
+    USERPROFILE: homeDir
+  };
+  s = s.replace(
+    /\$\{?([A-Z_][A-Z0-9_]*)\}?/g,
+    (m, name) => name in replacements ? replacements[name] : m
+  );
+  if (/\$\{?[A-Za-z_]/.test(s)) return null;
+  if (!path11.isAbsolute(s)) s = path11.resolve(projectRoot, s);
+  return s;
+}
+function looksLikePath(token) {
+  const hasSep = token.includes("/") || token.includes("\\");
+  if (PATH_PREFIX.test(token)) return true;
+  return hasSep && SCRIPT_EXT.test(token);
+}
+function extractCommandPaths(command, projectRoot, homeDir) {
+  const tokens = command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  const out = [];
+  for (const t2 of tokens) {
+    const token = t2.replace(/^['"]|['"]$/g, "");
+    if (!looksLikePath(token)) continue;
+    out.push({ raw: token, resolved: expandPath(token, projectRoot, homeDir) });
+  }
+  return out;
+}
+function extractPermissionPaths(entry, projectRoot, homeDir) {
+  const inner = entry.replace(/^[A-Za-z]+\((.*)\)$/, "$1");
+  return extractCommandPaths(inner, projectRoot, homeDir);
+}
+function lineForPath(source, jsonPath) {
+  if (!source.tree) return 1;
+  const node = findNodeAtLocation2(source.tree, jsonPath);
+  if (!node) return 1;
+  return offsetToPosition(source.content, node.offset).line;
+}
+function checkSource(source, projectRoot, homeDir) {
+  if (!source.tree) return [];
+  const data = getNodeValue2(source.tree);
+  if (!data || typeof data !== "object") return [];
+  const issues = [];
+  const report = (cand, line, origin) => {
+    if (cand.resolved === null) return;
+    if (fileExists(cand.resolved)) return;
+    const where = source.isUserGlobal ? ` (in ${source.displayPath})` : "";
+    issues.push({
+      severity: "warning",
+      check: "hook-coverage",
+      ruleId: "hook-coverage/dead-hook",
+      line,
+      message: `${origin} references "${cand.raw}" which does not exist on disk${where} \u2014 the gate silently no-ops`,
+      suggestion: source.isUserGlobal ? `Restore the script at ${cand.resolved}, or remove the dead entry from ${source.displayPath}.` : `Restore the script, fix the path, or remove the dead entry. A PreToolUse hook pointing at a missing script does not block anything.`
+    });
+  };
+  const hooks = data.hooks ?? {};
+  for (const [event, matchers] of Object.entries(hooks)) {
+    if (!Array.isArray(matchers)) continue;
+    matchers.forEach((matcher, mi2) => {
+      const subHooks = matcher?.hooks;
+      if (!Array.isArray(subHooks)) return;
+      subHooks.forEach((h2, hi2) => {
+        if (!h2 || typeof h2.command !== "string") return;
+        const line = lineForPath(source, ["hooks", event, mi2, "hooks", hi2, "command"]);
+        for (const cand of extractCommandPaths(h2.command, projectRoot, homeDir)) {
+          report(cand, line, `${event} hook`);
+        }
+      });
+    });
+  }
+  const perms = data.permissions ?? {};
+  for (const listName of ["allow", "deny", "ask"]) {
+    const list = perms[listName];
+    if (!Array.isArray(list)) continue;
+    list.forEach((entry, i2) => {
+      if (typeof entry !== "string") return;
+      const line = lineForPath(source, ["permissions", listName, i2]);
+      for (const cand of extractPermissionPaths(entry, projectRoot, homeDir)) {
+        report(cand, line, `permissions.${listName} entry`);
+      }
+    });
+  }
+  return issues;
+}
+async function checkHookCoverage(projectRoot, homeDir = os2.homedir(), options = {}) {
+  const sources = loadSettingsSources2(projectRoot, homeDir, options.userGlobal ?? false);
+  const issues = [];
+  for (const source of sources) {
+    issues.push(...checkSource(source, projectRoot, homeDir));
+  }
+  return issues;
+}
+var SCRIPT_EXT, PATH_PREFIX;
+var init_hook_coverage = __esm({
+  "src/core/checks/hook-coverage.ts"() {
+    "use strict";
+    init_define_WEB_FIRST_SEGMENTS();
+    init_main();
+    init_fs();
+    init_positions();
+    SCRIPT_EXT = /\.(sh|bash|zsh|fish|js|mjs|cjs|ts|py|rb|pl|ps1|cmd|bat|exe)$/i;
+    PATH_PREFIX = /^(~|\.\.?[/\\]|[/\\]|\$\{?[A-Za-z_]|[A-Za-z]:[/\\])/;
+  }
+});
+
+// src/core/skill-scanner.ts
+import * as fs8 from "node:fs";
+import * as os3 from "node:os";
+import * as path12 from "node:path";
+function defaultHome() {
+  return process.env.HOME || process.env.USERPROFILE || os3.homedir();
+}
+function scanSkillFiles(homeDir = defaultHome()) {
+  const files = [];
+  const orphanedSkillDirs = [];
+  const claudeDir = path12.join(homeDir, ".claude");
+  const skillsRoot = path12.join(claudeDir, "skills");
+  for (const name of safeReadDir(skillsRoot, "dir")) {
+    const skillMd = path12.join(skillsRoot, name, "SKILL.md");
+    const content = safeRead(skillMd);
+    if (content === null) {
+      orphanedSkillDirs.push({ name, displayPath: `~/.claude/skills/${name}/` });
+      continue;
+    }
+    files.push({
+      filePath: skillMd,
+      displayPath: `~/.claude/skills/${name}/SKILL.md`,
+      kind: "skill",
+      name,
+      content
+    });
+  }
+  const agentsRoot = path12.join(claudeDir, "agents");
+  for (const fileName of safeReadDir(agentsRoot, "file")) {
+    if (!fileName.endsWith(".md")) continue;
+    const agentMd = path12.join(agentsRoot, fileName);
+    const content = safeRead(agentMd);
+    if (content === null) continue;
+    files.push({
+      filePath: agentMd,
+      displayPath: `~/.claude/agents/${fileName}`,
+      kind: "agent",
+      name: fileName.replace(/\.md$/, ""),
+      content
+    });
+  }
+  return { files, orphanedSkillDirs };
+}
+function safeReadDir(dir, want) {
+  let entries;
+  try {
+    entries = fs8.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((e) => want === "dir" ? e.isDirectory() : e.isFile()).map((e) => e.name).sort();
+}
+function safeRead(file2) {
+  try {
+    return stripBom(fs8.readFileSync(file2, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var init_skill_scanner = __esm({
+  "src/core/skill-scanner.ts"() {
+    "use strict";
+    init_define_WEB_FIRST_SEGMENTS();
+    init_fs();
+  }
+});
+
+// src/core/checks/skills.ts
+import * as path13 from "node:path";
+function parseFrontmatter3(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") {
+    return { found: false, unclosed: false, fields: {}, endLine: 0 };
+  }
+  const fields = {};
+  let arrayKey = "";
+  let endLine = 0;
+  for (let i2 = 1; i2 < lines.length; i2++) {
+    const line = lines[i2].trim();
+    if (line === "---") {
+      endLine = i2 + 1;
+      break;
+    }
+    if (line.startsWith("- ") && arrayKey) {
+      const item = line.slice(2).trim().replace(/^["']|["']$/g, "");
+      fields[arrayKey] = fields[arrayKey] ? `${fields[arrayKey]}, ${item}` : item;
+      continue;
+    }
+    arrayKey = "";
+    const m = line.match(/^([\w-]+)\s*:\s*(.*)$/);
+    if (m) {
+      let val = m[2].trim();
+      const inline = val.match(/^\[(.*)\]$/);
+      if (inline) {
+        val = inline[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean).join(", ");
+      }
+      fields[m[1]] = val;
+      if (!m[2].trim()) arrayKey = m[1];
+    }
+  }
+  if (endLine === 0) return { found: true, unclosed: true, fields, endLine: lines.length };
+  return { found: true, unclosed: false, fields, endLine };
+}
+function checkMissingFrontmatter(file2, fm) {
+  if (fm.unclosed) {
+    return [
+      {
+        severity: "error",
+        check: "skill-frontmatter",
+        ruleId: "skill/missing-frontmatter",
+        line: 1,
+        message: `${file2.displayPath}: frontmatter opens with \`---\` but is never closed`,
+        suggestion: "Add a matching `---` line after the last frontmatter field."
+      }
+    ];
+  }
+  if (!fm.found) {
+    return [
+      {
+        severity: "error",
+        check: "skill-frontmatter",
+        ruleId: "skill/missing-frontmatter",
+        line: 1,
+        message: `${file2.displayPath}: missing YAML frontmatter`,
+        suggestion: `Add frontmatter with ${REQUIRED_FIELDS[file2.kind].join(" + ")}.`
+      }
+    ];
+  }
+  const issues = [];
+  for (const field of REQUIRED_FIELDS[file2.kind]) {
+    if (!fm.fields[field]) {
+      issues.push({
+        severity: "warning",
+        check: "skill-frontmatter",
+        ruleId: "skill/missing-frontmatter",
+        line: 1,
+        message: `${file2.displayPath}: missing required frontmatter field "${field}"`,
+        suggestion: field === "description" ? "A skill/agent with no description is never selected \u2014 add one describing when to use it." : `Add a "${field}" field to the frontmatter.`
+      });
+    }
+  }
+  return issues;
+}
+function checkBrokenRefs(file2, fmEndLine) {
+  const issues = [];
+  const skillDir = path13.dirname(file2.filePath);
+  const lines = file2.content.split("\n");
+  let inCode = false;
+  let codeLang = "";
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    if (i2 + 1 <= fmEndLine) continue;
+    const raw = lines[i2];
+    if (raw.trimStart().startsWith("```")) {
+      inCode = !inCode;
+      codeLang = inCode ? raw.trimStart().slice(3).trim().toLowerCase() : "";
+      continue;
+    }
+    if (inCode && isExampleLang(codeLang)) continue;
+    BODY_PATH.lastIndex = 0;
+    let m;
+    while ((m = BODY_PATH.exec(raw)) !== null) {
+      let value = m[1];
+      if (PATH_SKIP.test(value)) continue;
+      if (!value.startsWith("./") && !value.startsWith("../")) continue;
+      while (/[.,;:]$/.test(value)) value = value.slice(0, -1);
+      const resolved = path13.resolve(skillDir, value);
+      if (fileExists(resolved) || isDirectory(resolved)) continue;
+      issues.push({
+        severity: "warning",
+        check: "skill-broken-ref",
+        ruleId: "skill/broken-ref",
+        line: i2 + 1,
+        message: `${file2.displayPath}: references "${value}" which does not exist relative to the skill directory`,
+        suggestion: "Fix the path, or use a path that exists relative to the skill/agent file."
+      });
+    }
+  }
+  return issues;
+}
+function isExampleLang(lang) {
+  return [
+    "js",
+    "javascript",
+    "ts",
+    "typescript",
+    "tsx",
+    "jsx",
+    "py",
+    "python",
+    "go",
+    "rust",
+    "java",
+    "c",
+    "cpp",
+    "ruby",
+    "php",
+    "json",
+    "yaml",
+    "yml",
+    "toml",
+    // Shell fences hold command/example snippets, not in-repo refs. A `./foo.sh`
+    // inside a bash block is an invocation example (often a cross-repo script or
+    // a placeholder), not a path that should resolve relative to the skill dir.
+    // Matches the rule's "prefer a false negative over a false positive" posture.
+    "bash",
+    "sh",
+    "shell",
+    "shellscript",
+    "zsh",
+    "console"
+  ].includes(lang);
+}
+function extractTriggers(fm) {
+  const phrases = /* @__PURE__ */ new Set();
+  const desc = fm.fields["description"] ?? "";
+  for (const q3 of desc.matchAll(/["']([^"']{3,})["']/g)) {
+    phrases.add(normalizeTrigger(q3[1]));
+  }
+  for (const key of ["trigger", "triggers"]) {
+    const val = fm.fields[key];
+    if (val) for (const part of val.split(",")) phrases.add(normalizeTrigger(part));
+  }
+  phrases.delete("");
+  return [...phrases];
+}
+function normalizeTrigger(s) {
+  return s.toLowerCase().trim().replace(/\s+/g, " ");
+}
+function checkTriggerCollisions(parsed) {
+  const byTrigger = /* @__PURE__ */ new Map();
+  for (const { file: file2, fm } of parsed) {
+    for (const t2 of extractTriggers(fm)) {
+      const list = byTrigger.get(t2) ?? [];
+      list.push(file2);
+      byTrigger.set(t2, list);
+    }
+  }
+  const issues = [];
+  for (const [trigger, owners] of byTrigger) {
+    const distinct = [...new Set(owners.map((o2) => o2.displayPath))];
+    if (distinct.length > 1) {
+      issues.push({
+        severity: "warning",
+        check: "skill-trigger-collision",
+        ruleId: "skill/trigger-collision",
+        line: 1,
+        message: `Trigger phrase "${trigger}" is declared by ${distinct.length} skills/agents \u2014 only one will win`,
+        detail: distinct.map((d) => `  - ${d}`).join("\n"),
+        suggestion: "Make trigger phrases unique so invocation is deterministic."
+      });
+    }
+  }
+  return issues;
+}
+function checkOrphaned(ctx) {
+  return ctx.orphanedSkillDirs.map((o2) => ({
+    severity: "warning",
+    check: "skill-orphaned",
+    ruleId: "skill/orphaned",
+    line: 1,
+    message: `${o2.displayPath}: skill directory has no SKILL.md \u2014 Claude Code has nothing to load`,
+    suggestion: `Add a SKILL.md, or remove the empty ${o2.displayPath} directory.`
+  }));
+}
+function checkDeadToolRestrictions(file2, fm) {
+  if (file2.kind !== "agent") return [];
+  const raw = fm.fields["tools"] ?? fm.fields["allowed-tools"] ?? fm.fields["allowedTools"];
+  if (!raw) return [];
+  const issues = [];
+  for (const entry of raw.split(",").map((s) => s.trim()).filter(Boolean)) {
+    if (entry.startsWith("mcp__") || entry.includes("*")) continue;
+    const base = entry.replace(/\(.*\)$/, "").trim();
+    if (KNOWN_TOOLS.has(base)) continue;
+    issues.push({
+      severity: "warning",
+      check: "skill-dead-tool-restriction",
+      ruleId: "skill/dead-tool-restriction",
+      line: 1,
+      message: `${file2.displayPath}: tool restriction lists "${entry}" which is not a known Claude Code tool`,
+      suggestion: `Known built-in tools: ${[...KNOWN_TOOLS].join(", ")}. MCP tools use the mcp__server__tool form.`
+    });
+  }
+  return issues;
+}
+function checkSkills(ctx, sel) {
+  const issues = [];
+  const parsed = ctx.files.map((file2) => ({ file: file2, fm: parseFrontmatter3(file2.content) }));
+  for (const { file: file2, fm } of parsed) {
+    if (sel.frontmatter) issues.push(...checkMissingFrontmatter(file2, fm));
+    if (sel.brokenRef) issues.push(...checkBrokenRefs(file2, fm.found ? fm.endLine : 0));
+    if (sel.deadToolRestriction) issues.push(...checkDeadToolRestrictions(file2, fm));
+  }
+  if (sel.triggerCollision) issues.push(...checkTriggerCollisions(parsed));
+  if (sel.orphaned) issues.push(...checkOrphaned(ctx));
+  return issues;
+}
+var REQUIRED_FIELDS, BODY_PATH, PATH_SKIP, KNOWN_TOOLS;
+var init_skills = __esm({
+  "src/core/checks/skills.ts"() {
+    "use strict";
+    init_define_WEB_FIRST_SEGMENTS();
+    init_fs();
+    REQUIRED_FIELDS = {
+      skill: ["name", "description"],
+      agent: ["name", "description"]
+    };
+    BODY_PATH = /(?:^|[\s`"'(])((?:\.{1,2}\/)[\w@./-]+|(?:[\w@-]+\/)+[\w.-]+)(?=[\s`"'),;:]|$)/gm;
+    PATH_SKIP = /^(https?:\/\/|mailto:|n\/a|e\.g\.|i\.e\.)/i;
+    KNOWN_TOOLS = /* @__PURE__ */ new Set([
+      "Agent",
+      "Bash",
+      "BashOutput",
+      "Edit",
+      "ExitPlanMode",
+      "Glob",
+      "Grep",
+      "KillShell",
+      "MultiEdit",
+      "NotebookEdit",
+      "Read",
+      "Skill",
+      "SlashCommand",
+      "Task",
+      "TodoWrite",
+      "WebFetch",
+      "WebSearch",
+      "Write"
+    ]);
+  }
+});
+
 // src/core/ignore-rules.ts
 function compileRules(rules) {
   return rules.map((r2) => ({
@@ -46044,25 +46570,26 @@ var init_ignore_rules = __esm({
 });
 
 // src/core/types.ts
-var SESSION_AUDIT_LABEL, SESSION_AUDIT_PATH_MARKER;
+var SESSION_AUDIT_LABEL, SESSION_AUDIT_PATH_MARKER, SKILL_AUDIT_LABEL;
 var init_types3 = __esm({
   "src/core/types.ts"() {
     "use strict";
     init_define_WEB_FIRST_SEGMENTS();
     SESSION_AUDIT_LABEL = "~/.claude/ (session audit)";
     SESSION_AUDIT_PATH_MARKER = "(session audit)";
+    SKILL_AUDIT_LABEL = "~/.claude/ (skill audit)";
   }
 });
 
 // src/version.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import { resolve as resolve9, dirname as dirname4 } from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { resolve as resolve11, dirname as dirname5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function loadVersion() {
-  if (true) return "0.12.2";
-  const __dir = dirname4(fileURLToPath2(import.meta.url));
-  const pkgPath = resolve9(__dir, "../package.json");
-  const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+  if (true) return "0.13.0";
+  const __dir = dirname5(fileURLToPath2(import.meta.url));
+  const pkgPath = resolve11(__dir, "../package.json");
+  const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
   return pkg.version;
 }
 var VERSION;
@@ -46084,6 +46611,9 @@ function hasMcphChecks(checks) {
 function hasSessionChecks(checks) {
   return checks.some((c3) => c3.startsWith("session-"));
 }
+function hasSkillChecks(checks) {
+  return checks.some((c3) => c3.startsWith("skill-"));
+}
 function deriveChecksToRun(activeChecks, prefix, enabled, allChecks) {
   const filtered = activeChecks.filter((c3) => c3.startsWith(prefix));
   if (filtered.length > 0) return filtered;
@@ -46092,10 +46622,11 @@ function deriveChecksToRun(activeChecks, prefix, enabled, allChecks) {
 async function runAudit(projectRoot, activeChecks, options = {}) {
   const fileResults = [];
   const thresholds = resolveTokenThresholds(options.tokenThresholds);
-  const shouldRunContextChecks = !options.mcpOnly && !options.mcphOnly && !options.sessionOnly;
+  const shouldRunContextChecks = !options.mcpOnly && !options.mcphOnly && !options.sessionOnly && !options.skillsOnly;
   const shouldRunMcpChecks = options.mcp || options.mcpGlobal || options.mcpOnly || hasMcpChecks(activeChecks);
   const shouldRunMcphChecks = options.mcph || options.mcphGlobal || options.mcphOnly || hasMcphChecks(activeChecks);
   const shouldRunSessionChecks = options.session || options.sessionOnly || hasSessionChecks(activeChecks);
+  const shouldRunSkillChecks = options.skills || options.skillsOnly || hasSkillChecks(activeChecks);
   if (shouldRunContextChecks) {
     const discovered = await scanForContextFiles(projectRoot, {
       depth: options.depth,
@@ -46152,6 +46683,13 @@ async function runAudit(projectRoot, activeChecks, options = {}) {
     if (activeChecks.includes("ci-secrets")) {
       crossFileIssues.push(...await checkCiSecrets(parsed, projectRoot));
     }
+    if (activeChecks.includes("hook-coverage")) {
+      crossFileIssues.push(
+        ...await checkHookCoverage(projectRoot, void 0, {
+          userGlobal: options.hooksGlobal
+        })
+      );
+    }
     if (crossFileIssues.length > 0) {
       fileResults.push({
         path: "(project)",
@@ -46322,6 +46860,31 @@ async function runAudit(projectRoot, activeChecks, options = {}) {
       });
     }
   }
+  if (shouldRunSkillChecks) {
+    const skillChecksToRun = deriveChecksToRun(
+      activeChecks,
+      "skill-",
+      Boolean(options.skills || options.skillsOnly),
+      ALL_SKILL_CHECKS
+    );
+    if (skillChecksToRun.length > 0) {
+      const skillCtx = scanSkillFiles();
+      const skillIssues = checkSkills(skillCtx, {
+        frontmatter: skillChecksToRun.includes("skill-frontmatter"),
+        brokenRef: skillChecksToRun.includes("skill-broken-ref"),
+        triggerCollision: skillChecksToRun.includes("skill-trigger-collision"),
+        orphaned: skillChecksToRun.includes("skill-orphaned"),
+        deadToolRestriction: skillChecksToRun.includes("skill-dead-tool-restriction")
+      });
+      fileResults.push({
+        path: SKILL_AUDIT_LABEL,
+        isSymlink: false,
+        tokens: 0,
+        lines: 0,
+        issues: skillIssues
+      });
+    }
+  }
   let ignoreReport;
   if (options.ignoreRules && options.ignoreRules.length > 0) {
     const flat = [];
@@ -46383,7 +46946,7 @@ async function runAudit(projectRoot, activeChecks, options = {}) {
   }
   return result;
 }
-var ALL_CHECKS, ALL_MCP_CHECKS, ALL_MCPH_CHECKS, ALL_SESSION_CHECKS;
+var ALL_CHECKS, ALL_MCP_CHECKS, ALL_MCPH_CHECKS, ALL_SESSION_CHECKS, ALL_SKILL_CHECKS;
 var init_audit = __esm({
   "src/core/audit.ts"() {
     "use strict";
@@ -46425,6 +46988,9 @@ var init_audit = __esm({
     init_ci_coverage();
     init_ci_secrets();
     init_content_secrets();
+    init_hook_coverage();
+    init_skill_scanner();
+    init_skills();
     init_ignore_rules();
     init_types3();
     init_version2();
@@ -46439,7 +47005,8 @@ var init_audit = __esm({
       "frontmatter",
       "ci-coverage",
       "ci-secrets",
-      "content-secrets"
+      "content-secrets",
+      "hook-coverage"
     ];
     ALL_MCP_CHECKS = [
       "mcp-schema",
@@ -46467,6 +47034,13 @@ var init_audit = __esm({
       "session-loop-detection",
       "session-memory-index-overflow"
     ];
+    ALL_SKILL_CHECKS = [
+      "skill-frontmatter",
+      "skill-broken-ref",
+      "skill-trigger-collision",
+      "skill-orphaned",
+      "skill-dead-tool-restriction"
+    ];
   }
 });
 
@@ -46664,7 +47238,7 @@ var init_ansi_styles = __esm({
 
 // node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
 import process4 from "node:process";
-import os2 from "node:os";
+import os4 from "node:os";
 import tty from "node:tty";
 function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process4.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
@@ -46722,7 +47296,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if (process4.platform === "win32") {
-    const osRelease = os2.release().split(".");
+    const osRelease = os4.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
@@ -47013,7 +47587,7 @@ var init_source = __esm({
 });
 
 // src/core/fixer.ts
-import * as fs7 from "node:fs";
+import * as fs9 from "node:fs";
 function applyFixes(result, options = {}) {
   const log = options.quiet ? () => {
   } : console.log.bind(console);
@@ -47055,7 +47629,7 @@ function applyFixes(result, options = {}) {
   let totalFixes = 0;
   const filesModified = [];
   for (const [filePath, fixes] of fixesByFile) {
-    const content = fs7.readFileSync(filePath, "utf-8");
+    const content = fs9.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
     let modified = false;
     const fixesByLine = /* @__PURE__ */ new Map();
@@ -47097,7 +47671,7 @@ function applyFixes(result, options = {}) {
         }
       }
       if (!dryRun) {
-        fs7.writeFileSync(filePath, newContent, "utf-8");
+        fs9.writeFileSync(filePath, newContent, "utf-8");
       }
       filesModified.push(filePath);
       totalFixes += perFileFixCount;
@@ -47115,8 +47689,8 @@ var init_fixer = __esm({
 });
 
 // src/core/config.ts
-import * as fs8 from "node:fs";
-import * as path11 from "node:path";
+import * as fs10 from "node:fs";
+import * as path14 from "node:path";
 function formatJsonError(content, err) {
   const msg = err instanceof Error ? err.message : String(err);
   const posMatch = msg.match(/position (\d+)/);
@@ -47214,10 +47788,10 @@ function warnIgnoreRulePathPatternMisuse(config2, source) {
 }
 function loadConfig(projectRoot) {
   for (const filename of CONFIG_FILENAMES) {
-    const filePath = path11.join(projectRoot, filename);
+    const filePath = path14.join(projectRoot, filename);
     let content;
     try {
-      content = stripBom(fs8.readFileSync(filePath, "utf-8"));
+      content = stripBom(fs10.readFileSync(filePath, "utf-8"));
     } catch {
       continue;
     }
@@ -47228,7 +47802,7 @@ function loadConfig(projectRoot) {
 function loadConfigFromExplicitPath(configPath) {
   let content;
   try {
-    content = stripBom(fs8.readFileSync(configPath, "utf-8"));
+    content = stripBom(fs10.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 });
@@ -47259,7 +47833,10 @@ var init_config2 = __esm({
       "mcphGlobal",
       "mcphStrictEnvToken",
       "session",
-      "sessionOnly"
+      "sessionOnly",
+      "skills",
+      "skillsOnly",
+      "hooksGlobal"
     ];
     CONFIG_FILENAMES = [".ctxlintrc", ".ctxlintrc.json"];
   }
@@ -47271,7 +47848,7 @@ __export(server_exports, {
   server: () => server,
   startServer: () => startServer
 });
-import * as path12 from "node:path";
+import * as path15 from "node:path";
 function describeDisallowed(rawPath) {
   const m = rawPath.match(PATH_DISALLOWED);
   if (!m) return "unknown";
@@ -47284,7 +47861,7 @@ function validateProjectPath(rawPath) {
       `projectPath contains disallowed character ${describeDisallowed(rawPath)} (control chars and shell metacharacters are rejected)`
     );
   }
-  const resolved = path12.resolve(rawPath);
+  const resolved = path15.resolve(rawPath);
   if (!isDirectory(resolved)) {
     throw new Error("projectPath is not an existing directory");
   }
@@ -47305,10 +47882,10 @@ function validateFilePathInput(rawPath) {
   }
 }
 function resolveWithinRoot(filePath, root) {
-  const resolvedRoot = path12.resolve(root);
-  const resolved = path12.resolve(resolvedRoot, filePath);
-  const rel = path12.relative(resolvedRoot, resolved);
-  if (rel.startsWith("..") || path12.isAbsolute(rel)) {
+  const resolvedRoot = path15.resolve(root);
+  const resolved = path15.resolve(resolvedRoot, filePath);
+  const rel = path15.relative(resolvedRoot, resolved);
+  if (rel.startsWith("..") || path15.isAbsolute(rel)) {
     throw new Error("path escapes the project root");
   }
   return resolved;
@@ -48823,8 +49400,8 @@ var require_command = __commonJS({
     init_define_WEB_FIRST_SEGMENTS();
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
-    var path14 = __require("node:path");
-    var fs10 = __require("node:fs");
+    var path17 = __require("node:path");
+    var fs12 = __require("node:fs");
     var process11 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -49818,7 +50395,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs10.existsSync(executableFile)) return;
+        if (fs12.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
@@ -49836,11 +50413,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path14.resolve(baseDir, baseName);
-          if (fs10.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path14.extname(baseName))) return void 0;
+          const localBin = path17.resolve(baseDir, baseName);
+          if (fs12.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path17.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs10.existsSync(`${localBin}${ext}`)
+            (ext) => fs12.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -49852,21 +50429,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs10.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs12.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path14.resolve(
-            path14.dirname(resolvedScriptPath),
+          executableDir = path17.resolve(
+            path17.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path14.basename(
+            const legacyName = path17.basename(
               this._scriptPath,
-              path14.extname(this._scriptPath)
+              path17.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -49877,7 +50454,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path14.extname(executableFile));
+        launchWithNode = sourceExt.includes(path17.extname(executableFile));
         let proc;
         if (process11.platform !== "win32") {
           if (launchWithNode) {
@@ -50792,7 +51369,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path14.basename(filename, path14.extname(filename));
+        this._name = path17.basename(filename, path17.extname(filename));
         return this;
       }
       /**
@@ -50806,9 +51383,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path15) {
-        if (path15 === void 0) return this._executableDir;
-        this._executableDir = path15;
+      executableDir(path18) {
+        if (path18 === void 0) return this._executableDir;
+        this._executableDir = path18;
         return this;
       }
       /**
@@ -54161,8 +54738,10 @@ function classifyFile(f) {
   if (f.path === "(project)") return "context";
   if (f.path === "(mcp)") return "mcp";
   if (f.path.includes(SESSION_AUDIT_PATH_MARKER)) return "session";
+  if (f.path.includes(SKILL_AUDIT_PATH_MARKER)) return "skill";
   for (const issue2 of f.issues) {
     if (issue2.check.startsWith("session-")) return "session";
+    if (issue2.check.startsWith("skill-")) return "skill";
     if (issue2.check.startsWith("mcph-")) return "mcph";
     if (issue2.check.startsWith("mcp-")) return "mcp";
   }
@@ -54174,7 +54753,7 @@ function classifyFile(f) {
   return "context";
 }
 function isSyntheticBucket(p2) {
-  return p2.startsWith("(") || p2.includes(SESSION_AUDIT_PATH_MARKER);
+  return p2.startsWith("(") || p2.includes(SESSION_AUDIT_PATH_MARKER) || p2.includes(SKILL_AUDIT_PATH_MARKER);
 }
 function formatText(result, verbose = false) {
   const lines = [];
@@ -54187,7 +54766,8 @@ function formatText(result, verbose = false) {
     context: [],
     mcp: [],
     mcph: [],
-    session: []
+    session: [],
+    skill: []
   };
   for (const f of result.files) {
     groups[classifyFile(f)].push(f);
@@ -54464,6 +55044,11 @@ function buildRuleDescriptors() {
       shortDescription: { text: "Inline-pasted secret detected in a context file" },
       helpUri: "https://github.com/yawlabs/ctxlint#what-it-checks"
     },
+    {
+      id: "ctxlint/hook-coverage",
+      shortDescription: { text: "Hook/permission entry references a script that no longer exists" },
+      helpUri: "https://github.com/yawlabs/ctxlint#what-it-checks"
+    },
     {
       id: "ctxlint/mcp-schema",
       shortDescription: { text: "MCP config structural validation error" },
@@ -54565,6 +55150,31 @@ function buildRuleDescriptors() {
         text: "MEMORY.md exceeds Claude Code's 200-line / 25KB session-load cap"
       },
       helpUri: "https://github.com/yawlabs/ctxlint#what-it-checks"
+    },
+    {
+      id: "ctxlint/skill-frontmatter",
+      shortDescription: { text: "Skill/agent definition missing required frontmatter" },
+      helpUri: "https://github.com/yawlabs/ctxlint#what-it-checks"
+    },
+    {
+      id: "ctxlint/skill-broken-ref",
+      shortDescription: { text: "Skill/agent body references a path that does not exist" },
+      helpUri: "https://github.com/yawlabs/ctxlint#what-it-checks"
+    },
+    {
+      id: "ctxlint/skill-trigger-collision",
+      shortDescription: { text: "Two skills/agents declare the same trigger phrase" },
+      helpUri: "https://github.com/yawlabs/ctxlint#what-it-checks"
+    },
+    {
+      id: "ctxlint/skill-orphaned",
+      shortDescription: { text: "Skill directory has no SKILL.md" },
+      helpUri: "https://github.com/yawlabs/ctxlint#what-it-checks"
+    },
+    {
+      id: "ctxlint/skill-dead-tool-restriction",
+      shortDescription: { text: "Agent tool restriction names an unknown Claude Code tool" },
+      helpUri: "https://github.com/yawlabs/ctxlint#what-it-checks"
     }
   ];
 }
@@ -54582,25 +55192,28 @@ function formatIssue(issue2) {
   }
   return line;
 }
-var GROUP_ORDER, GROUP_LABELS, GROUP_SUMMARY_NOUNS;
+var SKILL_AUDIT_PATH_MARKER, GROUP_ORDER, GROUP_LABELS, GROUP_SUMMARY_NOUNS;
 var init_reporter = __esm({
   "src/core/reporter.ts"() {
     "use strict";
     init_define_WEB_FIRST_SEGMENTS();
     init_source();
     init_types3();
-    GROUP_ORDER = ["context", "mcp", "mcph", "session"];
+    SKILL_AUDIT_PATH_MARKER = "(skill audit)";
+    GROUP_ORDER = ["context", "mcp", "mcph", "session", "skill"];
     GROUP_LABELS = {
       context: "Context Files",
       mcp: "MCP Configs",
       mcph: "mcph Configs",
-      session: "Session Audit"
+      session: "Session Audit",
+      skill: "Skill Audit"
     };
     GROUP_SUMMARY_NOUNS = {
       context: "context file",
       mcp: "MCP config",
       mcph: "mcph config",
-      session: "session audit"
+      session: "session audit",
+      skill: "skill audit"
     };
   }
 });
@@ -54610,8 +55223,8 @@ var cli_exports = {};
 __export(cli_exports, {
   runCli: () => runCli
 });
-import * as fs9 from "node:fs";
-import * as path13 from "node:path";
+import * as fs11 from "node:fs";
+import * as path16 from "node:path";
 function validateCheckNames(names, source) {
   const invalid = names.filter((n7) => n7 && !VALID_CHECKS.has(n7));
   if (invalid.length > 0) {
@@ -54633,8 +55246,12 @@ async function runCli() {
     "--mcph-strict-env-token",
     "Upgrade mcph-config/prefer-env-token from warning to error (strict env-var-only posture)",
     false
-  ).option("--session", "Run session audit checks (cross-project consistency)", false).option("--session-only", "Run only session checks, skip context and MCP checks", false).option("--watch", "Re-lint on context file changes", false).action(async (projectPath, opts) => {
-    const resolvedPath = path13.resolve(projectPath);
+  ).option("--session", "Run session audit checks (cross-project consistency)", false).option("--session-only", "Run only session checks, skip context and MCP checks", false).option("--skills", "Run agent-skill checks (~/.claude/skills + ~/.claude/agents)", false).option("--skills-only", "Run only agent-skill checks, skip everything else", false).option(
+    "--hooks-global",
+    "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("--watch", "Re-lint on context file changes", false).action(async (projectPath, opts) => {
+    const resolvedPath = path16.resolve(projectPath);
     const { config: config2, options, activeChecks } = resolveSession(resolvedPath, opts);
     const spinner = options.format === "text" && !options.quiet ? ora("Scanning for context files...").start() : void 0;
     try {
@@ -54651,6 +55268,9 @@ async function runCli() {
         mcphStrictEnvToken: options.mcphStrictEnvToken,
         session: options.session,
         sessionOnly: options.sessionOnly,
+        skills: options.skills,
+        skillsOnly: options.skillsOnly,
+        hooksGlobal: options.hooksGlobal,
         tokenThresholds: config2?.tokenThresholds,
         ignoreRules: config2?.ignoreRules
       });
@@ -54750,43 +55370,43 @@ 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 = [
-        path13.join(resolvedPath, "CLAUDE.md"),
-        path13.join(resolvedPath, "CLAUDE.local.md"),
-        path13.join(resolvedPath, "AGENTS.md"),
-        path13.join(resolvedPath, "AGENT.md"),
-        path13.join(resolvedPath, ".cursorrules"),
-        path13.join(resolvedPath, ".windsurfrules"),
-        path13.join(resolvedPath, ".clinerules"),
-        path13.join(resolvedPath, ".aiderules"),
-        path13.join(resolvedPath, ".continuerules"),
-        path13.join(resolvedPath, ".rules"),
-        path13.join(resolvedPath, ".goosehints"),
-        path13.join(resolvedPath, "GEMINI.md"),
-        path13.join(resolvedPath, "replit.md"),
-        path13.join(resolvedPath, "package.json"),
-        path13.join(resolvedPath, ".mcp.json"),
+        path16.join(resolvedPath, "CLAUDE.md"),
+        path16.join(resolvedPath, "CLAUDE.local.md"),
+        path16.join(resolvedPath, "AGENTS.md"),
+        path16.join(resolvedPath, "AGENT.md"),
+        path16.join(resolvedPath, ".cursorrules"),
+        path16.join(resolvedPath, ".windsurfrules"),
+        path16.join(resolvedPath, ".clinerules"),
+        path16.join(resolvedPath, ".aiderules"),
+        path16.join(resolvedPath, ".continuerules"),
+        path16.join(resolvedPath, ".rules"),
+        path16.join(resolvedPath, ".goosehints"),
+        path16.join(resolvedPath, "GEMINI.md"),
+        path16.join(resolvedPath, "replit.md"),
+        path16.join(resolvedPath, "package.json"),
+        path16.join(resolvedPath, ".mcp.json"),
         // mcph configs — without these, edits to the .mcph.json the user is
         // actively iterating on don't trigger a re-lint.
-        path13.join(resolvedPath, ".mcph.json"),
-        path13.join(resolvedPath, ".mcph.local.json"),
+        path16.join(resolvedPath, ".mcph.json"),
+        path16.join(resolvedPath, ".mcph.local.json"),
         // ctxlint config — re-resolve on edit so threshold changes,
         // ignore-list edits, and check-list overrides take effect without
         // restarting the watcher.
-        path13.join(resolvedPath, ".ctxlintrc"),
-        path13.join(resolvedPath, ".ctxlintrc.json")
+        path16.join(resolvedPath, ".ctxlintrc"),
+        path16.join(resolvedPath, ".ctxlintrc.json")
       ];
       const watchDirs = [
-        path13.join(resolvedPath, ".claude"),
-        path13.join(resolvedPath, ".cursor"),
-        path13.join(resolvedPath, ".github"),
-        path13.join(resolvedPath, ".windsurf"),
-        path13.join(resolvedPath, ".aide"),
-        path13.join(resolvedPath, ".amazonq"),
-        path13.join(resolvedPath, ".goose"),
-        path13.join(resolvedPath, ".junie"),
-        path13.join(resolvedPath, ".aiassistant"),
-        path13.join(resolvedPath, ".continue"),
-        path13.join(resolvedPath, ".vscode")
+        path16.join(resolvedPath, ".claude"),
+        path16.join(resolvedPath, ".cursor"),
+        path16.join(resolvedPath, ".github"),
+        path16.join(resolvedPath, ".windsurf"),
+        path16.join(resolvedPath, ".aide"),
+        path16.join(resolvedPath, ".amazonq"),
+        path16.join(resolvedPath, ".goose"),
+        path16.join(resolvedPath, ".junie"),
+        path16.join(resolvedPath, ".aiassistant"),
+        path16.join(resolvedPath, ".continue"),
+        path16.join(resolvedPath, ".vscode")
       ];
       const watchers = [];
       let debounceTimer = null;
@@ -54818,6 +55438,9 @@ Fixed ${applied.totalFixes} issue${applied.totalFixes !== 1 ? "s" : ""} in ${app
               mcphStrictEnvToken: liveOptions.mcphStrictEnvToken,
               session: liveOptions.session,
               sessionOnly: liveOptions.sessionOnly,
+              skills: liveOptions.skills,
+              skillsOnly: liveOptions.skillsOnly,
+              hooksGlobal: liveOptions.hooksGlobal,
               tokenThresholds: liveConfig?.tokenThresholds,
               ignoreRules: liveConfig?.ignoreRules
             });
@@ -54845,13 +55468,13 @@ Fixed ${applied.totalFixes} issue${applied.totalFixes !== 1 ? "s" : ""} in ${app
       };
       for (const filePath of watchPaths) {
         try {
-          watchers.push(fs9.watch(filePath, rerun));
+          watchers.push(fs11.watch(filePath, rerun));
         } catch {
         }
       }
       for (const dir of watchDirs) {
         try {
-          watchers.push(fs9.watch(dir, { recursive: true }, rerun));
+          watchers.push(fs11.watch(dir, { recursive: true }, rerun));
         } catch {
         }
       }
@@ -54872,17 +55495,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 = path13.resolve(projectPath);
-    const gitDir = path13.join(resolvedRoot, ".git");
-    const hooksDir = path13.join(gitDir, "hooks");
-    if (!fs9.existsSync(gitDir)) {
+    const resolvedRoot = path16.resolve(projectPath);
+    const gitDir = path16.join(resolvedRoot, ".git");
+    const hooksDir = path16.join(gitDir, "hooks");
+    if (!fs11.existsSync(gitDir)) {
       console.error('Error: not a git repository. Run "git init" first.');
       process.exit(1);
     }
-    if (!fs9.existsSync(hooksDir)) {
-      fs9.mkdirSync(hooksDir, { recursive: true });
+    if (!fs11.existsSync(hooksDir)) {
+      fs11.mkdirSync(hooksDir, { recursive: true });
     }
-    const hookPath = path13.join(hooksDir, "pre-commit");
+    const hookPath = path16.join(hooksDir, "pre-commit");
     const fullHookContent = `#!/bin/sh
 # ctxlint pre-commit hook
 npx @yawlabs/ctxlint@${VERSION} --strict
@@ -54891,16 +55514,16 @@ npx @yawlabs/ctxlint@${VERSION} --strict
 # ctxlint pre-commit hook
 npx @yawlabs/ctxlint@${VERSION} --strict
 `;
-    if (fs9.existsSync(hookPath)) {
-      const existing = fs9.readFileSync(hookPath, "utf-8");
+    if (fs11.existsSync(hookPath)) {
+      const existing = fs11.readFileSync(hookPath, "utf-8");
       if (existing.includes("ctxlint")) {
         console.log("Pre-commit hook already includes ctxlint.");
         return;
       }
-      fs9.appendFileSync(hookPath, appendHookContent);
+      fs11.appendFileSync(hookPath, appendHookContent);
       console.log("Added ctxlint to existing pre-commit hook.");
     } else {
-      fs9.writeFileSync(hookPath, fullHookContent, { mode: 493 });
+      fs11.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.");
@@ -54918,7 +55541,7 @@ async function promptYesNo(question) {
   }
 }
 function resolveSession(resolvedPath, opts) {
-  const configPath = opts.config ? path13.resolve(opts.config) : void 0;
+  const configPath = opts.config ? path16.resolve(opts.config) : void 0;
   const config2 = configPath ? loadConfigFromPath(configPath) : loadConfig(resolvedPath);
   const mcpGlobal = opts.mcpGlobal || config2?.mcpGlobal || false;
   const mcpOnly = opts.mcpOnly || config2?.mcpOnly || false;
@@ -54929,6 +55552,9 @@ function resolveSession(resolvedPath, opts) {
   const mcphStrictEnvToken = opts.mcphStrictEnvToken || config2?.mcphStrictEnvToken || false;
   const sessionOnly = opts.sessionOnly || config2?.sessionOnly || false;
   const sessionFlag = opts.session || sessionOnly || config2?.session || false;
+  const skillsOnly = opts.skillsOnly || config2?.skillsOnly || false;
+  const skillsFlag = opts.skills || skillsOnly || config2?.skills || false;
+  const hooksGlobal = opts.hooksGlobal || config2?.hooksGlobal || false;
   let explicitChecks = opts.checks ? validateCheckNames(
     opts.checks.split(",").map((c3) => c3.trim()),
     "--checks"
@@ -54937,14 +55563,18 @@ function resolveSession(resolvedPath, opts) {
   const hasMcpInChecks = explicitChecks?.some((c3) => c3.startsWith("mcp-") && !c3.startsWith("mcph-")) || false;
   const hasMcphInChecks = explicitChecks?.some((c3) => c3.startsWith("mcph-")) || false;
   const hasSessionInChecks = explicitChecks?.some((c3) => c3.startsWith("session-")) || false;
+  const hasSkillInChecks = explicitChecks?.some((c3) => c3.startsWith("skill-")) || false;
   const effectiveMcp = mcpFlag || hasMcpInChecks;
   const effectiveMcph = mcphFlag || hasMcphInChecks;
   const effectiveSession = sessionFlag || sessionOnly || hasSessionInChecks;
+  const effectiveSkills = skillsFlag || skillsOnly || hasSkillInChecks;
   let checks;
   if (explicitChecks) {
     checks = explicitChecks;
   } else if (sessionOnly) {
     checks = ALL_SESSION_CHECKS;
+  } else if (skillsOnly) {
+    checks = ALL_SKILL_CHECKS;
   } else if (mcpOnly) {
     checks = ALL_MCP_CHECKS;
   } else if (mcphOnly) {
@@ -54955,7 +55585,8 @@ function resolveSession(resolvedPath, opts) {
       ...base,
       ...effectiveMcp ? ALL_MCP_CHECKS : [],
       ...effectiveMcph ? ALL_MCPH_CHECKS : [],
-      ...effectiveSession ? ALL_SESSION_CHECKS : []
+      ...effectiveSession ? ALL_SESSION_CHECKS : [],
+      ...effectiveSkills ? ALL_SKILL_CHECKS : []
     ];
   }
   const options = {
@@ -54980,7 +55611,10 @@ function resolveSession(resolvedPath, opts) {
     mcphGlobal,
     mcphStrictEnvToken,
     session: effectiveSession,
-    sessionOnly
+    sessionOnly,
+    skills: effectiveSkills,
+    skillsOnly,
+    hooksGlobal
   };
   const activeChecks = options.checks.filter((c3) => !options.ignore.includes(c3));
   return { config: config2, options, activeChecks };
@@ -55014,7 +55648,8 @@ var init_cli = __esm({
       ...ALL_CHECKS,
       ...ALL_MCP_CHECKS,
       ...ALL_MCPH_CHECKS,
-      ...ALL_SESSION_CHECKS
+      ...ALL_SESSION_CHECKS,
+      ...ALL_SKILL_CHECKS
     ]);
   }
 });