@wrongstack/plugins 0.284.1 → 0.286.0

package/dist/llm-cache.js

@@ -1,6 +1,5 @@
-import { createHash } from 'crypto';
-
 // src/llm-cache/index.ts
+import { createHash } from "node:crypto";
 var state = {
   cache: /* @__PURE__ */ new Map(),
   hits: 0,
@@ -252,5 +251,8 @@ var plugin = {
   }
 };
 var llm_cache_default = plugin;
-
-export { llm_cache_default as default, fingerprintRequest, isDeterministic };
+export {
+  llm_cache_default as default,
+  fingerprintRequest,
+  isDeterministic
+};

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

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

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

@@ -0,0 +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"}

package/dist/loop-breaker.d.ts

@@ -1,5 +1,2 @@
-import { Plugin } from '@wrongstack/core';
-
-declare const plugin: Plugin;
-
-export { plugin as default };
+export * from './loop-breaker/index.js';
+export { default } from './loop-breaker/index.js';

package/dist/loop-breaker.js

@@ -1,6 +1,5 @@
-import { execFile } from 'child_process';
-
 // src/loop-breaker/index.ts
+import { execFile } from "node:child_process";
 var state = {
   lastFingerprint: null,
   streak: 0,
@@ -461,5 +460,6 @@ var plugin = {
   }
 };
 var loop_breaker_default = plugin;
-
-export { loop_breaker_default as default };
+export {
+  loop_breaker_default as default
+};

