@wrongstack/plugins 0.293.0 → 0.295.1

package/dist/branch-guard.js

@@ -1,5 +1,107 @@
 // 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/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,6 +153,7 @@ function hasDisabledPluginEntry(raw) {
     return name === "branch-guard" || name === "@wrongstack/plugins/branch-guard";
   });
 }
+var branchCache = new BoundedMap({ max: 64, ttlMs: 3e4 });
 function runGit(args, cwd, signal) {
   return new Promise((resolve, reject) => {
     execFile(
@@ -65,11 +168,17 @@ function runGit(args, cwd, signal) {
   });
 }
 async function getCurrentBranch(cwd, signal) {
+  const cacheKey = `${cwd ?? "undefined"}`;
+  const cached = branchCache.get(cacheKey);
+  if (cached !== void 0) return cached;
   try {
     const branch = (await runGit(["branch", "--show-current"], cwd, signal)).trim();
-    return branch || null;
+    const result = branch || null;
+    branchCache.set(cacheKey, result);
+    return result;
   } catch (err) {
     if (signal.aborted) throw err;
+    branchCache.set(cacheKey, null);
     return null;
   }
 }
@@ -157,6 +266,7 @@ var plugin = {
     state.hookUnregister = null;
     state.configUnregister = null;
     state.lastBlock = null;
+    branchCache.clear();
     let cfg = readHostConfig(api.config);
     state.configUnregister = api.onConfigChange((next) => {
       cfg = readHostConfig(next);

package/dist/catalog.d.ts

@@ -1,39 +1,14 @@
 /**
- * Plugin catalog — single source of truth for plugin names and their
- * canonical source paths. Used by `spec-linker` to detect unlinked
- * plugin references in markdown files.
- *
- * The catalog is built at module load time by importing each plugin
- * source and reading its `name` field. This means the catalog is
- * always in sync with the actual plugins — adding a new plugin
- * (exporting it from `./index.ts` AND adding a row to the table
- * below) is enough for `spec-linker` to start detecting references
- * to it.
- *
- * To add a new plugin: see the table in `catalog.ts`. The `name`
- * must match the plugin's `name` field; the `path` is the
- * relative source directory under `packages/plugins/src/`.
- *
- * @public
+ * Catalog projections used by spec-linker and public discovery APIs.
+ * Plugin identity and source paths are owned by the typed manifest.
  */
-import type { Plugin } from '@wrongstack/core';
-interface CatalogEntry {
-    /** The plugin's `name` field. */
+import type { Plugin } from '@wrongstack/core/types';
+export interface CatalogEntry {
     name: string;
-    /** Relative path under `packages/plugins/src/`, e.g. `./src/auto-doc`. */
     path: string;
 }
-/**
- * Read-only view of the catalog as a Map from plugin name to its
- * source path. Frozen so consumers cannot mutate it.
- */
-export declare const PLUGIN_CATALOG: ReadonlyMap<string, string>;
-/**
- * The list of catalog entries, ordered by the table above. Used by
- * `spec-linker` to iterate names in a stable order for detection.
- */
 export declare const PLUGIN_CATALOG_ENTRIES: readonly CatalogEntry[];
-/** Convenience accessor: just the names, in declaration order. */
+export declare const PLUGIN_CATALOG: ReadonlyMap<string, string>;
 export declare const PLUGIN_NAMES: readonly string[];
 export type { Plugin };
 //# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAwE/C,UAAU,YAAY;IACpB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;CACd;AAgGD;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAInD,CAAC;AAEL;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,YAAY,EAEzD,CAAC;AAEF,kEAAkE;AAClE,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAA8C,CAAC;AAIzF,YAAY,EAAE,MAAM,EAAE,CAAC"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGrD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,sBAAsB,EAAE,SAAS,YAAY,EAIzD,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAEtD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAEzC,CAAC;AAEF,YAAY,EAAE,MAAM,EAAE,CAAC"}

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

@@ -43,7 +43,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 type Section = 'Added' | 'Changed' | 'Fixed' | 'Removed' | 'Security' | 'Documentation' | 'Maintenance';
 export interface ChangelogEntry {
     section: Section;

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,kBAAkB,CAAC;AAM/C,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

@@ -35,7 +35,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core';
+import type { Plugin } from '@wrongstack/core/types';
 export interface Snapshot {
     id: string;
     createdAt: string;
@@ -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;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAM/C,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;AA+HD,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

@@ -1,6 +1,5 @@
 // src/checkpoint/index.ts
-import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { readFile, stat } from "node:fs/promises";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 var state = {
   snapshots: [],
@@ -8,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 };
@@ -23,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
   };
 }
@@ -41,11 +43,11 @@ function hashContent(s) {
   }
   return h >>> 0;
 }
-function captureFile(path, maxBytes) {
+async function captureFile(path, maxBytes) {
   try {
-    const st = statSync(path);
+    const st = await stat(path);
     if (st.size > maxBytes) return "too-large";
-    const content = readFileSync(path, "utf-8");
+    const content = await readFile(path, "utf-8");
     return { path, content, bytes: st.size };
   } catch {
     return { path, content: null, bytes: 0 };
@@ -64,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",
@@ -107,6 +120,7 @@ var plugin = {
     state.captures = 0;
     state.restores = 0;
     state.skippedLarge = 0;
+    state.evictedForBytes = 0;
     if (state.hookUnregister) {
       try {
         state.hookUnregister();
@@ -134,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");
@@ -188,7 +203,7 @@ var plugin = {
             rejectedOutsideProject.push(p);
             continue;
           }
-          const captured = captureFile(safePath, cfg.maxFileBytes);
+          const captured = await captureFile(safePath, cfg.maxFileBytes);
           if (captured === "too-large") {
             skipped += 1;
             state.skippedLarge += 1;
@@ -212,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 {
@@ -255,7 +270,9 @@ var plugin = {
           counters: {
             captures: state.captures,
             restores: state.restores,
-            skippedLarge: state.skippedLarge
+            skippedLarge: state.skippedLarge,
+            retainedBytes: retainedSnapshotBytes(),
+            evictedForBytes: state.evictedForBytes
           }
         };
       }
@@ -298,8 +315,8 @@ var plugin = {
             continue;
           }
           try {
-            mkdirSync(dirname(f.path), { recursive: true });
-            writeFileSync(f.path, f.content);
+            await mkdir(dirname(f.path), { recursive: true });
+            await writeFile(f.path, f.content);
             restored.push(f.path);
           } catch (err) {
             errors.push({ path: f.path, error: err instanceof Error ? err.message : String(err) });
@@ -337,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() {
@@ -354,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/index.d.ts

@@ -23,7 +23,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/code-metrics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/code-metrics/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA0M/C,QAAA,MAAM,MAAM,EAAE,MAgMb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/code-metrics/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA6MrD,QAAA,MAAM,MAAM,EAAE,MAgMb,CAAC;eAEa,MAAM"}