@wrongstack/plugins 0.295.0 → 0.296.2

package/dist/accessibility-auditor/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/accessibility-auditor/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AASrD,MAAM,MAAM,QAAQ,GAChB,aAAa,GACb,qBAAqB,GACrB,0BAA0B,GAC1B,qBAAqB,GACrB,cAAc,CAAC;AAEnB,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB;AAuPD,QAAA,MAAM,MAAM,EAAE,MA0Nb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/accessibility-auditor/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AASrD,MAAM,MAAM,QAAQ,GAChB,aAAa,GACb,qBAAqB,GACrB,0BAA0B,GAC1B,qBAAqB,GACrB,cAAc,CAAC;AAEnB,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB;AAwQD,QAAA,MAAM,MAAM,EAAE,MA8Nb,CAAC;eAEa,MAAM"}

package/dist/accessibility-auditor.js

@@ -4,6 +4,22 @@ import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 }
 
 // src/runtime/index.ts
 import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+
+// src/runtime/local-bin.ts
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+
+// src/runtime/handles.ts
+function releaseHandle(off) {
+  if (off) {
+    try {
+      off();
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/runtime/index.ts
 var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 function hasLeadingDash(arg) {
   return arg.length > 0 && arg.startsWith("-");
@@ -204,15 +220,23 @@ async function auditPath(rawPath, cfg) {
   const exts = normalizeExtensions(cfg.includeExtensions);
   const files = await collectSourceFilesAsync(resolved, { extensions: exts });
   const findings = [];
+  let scannedFiles = 0;
+  let truncated = false;
   for (const file of files) {
     const fileFindings = await auditFile(file, root);
+    scannedFiles += 1;
     findings.push(...fileFindings);
-    if (findings.length >= cfg.maxFindings) break;
+    if (findings.length >= cfg.maxFindings) {
+      truncated = scannedFiles < files.length;
+      break;
+    }
   }
   return {
     path: relative2(root, resolved),
     findings: findings.slice(0, cfg.maxFindings),
-    fileCount: files.length
+    fileCount: files.length,
+    scannedFiles,
+    truncated
   };
 }
 function formatSummary(result) {
@@ -272,7 +296,7 @@ var plugin = {
     state.findingCount = 0;
     state.hookInvocationCount = 0;
     state.lastResult = null;
-    state.hookUnregister = null;
+    state.hookUnregister = releaseHandle(state.hookUnregister);
     const cfg = readConfig(api.config.extensions?.["accessibility-auditor"]);
     const hook = async (input) => {
       if (!cfg.enabled || !cfg.onWriteEdit) return;
@@ -341,6 +365,10 @@ var plugin = {
           ok: true,
           path: result.path,
           fileCount: result.fileCount,
+          scannedFiles: result.scannedFiles,
+          // 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,
           findingCount: result.findings.length,
           findings: result.findings
         };

package/dist/agent-handoff/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-handoff/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAwKrD,QAAA,MAAM,MAAM,EAAE,MAsNb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-handoff/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA2KrD,QAAA,MAAM,MAAM,EAAE,MAsNb,CAAC;eAEa,MAAM"}

package/dist/agent-handoff.js

@@ -1,3 +1,32 @@
+// src/runtime/local-bin.ts
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+
+// src/runtime/safe-json.ts
+var UNSERIALIZABLE = "[unserializable]";
+function safeJsonStringify(value, indent) {
+  try {
+    const stack = [];
+    const out = JSON.stringify(
+      value,
+      function replacer(_key, val) {
+        if (typeof val === "bigint") return `${val.toString()}n`;
+        if (val === null || typeof val !== "object") return val;
+        while (stack.length > 0 && stack[stack.length - 1] !== this) stack.pop();
+        if (stack.includes(val)) return "[circular]";
+        stack.push(val);
+        return val;
+      },
+      indent
+    );
+    return out ?? String(value);
+  } catch {
+    return UNSERIALIZABLE;
+  }
+}
+
+// src/runtime/index.ts
+var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+
 // src/agent-handoff/index.ts
 var API_VERSION = "^0.1.10";
 var state = {
@@ -55,7 +84,7 @@ function buildBody(payload, cfg) {
   if (cfg.includeResult && payload.result !== void 0) {
     lines.push("## Result");
     lines.push("```json");
-    lines.push(JSON.stringify(payload.result, null, 2));
+    lines.push(safeJsonStringify(payload.result, 2));
     lines.push("```");
     lines.push("");
   }

package/dist/auto-doc/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auto-doc/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,MAAM,EAAa,MAAM,wBAAwB,CAAC;AA4WhE,QAAA,MAAM,MAAM,EAAE,MAqIb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auto-doc/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,MAAM,EAAa,MAAM,wBAAwB,CAAC;AAsXhE,QAAA,MAAM,MAAM,EAAE,MAqIb,CAAC;eAEa,MAAM"}

package/dist/auto-doc.js

@@ -196,6 +196,7 @@ async function runAutoDoc(input, api) {
       }
       const entities = parseSource(content);
       let modified = content;
+      const beforeCount = results.length;
       for (const entity of entities) {
         if (!input.force && !needsDocComment(modified, entity)) continue;
         let doc = null;
@@ -221,7 +222,8 @@ async function runAutoDoc(input, api) {
         modified = injectDocComment(modified, entity, doc);
         results.push({ file: safeFile, entity: entity.name, source });
       }
-      if (!input.dry_run && results.length > 0) {
+      const changedThisFile = results.length > beforeCount && modified !== content;
+      if (!input.dry_run && changedThisFile) {
         writeFileSync(safeFile, modified, "utf-8");
         api.log.info(`auto-doc: updated ${safeFile}`);
       }

package/dist/auto-i18n-extractor.js

@@ -3,6 +3,11 @@ import { readFileSync } from "node:fs";
 
 // src/runtime/index.ts
 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("-");

package/dist/branch-guard/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/branch-guard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAqNrD,QAAA,MAAM,MAAM,EAAE,MAuPb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/branch-guard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA2NrD,QAAA,MAAM,MAAM,EAAE,MAuPb,CAAC;eAEa,MAAM"}

package/dist/branch-guard.js

@@ -1,5 +1,118 @@
 // src/branch-guard/index.ts
 import { execFile } from "node:child_process";
+
+// 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/handles.ts
+function releaseHandle(off) {
+  if (off) {
+    try {
+      off();
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/runtime/index.ts
+var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+
+// src/branch-guard/index.ts
 var API_VERSION = "^0.1.10";
 var state = {
   invocationCount: 0,
@@ -51,7 +164,7 @@ function hasDisabledPluginEntry(raw) {
     return name === "branch-guard" || name === "@wrongstack/plugins/branch-guard";
   });
 }
-var branchCache = /* @__PURE__ */ new Map();
+var branchCache = new BoundedMap({ max: 64, ttlMs: 3e4 });
 function runGit(args, cwd, signal) {
   return new Promise((resolve, reject) => {
     execFile(
@@ -161,8 +274,8 @@ var plugin = {
     state.invocationCount = 0;
     state.blockCount = 0;
     state.warnCount = 0;
-    state.hookUnregister = null;
-    state.configUnregister = null;
+    state.hookUnregister = releaseHandle(state.hookUnregister);
+    state.configUnregister = releaseHandle(state.configUnregister);
     state.lastBlock = null;
     branchCache.clear();
     let cfg = readHostConfig(api.config);

package/dist/changelog-writer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/changelog-writer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAMrD,KAAK,OAAO,GACR,OAAO,GACP,SAAS,GACT,OAAO,GACP,SAAS,GACT,UAAU,GACV,eAAe,GACf,aAAa,CAAC;AAElB,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd;AAmGD,8FAA8F;AAC9F,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAQjF;AAED,+EAA+E;AAC/E,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOvE;AAeD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,MAAM,CAiBvE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBjF;AAMD,QAAA,MAAM,MAAM,EAAE,MAqRb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/changelog-writer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAOrD,KAAK,OAAO,GACR,OAAO,GACP,SAAS,GACT,OAAO,GACP,SAAS,GACT,UAAU,GACV,eAAe,GACf,aAAa,CAAC;AAElB,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd;AAwGD,8FAA8F;AAC9F,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAQjF;AAED,+EAA+E;AAC/E,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOvE;AAeD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,MAAM,CAiBvE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBjF;AAMD,QAAA,MAAM,MAAM,EAAE,MAqRb,CAAC;eAEa,MAAM"}

package/dist/changelog-writer.js

@@ -1,9 +1,143 @@
 // src/changelog-writer/index.ts
 import { readFileSync, writeFileSync } from "node:fs";
 import { isAbsolute, relative, resolve } 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();
+  }
+};
+var BoundedSet = class {
+  inner;
+  constructor(options) {
+    this.inner = new BoundedMap(options);
+  }
+  has(value) {
+    return this.inner.has(value);
+  }
+  add(value) {
+    this.inner.set(value, true);
+    return this;
+  }
+  delete(value) {
+    return this.inner.delete(value);
+  }
+  clear() {
+    this.inner.clear();
+  }
+  get size() {
+    return this.inner.size;
+  }
+  /** How many entries have been dropped to respect `max`, since the last clear. */
+  get evictionCount() {
+    return this.inner.evictionCount;
+  }
+  *values() {
+    for (const [key] of this.inner) yield key;
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+};
+
+// src/runtime/index.ts
+var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+
+// src/changelog-writer/index.ts
 var state = {
   entries: [],
-  filesTouched: /* @__PURE__ */ new Set(),
+  filesTouched: new BoundedSet({ max: 2e3 }),
   commitsSeen: 0,
   writes: 0,
   polishes: 0,
@@ -164,7 +298,7 @@ var plugin = {
   },
   setup(api) {
     state.entries = [];
-    state.filesTouched = /* @__PURE__ */ new Set();
+    state.filesTouched = new BoundedSet({ max: 2e3 });
     state.commitsSeen = 0;
     state.writes = 0;
     for (const off of state.eventUnsubscribers) {
@@ -356,7 +490,7 @@ var plugin = {
       filesTouched: state.filesTouched.size
     };
     state.entries = [];
-    state.filesTouched = /* @__PURE__ */ new Set();
+    state.filesTouched = new BoundedSet({ max: 2e3 });
     state.commitsSeen = 0;
     state.writes = 0;
     api.log.info("changelog-writer: teardown complete", { final });

package/dist/checkpoint/index.d.ts

@@ -48,6 +48,8 @@ export interface Snapshot {
         bytes: number;
     }>;
 }
+/** Retained bytes across all snapshots — surfaced by status/health(). */
+export declare function retainedSnapshotBytes(): number;
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/checkpoint/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/checkpoint/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAMrD,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,iDAAiD;QACjD,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;CACJ;AAkID,QAAA,MAAM,MAAM,EAAE,MAwUb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/checkpoint/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAMrD,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,iDAAiD;QACjD,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;CACJ;AAsID,yEAAyE;AACzE,wBAAgB,qBAAqB,IAAI,MAAM,CAM9C;AAuBD,QAAA,MAAM,MAAM,EAAE,MAmVb,CAAC;eAEa,MAAM"}

package/dist/checkpoint.js

@@ -7,13 +7,15 @@ var state = {
   captures: 0,
   restores: 0,
   skippedLarge: 0,
+  evictedForBytes: 0,
   hookUnregister: null
 };
 var DEFAULTS = {
   enabled: true,
   autoCapture: true,
   maxSnapshots: 50,
-  maxFileBytes: 1048576
+  maxFileBytes: 1048576,
+  maxTotalBytes: 64 * 1048576
 };
 function readConfig(raw) {
   if (!raw || typeof raw !== "object") return { ...DEFAULTS };
@@ -22,6 +24,7 @@ function readConfig(raw) {
     enabled: r["enabled"] !== false,
     autoCapture: r["autoCapture"] !== false,
     maxSnapshots: typeof r["maxSnapshots"] === "number" && r["maxSnapshots"] >= 1 && r["maxSnapshots"] <= 500 ? r["maxSnapshots"] : DEFAULTS.maxSnapshots,
+    maxTotalBytes: typeof r["maxTotalBytes"] === "number" && r["maxTotalBytes"] >= 1024 ? r["maxTotalBytes"] : DEFAULTS.maxTotalBytes,
     maxFileBytes: typeof r["maxFileBytes"] === "number" && r["maxFileBytes"] >= 1024 ? r["maxFileBytes"] : DEFAULTS.maxFileBytes
   };
 }
@@ -63,11 +66,22 @@ async function captureFileForHook(path, maxBytes, signal) {
     return { path, content: null, bytes: 0 };
   }
 }
-function pushSnapshot(snapshot, maxSnapshots) {
+function retainedSnapshotBytes() {
+  let total = 0;
+  for (const snap of state.snapshots) {
+    for (const f of snap.files) total += f.content === null ? 0 : f.content.length;
+  }
+  return total;
+}
+function pushSnapshot(snapshot, maxSnapshots, maxTotalBytes) {
   state.snapshots.push(snapshot);
   if (state.snapshots.length > maxSnapshots) {
     state.snapshots.splice(0, state.snapshots.length - maxSnapshots);
   }
+  while (state.snapshots.length > 1 && retainedSnapshotBytes() > maxTotalBytes) {
+    state.snapshots.shift();
+    state.evictedForBytes += 1;
+  }
 }
 var plugin = {
   name: "checkpoint",
@@ -106,6 +120,7 @@ var plugin = {
     state.captures = 0;
     state.restores = 0;
     state.skippedLarge = 0;
+    state.evictedForBytes = 0;
     if (state.hookUnregister) {
       try {
         state.hookUnregister();
@@ -133,7 +148,8 @@ var plugin = {
             origin: `auto:${input.toolName ?? "unknown"}`,
             files: [captured]
           },
-          cfg.maxSnapshots
+          cfg.maxSnapshots,
+          cfg.maxTotalBytes
         );
         state.captures += 1;
         api.metrics.counter("captures");
@@ -211,7 +227,7 @@ var plugin = {
           origin: input.label?.trim() ? `manual:${input.label.trim()}` : "manual",
           files
         };
-        pushSnapshot(snapshot, cfg.maxSnapshots);
+        pushSnapshot(snapshot, cfg.maxSnapshots, cfg.maxTotalBytes);
         state.captures += 1;
         api.metrics.counter("captures");
         return {
@@ -254,7 +270,9 @@ var plugin = {
           counters: {
             captures: state.captures,
             restores: state.restores,
-            skippedLarge: state.skippedLarge
+            skippedLarge: state.skippedLarge,
+            retainedBytes: retainedSnapshotBytes(),
+            evictedForBytes: state.evictedForBytes
           }
         };
       }
@@ -336,13 +354,16 @@ var plugin = {
       captures: state.captures,
       restores: state.restores,
       skippedLarge: state.skippedLarge,
-      snapshotsHeld: state.snapshots.length
+      snapshotsHeld: state.snapshots.length,
+      retainedBytes: retainedSnapshotBytes(),
+      evictedForBytes: state.evictedForBytes
     };
     state.snapshots = [];
     state.nextId = 1;
     state.captures = 0;
     state.restores = 0;
     state.skippedLarge = 0;
+    state.evictedForBytes = 0;
     api.log.info("checkpoint: teardown complete", { final });
   },
   async health() {
@@ -353,12 +374,17 @@ var plugin = {
         snapshotsHeld: state.snapshots.length,
         captures: state.captures,
         restores: state.restores,
-        skippedLarge: state.skippedLarge
+        skippedLarge: state.skippedLarge,
+        // Retained snapshot bytes: the count-based ring alone does not
+        // bound memory, so surface the number the byte budget acts on.
+        retainedBytes: retainedSnapshotBytes(),
+        evictedForBytes: state.evictedForBytes
       }
     };
   }
 };
 var checkpoint_default = plugin;
 export {
-  checkpoint_default as default
+  checkpoint_default as default,
+  retainedSnapshotBytes
 };

package/dist/code-metrics.js

@@ -4,6 +4,11 @@ import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 }
 
 // src/runtime/index.ts
 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("-");

package/dist/commit-validator/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commit-validator/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAsPrD,QAAA,MAAM,MAAM,EAAE,MAgSb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commit-validator/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAkRrD,QAAA,MAAM,MAAM,EAAE,MAgSb,CAAC;eAEa,MAAM"}