package/dist/migration-planner/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * migration-planner plugin — helps plan dependency or framework migrations.
+ *
+ * The plugin reads a package CHANGELOG (project root or node_modules) and
+ * produces a migration checklist with breaking changes and recommended steps
+ * between two versions. If no changelog is available it returns a generic
+ * migration guide.
+ *
+ * Tools registered:
+ * - migration_plan   — produce a migration checklist for a package/version range
+ * - migration_status — report plugin state and counters
+ *
+ * Config (`config.extensions['migration-planner']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "changelogPaths": ["CHANGELOG.md"],
+ *   "maxChars": 100_000
+ * }
+ * ```
+ *
+ * @public
+ */
+import type { Plugin } from '@wrongstack/core';
+declare const plugin: Plugin;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/migration-planner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migration-planner/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAmP/C,QAAA,MAAM,MAAM,EAAE,MAgOb,CAAC;eAEa,MAAM"}

package/dist/migration-planner.d.ts

@@ -1,30 +1,2 @@
-import { Plugin } from '@wrongstack/core';
-
-/**
- * migration-planner plugin — helps plan dependency or framework migrations.
- *
- * The plugin reads a package CHANGELOG (project root or node_modules) and
- * produces a migration checklist with breaking changes and recommended steps
- * between two versions. If no changelog is available it returns a generic
- * migration guide.
- *
- * Tools registered:
- * - migration_plan   — produce a migration checklist for a package/version range
- * - migration_status — report plugin state and counters
- *
- * Config (`config.extensions['migration-planner']`):
- *
- * ```jsonc
- * {
- *   "enabled": true,
- *   "changelogPaths": ["CHANGELOG.md"],
- *   "maxChars": 100_000
- * }
- * ```
- *
- * @public
- */
-
-declare const plugin: Plugin;
-
-export { plugin as default };
+export * from './migration-planner/index.js';
+export { default } from './migration-planner/index.js';

package/dist/migration-planner.js

@@ -1,7 +1,6 @@
-import { existsSync, readFileSync } from 'fs';
-import { isAbsolute, resolve, relative } from 'path';
-
 // src/migration-planner/index.ts
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
 var API_VERSION = "^0.1.10";
 var state = {
   plansGenerated: 0,
@@ -345,5 +344,6 @@ var plugin = {
   }
 };
 var migration_planner_default = plugin;
-
-export { migration_planner_default as default };
+export {
+  migration_planner_default as default
+};

package/dist/model-router/index.d.ts

@@ -0,0 +1,67 @@
+/**
+ * model-router plugin — routes each provider call to a different model
+ * based on declarative rules, on the wire.
+ *
+ * Like `llm-cache`, this registers an `AgentExtension.wrapProviderRunner`
+ * (composed around EVERY provider call in the agent loop). Before the
+ * request goes out, the plugin evaluates an ordered rule list against
+ * the request's size and shape and rewrites `request.model` to the
+ * first matching rule's target — e.g. small/tool-free turns to a cheap
+ * fast model, large refactors to a capable one.
+ *
+ * IMPORTANT constraint: the active provider instance is fixed for the
+ * session. Rerouting only works among models the CURRENT provider
+ * serves (e.g. anthropic `haiku` ↔ `opus`). Routing to a model id the
+ * provider doesn't recognize will fail at the provider — keep targets
+ * within one provider's catalog.
+ *
+ * Safety posture: opt-in — loads inert until
+ * `config.extensions['model-router'].enabled = true`. A `dryRun` mode
+ * (default) only records what it WOULD route without changing the model,
+ * so you can observe the routing before trusting it.
+ *
+ * Config (`config.extensions['model-router']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": false,
+ *   "dryRun": true,             // observe only; do not rewrite the model
+ *   "rules": [
+ *     { "maxChars": 2000, "hasTools": false, "model": "claude-haiku-4-5" },
+ *     { "minChars": 40000, "model": "claude-opus-4-8" }
+ *   ]
+ * }
+ * ```
+ *
+ * A rule matches when ALL of its present conditions hold. The first
+ * matching rule wins; if none match, the request passes through with its
+ * original model.
+ *
+ * Tools:
+ *  - `model_router_status` — rules, mode, and per-target routing counts
+ *
+ * @public
+ */
+import type { Plugin } from '@wrongstack/core';
+interface RouteRule {
+    /** Match when the request's total char size is <= this. */
+    maxChars?: number | undefined;
+    /** Match when the request's total char size is >= this. */
+    minChars?: number | undefined;
+    /** Match when the request has (true) / lacks (false) tools. */
+    hasTools?: boolean | undefined;
+    /** The model id to route matching requests to (required). */
+    model: string;
+}
+/**
+ * Total character size of the request's actual prompt text (system +
+ * message content). Only counts `text` block values and bare-string
+ * content — not structural fields like `type`/`role` — so the size is a
+ * meaningful proxy for prompt weight.
+ */
+export declare function requestCharSize(request: Record<string, unknown>): number;
+/** First rule whose present conditions all hold, or null. */
+export declare function pickRule(rules: RouteRule[], size: number, hasTools: boolean): RouteRule | null;
+declare const plugin: Plugin;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/model-router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/model-router/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,KAAK,EAAE,MAAM,EAAa,MAAM,kBAAkB,CAAC;AAM1D,UAAU,SAAS;IACjB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC/B,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;CACf;AA8DD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAgBxE;AAED,6DAA6D;AAC7D,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAQ9F;AAMD,QAAA,MAAM,MAAM,EAAE,MAyKb,CAAC;eAEa,MAAM"}

package/dist/model-router.d.ts

@@ -1,69 +1,2 @@
-import { Plugin } from '@wrongstack/core';
-
-/**
- * model-router plugin — routes each provider call to a different model
- * based on declarative rules, on the wire.
- *
- * Like `llm-cache`, this registers an `AgentExtension.wrapProviderRunner`
- * (composed around EVERY provider call in the agent loop). Before the
- * request goes out, the plugin evaluates an ordered rule list against
- * the request's size and shape and rewrites `request.model` to the
- * first matching rule's target — e.g. small/tool-free turns to a cheap
- * fast model, large refactors to a capable one.
- *
- * IMPORTANT constraint: the active provider instance is fixed for the
- * session. Rerouting only works among models the CURRENT provider
- * serves (e.g. anthropic `haiku` ↔ `opus`). Routing to a model id the
- * provider doesn't recognize will fail at the provider — keep targets
- * within one provider's catalog.
- *
- * Safety posture: opt-in — loads inert until
- * `config.extensions['model-router'].enabled = true`. A `dryRun` mode
- * (default) only records what it WOULD route without changing the model,
- * so you can observe the routing before trusting it.
- *
- * Config (`config.extensions['model-router']`):
- *
- * ```jsonc
- * {
- *   "enabled": false,
- *   "dryRun": true,             // observe only; do not rewrite the model
- *   "rules": [
- *     { "maxChars": 2000, "hasTools": false, "model": "claude-haiku-4-5" },
- *     { "minChars": 40000, "model": "claude-opus-4-8" }
- *   ]
- * }
- * ```
- *
- * A rule matches when ALL of its present conditions hold. The first
- * matching rule wins; if none match, the request passes through with its
- * original model.
- *
- * Tools:
- *  - `model_router_status` — rules, mode, and per-target routing counts
- *
- * @public
- */
-
-interface RouteRule {
-    /** Match when the request's total char size is <= this. */
-    maxChars?: number | undefined;
-    /** Match when the request's total char size is >= this. */
-    minChars?: number | undefined;
-    /** Match when the request has (true) / lacks (false) tools. */
-    hasTools?: boolean | undefined;
-    /** The model id to route matching requests to (required). */
-    model: string;
-}
-/**
- * Total character size of the request's actual prompt text (system +
- * message content). Only counts `text` block values and bare-string
- * content — not structural fields like `type`/`role` — so the size is a
- * meaningful proxy for prompt weight.
- */
-declare function requestCharSize(request: Record<string, unknown>): number;
-/** First rule whose present conditions all hold, or null. */
-declare function pickRule(rules: RouteRule[], size: number, hasTools: boolean): RouteRule | null;
-declare const plugin: Plugin;
-
-export { plugin as default, pickRule, requestCharSize };
+export * from './model-router/index.js';
+export { default } from './model-router/index.js';

package/dist/model-router.js

@@ -199,5 +199,8 @@ var plugin = {
   }
 };
 var model_router_default = plugin;
