@wrongstack/plugins 0.293.0 → 0.295.1

package/dist/feature-flag-tracker.js

@@ -1,10 +1,14 @@
 // src/feature-flag-tracker/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) {
@@ -103,8 +108,14 @@ function relativePath(p) {
   return toPosix(relative2(process.cwd(), p));
 }
 function compilePatterns(patterns) {
-  const sources = [...DEFAULT_PATTERNS, ...patterns];
-  return sources.map((src) => new RegExp(src, "g"));
+  const out = [];
+  for (const src of [...DEFAULT_PATTERNS, ...patterns]) {
+    try {
+      out.push(new RegExp(src, "g"));
+    } catch {
+    }
+  }
+  return out;
 }
 function scanFile(filePath, content, patterns, maxFindings) {
   const usages = [];
@@ -128,22 +139,33 @@ function scanFile(filePath, content, patterns, maxFindings) {
   }
   return usages.slice(0, maxFindings);
 }
-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 files = await collectSourceFilesAsync(resolved, { extensions: exts });
   const patterns = compilePatterns(cfg.patterns);
   const usages = [];
+  let scannedFiles = 0;
+  let truncated = false;
   for (const p of files) {
     try {
-      const content = readFileSync(p, "utf-8");
+      const content = await readFile(p, "utf-8");
+      scannedFiles += 1;
       usages.push(...scanFile(p, content, patterns, cfg.maxFindings));
-      if (usages.length >= cfg.maxFindings) break;
+      if (usages.length >= cfg.maxFindings) {
+        truncated = scannedFiles < files.length;
+        break;
+      }
     } catch {
     }
   }
-  return { usages: usages.slice(0, cfg.maxFindings), scannedFiles: files.length };
+  return {
+    usages: usages.slice(0, cfg.maxFindings),
+    scannedFiles,
+    discoveredFiles: files.length,
+    truncated
+  };
 }
 var plugin = {
   name: "feature-flag-tracker",
@@ -191,7 +213,7 @@ var plugin = {
       state.hookUnregister = null;
     }
     const cfg = readConfig(api.config.extensions?.["feature-flag-tracker"]);
-    const hook = (input) => {
+    const hook = async (input) => {
       if (!cfg.enabled) return;
       if (input.toolResult?.isError) return;
       const inp = input.toolInput ?? {};
@@ -204,7 +226,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;
@@ -242,7 +264,7 @@ Make sure flag behavior is intentional and consider updating flag inventory/docs
         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) };
@@ -252,6 +274,10 @@ Make sure flag behavior is intentional and consider updating flag inventory/docs
           ok: true,
           path: relativePath(resolve2(process.cwd(), rawPath)),
           scannedFiles: result.scannedFiles,
+          discoveredFiles: result.discoveredFiles,
+          // Say so when the cap stopped the walk early: a partial scan
+          // that reports few findings must not read as a clean result.
+          truncated: result.truncated,
           usages: result.usages
         };
       }

package/dist/file-watcher/index.d.ts

@@ -6,7 +6,7 @@
  * - watch_stop: Stop a watch by ID
  * - watch_list: List all active watches
  */
-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/file-watcher/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/file-watcher/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA2D/C,QAAA,MAAM,MAAM,EAAE,MAsYb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/file-watcher/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAqErD,QAAA,MAAM,MAAM,EAAE,MA+Yb,CAAC;eAEa,MAAM"}

package/dist/file-watcher.js

