@wrongstack/plugins 0.277.1 → 0.280.0

package/dist/token-budget.js

@@ -0,0 +1,254 @@
+// src/token-budget/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  totalTokens: 0,
+  totalPromptTokens: 0,
+  totalCompletionTokens: 0,
+  requestCount: 0,
+  /** Whether the warning has already fired (one-shot). */
+  warningFired: false,
+  /** Whether the stop has already fired (one-shot). */
+  stopFired: false,
+  /** Whether the warning context has been injected into the LLM (one-shot). */
+  warnContextInjected: false,
+  /** Whether the stop context has been injected into the LLM (one-shot). */
+  stopContextInjected: false,
+  /** Stop hook unregister handle. */
+  hookUnregister: null,
+  /** PostToolUse hook unregister handle. */
+  postHookUnregister: null,
+  /** Last token breakdown — surfaced by health(). */
+  lastRequest: null
+};
+var DEFAULTS = {
+  limit: 0,
+  warnPercent: 80,
+  stopPercent: 100,
+  model: ""
+};
+function modelMatches(pattern, model) {
+  if (pattern === "") return true;
+  if (pattern.endsWith("*")) {
+    const prefix = pattern.slice(0, -1).toLowerCase();
+    return model.toLowerCase().startsWith(prefix);
+  }
+  return model.toLowerCase() === pattern.toLowerCase();
+}
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    limit: typeof r["limit"] === "number" ? r["limit"] : DEFAULTS.limit,
+    warnPercent: typeof r["warnPercent"] === "number" ? r["warnPercent"] : DEFAULTS.warnPercent,
+    stopPercent: typeof r["stopPercent"] === "number" ? r["stopPercent"] : DEFAULTS.stopPercent,
+    model: typeof r["model"] === "string" ? r["model"] : ""
+  };
+}
+var plugin = {
+  name: "token-budget",
+  version: "0.1.0",
+  description: "Enforces a per-session token budget \u2014 warns at a threshold and stops the agent loop when the limit is hit",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      limit: {
+        type: "number",
+        minimum: 0,
+        default: 0,
+        description: "Hard token limit (prompt + completion combined). 0 = disabled (tracking only)."
+      },
+      warnPercent: {
+        type: "number",
+        minimum: 1,
+        maximum: 100,
+        default: 80,
+        description: 'Percentage of limit at which to inject a "wrap up" context signal.'
+      },
+      stopPercent: {
+        type: "number",
+        minimum: 1,
+        maximum: 100,
+        default: 100,
+        description: "Percentage of limit at which to trigger Stop (end the agent loop)."
+      },
+      model: {
+        type: "string",
+        default: "",
+        description: 'Restrict counting to a specific model. Supports "*" trailing wildcard (e.g. "gpt-4*" matches gpt-4o, gpt-4o-mini). Empty string = count all models.'
+      }
+    }
+  },
+  setup(api) {
+    state.totalTokens = 0;
+    state.totalPromptTokens = 0;
+    state.totalCompletionTokens = 0;
+    state.requestCount = 0;
+    state.warningFired = false;
+    state.stopFired = false;
+    state.warnContextInjected = false;
+    state.stopContextInjected = false;
+    state.hookUnregister = null;
+    state.postHookUnregister = null;
+    state.lastRequest = null;
+    const cfg = readConfig(api.config.extensions?.["token-budget"]);
+    api.onEvent("provider.response", (payload) => {
+      const p = payload;
+      const usage = p?.usage;
+      if (!usage) return;
+      if (cfg.model !== "" && p?.ctx?.model !== void 0) {
+        const model = p.ctx.model;
+        if (!modelMatches(cfg.model, model)) return;
+      }
+      const promptTokens = usage.input ?? 0;
+      const completionTokens = usage.output ?? 0;
+      const total = promptTokens + completionTokens;
+      state.totalPromptTokens += promptTokens;
+      state.totalCompletionTokens += completionTokens;
+      state.totalTokens += total;
+      state.requestCount += 1;
+      state.lastRequest = {
+        model: p?.ctx?.model ?? "unknown",
+        prompt: promptTokens,
+        completion: completionTokens,
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (cfg.limit <= 0) return;
+      const percent = state.totalTokens / cfg.limit * 100;
+      if (!state.warningFired && percent >= cfg.warnPercent && percent < cfg.stopPercent) {
+        state.warningFired = true;
+        const remaining = cfg.limit - state.totalTokens;
+        api.log.info("token-budget: warning threshold reached", {
+          percent: Math.round(percent),
+          remaining
+        });
+        api.emitCustom("token-budget:warning", {
+          percent: Math.round(percent),
+          remaining,
+          total: state.totalTokens,
+          limit: cfg.limit
+        });
+      }
+      if (!state.stopFired && percent >= cfg.stopPercent) {
+        state.stopFired = true;
+        api.log.warn("token-budget: hard limit reached \u2014 agent loop will be stopped", {
+          total: state.totalTokens,
+          limit: cfg.limit
+        });
+        api.emitCustom("token-budget:limit_reached", {
+          total: state.totalTokens,
+          limit: cfg.limit
+        });
+      }
+    });
+    state.hookUnregister = api.registerHook("Stop", void 0, () => {
+      if (cfg.limit <= 0 || !state.stopFired) return;
+      return {
+        decision: "block",
+        reason: `token-budget: session token limit reached (${state.totalTokens.toLocaleString()} / ${cfg.limit.toLocaleString()} tokens). The budget is exhausted \u2014 wrap up the current task and summarize what was accomplished.`
+      };
+    });
+    state.postHookUnregister = api.registerHook("PostToolUse", "*", () => {
+      if (cfg.limit <= 0) return;
+      const percent = Math.round(state.totalTokens / cfg.limit * 100);
+      const remaining = Math.max(cfg.limit - state.totalTokens, 0);
+      if (state.stopFired && !state.stopContextInjected) {
+        state.stopContextInjected = true;
+        return {
+          additionalContext: `
+\u{1F6D1} token-budget: HARD LIMIT REACHED \u2014 ${state.totalTokens.toLocaleString()} / ${cfg.limit.toLocaleString()} tokens (${percent}%). You must stop here. Do NOT start any new task. Summarize what was accomplished and list any remaining work.`
+        };
+      }
+      if (state.warningFired && !state.warnContextInjected) {
+        state.warnContextInjected = true;
+        return {
+          additionalContext: `
+\u26A0\uFE0F token-budget: ${percent}% of budget used (${state.totalTokens.toLocaleString()} / ${cfg.limit.toLocaleString()} tokens, ${remaining.toLocaleString()} remaining). Start wrapping up \u2014 prioritize finishing the current task over starting new ones.`
+        };
+      }
+      return;
+    });
+    api.tools.register({
+      name: "token_budget_status",
+      description: "Shows the current token budget status: limit, consumed, remaining, percentage, and whether warning/stop thresholds have been crossed.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Meta",
+      mutating: false,
+      async execute() {
+        const consumed = state.totalTokens;
+        const limit = cfg.limit;
+        const percent = limit > 0 ? Math.round(consumed / limit * 100) : 0;
+        const remaining = limit > 0 ? Math.max(limit - consumed, 0) : Infinity;
+        return {
+          ok: true,
+          limit,
+          consumed,
+          remaining,
+          percent,
+          requestCount: state.requestCount,
+          breakdown: {
+            prompt: state.totalPromptTokens,
+            completion: state.totalCompletionTokens
+          },
+          warningFired: state.warningFired,
+          stopFired: state.stopFired,
+          lastRequest: state.lastRequest
+        };
+      }
+    });
+    api.log.info("token-budget plugin loaded", {
+      version: "0.1.0",
+      limit: cfg.limit > 0 ? cfg.limit.toLocaleString() : "unlimited",
+      warnPercent: cfg.warnPercent,
+      stopPercent: cfg.stopPercent
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    if (state.postHookUnregister) {
+      try {
+        state.postHookUnregister();
+      } catch {
+      }
+      state.postHookUnregister = null;
+    }
+    const final = {
+      totalTokens: state.totalTokens,
+      requestCount: state.requestCount,
+      warningFired: state.warningFired,
+      stopFired: state.stopFired
+    };
+    state.totalTokens = 0;
+    state.totalPromptTokens = 0;
+    state.totalCompletionTokens = 0;
+    state.requestCount = 0;
+    state.warningFired = false;
+    state.stopFired = false;
+    state.warnContextInjected = false;
+    state.stopContextInjected = false;
+    state.lastRequest = null;
+    api.log.info("token-budget: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastRequest === null ? `token-budget: ${state.totalTokens.toLocaleString()} tokens across ${state.requestCount} request(s)` : `token-budget: ${state.totalTokens.toLocaleString()} tokens, last ${state.lastRequest.model} at ${state.lastRequest.when}`,
+      totalTokens: state.totalTokens,
+      requestCount: state.requestCount,
+      warningFired: state.warningFired,
+      stopFired: state.stopFired
+    };
+  }
+};
+var token_budget_default = plugin;
+
+export { token_budget_default as default };

package/dist/token-throttle.d.ts

@@ -0,0 +1,54 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * token-throttle plugin — enforces a rolling-window token budget on the
+ * provider wire, delaying calls to stay under a rate limit.
+ *
+ * Registers an `AgentExtension.wrapProviderRunner`. Before each provider
+ * call it prunes a 60-second sliding window of recorded spend, estimates
+ * the outgoing request's tokens, and if the window's spend plus the
+ * estimate would exceed `tokensPerMinute`, it sleeps just long enough for
+ * older spend to age out of the window (capped at `maxDelayMs`). After
+ * the call it records the response's actual usage. This smooths bursty
+ * agent loops under a provider's TPM limit instead of hitting 429s.
+ *
+ * Safety posture: opt-in — loads inert until
+ * `config.extensions['token-throttle'].enabled = true`. Delay is bounded
+ * by `maxDelayMs` so a mis-set budget can never hang the agent
+ * indefinitely.
+ *
+ * Config (`config.extensions['token-throttle']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": false,
+ *   "tokensPerMinute": 100000,  // rolling-window budget
+ *   "maxDelayMs": 30000,        // hard cap on any single wait
+ *   "charsPerToken": 4          // request-size → token estimate divisor
+ * }
+ * ```
+ *
+ * Tools:
+ *  - `token_throttle_status` — window spend, throttle counters, total delay
+ *
+ * @public
+ */
+
+interface SpendEntry {
+    at: number;
+    tokens: number;
+}
+/** Drop entries older than the 60s window relative to `now`. */
+declare function pruneWindow(entries: SpendEntry[], now: number): SpendEntry[];
+/** Sum tokens currently in the window. */
+declare function windowSpend(entries: SpendEntry[]): number;
+/**
+ * Delay (ms) needed before a request of `projected` tokens can proceed
+ * without the window exceeding `limit`. 0 when it already fits. Computed
+ * by aging out just enough of the oldest spend: we find the earliest
+ * point at which enough tokens have expired to make room.
+ */
+declare function computeThrottleDelay(entries: SpendEntry[], now: number, limit: number, projected: number): number;
+declare const plugin: Plugin;
+
+export { type SpendEntry, computeThrottleDelay, plugin as default, pruneWindow, windowSpend };

package/dist/token-throttle.js

@@ -0,0 +1,203 @@
+// src/token-throttle/index.ts
+var WINDOW_MS = 6e4;
+var DEFAULTS = {
+  enabled: false,
+  tokensPerMinute: 1e5,
+  maxDelayMs: 3e4,
+  charsPerToken: 4
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] === true,
+    tokensPerMinute: typeof r["tokensPerMinute"] === "number" && r["tokensPerMinute"] > 0 ? r["tokensPerMinute"] : DEFAULTS.tokensPerMinute,
+    maxDelayMs: typeof r["maxDelayMs"] === "number" && r["maxDelayMs"] >= 0 ? r["maxDelayMs"] : DEFAULTS.maxDelayMs,
+    charsPerToken: typeof r["charsPerToken"] === "number" && r["charsPerToken"] >= 1 ? r["charsPerToken"] : DEFAULTS.charsPerToken
+  };
+}
+function pruneWindow(entries, now) {
+  return entries.filter((e) => now - e.at < WINDOW_MS);
+}
+function windowSpend(entries) {
+  return entries.reduce((sum, e) => sum + e.tokens, 0);
+}
+function computeThrottleDelay(entries, now, limit, projected) {
+  const current = windowSpend(entries);
+  if (current + projected <= limit) return 0;
+  const mustFree = current + projected - limit;
+  const sorted = [...entries].sort((a, b) => a.at - b.at);
+  let freed = 0;
+  for (const e of sorted) {
+    freed += e.tokens;
+    if (freed >= mustFree) {
+      const leavesAt = e.at + WINDOW_MS;
+      return Math.max(0, leavesAt - now);
+    }
+  }
+  const oldest = sorted[0];
+  return oldest ? Math.max(0, oldest.at + WINDOW_MS - now) : 0;
+}
+var state = {
+  window: [],
+  invocations: 0,
+  throttled: 0,
+  totalDelayMs: 0,
+  extensionUnregister: null
+};
+function estimateRequestTokens(request, charsPerToken) {
+  let chars = 0;
+  const walk = (v) => {
+    if (typeof v === "string") chars += v.length;
+    else if (Array.isArray(v)) for (const i of v) walk(i);
+    else if (v && typeof v === "object") {
+      const o = v;
+      if (typeof o["text"] === "string") chars += o["text"].length;
+      if (o["content"] !== void 0) walk(o["content"]);
+    }
+  };
+  walk(request["system"]);
+  walk(request["messages"]);
+  return Math.ceil(chars / charsPerToken);
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var plugin = {
+  name: "token-throttle",
+  version: "0.1.0",
+  description: "Rolling-window tokens/min budget that delays provider calls to stay under a rate limit (wrapProviderRunner). Opt-in; delay capped by maxDelayMs.",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: false,
+        description: "Master switch. OFF by default because throttling injects delays into provider calls."
+      },
+      tokensPerMinute: {
+        type: "number",
+        minimum: 1,
+        default: 1e5,
+        description: "Rolling 60s-window token budget."
+      },
+      maxDelayMs: {
+        type: "number",
+        minimum: 0,
+        default: 3e4,
+        description: "Hard cap on any single throttle wait so a mis-set budget cannot hang the agent."
+      },
+      charsPerToken: {
+        type: "number",
+        minimum: 1,
+        default: 4,
+        description: "Divisor turning request char size into a token estimate."
+      }
+    }
+  },
+  setup(api) {
+    state.window = [];
+    state.invocations = 0;
+    state.throttled = 0;
+    state.totalDelayMs = 0;
+    if (state.extensionUnregister) {
+      try {
+        state.extensionUnregister();
+      } catch {
+      }
+      state.extensionUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["token-throttle"]);
+    if (cfg.enabled) {
+      state.extensionUnregister = api.extensions.register({
+        name: "token-throttle",
+        owner: "token-throttle",
+        async wrapProviderRunner(_ctx, request, inner) {
+          const req = request ?? {};
+          state.invocations += 1;
+          const now = Date.now();
+          state.window = pruneWindow(state.window, now);
+          const projected = estimateRequestTokens(req, cfg.charsPerToken);
+          const rawDelay = computeThrottleDelay(state.window, now, cfg.tokensPerMinute, projected);
+          const delay = Math.min(rawDelay, cfg.maxDelayMs);
+          if (delay > 0) {
+            state.throttled += 1;
+            state.totalDelayMs += delay;
+            api.metrics.counter("throttled");
+            api.metrics.histogram("delay_ms", delay);
+            api.log.info("token-throttle: delaying provider call", { delayMs: delay, projected });
+            await sleep(delay);
+          }
+          const response = await inner(_ctx, request);
+          const used = (response?.usage?.input ?? 0) + (response?.usage?.output ?? 0) || projected;
+          state.window.push({ at: Date.now(), tokens: used });
+          return response;
+        }
+      });
+    }
+    api.tools.register({
+      name: "token_throttle_status",
+      description: "Reports token-throttle state: window spend, throttle counters, and total injected delay.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        const now = Date.now();
+        const live = pruneWindow(state.window, now);
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          tokensPerMinute: cfg.tokensPerMinute,
+          maxDelayMs: cfg.maxDelayMs,
+          windowSpend: windowSpend(live),
+          windowEntries: live.length,
+          counters: {
+            invocations: state.invocations,
+            throttled: state.throttled,
+            totalDelayMs: state.totalDelayMs
+          }
+        };
+      }
+    });
+    api.log.info("token-throttle plugin loaded", {
+      version: "0.1.0",
+      enabled: cfg.enabled,
+      tokensPerMinute: cfg.tokensPerMinute
+    });
+  },
+  teardown(api) {
+    if (state.extensionUnregister) {
+      try {
+        state.extensionUnregister();
+      } catch {
+      }
+      state.extensionUnregister = null;
+    }
+    const final = {
+      invocations: state.invocations,
+      throttled: state.throttled,
+      totalDelayMs: state.totalDelayMs
+    };
+    state.window = [];
+    state.invocations = 0;
+    state.throttled = 0;
+    state.totalDelayMs = 0;
+    api.log.info("token-throttle: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: `token-throttle: ${state.throttled} throttle(s) of ${state.invocations} call(s), ${state.totalDelayMs}ms total delay`,
+      counters: {
+        invocations: state.invocations,
+        throttled: state.throttled,
+        totalDelayMs: state.totalDelayMs
+      }
+    };
+  }
+};
+var token_throttle_default = plugin;
+
+export { computeThrottleDelay, token_throttle_default as default, pruneWindow, windowSpend };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wrongstack/plugins",
-  "version": "0.277.1",
-  "description": "Official WrongStack plugin collection — auto-doc, git-autocommit, shell-check, cost-tracker, file-watcher, web-search, json-path, cron, template-engine, semver-bump",
+  "version": "0.280.0",
+  "description": "Official WrongStack plugin collection — auto-doc, git-autocommit, shell-check, cost-tracker, file-watcher, cron, template-engine, semver-bump, secret-scanner, todo-tracker, token-budget, lint-gate, branch-guard, diff-summary, commit-validator, format-on-save, test-runner-gate, import-organizer, todo-listener, session-recap, spec-linker, loop-breaker, path-guard, context-pins, checkpoint, error-lens, dep-guard, config-validator, notify-hub, changelog-writer, injection-shield, llm-cache, model-router, prompt-firewall, auto-escalate, token-throttle",
   "license": "MIT",
   "author": "ECOSTACK TECHNOLOGY OÜ",
   "type": "module",