-
-export { model_router_default as default, pickRule, requestCharSize };
+export {
+  model_router_default as default,
+  pickRule,
+  requestCharSize
+};

package/dist/notify-hub/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * notify-hub plugin — pushes session events to a webhook.
+ *
+ * Long-running autonomous sessions need a way to reach the user when
+ * something noteworthy happens and nobody is watching the terminal.
+ * notify-hub POSTs compact JSON payloads to a configurable webhook
+ * URL (Slack/Discord-compatible via generic JSON, n8n, ntfy, or any
+ * HTTP endpoint) for a configurable set of events:
+ *
+ *  - `session.stop`      — the agent loop ended (Stop hook)
+ *  - `tool.error`        — a tool invocation failed
+ *  - `budget.threshold`  — a budget threshold event fired on the bus
+ *
+ * Deliveries are fire-and-forget with a timeout — a dead webhook can
+ * never stall the agent. Failures are counted and reported via
+ * `notify_hub_status` / `health()`, and delivery stops trying after
+ * `maxConsecutiveFailures` (circuit breaker) until setup runs again.
+ *
+ * The agent can also send an ad-hoc notification with `notify_send`
+ * ("tell the user the migration finished").
+ *
+ * Config (`config.extensions['notify-hub']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "webhookUrl": "",                  // empty = plugin idles
+ *   "events": ["session.stop", "tool.error"],
+ *   "headers": {},                     // extra HTTP headers (auth…)
+ *   "timeoutMs": 5000,
+ *   "maxConsecutiveFailures": 5
+ * }
+ * ```
+ *
+ * Toggle off with `{ "name": "notify-hub", "enabled": false }` in
+ * `config.plugins`, or `"enabled": false` in the options above.
+ *
+ * @public
+ */
+import type { Plugin } from '@wrongstack/core';
+declare const plugin: Plugin;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/notify-hub/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/notify-hub/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA2L/C,QAAA,MAAM,MAAM,EAAE,MAsPb,CAAC;eAEa,MAAM"}

package/dist/notify-hub.d.ts

@@ -1,45 +1,2 @@
-import { Plugin } from '@wrongstack/core';
-
-/**
- * notify-hub plugin — pushes session events to a webhook.
- *
- * Long-running autonomous sessions need a way to reach the user when
- * something noteworthy happens and nobody is watching the terminal.
- * notify-hub POSTs compact JSON payloads to a configurable webhook
- * URL (Slack/Discord-compatible via generic JSON, n8n, ntfy, or any
- * HTTP endpoint) for a configurable set of events:
- *
- *  - `session.stop`      — the agent loop ended (Stop hook)
- *  - `tool.error`        — a tool invocation failed
- *  - `budget.threshold`  — a budget threshold event fired on the bus
- *
- * Deliveries are fire-and-forget with a timeout — a dead webhook can
- * never stall the agent. Failures are counted and reported via
- * `notify_hub_status` / `health()`, and delivery stops trying after
- * `maxConsecutiveFailures` (circuit breaker) until setup runs again.
- *
- * The agent can also send an ad-hoc notification with `notify_send`
- * ("tell the user the migration finished").
- *
- * Config (`config.extensions['notify-hub']`):
- *
- * ```jsonc
- * {
- *   "enabled": true,
- *   "webhookUrl": "",                  // empty = plugin idles
- *   "events": ["session.stop", "tool.error"],
- *   "headers": {},                     // extra HTTP headers (auth…)
- *   "timeoutMs": 5000,
- *   "maxConsecutiveFailures": 5
- * }
- * ```
- *
- * Toggle off with `{ "name": "notify-hub", "enabled": false }` in
- * `config.plugins`, or `"enabled": false` in the options above.
- *
- * @public
- */
-
-declare const plugin: Plugin;
-
-export { plugin as default };
+export * from './notify-hub/index.js';
+export { default } from './notify-hub/index.js';

package/dist/notify-hub.js

@@ -325,5 +325,6 @@ var plugin = {
   }
 };
 var notify_hub_default = plugin;
