@wrongstack/plugins 0.293.0 → 0.295.1

package/dist/injection-shield/index.d.ts

@@ -40,7 +40,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 export declare function scanForInjection(text: string): string[];
 declare const plugin: Plugin;
 export default plugin;

package/dist/injection-shield/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/injection-shield/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA6G/C,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAMvD;AAMD,QAAA,MAAM,MAAM,EAAE,MAwJb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/injection-shield/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA6GrD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAMvD;AAMD,QAAA,MAAM,MAAM,EAAE,MAwJb,CAAC;eAEa,MAAM"}

package/dist/interface-contract-guard/index.d.ts

@@ -23,7 +23,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 export interface InterfaceContractFinding {
     interfaceName: string;
     file: string;

package/dist/interface-contract-guard/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interface-contract-guard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAS/C,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAqID,QAAA,MAAM,MAAM,EAAE,MAuMb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interface-contract-guard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AASrD,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAqLD,QAAA,MAAM,MAAM,EAAE,MAyNb,CAAC;eAEa,MAAM"}

package/dist/interface-contract-guard.js

@@ -1,10 +1,14 @@
 // src/interface-contract-guard/index.ts
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
 
 // src/runtime/index.ts
-import { existsSync, readdirSync, statSync } from "node:fs";
 import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+
+// src/runtime/local-bin.ts
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+
+// src/runtime/index.ts
 var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 function hasLeadingDash(arg) {
   return arg.length > 0 && arg.startsWith("-");
@@ -17,44 +21,45 @@ function withinProjectPath(projectRoot, candidate) {
   return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
 }
 function withinProject(p) {
-  return withinProjectPath(process.cwd(), p) || relative(process.cwd(), p) === ".";
+  const cwd = process.cwd();
+  return withinProjectPath(cwd, p) || relative(cwd, p) === ".";
 }
 var DEFAULT_EXCLUDE_DIRS = ["node_modules", "dist", ".git", "coverage"];
-function collectSourceFiles(root, opts) {
+async function collectSourceFilesAsync(root, opts) {
+  const { readdir, stat } = await import("node:fs/promises");
   const files = [];
-  if (!existsSync(root)) return files;
-  const s = statSync(root);
-  if (s.isFile()) {
-    if (matchesExtension(root, opts.extensions)) files.push(root);
+  try {
+    const s = await stat(root);
+    if (s.isFile()) {
+      if (matchesExtension(root, opts.extensions)) files.push(root);
+      return files;
+    }
+    if (!s.isDirectory()) return files;
+  } catch {
     return files;
   }
-  if (!s.isDirectory()) return files;
   const exclude = opts.excludeDirs ?? DEFAULT_EXCLUDE_DIRS;
-  function walk(dir, depth) {
+  const excludeSet = new Set(exclude);
+  async function walk(dir, depth) {
     if (opts.maxDepth !== void 0 && depth > opts.maxDepth) return;
     let entries;
     try {
-      entries = readdirSync(dir);
+      entries = await readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      if (exclude.includes(entry)) continue;
-      const full = resolve(dir, entry);
-      let st;
-      try {
-        st = statSync(full);
-      } catch {
-        continue;
-      }
-      if (st.isDirectory()) {
-        walk(full, depth + 1);
-      } else if (st.isFile() && matchesExtension(full, opts.extensions)) {
+      if (excludeSet.has(entry.name)) continue;
+      const full = resolve(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full, depth + 1);
+      } else if (entry.isFile() && matchesExtension(full, opts.extensions)) {
         files.push(full);
       }
     }
   }
-  walk(root, 0);
+  await walk(root, 0);
   return files;
 }
 function matchesExtension(p, exts) {
@@ -74,7 +79,8 @@ var state = {
 var DEFAULTS = {
   enabled: false,
   extensions: [".ts", ".tsx"],
-  maxFindings: 50
+  maxFindings: 50,
+  maxFiles: 2e3
 };
 function readConfig(raw) {
   if (!raw || typeof raw !== "object") return { ...DEFAULTS };
@@ -82,7 +88,8 @@ function readConfig(raw) {
   return {
     enabled: r["enabled"] !== false,
     extensions: Array.isArray(r["extensions"]) ? r["extensions"].filter((x) => typeof x === "string") : DEFAULTS.extensions,
-    maxFindings: typeof r["maxFindings"] === "number" && r["maxFindings"] >= 1 && r["maxFindings"] <= 500 ? r["maxFindings"] : DEFAULTS.maxFindings
+    maxFindings: typeof r["maxFindings"] === "number" && r["maxFindings"] >= 1 && r["maxFindings"] <= 500 ? r["maxFindings"] : DEFAULTS.maxFindings,
+    maxFiles: typeof r["maxFiles"] === "number" && r["maxFiles"] >= 1 && r["maxFiles"] <= 5e4 ? Math.floor(r["maxFiles"]) : DEFAULTS.maxFiles
   };
 }
 function normalizeExtensions(exts) {
@@ -98,47 +105,60 @@ var INTERFACE_RE = /(?:export\s+)?interface\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
 function extractInterfaceNames(content) {
   const names = [];
   INTERFACE_RE.lastIndex = 0;
+  let searchedUpTo = 0;
+  let line = 1;
   for (const m of content.matchAll(INTERFACE_RE)) {
-    names.push({ name: m[1], line: content.slice(0, m.index).split(/\r?\n/).length });
+    const index = m.index ?? 0;
+    for (let i = searchedUpTo; i < index; i++) {
+      if (content.charCodeAt(i) === 10) line += 1;
+    }
+    searchedUpTo = index;
+    names.push({ name: m[1], line });
   }
   return names;
 }
-function hasImplementer(name, contents) {
-  const implRe = new RegExp(`(?:implements|satisfies|\\bas)\\s+${name}\\b`, "g");
-  for (const content of contents) {
-    if (implRe.test(content)) return true;
+var IMPLEMENTER_RE = /(?:implements|satisfies|\bas)\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
+function collectImplementedNames(content, into) {
+  IMPLEMENTER_RE.lastIndex = 0;
+  for (const m of content.matchAll(IMPLEMENTER_RE)) {
+    const name = m[1];
+    if (name) into.add(name);
   }
-  return false;
 }
-function scanPath(rawPath, cfg) {
+async function scanPath(rawPath, cfg) {
   const root = process.cwd();
   const resolved = isAbsolute2(rawPath) ? resolve2(rawPath) : resolve2(root, rawPath);
   const exts = normalizeExtensions(cfg.extensions);
-  const files = collectSourceFiles(resolved, { extensions: exts });
-  const contents = [];
+  const allFiles = await collectSourceFilesAsync(resolved, { extensions: exts });
+  const files = allFiles.slice(0, cfg.maxFiles);
+  const implemented = /* @__PURE__ */ new Set();
+  const declarations = [];
+  let scannedFiles = 0;
   for (const p of files) {
+    let content;
     try {
-      contents.push({ path: p, content: readFileSync(p, "utf-8") });
+      content = await readFile(p, "utf-8");
     } catch {
+      continue;
     }
-  }
-  const allContentStrings = contents.map((c) => c.content);
-  const findings = [];
-  for (const { path, content } of contents) {
+    scannedFiles += 1;
+    collectImplementedNames(content, implemented);
     for (const { name, line } of extractInterfaceNames(content)) {
-      if (!hasImplementer(name, allContentStrings)) {
-        findings.push({
-          interfaceName: name,
-          file: relativePath(path),
-          line,
-          message: `interface "${name}" is declared but has no visible implementer`
-        });
-        if (findings.length >= cfg.maxFindings) break;
-      }
+      declarations.push({ name, line, file: p });
     }
+  }
+  const findings = [];
+  for (const { name, line, file } of declarations) {
+    if (implemented.has(name)) continue;
+    findings.push({
+      interfaceName: name,
+      file: relativePath(file),
+      line,
+      message: `interface "${name}" is declared but has no visible implementer`
+    });
     if (findings.length >= cfg.maxFindings) break;
   }
-  return { findings, scannedFiles: contents.length };
+  return { findings, scannedFiles, truncated: allFiles.length > files.length };
 }
 var plugin = {
   name: "interface-contract-guard",
@@ -157,6 +177,13 @@ var plugin = {
         default: [".ts", ".tsx"],
         description: "File extensions to scan."
       },
+      maxFiles: {
+        type: "number",
+        minimum: 1,
+        maximum: 5e4,
+        default: 2e3,
+        description: "Upper bound on files read per scan."
+      },
       maxFindings: {
         type: "number",
         minimum: 1,
@@ -180,7 +207,7 @@ var plugin = {
       state.hookUnregister = null;
     }
     const cfg = readConfig(api.config.extensions?.["interface-contract-guard"]);
-    const hook = (input) => {
+    const hook = async (input) => {
       if (!cfg.enabled) return;
       if (input.toolResult?.isError) return;
       const inp = input.toolInput ?? {};
@@ -193,7 +220,7 @@ var plugin = {
       const resolved = resolve2(process.cwd(), sourcePath);
       let content;
       try {
-        content = readFileSync(resolved, "utf-8");
+        content = await readFile(resolved, "utf-8");
       } catch {
         state.errorCount += 1;
         return;
@@ -230,7 +257,7 @@ If you changed member shapes, search the project for implementers/\`satisfies\`/
         state.scanCount += 1;
         let result;
         try {
-          result = scanPath(rawPath, cfg);
+          result = await scanPath(rawPath, cfg);
         } catch (err) {
           state.errorCount += 1;
           return { ok: false, error: String(err) };
@@ -240,7 +267,14 @@ If you changed member shapes, search the project for implementers/\`satisfies\`/
           ok: true,
           path: relativePath(resolve2(process.cwd(), rawPath)),
           scannedFiles: result.scannedFiles,
-          findings: result.findings
+          findings: result.findings,
+          // Say so when the corpus was cut short. A partial scan that
+          // reports "no findings" is not the same as a clean result, and
+          // the caller has no other way to tell the difference.
+          truncated: result.truncated,
+          ...result.truncated ? {
+            note: `Scan stopped at the maxFiles limit (${cfg.maxFiles}); results are partial. Raise \`maxFiles\` or scan a narrower path for full coverage.`
+          } : {}
         };
       }
     });

package/dist/knowledge-graph/index.d.ts

@@ -28,7 +28,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 export interface Fact {
     id: string;
     subject: string;

package/dist/knowledge-graph/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/knowledge-graph/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAQ/C,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACtC,SAAS,EAAE,MAAM,CAAC;CACnB;AA2HD,QAAA,MAAM,MAAM,EAAE,MA2Sb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/knowledge-graph/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AASrD,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACtC,SAAS,EAAE,MAAM,CAAC;CACnB;AAiID,QAAA,MAAM,MAAM,EAAE,MA2Sb,CAAC;eAEa,MAAM"}

package/dist/knowledge-graph.js

@@ -1,6 +1,7 @@
 // src/knowledge-graph/index.ts
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { atomicWrite, ensureDir } from "@wrongstack/core/utils";
 var API_VERSION = "^0.1.10";
 var state = {
   facts: [],
@@ -52,11 +53,11 @@ function loadFacts(filePath) {
     return { facts: [], nextId: 1 };
   }
 }
-function persistFacts(filePath) {
+async function persistFacts(filePath) {
   if (!filePath) return true;
   try {
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(
+    await ensureDir(dirname(filePath));
+    await atomicWrite(
       filePath,
       JSON.stringify({ facts: state.facts, nextId: state.nextId }, null, 2)
     );
@@ -187,7 +188,7 @@ var plugin = {
         state.facts.push(fact);
         state.adds += 1;
         api.metrics.counter("adds");
-        const persisted = persistFacts(resolved);
+        const persisted = await persistFacts(resolved);
         return { ok: true, fact, persisted, totalFacts: state.facts.length };
       }
     });
@@ -247,7 +248,7 @@ var plugin = {
         if (removed === 0) return { ok: false, error: `no fact matches "${input.id}"` };
         state.removals += removed;
         api.metrics.counter("removals", removed);
-        const persisted = persistFacts(resolved);
+        const persisted = await persistFacts(resolved);
         return { ok: true, removed, persisted, totalFacts: state.facts.length };
       }
     });

package/dist/license-audit-gate/index.d.ts

@@ -26,7 +26,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/license-audit-gate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/license-audit-gate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAkK/C,QAAA,MAAM,MAAM,EAAE,MAqMb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/license-audit-gate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAkKrD,QAAA,MAAM,MAAM,EAAE,MAqMb,CAAC;eAEa,MAAM"}

package/dist/lint-gate/index.d.ts

@@ -25,7 +25,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/lint-gate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lint-gate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAQH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAwU/C,QAAA,MAAM,MAAM,EAAE,MAwWb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lint-gate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAQH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA+VrD,QAAA,MAAM,MAAM,EAAE,MA2Wb,CAAC;eAEa,MAAM"}

package/dist/lint-gate.js

@@ -5,6 +5,108 @@ import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+
+// src/runtime/local-bin.ts
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+
+// src/runtime/bounded-map.ts
+var BoundedMap = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  ttlMs;
+  now;
+  /** Entries dropped to stay under `max`. Surfaced by plugin health(). */
+  evictions = 0;
+  constructor(options) {
+    const normalizedMax = Math.floor(options.max);
+    this.max = Number.isSafeInteger(normalizedMax) ? Math.max(1, normalizedMax) : 1;
+    this.ttlMs = options.ttlMs;
+    this.now = options.now ?? Date.now;
+  }
+  expired(entry) {
+    return this.ttlMs !== void 0 && this.now() - entry.storedAt > this.ttlMs;
+  }
+  get(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0) return void 0;
+    if (this.expired(entry)) {
+      this.map.delete(key);
+      return void 0;
+    }
+    this.map.delete(key);
+    this.map.set(key, entry);
+    return entry.value;
+  }
+  /**
+   * Read without promoting the key to most-recently-used. Use for
+   * diagnostics that must not perturb the eviction order.
+   */
+  peek(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0 || this.expired(entry)) return void 0;
+    return entry.value;
+  }
+  has(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0) return false;
+    if (this.expired(entry)) {
+      this.map.delete(key);
+      return false;
+    }
+    return true;
+  }
+  set(key, value) {
+    this.map.delete(key);
+    this.map.set(key, { value, storedAt: this.now() });
+    while (this.map.size > this.max) {
+      const coldest = this.map.keys().next().value;
+      if (coldest === void 0) break;
+      this.map.delete(coldest);
+      this.evictions += 1;
+    }
+    return this;
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+    this.evictions = 0;
+  }
+  get size() {
+    return this.map.size;
+  }
+  /** How many entries have been dropped to respect `max`, since the last clear. */
+  get evictionCount() {
+    return this.evictions;
+  }
+  /** Drop every expired entry. Cheap enough to call from a status tool. */
+  prune() {
+    if (this.ttlMs === void 0) return 0;
+    let removed = 0;
+    for (const [key, entry] of this.map) {
+      if (this.expired(entry)) {
+        this.map.delete(key);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+  /** Live (non-expired) entries, coldest first. */
+  *entries() {
+    for (const [key, entry] of this.map) {
+      if (!this.expired(entry)) yield [key, entry.value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+
+// src/runtime/index.ts
+var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+
+// src/lint-gate/index.ts
 var API_VERSION = "^0.1.10";
 var state = {
   /** Total PreToolUse invocations. */
@@ -42,6 +144,7 @@ var LINTER_PACKAGES = {
   biome: "@biomejs/biome",
   eslint: "eslint"
 };
+var linterCache = new BoundedMap({ max: 32, ttlMs: 3e5 });
 function isInside(parent, candidate) {
   const rel = relative(parent, candidate);
   return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
@@ -89,13 +192,20 @@ function runCommand(command, args, timeoutMs, cwd, signal) {
   });
 }
 async function detectLinter(requested, cwd) {
+  const cacheKey = `${requested}:${cwd}`;
+  const cached = linterCache.get(cacheKey);
+  if (cached !== void 0) return cached;
   const candidates = requested === "auto" ? ["biome", "eslint"] : [requested];
   for (const name of candidates) {
     const linter = resolveLocalLinter(name, cwd);
     if (!linter) continue;
     const probe = await runCommand(linter.cmd, [linter.args[0], "--version"], 5e3, cwd);
-    if (!probe.error) return linter;
+    if (!probe.error) {
+      linterCache.set(cacheKey, linter);
+      return linter;
+    }
   }
+  linterCache.set(cacheKey, null);
   return null;
 }
 async function lintContent(content, filePath, linter, timeoutMs, cwd, signal) {
@@ -223,6 +333,7 @@ var plugin = {
     state.linterErrorCount = 0;
     state.hookUnregister = null;
     state.lastResult = null;
+    linterCache.clear();
     const cfg = readConfig(api.config.extensions?.["lint-gate"]);
     const cwd = resolve(api.config.cwd ?? process.cwd());
     const linterReady = detectLinter(cfg.linter, cwd).then((linter) => {

package/dist/llm-cache/index.d.ts

@@ -37,7 +37,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 /**
  * Whether a request is safe to cache under `onlyDeterministic`. Sampled
  * requests (temperature > 0) return different content each call, so
@@ -47,6 +47,10 @@ export declare function isDeterministic(request: Record<string, unknown>): boole
 /**
  * Stable fingerprint of the request fields that affect the response.
  * Excludes anything cosmetic (user id, etc.). Same inputs → same key.
+ *
+ * Determinism: uses canonical JSON key ordering (alphabetical) so
+ * identical semantic requests produce identical fingerprints regardless
+ * of property insertion order.
  */
 export declare function fingerprintRequest(request: Record<string, unknown>): string;
 declare const plugin: Plugin;

package/dist/llm-cache/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/llm-cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAa,MAAM,kBAAkB,CAAC;AAwF1D;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAGzE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAiB3E;AAkCD,QAAA,MAAM,MAAM,EAAE,MAkNb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/llm-cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAa,MAAM,wBAAwB,CAAC;AAwFhE;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAGzE;AAeD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAsB3E;AA6CD,QAAA,MAAM,MAAM,EAAE,MAkNb,CAAC;eAEa,MAAM"}

package/dist/llm-cache.js

@@ -32,21 +32,26 @@ function isDeterministic(request) {
   const t = request["temperature"];
   return t === void 0 || t === 0;
 }
+var fingerprintCache = /* @__PURE__ */ new WeakMap();
 function fingerprintRequest(request) {
+  const cached = fingerprintCache.get(request);
+  if (cached) return cached;
   const subset = {
+    maxTokens: request["maxTokens"] ?? null,
+    messages: request["messages"] ?? null,
     model: request["model"] ?? null,
+    reasoning: request["reasoning"] ?? null,
+    responseFormat: request["responseFormat"] ?? null,
+    stopSequences: request["stopSequences"] ?? null,
     system: request["system"] ?? null,
-    messages: request["messages"] ?? null,
-    tools: Array.isArray(request["tools"]) ? request["tools"].map((t) => t?.name ?? t) : null,
     temperature: request["temperature"] ?? null,
-    topP: request["topP"] ?? null,
+    tools: Array.isArray(request["tools"]) ? request["tools"].map((t) => t?.name ?? t) : null,
     topK: request["topK"] ?? null,
-    maxTokens: request["maxTokens"] ?? null,
-    stopSequences: request["stopSequences"] ?? null,
-    responseFormat: request["responseFormat"] ?? null,
-    reasoning: request["reasoning"] ?? null
+    topP: request["topP"] ?? null
   };
-  return createHash("sha256").update(JSON.stringify(subset)).digest("hex");
+  const fingerprint = createHash("sha256").update(JSON.stringify(subset)).digest("hex");
+  fingerprintCache.set(request, fingerprint);
+  return fingerprint;
 }
 function lruGet(key, ttlMs) {
   const entry = state.cache.get(key);
@@ -60,6 +65,9 @@ function lruGet(key, ttlMs) {
   return entry;
 }
 function lruSet(key, response, maxEntries) {
+  if (state.cache.has(key)) {
+    state.cache.delete(key);
+  }
   state.cache.set(key, { response, storedAt: Date.now(), hits: 0 });
   while (state.cache.size > maxEntries) {
     const oldest = state.cache.keys().next().value;

package/dist/loop-breaker/index.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/loop-breaker/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/loop-breaker/index.ts"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAqP/C,QAAA,MAAM,MAAM,EAAE,MA6Yb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/loop-breaker/index.ts"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAmSrD,QAAA,MAAM,MAAM,EAAE,MA+Yb,CAAC;eAEa,MAAM"}