@yawlabs/ctxlint 0.13.0 → 0.13.2

package/.pre-commit-hooks.yaml

@@ -4,7 +4,7 @@
   # Version-pinned so a checkout at `rev: vX.Y.Z` runs exactly that release
   # of ctxlint — matches the pinning done by `ctxlint init`. release.sh keeps
   # this in sync with package.json on each bump.
-  entry: npx @yawlabs/ctxlint@0.13.0 --strict
+  entry: npx @yawlabs/ctxlint@0.13.2 --strict
   language: node
   always_run: true
   pass_filenames: false

package/dist/index.js

@@ -22404,7 +22404,7 @@ var init_protocol = __esm({
               return;
             }
             const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-            await new Promise((resolve14) => setTimeout(resolve14, pollInterval));
+            await new Promise((resolve15) => setTimeout(resolve15, 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((resolve14, reject) => {
+        return new Promise((resolve15, reject) => {
           const earlyReject = (error49) => {
             reject(error49);
           };
@@ -22499,7 +22499,7 @@ var init_protocol = __esm({
               if (!parseResult.success) {
                 reject(parseResult.error);
               } else {
-                resolve14(parseResult.data);
+                resolve15(parseResult.data);
               }
             } catch (error49) {
               reject(error49);
@@ -22760,12 +22760,12 @@ var init_protocol = __esm({
           }
         } catch {
         }
-        return new Promise((resolve14, reject) => {
+        return new Promise((resolve15, reject) => {
           if (signal.aborted) {
             reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
             return;
           }
-          const timeoutId = setTimeout(resolve14, interval);
+          const timeoutId = setTimeout(resolve15, 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 = resolve14.call(this, root, ref);
+      let _sch = resolve15.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 resolve14(root, ref) {
+    function resolve15(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -26418,7 +26418,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve14(baseURI, relativeURI, options) {
+    function resolve15(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: resolve14,
+      resolve: resolve15,
       resolveComponent,
       equal,
       serialize,
@@ -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((resolve14) => setTimeout(resolve14, pollInterval));
+          await new Promise((resolve15) => setTimeout(resolve15, 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((resolve14) => {
+        return new Promise((resolve15) => {
           const json2 = serializeMessage(message);
           if (this._stdout.write(json2)) {
-            resolve14();
+            resolve15();
           } else {
-            this._stdout.once("drain", resolve14);
+            this._stdout.once("drain", resolve15);
           }
         });
       }
@@ -34433,19 +34433,28 @@ function stripBom(content) {
   return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
 }
 function loadPackageJson(projectRoot) {
-  if (pkgJsonCache?.root === projectRoot) return pkgJsonCache.data;
+  if (pkgJsonCache.has(projectRoot)) {
+    const cached2 = pkgJsonCache.get(projectRoot) ?? null;
+    pkgJsonCache.delete(projectRoot);
+    pkgJsonCache.set(projectRoot, cached2);
+    return cached2;
+  }
+  let data;
   try {
     const content = stripBom(fs2.readFileSync(path.join(projectRoot, "package.json"), "utf-8"));
-    const data = JSON.parse(content);
-    pkgJsonCache = { root: projectRoot, data };
-    return data;
+    data = JSON.parse(content);
   } catch {
-    pkgJsonCache = { root: projectRoot, data: null };
-    return null;
+    data = null;
+  }
+  pkgJsonCache.set(projectRoot, data);
+  if (pkgJsonCache.size > PKG_CACHE_MAX_ENTRIES) {
+    const oldest = pkgJsonCache.keys().next().value;
+    if (oldest !== void 0) pkgJsonCache.delete(oldest);
   }
+  return data;
 }
 function resetPackageJsonCache() {
-  pkgJsonCache = null;
+  pkgJsonCache.clear();
 }
 function fileExists(filePath) {
   try {
@@ -34511,12 +34520,13 @@ function getAllProjectFiles(projectRoot) {
   walk(projectRoot, 0);
   return files;
 }
-var pkgJsonCache, IGNORED_DIRS;
+var PKG_CACHE_MAX_ENTRIES, pkgJsonCache, IGNORED_DIRS;
 var init_fs = __esm({
   "src/utils/fs.ts"() {
     "use strict";
     init_define_WEB_FIRST_SEGMENTS();
-    pkgJsonCache = null;
+    PKG_CACHE_MAX_ENTRIES = 256;
+    pkgJsonCache = /* @__PURE__ */ new Map();
     IGNORED_DIRS = /* @__PURE__ */ new Set([
       "node_modules",
       ".git",
@@ -40905,6 +40915,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+(\d{4}-\d\d-\d\d\b.*)$/);
+    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 +40963,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;
   }
@@ -42590,10 +42613,26 @@ function extractNpxPackage(cmd) {
   }
   return null;
 }
+function wouldNeedPackageJson(cmd) {
+  return NPM_SCRIPT_PATTERN.test(cmd) || PKG_SHORTHAND_PATTERN.test(cmd) || /^npx\b/.test(cmd) || PKG_DEPENDENT_TOOL_PATTERN.test(cmd);
+}
 async function checkCommands(file2, projectRoot) {
   const issues = [];
   const pkgJson = loadPackageJson(projectRoot);
   const makefile = loadMakefile(projectRoot);
+  if (!pkgJson) {
+    const skipped = file2.references.commands.find((ref) => wouldNeedPackageJson(ref.value));
+    if (skipped) {
+      issues.push({
+        severity: "info",
+        check: "commands",
+        ruleId: "commands/package-json-missing",
+        line: skipped.line,
+        message: "package.json missing or unparseable \u2014 command checks skipped",
+        suggestion: "Add a parseable package.json at the project root so script, npx, and tool references can be validated."
+      });
+    }
+  }
   for (const ref of file2.references.commands) {
     const cmd = ref.value;
     const scriptMatch = cmd.match(NPM_SCRIPT_PATTERN);
@@ -42612,9 +42651,7 @@ async function checkCommands(file2, projectRoot) {
       }
       continue;
     }
-    const shorthandMatch = cmd.match(
-      /^(npm|pnpm|yarn|bun)\s+(test|start|build|dev|lint|format|check|typecheck|clean|serve|preview|e2e)\b/
-    );
+    const shorthandMatch = cmd.match(PKG_SHORTHAND_PATTERN);
     if (shorthandMatch && pkgJson) {
       const scriptName = shorthandMatch[2];
       if (pkgJson.scripts && !(scriptName in pkgJson.scripts)) {
@@ -42676,7 +42713,7 @@ async function checkCommands(file2, projectRoot) {
       }
       continue;
     }
-    const toolMatch = cmd.match(/^(vitest|jest|pytest|mocha|eslint|prettier|tsc)\b/);
+    const toolMatch = cmd.match(PKG_DEPENDENT_TOOL_PATTERN);
     if (toolMatch && pkgJson) {
       const tool = toolMatch[1];
       const allDeps = {
@@ -42714,7 +42751,7 @@ function hasMakeTarget(makefile, target) {
   const pattern = new RegExp(`^${target.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*:`, "m");
   return pattern.test(makefile);
 }
-var NPM_SCRIPT_PATTERN, MAKE_PATTERN;
+var NPM_SCRIPT_PATTERN, MAKE_PATTERN, PKG_DEPENDENT_TOOL_PATTERN, PKG_SHORTHAND_PATTERN;
 var init_commands = __esm({
   "src/core/checks/commands.ts"() {
     "use strict";
@@ -42722,6 +42759,8 @@ var init_commands = __esm({
     init_fs();
     NPM_SCRIPT_PATTERN = /^(?:npm\s+run|pnpm(?:\s+run)?|yarn(?:\s+run)?|bun(?:\s+run)?)\s+(\S+)/;
     MAKE_PATTERN = /^make\s+(\S+)/;
+    PKG_DEPENDENT_TOOL_PATTERN = /^(vitest|jest|pytest|mocha|eslint|prettier|tsc)\b/;
+    PKG_SHORTHAND_PATTERN = /^(npm|pnpm|yarn|bun)\s+(test|start|build|dev|lint|format|check|typecheck|clean|serve|preview|e2e)\b/;
   }
 });
 
@@ -42912,6 +42951,7 @@ function computeSectionCosts(file2) {
   }).sort((a, b2) => b2.tokens - a.tokens);
 }
 function loadSettingsSources(projectRoot) {
+  if (settingsCache?.root === projectRoot) return settingsCache.data;
   const sources = [];
   const candidates = [
     path7.join(projectRoot, ".claude", "settings.json"),
@@ -42931,6 +42971,7 @@ function loadSettingsSources(projectRoot) {
       console.warn(`ctxlint: could not parse ${p2}: ${err.message}`);
     }
   }
+  settingsCache = { root: projectRoot, data: sources };
   return sources;
 }
 function canonicalizeCommand(backticked) {
@@ -43025,7 +43066,7 @@ function checkAggregateTierTokens(files, thresholds = DEFAULT_TOKEN_THRESHOLDS)
     suggestion: "Consider moving the largest files or their heaviest sections to on-demand tiers (skills, subagents, memory)."
   };
 }
-var ALWAYS_LOADED_NAMES, TOP_SECTIONS_TO_REPORT, INVIOLABLE_WITH_COMMAND;
+var ALWAYS_LOADED_NAMES, TOP_SECTIONS_TO_REPORT, INVIOLABLE_WITH_COMMAND, settingsCache;
 var init_tier_tokens = __esm({
   "src/core/checks/tier-tokens.ts"() {
     "use strict";
@@ -43055,6 +43096,7 @@ var init_tier_tokens = __esm({
     ];
     TOP_SECTIONS_TO_REPORT = 3;
     INVIOLABLE_WITH_COMMAND = /\b(NEVER|ALWAYS|DON'?T|DO NOT|MUST NOT)\b[^.!?`]{0,80}`([^`]+)`/i;
+    settingsCache = null;
   }
 });
 
@@ -43151,7 +43193,8 @@ async function checkRedundancy(file2, projectRoot) {
             ruleId: "redundancy/tech-mention",
             line: i2 + 1,
             message: `"${mention}" is in package.json ${pkgJson.dependencies?.[pkg] ? "dependencies" : pkgJson.devDependencies?.[pkg] ? "devDependencies" : pkgJson.peerDependencies?.[pkg] ? "peerDependencies" : "optionalDependencies"} \u2014 agent can infer this`,
-            suggestion: `~${wastedTokens} tokens could be saved`
+            suggestion: `~${wastedTokens} tokens could be saved`,
+            wastedTokens
           });
         }
       }
@@ -43165,7 +43208,8 @@ async function checkRedundancy(file2, projectRoot) {
     );
     if (dirMatch) {
       const dir = dirMatch[1].replace(/[`"]/g, "");
-      const fullPath = path8.resolve(projectRoot, dir);
+      const baseDir = dir.startsWith("./") || dir.startsWith("../") ? path8.dirname(file2.filePath) : projectRoot;
+      const fullPath = path8.resolve(baseDir, dir);
       if (isDirectory(fullPath)) {
         issues.push({
           severity: "info",
@@ -43397,19 +43441,23 @@ var init_contradictions = __esm({
         options: [
           {
             label: "Jest",
-            patterns: [/\buse\s+jest\b/i, /\bjest\s+for\s+test/i, /\btest.*with\s+jest\b/i]
+            // The third pattern bounds the gap between `test` and `with <fw>` to a
+            // few intra-clause chars so prose like "run our test suite and then
+            // deploy with jest" no longer matches the framework directive — only
+            // tight phrasings like "test with jest" / "tests run with jest" do.
+            patterns: [/\buse\s+jest\b/i, /\bjest\s+for\s+test/i, /\btest\w*\s+with\s+jest\b/i]
           },
           {
             label: "Vitest",
-            patterns: [/\buse\s+vitest\b/i, /\bvitest\s+for\s+test/i, /\btest.*with\s+vitest\b/i]
+            patterns: [/\buse\s+vitest\b/i, /\bvitest\s+for\s+test/i, /\btest\w*\s+with\s+vitest\b/i]
           },
           {
             label: "Mocha",
-            patterns: [/\buse\s+mocha\b/i, /\bmocha\s+for\s+test/i, /\btest.*with\s+mocha\b/i]
+            patterns: [/\buse\s+mocha\b/i, /\bmocha\s+for\s+test/i, /\btest\w*\s+with\s+mocha\b/i]
           },
           {
             label: "pytest",
-            patterns: [/\buse\s+pytest\b/i, /\bpytest\s+for\s+test/i, /\btest.*with\s+pytest\b/i]
+            patterns: [/\buse\s+pytest\b/i, /\bpytest\s+for\s+test/i, /\btest\w*\s+with\s+pytest\b/i]
           },
           {
             label: "Playwright",
@@ -43464,19 +43512,11 @@ var init_contradictions = __esm({
           },
           {
             label: "2 spaces",
-            patterns: [
-              /\b2[\s-]?space\s+indent/i,
-              /\bindent\s+with\s+2\s+spaces/i,
-              /\b2[\s-]?space\s+tabs?\b/i
-            ]
+            patterns: [/\b2[\s-]?space\s+indent/i, /\bindent\s+with\s+2\s+spaces/i]
           },
           {
             label: "4 spaces",
-            patterns: [
-              /\b4[\s-]?space\s+indent/i,
-              /\bindent\s+with\s+4\s+spaces/i,
-              /\b4[\s-]?space\s+tabs?\b/i
-            ]
+            patterns: [/\b4[\s-]?space\s+indent/i, /\bindent\s+with\s+4\s+spaces/i]
           }
         ]
       },
@@ -43638,10 +43678,11 @@ function hasUnbalancedBracketsOrQuotes(val) {
     if (square < 0 || curly < 0) return true;
   }
   if (square !== 0 || curly !== 0) return true;
-  const doubleQuotes = (val.match(/"/g) || []).length;
-  const singleQuotes = (val.match(/'/g) || []).length;
-  if (doubleQuotes % 2 !== 0) return true;
-  if (singleQuotes % 2 !== 0) return true;
+  const quoteChar = val[0];
+  if (quoteChar === '"' || quoteChar === "'") {
+    const count = (val.match(quoteChar === '"' ? /"/g : /'/g) || []).length;
+    if (count % 2 !== 0) return true;
+  }
   return false;
 }
 async function checkFrontmatter(file2, _projectRoot) {
@@ -44851,13 +44892,13 @@ var init_gitignore = __esm({
 // src/core/session-parser.ts
 import { readFile } from "node:fs/promises";
 import { readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname2, resolve as resolve4 } from "node:path";
+import { dirname as dirname3, resolve as resolve4 } 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 = dirname2(fileURLToPath(import.meta.url));
+  const __dir = dirname3(fileURLToPath(import.meta.url));
   const fixturePath = resolve4(__dir, "../../tests/fixtures/web-first-segments.json");
   const raw = JSON.parse(readFileSync4(fixturePath, "utf-8"));
   const list = Array.isArray(raw) ? raw : raw.segments;
@@ -44968,7 +45009,7 @@ var init_session_parser = __esm({
 import { readdir, stat } from "node:fs/promises";
 import { createReadStream } from "node:fs";
 import { createInterface } from "node:readline";
-import { dirname as dirname3, join as join5, resolve as resolve5 } from "node:path";
+import { dirname as dirname4, join as join5, resolve as resolve5 } from "node:path";
 import { existsSync } from "node:fs";
 function detectProviders() {
   if (!home) return [];
@@ -45063,7 +45104,7 @@ function detectAiderInSiblings(siblings) {
   return null;
 }
 async function detectSiblings(projectRoot) {
-  const parentDir = dirname3(resolve5(projectRoot));
+  const parentDir = dirname4(resolve5(projectRoot));
   let entries;
   try {
     entries = await readdir(parentDir);
@@ -45180,11 +45221,12 @@ async function checkMissingSecret(ctx) {
   const issues = [];
   const secrets = [];
   for (const entry of ctx.history) {
-    const match = entry.display.match(SECRET_SET_PATTERN) || entry.display.match(SECRET_SET_SIMPLE);
+    const match = entry.display.match(SECRET_SET_SIMPLE);
     if (!match) continue;
+    const repoMatch = entry.display.match(REPO_FLAG_PATTERN);
     secrets.push({
       name: match[1],
-      repo: match[2],
+      repo: repoMatch ? repoMatch[1] : void 0,
       project: entry.project
     });
   }
@@ -45229,19 +45271,19 @@ async function checkMissingSecret(ctx) {
   }
   return issues;
 }
-var SECRET_SET_PATTERN, SECRET_SET_SIMPLE;
+var SECRET_SET_SIMPLE, REPO_FLAG_PATTERN;
 var init_missing_secret = __esm({
   "src/core/checks/session/missing-secret.ts"() {
     "use strict";
     init_define_WEB_FIRST_SEGMENTS();
-    SECRET_SET_PATTERN = /gh\s+secret\s+set\s+(\S+)\s+--repo\s+(\S+)/;
     SECRET_SET_SIMPLE = /gh\s+secret\s+set\s+(\S+)/;
+    REPO_FLAG_PATTERN = /--repo\s+(\S+)/;
   }
 });
 
 // src/core/checks/session/diverged-file.ts
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { join as join6, resolve as resolve7 } from "node:path";
 import { existsSync as existsSync2 } from "node:fs";
 async function loadLineSet(absPath) {
   let mtimeMs;
@@ -45290,11 +45332,16 @@ async function checkDivergedFile(ctx) {
         bothEmptyIsIdentical: true
       });
       if (overlap >= 0.2 && overlap < 0.9) {
-        diverged.push({ sibling: sib.name, overlap: Math.round(overlap * 100) });
+        diverged.push({
+          sibling: sib.name,
+          overlap: Math.round(overlap * 100),
+          path: resolve7(sibPath)
+        });
       }
     }
     if (diverged.length > 0) {
       const details = diverged.map((d) => `${d.sibling} (${d.overlap}% overlap)`).join(", ");
+      const sibPaths = diverged.map((d) => `  ${d.sibling}: ${d.path}`).join("\n");
       issues.push({
         severity: "warning",
         check: "session-diverged-file",
@@ -45302,7 +45349,9 @@ async function checkDivergedFile(ctx) {
         line: 0,
         message: `${fileName} has diverged from sibling repos: ${details}`,
         suggestion: `Compare with sibling versions to identify unintentional drift`,
-        detail: `Files with the same name across sibling repos should be kept in sync when they serve the same purpose`
+        detail: `File: ${resolve7(currentPath)}
+Diverged siblings:
+${sibPaths}`
       });
     }
   }
@@ -45389,15 +45438,15 @@ var init_missing_workflow = __esm({
 
 // src/core/checks/session/stale-memory.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { resolve as resolve7, isAbsolute as isAbsolute2 } from "node:path";
+import { resolve as resolve8, isAbsolute as isAbsolute2 } from "node:path";
 function resolveRef2(ref, projectRoot) {
   if (ref.startsWith("~/") || ref === "~") {
     const home2 = process.env.HOME || process.env.USERPROFILE;
     if (!home2) return null;
-    return ref === "~" ? home2 : resolve7(home2, ref.slice(2));
+    return ref === "~" ? home2 : resolve8(home2, ref.slice(2));
   }
   if (isAbsolute2(ref)) return ref;
-  return resolve7(projectRoot, ref);
+  return resolve8(projectRoot, ref);
 }
 async function checkStaleMemory(ctx) {
   const issues = [];
@@ -45440,7 +45489,15 @@ var init_stale_memory = __esm({
 async function checkDuplicateMemory(ctx) {
   const issues = [];
   const reported = /* @__PURE__ */ new Set();
-  const lineSets = ctx.memories.map((m) => toLineSet(m.content, MIN_TOKEN_LEN2));
+  const lineSets = new Array(ctx.memories.length);
+  const getLineSet = (idx) => {
+    let ls2 = lineSets[idx];
+    if (ls2 === void 0) {
+      ls2 = toLineSet(ctx.memories[idx].content, MIN_TOKEN_LEN2);
+      lineSets[idx] = ls2;
+    }
+    return ls2;
+  };
   for (let i2 = 0; i2 < ctx.memories.length; i2++) {
     for (let j3 = i2 + 1; j3 < ctx.memories.length; j3++) {
       const a = ctx.memories[i2];
@@ -45450,7 +45507,7 @@ async function checkDuplicateMemory(ctx) {
       const bIsCurrent = projectDirMatchesPath(b2.projectDir, ctx.currentProject);
       if (!aIsCurrent && !bIsCurrent) continue;
       if (a.content.length < 50 || b2.content.length < 50) continue;
-      const overlap = jaccardSimilarityFromSets(lineSets[i2], lineSets[j3]);
+      const overlap = jaccardSimilarityFromSets(getLineSet(i2), getLineSet(j3));
       if (overlap < 0.6) continue;
       const pairKey = [a.filePath, b2.filePath].sort().join("::");
       if (reported.has(pairKey)) continue;
@@ -45484,9 +45541,9 @@ var init_duplicate_memory = __esm({
 });
 
 // src/core/checks/session/loop-detection.ts
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 function normalizeProject(p2) {
-  return resolve8(p2).replace(/\\/g, "/");
+  return resolve9(p2).replace(/\\/g, "/");
 }
 function findConsecutiveRepeats(displays) {
   const results = [];
@@ -45496,13 +45553,13 @@ function findConsecutiveRepeats(displays) {
     while (j3 < displays.length && displays[j3] === displays[i2]) j3++;
     const count = j3 - i2;
     if (count >= CONSECUTIVE_THRESHOLD) {
-      results.push({ command: displays[i2], count });
+      results.push({ command: displays[i2], count, startIdx: i2, endIdx: j3 });
     }
     i2 = j3;
   }
   return results;
 }
-function findCyclicPatterns(displays) {
+function findCyclicPatterns(displays, consecutiveSpans) {
   const results = [];
   for (let cycleLen = 2; cycleLen <= MAX_CYCLE_LENGTH; cycleLen++) {
     for (let start = 0; start <= displays.length - cycleLen * CYCLE_REPEAT_THRESHOLD; start++) {
@@ -45520,8 +45577,13 @@ function findCyclicPatterns(displays) {
         }
       }
       if (repeats >= CYCLE_REPEAT_THRESHOLD) {
+        const cycleEnd = start + cycleLen * repeats;
+        const overlapsConsecutive = consecutiveSpans.some(
+          (s) => s.startIdx < cycleEnd && start < s.endIdx
+        );
+        if (overlapsConsecutive) continue;
         const alreadyCovered = results.some(
-          (r2) => r2.startIdx <= start && r2.startIdx + r2.cycle.length * r2.repeats >= start + cycleLen * repeats
+          (r2) => r2.startIdx <= start && r2.startIdx + r2.cycle.length * r2.repeats >= cycleEnd
         );
         if (!alreadyCovered) {
           results.push({ cycle, repeats, startIdx: start });
@@ -45550,7 +45612,8 @@ async function checkLoopDetection(ctx) {
       suggestion: "An agent may be looping on this command. Check history.jsonl for context on what went wrong"
     });
   }
-  const cycles = findCyclicPatterns(displays);
+  const consecutiveSpans = repeats.map((r2) => ({ startIdx: r2.startIdx, endIdx: r2.endIdx }));
+  const cycles = findCyclicPatterns(displays, consecutiveSpans);
   for (const { cycle, repeats: reps } of cycles) {
     const cycleStr = cycle.map((c3) => c3.length > 40 ? c3.slice(0, 37) + "..." : c3).join(" -> ");
     issues.push({
@@ -45655,9 +45718,12 @@ async function findReleaseWorkflows(projectRoot) {
     }
     try {
       const content = stripBom(await readFile4(join9(workflowDir, f), "utf-8"));
-      const nameMatch = content.match(/^name:\s*(.+)$/m);
-      if (nameMatch && RELEASE_FILENAME_PATTERNS.some((p2) => p2.test(nameMatch[1]))) {
-        releaseWorkflows.push(f);
+      const nameMatch = content.match(/^\s*name:\s*(.+?)\s*$/m);
+      if (nameMatch) {
+        const name = nameMatch[1].replace(/^(['"])(.*)\1$/, "$2");
+        if (RELEASE_FILENAME_PATTERNS.some((p2) => p2.test(name))) {
+          releaseWorkflows.push(f);
+        }
       }
     } catch {
     }
@@ -46511,6 +46577,7 @@ function extractPathsFromMessage(msg) {
 function applyIgnoreRules(issues, rules) {
   const compiled = compileRules(rules);
   const kept = [];
+  const keepMask = [];
   let dropped = 0;
   for (const issue2 of issues) {
     let suppress = false;
@@ -46530,12 +46597,15 @@ function applyIgnoreRules(issues, rules) {
     }
     if (suppress) {
       dropped++;
+      keepMask.push(false);
     } else {
       kept.push(issue2);
+      keepMask.push(true);
     }
   }
   return {
     kept,
+    keepMask,
     dropped,
     unusedRules: compiled.filter((r2) => !r2.fired).map(stripCompiled),
     rulesMissingReason: rules.filter((r2) => !r2.reason)
@@ -46570,12 +46640,12 @@ var init_types3 = __esm({
 
 // src/version.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { resolve as resolve11, dirname as dirname5 } from "node:path";
+import { resolve as resolve12, dirname as dirname6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function loadVersion() {
-  if (true) return "0.12.3";
-  const __dir = dirname5(fileURLToPath2(import.meta.url));
-  const pkgPath = resolve11(__dir, "../package.json");
+  if (true) return "0.13.1";
+  const __dir = dirname6(fileURLToPath2(import.meta.url));
+  const pkgPath = resolve12(__dir, "../package.json");
   const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
   return pkg.version;
 }
@@ -46883,10 +46953,9 @@ async function runAudit(projectRoot, activeChecks, options = {}) {
       }
     });
     const applied = applyIgnoreRules(flat, options.ignoreRules);
-    const keptSet = new Set(applied.kept);
     const rebuilt = fileResults.map(() => []);
     flat.forEach((issue2, i2) => {
-      if (keptSet.has(issue2)) rebuilt[owners[i2]].push(issue2);
+      if (applied.keepMask[i2]) rebuilt[owners[i2]].push(issue2);
     });
     fileResults.forEach((fr, idx) => {
       fr.issues = rebuilt[idx];
@@ -46900,7 +46969,10 @@ async function runAudit(projectRoot, activeChecks, options = {}) {
   let estimatedWaste = 0;
   for (const fr of fileResults) {
     for (const issue2 of fr.issues) {
-      if (issue2.check === "redundancy" && issue2.suggestion) {
+      if (issue2.check !== "redundancy") continue;
+      if (typeof issue2.wastedTokens === "number") {
+        estimatedWaste += issue2.wastedTokens;
+      } else if (issue2.suggestion) {
         const tokenMatch = issue2.suggestion.match(/~(\d+)\s+tokens/);
         if (tokenMatch) estimatedWaste += parseInt(tokenMatch[1], 10);
       }
@@ -54788,6 +54860,11 @@ function formatText(result, verbose = false) {
     lines.push("Session audit scanned");
     renderedAnySummary = true;
   }
+  if (groups.skill.length > 0) {
+    if (renderedAnySummary) lines.push("");
+    lines.push("Skill audit scanned");
+    renderedAnySummary = true;
+  }
   if (!renderedAnySummary) {
     lines.push(`Found ${result.files.length} file${result.files.length !== 1 ? "s" : ""}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yawlabs/ctxlint",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "mcpName": "io.github.YawLabs/ctxlint",
   "description": "Lint your AI agent context files, MCP server configs, and session data against your actual codebase",
   "bin": {