-
-export { notify_hub_default as default };
+export {
+  notify_hub_default as default
+};

package/dist/path-guard/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * path-guard plugin — blocks (or warns about) writes, edits, and
+ * destructive shell commands that touch protected paths.
+ *
+ * `branch-guard` protects git *branches*; this plugin protects
+ * *files and directories*. A `PreToolUse` hook on `write|edit|bash`
+ * matches the target path against a configurable glob list:
+ *
+ *  - `write` / `edit` → the `path` / `file_path` input field
+ *  - `bash`           → destructive commands only (`rm`, `rmdir`,
+ *    `mv`, `del`, output redirection `>` / `>>`, `truncate`) whose
+ *    arguments mention a protected path
+ *
+ * Default protected set: lockfiles, `.env*` secrets, `.git/`
+ * internals, and production migration folders — files an agent
+ * should virtually never rewrite by hand.
+ *
+ * Config (`config.extensions['path-guard']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "mode": "block",                     // "block" | "warn"
+ *   "protect": ["pnpm-lock.yaml", ".env*", ".git/**", "**/migrations/**"],
+ *   "allow": []                          // globs that override protect
+ * }
+ * ```
+ *
+ * Toggle off with `{ "name": "path-guard", "enabled": false }` in
+ * `config.plugins`, or `"enabled": false` in the options above.
+ *
+ * @public
+ */
+import type { Plugin } from '@wrongstack/core';
+/**
+ * Compile a glob pattern to a RegExp. Supports `**` (any depth),
+ * `*` (within one segment), and `?` (single char). Matching is done
+ * against forward-slash-normalized relative-ish paths, and a pattern
+ * without a slash matches the basename anywhere in the tree
+ * (`.env` matches `sub/dir/.env`).
+ */
+export declare function compilePathGlob(pattern: string): RegExp;
+/**
+ * Extract candidate target paths from a shell command, but only when
+ * the command looks destructive. Non-destructive commands (cat, ls,
+ * grep …) never trigger the guard, even if they mention a protected
+ * path.
+ */
+export declare function destructiveTargets(command: string): string[];
+declare const plugin: Plugin;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/path-guard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAwE/C;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAyBvD;AAWD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAuB5D;AAMD,QAAA,MAAM,MAAM,EAAE,MA8Kb,CAAC;eAEa,MAAM"}

package/dist/path-guard.d.ts

@@ -1,54 +1,2 @@
-import { Plugin } from '@wrongstack/core';
-
-/**
- * path-guard plugin — blocks (or warns about) writes, edits, and
- * destructive shell commands that touch protected paths.
- *
- * `branch-guard` protects git *branches*; this plugin protects
- * *files and directories*. A `PreToolUse` hook on `write|edit|bash`
- * matches the target path against a configurable glob list:
- *
- *  - `write` / `edit` → the `path` / `file_path` input field
- *  - `bash`           → destructive commands only (`rm`, `rmdir`,
- *    `mv`, `del`, output redirection `>` / `>>`, `truncate`) whose
- *    arguments mention a protected path
- *
- * Default protected set: lockfiles, `.env*` secrets, `.git/`
- * internals, and production migration folders — files an agent
- * should virtually never rewrite by hand.
- *
- * Config (`config.extensions['path-guard']`):
- *
- * ```jsonc
- * {
- *   "enabled": true,
- *   "mode": "block",                     // "block" | "warn"
- *   "protect": ["pnpm-lock.yaml", ".env*", ".git/**", "**/migrations/**"],
- *   "allow": []                          // globs that override protect
- * }
- * ```
- *
- * Toggle off with `{ "name": "path-guard", "enabled": false }` in
- * `config.plugins`, or `"enabled": false` in the options above.
- *
- * @public
- */
-
-/**
- * Compile a glob pattern to a RegExp. Supports `**` (any depth),
- * `*` (within one segment), and `?` (single char). Matching is done
- * against forward-slash-normalized relative-ish paths, and a pattern
- * without a slash matches the basename anywhere in the tree
- * (`.env` matches `sub/dir/.env`).
- */
-declare function compilePathGlob(pattern: string): RegExp;
-/**
- * Extract candidate target paths from a shell command, but only when
- * the command looks destructive. Non-destructive commands (cat, ls,
- * grep …) never trigger the guard, even if they mention a protected
- * path.
- */
-declare function destructiveTargets(command: string): string[];
-declare const plugin: Plugin;
-
-export { compilePathGlob, plugin as default, destructiveTargets };
+export * from './path-guard/index.js';
+export { default } from './path-guard/index.js';

package/dist/path-guard.js

@@ -236,5 +236,8 @@ var plugin = {
   }
 };
 var path_guard_default = plugin;