@@ -32,14 +32,6 @@
       "types": "./dist/file-watcher.d.ts",
       "import": "./dist/file-watcher.js"
     },
-    "./web-search": {
-      "types": "./dist/web-search.d.ts",
-      "import": "./dist/web-search.js"
-    },
-    "./json-path": {
-      "types": "./dist/json-path.d.ts",
-      "import": "./dist/json-path.js"
-    },
     "./cron": {
       "types": "./dist/cron.d.ts",
       "import": "./dist/cron.js"
@@ -51,6 +43,118 @@
     "./semver-bump": {
       "types": "./dist/semver-bump.d.ts",
       "import": "./dist/semver-bump.js"
+    },
+    "./secret-scanner": {
+      "types": "./dist/secret-scanner.d.ts",
+      "import": "./dist/secret-scanner.js"
+    },
+    "./todo-tracker": {
+      "types": "./dist/todo-tracker.d.ts",
+      "import": "./dist/todo-tracker.js"
+    },
+    "./token-budget": {
+      "types": "./dist/token-budget.d.ts",
+      "import": "./dist/token-budget.js"
+    },
+    "./lint-gate": {
+      "types": "./dist/lint-gate.d.ts",
+      "import": "./dist/lint-gate.js"
+    },
+    "./branch-guard": {
+      "types": "./dist/branch-guard.d.ts",
+      "import": "./dist/branch-guard.js"
+    },
+    "./diff-summary": {
+      "types": "./dist/diff-summary.d.ts",
+      "import": "./dist/diff-summary.js"
+    },
+    "./commit-validator": {
+      "types": "./dist/commit-validator.d.ts",
+      "import": "./dist/commit-validator.js"
+    },
+    "./format-on-save": {
+      "types": "./dist/format-on-save.d.ts",
+      "import": "./dist/format-on-save.js"
+    },
+    "./test-runner-gate": {
+      "types": "./dist/test-runner-gate.d.ts",
+      "import": "./dist/test-runner-gate.js"
+    },
+    "./import-organizer": {
+      "types": "./dist/import-organizer.d.ts",
+      "import": "./dist/import-organizer.js"
+    },
+    "./todo-listener": {
+      "types": "./dist/todo-listener.d.ts",
+      "import": "./dist/todo-listener.js"
+    },
+    "./session-recap": {
+      "types": "./dist/session-recap.d.ts",
+      "import": "./dist/session-recap.js"
+    },
+    "./spec-linker": {
+      "types": "./dist/spec-linker.d.ts",
+      "import": "./dist/spec-linker.js"
+    },
+    "./loop-breaker": {
+      "types": "./dist/loop-breaker.d.ts",
+      "import": "./dist/loop-breaker.js"
+    },
+    "./path-guard": {
+      "types": "./dist/path-guard.d.ts",
+      "import": "./dist/path-guard.js"
+    },
+    "./context-pins": {
+      "types": "./dist/context-pins.d.ts",
+      "import": "./dist/context-pins.js"
+    },
+    "./checkpoint": {
+      "types": "./dist/checkpoint.d.ts",
+      "import": "./dist/checkpoint.js"
+    },
+    "./error-lens": {
+      "types": "./dist/error-lens.d.ts",
+      "import": "./dist/error-lens.js"
+    },
+    "./dep-guard": {
+      "types": "./dist/dep-guard.d.ts",
+      "import": "./dist/dep-guard.js"
+    },
+    "./config-validator": {
+      "types": "./dist/config-validator.d.ts",
+      "import": "./dist/config-validator.js"
+    },
+    "./notify-hub": {
+      "types": "./dist/notify-hub.d.ts",
+      "import": "./dist/notify-hub.js"
+    },
+    "./changelog-writer": {
+      "types": "./dist/changelog-writer.d.ts",
+      "import": "./dist/changelog-writer.js"
+    },
+    "./injection-shield": {
+      "types": "./dist/injection-shield.d.ts",
+      "import": "./dist/injection-shield.js"
+    },
+    "./llm-cache": {
+      "types": "./dist/llm-cache.d.ts",
+      "import": "./dist/llm-cache.js"
+    },
+    "./model-router": {
+      "types": "./dist/model-router.d.ts",
+      "import": "./dist/model-router.js"
+    },
+    "./prompt-firewall": {
+      "types": "./dist/prompt-firewall.d.ts",
+      "import": "./dist/prompt-firewall.js"
+    },
+    "./auto-escalate": {
+      "types": "./dist/auto-escalate.d.ts",
+      "import": "./dist/auto-escalate.js"
+    },
+    "./token-throttle": {
+      "types": "./dist/token-throttle.d.ts",
+      "import": "./dist/token-throttle.js"
     }
   },
   "files": [
@@ -63,8 +167,8 @@
     "vitest": "^4.1.9"
   },
   "dependencies": {
-    "@wrongstack/tools": "0.277.1",
-    "@wrongstack/core": "0.277.1"
+    "@wrongstack/core": "0.280.0",
+    "@wrongstack/tools": "0.280.0"
   },
   "scripts": {
     "build": "tsup",

package/dist/json-path.d.ts

@@ -1,18 +0,0 @@
-import { Plugin } from '@wrongstack/core';
-
-/**
- * json-path plugin — RETIRED.
- *
- * The four tools this plugin previously registered (`jmespath_query`,
- * `json_validate`, `json_transform`, `json_merge`) have been consolidated
- * into the built-in `json` tool (packages/tools/src/json.ts) via its
- * `action` parameter.
- *
- * This file remains as a no-op stub so existing config references
- * (`"json-path": { "enabled": true }`) do not break. It registers no
- * tools and logs a deprecation notice on load.
- */
-
-declare const plugin: Plugin;
-
-export { plugin as default };