@@ -80,13 +80,12 @@ var plugin = {
     function debounceEvent(key, fn, ms) {
       const existing = debounceTimers.get(key);
       if (existing) clearTimeout(existing);
-      debounceTimers.set(
-        key,
-        setTimeout(() => {
-          debounceTimers.delete(key);
-          fn();
-        }, ms)
-      );
+      const timer = setTimeout(() => {
+        debounceTimers.delete(key);
+        fn();
+      }, ms);
+      timer.unref?.();
+      debounceTimers.set(key, timer);
     }
     const autoIndex = api.config.extensions?.["file-watcher"]?.["autoIndex"] ?? false;
     const indexProjectRoot = api.config.extensions?.["file-watcher"]?.["indexProjectRoot"] ?? "";

package/dist/format-on-save/index.d.ts

@@ -27,7 +27,9 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
+/** Which formatter is currently in use — surfaced by health()/status. */
+export declare function activeFormatterLabel(): string | null;
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/format-on-save/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/format-on-save/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA0P/C,QAAA,MAAM,MAAM,EAAE,MAuPb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/format-on-save/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAmPrD,yEAAyE;AACzE,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,IAAI,CAEpD;AAsGD,QAAA,MAAM,MAAM,EAAE,MAsPb,CAAC;eAEa,MAAM"}

package/dist/format-on-save.js

@@ -1,9 +1,200 @@
 // src/format-on-save/index.ts
 import { execFile } from "node:child_process";
-import { access, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { access, readFile, stat } from "node:fs/promises";
+
+// src/runtime/index.ts
+import { basename, extname as extname2, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
+
+// src/runtime/local-bin.ts
+import { createRequire } from "node:module";
+import { delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { accessSync, constants, readFileSync } from "node:fs";
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+function resolveExecInvocation(command, args = []) {
+  const resolved = resolveWin32Command(command);
+  const normalizedResolved = resolved.toLowerCase();
+  const needsShell = process.platform === "win32" && (normalizedResolved.endsWith(".cmd") || normalizedResolved.endsWith(".bat"));
+  if (needsShell) {
+    const shim = buildWin32CmdShimInvocation(resolved, args);
+    return { cmd: shim.command, args: shim.args, windowsVerbatimArguments: true };
+  }
+  return { cmd: resolved, args: [...args], windowsVerbatimArguments: false };
+}
+function findOnPath(cmd) {
+  if (!cmd) return null;
+  const exists = (p) => {
+    try {
+      accessSync(p, constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (cmd.includes("/") || cmd.includes("\\")) {
+    return exists(cmd) ? resolve(cmd) : null;
+  }
+  const suffixes = process.platform === "win32" && extname(cmd) === "" ? (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  for (const dir of (process.env["PATH"] ?? "").split(delimiter)) {
+    if (!dir) continue;
+    const base = join(dir, cmd);
+    for (const suffix of suffixes) {
+      const candidate = `${base}${suffix}`;
+      if (exists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function isInside(parent, candidate) {
+  const rel = relative(parent, candidate);
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+var binCache = /* @__PURE__ */ new Map();
+var BIN_CACHE_MAX = 64;
+var NEGATIVE_BIN_CACHE_TTL_MS = 5e3;
+function cachePut(key, value) {
+  while (binCache.size >= BIN_CACHE_MAX) {
+    const oldest = binCache.keys().next().value;
+    if (oldest === void 0) break;
+    binCache.delete(oldest);
+  }
+  binCache.set(key, { value, cachedAt: Date.now() });
+  return value;
+}
+function clearLocalBinCache() {
+  binCache.clear();
+}
+function resolveNodeBin(packageName, binName, cwd, extraArgs = []) {
+  const key = `${packageName}|${binName}|${cwd}`;
+  const cached = binCache.get(key);
+  if (cached !== void 0) {
+    if (cached.value !== null || Date.now() - cached.cachedAt < NEGATIVE_BIN_CACHE_TTL_MS) {
+      return cached.value === null ? null : { ...cached.value, args: [cached.value.entry, ...extraArgs] };
+    }
+    binCache.delete(key);
+  }
+  let resolved = null;
+  try {
+    const requireFromProject = createRequire(resolve(cwd, "package.json"));
+    const packagePath = requireFromProject.resolve(`${packageName}/package.json`);
+    const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+    const relativeBin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.[binName] ?? Object.values(packageJson.bin ?? {})[0];
+    if (relativeBin && !isAbsolute(relativeBin)) {
+      const packageDir = dirname(packagePath);
+      const entry = resolve(packageDir, relativeBin);
+      if (isInside(packageDir, entry)) {
+        resolved = { cmd: process.execPath, args: [entry], entry };
+      }
+    }
+  } catch {
+    resolved = null;
+  }
+  cachePut(key, resolved);
+  return resolved === null ? null : { ...resolved, args: [resolved.entry, ...extraArgs] };
+}
+function resolveFirstNodeBin(candidates, cwd) {
+  for (const c of candidates) {
+    const hit = resolveNodeBin(c.packageName, c.binName, cwd, c.args ?? []);
+    if (hit) return { ...hit, packageName: c.packageName, binName: c.binName };
+  }
+  return null;
+}
+
+// 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
-import { basename, extname, isAbsolute, relative, resolve } from "node:path";
 var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 function hasLeadingDash(arg) {
   return arg.length > 0 && arg.startsWith("-");
@@ -11,12 +202,13 @@ function hasLeadingDash(arg) {
 function withinProjectPath(projectRoot, candidate) {
   if (candidate.length === 0 || candidate.length > 4096) return false;
   if (hasLeadingDash(candidate)) return false;
-  const resolved = isAbsolute(candidate) ? resolve(candidate) : resolve(projectRoot, candidate);
-  const rel = relative(projectRoot, resolved);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+  const resolved = isAbsolute2(candidate) ? resolve2(candidate) : resolve2(projectRoot, candidate);
+  const rel = relative2(projectRoot, resolved);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
 }
 function withinProject(p) {
-  return withinProjectPath(process.cwd(), p) || relative(process.cwd(), p) === ".";
+  const cwd = process.cwd();
+  return withinProjectPath(cwd, p) || relative2(cwd, p) === ".";
 }
 
 // src/format-on-save/index.ts
@@ -55,7 +247,7 @@ function readConfig(raw) {
     skipTtlMs: typeof r["skipTtlMs"] === "number" && r["skipTtlMs"] >= 0 ? r["skipTtlMs"] : DEFAULTS.skipTtlMs
   };
 }
-var recentlyCovered = /* @__PURE__ */ new Map();
+var recentlyCovered = new BoundedMap({ max: 256 });
 function clearRegistrations() {
   if (state.hookUnregister) {
     try {
@@ -78,6 +270,55 @@ function evictExpired(ttlMs) {
     if (ts < cutoff) recentlyCovered.delete(path);
   }
 }
+var FORMATTERS = [
+  {
+    packageName: "@biomejs/biome",
+    binName: "biome",
+    writeArgs: ["format", "--write"],
+    label: "biome"
+  },
+  { packageName: "prettier", binName: "prettier", writeArgs: ["--write"], label: "prettier" },
+  { packageName: "dprint", binName: "dprint", writeArgs: ["fmt"], label: "dprint" }
+];
+var activeFormatter;
+function resetFormatter() {
+  activeFormatter = void 0;
+  clearLocalBinCache();
+}
+function resolveFormatter() {
+  if (activeFormatter !== void 0) return activeFormatter;
+  const cwd = process.cwd();
+  for (const f of FORMATTERS) {
+    const local = resolveNodeBinFor(f, cwd);
+    if (local) {
+      activeFormatter = local;
+      return local;
+    }
+  }
+  for (const f of FORMATTERS) {
+    const onPath = findOnPath(f.binName);
+    if (!onPath) continue;
+    activeFormatter = { cmd: onPath, args: [...f.writeArgs], label: f.label };
+    return activeFormatter;
+  }
+  activeFormatter = null;
+  return null;
+}
+function resolveNodeBinFor(f, cwd) {
+  const hit = resolveFirstNodeBin([{ packageName: f.packageName, binName: f.binName }], cwd);
+  if (!hit) return null;
+  return { cmd: hit.cmd, args: [...hit.args, ...f.writeArgs], label: f.label };
+}
+function activeFormatterLabel() {
+  return activeFormatter?.label ?? null;
+}
+async function sha256File(filePath) {
+  try {
+    return createHash("sha256").update(await readFile(filePath)).digest("hex");
+  } catch {
+    return null;
+  }
+}
 async function formatFile(filePath, timeoutMs) {
   if (!withinProject(filePath)) return null;
   try {
@@ -85,30 +326,40 @@ async function formatFile(filePath, timeoutMs) {
   } catch {
     return null;
   }
+  const formatter = resolveFormatter();
+  if (!formatter) return null;
   let bytesBefore;
   try {
     bytesBefore = (await stat(filePath)).size;
   } catch {
     return null;
   }
+  const hashBefore = await sha256File(filePath);
+  let invocation;
+  try {
+    invocation = resolveExecInvocation(formatter.cmd, [...formatter.args, filePath]);
+  } catch {
+    return null;
+  }
   try {
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve3, reject) => {
       execFile(
-        "npx",
-        ["biome", "format", "--write", filePath],
+        invocation.cmd,
+        invocation.args,
         {
           encoding: "utf-8",
           timeout: timeoutMs,
           cwd: process.cwd(),
           windowsHide: true,
-          maxBuffer: 16 * 1024 * 1024
+          maxBuffer: 16 * 1024 * 1024,
+          ...invocation.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
         },
         (err) => {
           if (err) {
             const e = err;
             if (e.killed) return reject(err);
           }
-          resolve2();
+          resolve3();
         }
       );
     });
@@ -124,28 +375,11 @@ async function formatFile(filePath, timeoutMs) {
   if (bytesAfter !== bytesBefore) {
     return { changed: true, bytesBefore, bytesAfter };
   }
-  try {
-    await new Promise((resolve2, reject) => {
-      execFile(
-        "npx",
-        ["biome", "format", filePath],
-        {
-          encoding: "utf-8",
-          timeout: timeoutMs,
-          cwd: process.cwd(),
-          windowsHide: true,
-          maxBuffer: 16 * 1024 * 1024
-        },
-        (err) => {
-          if (err) return reject(err);
-          resolve2();
-        }
-      );
-    });
+  const hashAfter = await sha256File(filePath);
+  if (hashBefore === null || hashAfter === null) {
     return { changed: false, bytesBefore, bytesAfter };
-  } catch {
-    return { changed: true, bytesBefore, bytesAfter };
   }
+  return { changed: hashBefore !== hashAfter, bytesBefore, bytesAfter };
 }
 var plugin = {
   name: "format-on-save",
@@ -191,32 +425,18 @@ var plugin = {
     state.lastResult = null;
     recentlyCovered.clear();
     const cfg = readConfig(api.config.extensions?.["format-on-save"]);
-    let biomeAvailable = false;
-    try {
-      await new Promise((resolve2, reject) => {
-        execFile(
-          "npx",
-          ["biome", "--version"],
-          {
-            encoding: "utf-8",
-            timeout: 5e3,
-            cwd: process.cwd(),
-            windowsHide: true
-          },
-          (err) => {
-            if (err) reject(err);
-            else resolve2();
-          }
-        );
-      });
-      biomeAvailable = true;
-      api.log.info("format-on-save: biome detected");
-    } catch {
-      biomeAvailable = false;
-      api.log.warn("format-on-save: biome not found \u2014 hook will be a no-op");
+    resetFormatter();
+    const formatter = resolveFormatter();
+    const formatterAvailable = formatter !== null;
+    if (formatter) {
+      api.log.info(`format-on-save: ${formatter.label} detected`);
+    } else {
+      api.log.warn(
+        "format-on-save: no formatter found (biome, prettier, dprint) \u2014 hook will be a no-op"
+      );
     }
     const hook = async (input) => {
-      if (!cfg.enabled || !biomeAvailable) return;
+      if (!cfg.enabled || !formatterAvailable) return;
       if (input.toolResult?.isError) return;
       const toolName = input.toolName ?? "";
       const inp = input.toolInput ?? {};
@@ -277,7 +497,7 @@ var plugin = {
     );
     api.tools.register({
       name: "format_on_save_status",
-      description: "Reports format-on-save state: biome availability, and per-session formatted/clean/error/skipped counters.",
+      description: "Reports format-on-save state: which formatter is active, and per-session formatted/clean/error/skipped counters.",
       inputSchema: { type: "object", properties: {} },
       permission: "auto",
       category: "Code Quality",
@@ -286,7 +506,14 @@ var plugin = {
         return {
           ok: true,
           enabled: cfg.enabled,
-          biomeAvailable,
+          formatterAvailable,
+          formatter: activeFormatterLabel(),
+          /**
+           * Back-compat alias for the pre-multi-formatter status shape.
+           * Now accurate rather than assumed: true only when the resolved
+           * formatter really is biome.
+           */
+          biomeAvailable: activeFormatterLabel() === "biome",
           timeoutMs: cfg.timeoutMs,
           skipWhenCoveredBy: cfg.skipWhenCoveredBy,
           skipTtlMs: cfg.skipTtlMs,
@@ -304,11 +531,13 @@ var plugin = {
     api.log.info("format-on-save plugin loaded", {
       version: "0.1.0",
       enabled: cfg.enabled,
-      biomeAvailable
+      formatterAvailable,
+      formatter: activeFormatterLabel()
     });
   },
   teardown(api) {
     clearRegistrations();
+    resetFormatter();
     const final = {
       invocations: state.invocationCount,
       formatted: state.formattedCount,
@@ -342,5 +571,6 @@ var plugin = {
 };
 var format_on_save_default = plugin;
 export {
+  activeFormatterLabel,
   format_on_save_default as default
 };