-
-export { compilePathGlob, path_guard_default as default, destructiveTargets };
+export {
+  compilePathGlob,
+  path_guard_default as default,
+  destructiveTargets
+};

package/dist/performance-regression-gate/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * performance-regression-gate plugin — compares benchmark results to detect
+ * performance regressions.
+ *
+ * Tool registered:
+ * - perf_regression_status : Reads `bench-results.json` in the project root
+ *   (or a supplied path) and reports benchmarks whose execution time (`mean`)
+ *   increased beyond the configured threshold.
+ *
+ * The tool supports two comparison modes:
+ * 1. Internal pairing: when only `resultsPath` is supplied, benchmarks named
+ *    with `(old)` and `(new)` suffixes are paired. This matches Vitest bench
+ *    output comparing an old implementation against a new one.
+ * 2. Cross-file comparison: when `baselinePath` is also supplied, benchmarks
+ *    are matched by name across the two files.
+ *
+ * Config (`config.extensions['performance-regression-gate']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "thresholdPercent": 10
+ * }
+ * ```
+ *
+ * @public
+ */
+import type { Plugin } from '@wrongstack/core';
+declare const plugin: Plugin;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/performance-regression-gate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/performance-regression-gate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAwO/C,QAAA,MAAM,MAAM,EAAE,MA8Mb,CAAC;eAEa,MAAM"}

package/dist/performance-regression-gate.d.ts

@@ -1,33 +1,2 @@
-import { Plugin } from '@wrongstack/core';
-
-/**
- * performance-regression-gate plugin — compares benchmark results to detect
- * performance regressions.
- *
- * Tool registered:
- * - perf_regression_status : Reads `bench-results.json` in the project root
- *   (or a supplied path) and reports benchmarks whose execution time (`mean`)
- *   increased beyond the configured threshold.
- *
- * The tool supports two comparison modes:
- * 1. Internal pairing: when only `resultsPath` is supplied, benchmarks named
- *    with `(old)` and `(new)` suffixes are paired. This matches Vitest bench
- *    output comparing an old implementation against a new one.
- * 2. Cross-file comparison: when `baselinePath` is also supplied, benchmarks
- *    are matched by name across the two files.
- *
- * Config (`config.extensions['performance-regression-gate']`):
- *
- * ```jsonc
- * {
- *   "enabled": true,
- *   "thresholdPercent": 10
- * }
- * ```
- *
- * @public
- */
-
-declare const plugin: Plugin;
-
-export { plugin as default };
+export * from './performance-regression-gate/index.js';
+export { default } from './performance-regression-gate/index.js';

package/dist/performance-regression-gate.js

@@ -1,7 +1,6 @@
-import { existsSync, readFileSync } from 'fs';
-import { resolve, isAbsolute, relative } from 'path';
-
 // src/performance-regression-gate/index.ts
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
 var API_VERSION = "^0.1.10";
 var state = {
   invocationCount: 0,
@@ -311,5 +310,6 @@ var plugin = {
   }
 };
 var performance_regression_gate_default = plugin;
-
-export { performance_regression_gate_default as default };
+export {
+  performance_regression_gate_default as default
+};

package/dist/plugin-stack-observer/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * plugin-stack-observer — observability over the providerRunner wrap stack.
+ *
+ * Several official plugins (llm-cache, model-router, prompt-firewall,
+ * token-throttle) register `AgentExtension.wrapProviderRunner` to
+ * intercept every provider call. The runtime composes them in
+ * registration order — but until now there was no way for an operator
+ * (or the LLM itself) to see WHICH wraps are active in what order.
+ *
+ * Each wrap plugin emits `customEvent('provider.wrap:loaded', …)` on
+ * setup. This plugin subscribes via `onPattern('provider.wrap:loaded')`
+ * and:
+ *
+ *   1. Builds an in-memory stack (preserves emission order)
+ *   2. Registers a system-prompt contributor that, when any wraps are
+ *      present, emits a compact one-line block listing them. The LLM
+ *      sees who is wrapping what, in registration order — making the
+ *      stack visible without /diag round-trips.
+ *
+ * Disabled by default (enabled=false) because not every user wants
+ * the LLM to be aware of the wrap stack. The plugin_stack tool is
+ * always registered so operators can read the stack at runtime
+ * regardless of the contributor setting.
+ *
+ * Tools registered:
+ *  - plugin_stack_status : Read the active wrap stack + load order
+ *
+ * @public
+ */
+import type { Plugin } from '@wrongstack/core';
+declare const PLUGIN: Plugin;
+export default PLUGIN;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugin-stack-observer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugin-stack-observer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAqC/C,QAAA,MAAM,MAAM,EAAE,MAyIb,CAAC;eAoBa,MAAM"}