@wrongstack/plugins 0.308.6 → 0.309.0

package/dist/release-notes-generator.js

@@ -2,41 +2,12 @@
 import { execFile } from "node:child_process";
 
 // src/runtime/llm.ts
-function stripOuterMarkdownFence(text) {
-  const trimmed = text.trim();
-  const match = trimmed.match(/^```(?:[a-z0-9_-]+)?\s*\r?\n([\s\S]*?)\r?\n```$/i);
-  return (match?.[1] ?? trimmed).trim();
-}
-async function runOptionalPluginLlm(request) {
-  if (!request.requested) {
-    return { used: false, value: null, fallbackReason: "not-requested" };
-  }
-  if (!request.api.llm) {
-    return { used: false, value: null, fallbackReason: "unavailable" };
-  }
-  if (request.options?.signal?.aborted) {
-    return { used: false, value: null, fallbackReason: "cancelled" };
-  }
-  try {
-    const response = await request.api.llm.complete(request.prompt, request.options);
-    const parsed = request.parse(response.text);
-    if (parsed === null) {
-      request.api.log.warn(`${request.label}: ignored invalid LLM response`);
-      return { used: false, value: null, fallbackReason: "invalid-response" };
-    }
-    return { used: true, value: parsed, fallbackReason: null };
-  } catch (error) {
-    const cancelled = request.options?.signal?.aborted === true;
-    request.api.log.warn(`${request.label}: LLM enrichment failed; using deterministic fallback`, {
-      error: error instanceof Error ? error.message : String(error)
-    });
-    return {
-      used: false,
-      value: null,
-      fallbackReason: cancelled ? "cancelled" : "provider-error"
-    };
-  }
-}
+import {
+  parseLlmJsonObject,
+  runOptionalPluginCouncil,
+  runOptionalPluginLlm,
+  stripOuterMarkdownFence
+} from "@wrongstack/plugin-sdk/runtime";
 
 // src/release-notes-generator/index.ts
 var API_VERSION = "^0.1.10";

package/dist/runtime/bounded-map.d.ts

@@ -1,86 +1,3 @@
-/**
- * @wrongstack/plugins — bounded key/value cache.
- *
- * Several plugins memoise per-path or per-model work in a module-scope
- * `Map` that is only ever cleared at teardown. In a short test that is
- * invisible; in a long session over a large repository it is a slow leak —
- * one entry per file touched, per branch resolved, per model seen — held
- * for the lifetime of the process.
- *
- * `BoundedMap` is a drop-in replacement for those maps: same `get`/`set`/
- * `delete`/`clear`/`size` surface, plus a hard entry cap with
- * least-recently-used eviction and an optional per-entry TTL. Nothing
- * about the call sites has to change beyond the constructor.
- *
- * Why LRU rather than insertion-order eviction: the access pattern for
- * these caches is "a few hot paths, a long tail of cold ones". Evicting by
- * insertion order throws away the hot entries first, which is exactly
- * backwards; re-reading a hot entry should keep it.
- */
-export interface BoundedMapOptions {
-    /** Hard cap on retained entries. Must be a safe integer >= 1. */
-    max: number;
-    /**
-     * Optional per-entry lifetime in ms. An entry older than this is treated
-     * as absent by `get`/`has` and dropped on access. Omit for no expiry.
-     */
-    ttlMs?: number | undefined;
-    /** Clock injection point — tests override this instead of faking timers. */
-    now?: (() => number) | undefined;
-}
-export declare class BoundedMap<K, V> {
-    private readonly map;
-    private readonly max;
-    private readonly ttlMs;
-    private readonly now;
-    /** Entries dropped to stay under `max`. Surfaced by plugin health(). */
-    private evictions;
-    constructor(options: BoundedMapOptions);
-    private expired;
-    get(key: K): V | undefined;
-    /**
-     * Read without promoting the key to most-recently-used. Use for
-     * diagnostics that must not perturb the eviction order.
-     */
-    peek(key: K): V | undefined;
-    has(key: K): boolean;
-    set(key: K, value: V): this;
-    delete(key: K): boolean;
-    clear(): void;
-    get size(): number;
-    /** How many entries have been dropped to respect `max`, since the last clear. */
-    get evictionCount(): number;
-    /** Drop every expired entry. Cheap enough to call from a status tool. */
-    prune(): number;
-    /** Live (non-expired) entries, coldest first. */
-    entries(): IterableIterator<[K, V]>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-}
-/**
- * A `Set` with the same hard cap and LRU eviction as {@link BoundedMap}.
- *
- * Plugins use module-scope sets to remember "already reported" keys so a
- * finding is surfaced once rather than on every scan. That set has to
- * outlive a single scan, which is why it lives at module scope — but
- * without a bound it grows one entry per distinct finding for the life of
- * the process.
- *
- * Eviction means a very old key may eventually be reported a second time.
- * That is the right trade: re-reporting a finding the user last saw
- * thousands of findings ago is reasonable behaviour, whereas unbounded
- * growth is not.
- */
-export declare class BoundedSet<T> {
-    private readonly inner;
-    constructor(options: BoundedMapOptions);
-    has(value: T): boolean;
-    add(value: T): this;
-    delete(value: T): boolean;
-    clear(): void;
-    get size(): number;
-    /** How many entries have been dropped to respect `max`, since the last clear. */
-    get evictionCount(): number;
-    values(): IterableIterator<T>;
-    [Symbol.iterator](): IterableIterator<T>;
-}
+/** Shim: implementation moved to @wrongstack/plugin-sdk/runtime. */
+export { BoundedMap, BoundedSet, type BoundedMapOptions } from '@wrongstack/plugin-sdk/runtime';
 //# sourceMappingURL=bounded-map.d.ts.map

package/dist/runtime/credential-patterns.d.ts

@@ -1,42 +1,3 @@
-/**
- * @wrongstack/plugins — canonical credential-pattern table.
- *
- * Two plugins detect credentials, at different points in the pipeline:
- *
- *  - `secret-scanner` gates tool *input* and inspects tool *output*.
- *  - `prompt-firewall` inspects the outgoing *provider request* (and the
- *    response) so a credential sitting in context is not shipped to a
- *    third party.
- *
- * They previously each carried their own pattern list. The lists drifted:
- * one grew GitLab, npm, SendGrid and DigitalOcean coverage while the other
- * did not, so which credentials were caught depended on which side of the
- * pipeline they crossed. A credential is a credential — the two surfaces
- * should never disagree about what one looks like.
- *
- * This module is the single source of truth. Adding a pattern here
- * strengthens both surfaces at once.
- *
- * Style notes for new entries:
- *  - Prefer explicit lookaround boundaries — `(?<![A-Za-z0-9])` /
- *    `(?![A-Za-z0-9])` — over ``. `` is defined against word
- *    characters, so it silently fails next to the `+`, `/` and `=` that
- *    base64-shaped secrets routinely end with.
- *  - Keep every group non-capturing (`(?:…)`). The combined regex maps a
- *    capture-group index back to the pattern that fired; an inner group
- *    shifts that mapping. `secret-scanner` compensates for user-supplied
- *    patterns, but built-ins should not need it.
- *  - Avoid unbounded `.*` lookarounds: these run on every provider
- *    request, against the full context.
- */
-/** One credential shape, with a stable machine-readable id. */
-export interface CredentialPattern {
-    /** Stable id, e.g. `github_pat`. Reported to users and in metrics. */
-    type: string;
-    /** Global-flagged matcher. */
-    regex: RegExp;
-}
-export declare const CREDENTIAL_PATTERNS: readonly CredentialPattern[];
-/** Fresh, independently-stateful copies (RegExp `lastIndex` is mutable). */
-export declare function cloneCredentialPatterns(): CredentialPattern[];
+/** Shim: implementation moved to @wrongstack/plugin-sdk/runtime. */
+export { cloneCredentialPatterns, CREDENTIAL_PATTERNS, type CredentialPattern, } from '@wrongstack/plugin-sdk/runtime';
 //# sourceMappingURL=credential-patterns.d.ts.map

package/dist/runtime/h1-state.d.ts

@@ -1,62 +1,3 @@
-/**
- * H1 idempotent state — single-slot plugin state with a registry of
- * releasable handles that survives `setup()` reload cycles.
- *
- * The "H1 audit pattern" (per SAGE memory T-03) is documented across
- * the plugin suite: a plugin's module-scope `state` object holds
- * counters plus a `hookUnregister` (or `extensionUnregister`) slot;
- * on reload, the slot MUST be released before a new one is stored.
- * Every plugin implements this inline with subtle variations:
- *
- *   - some use `releaseHandle(state.hookUnregister)` (`accessibility-auditor`)
- *   - some use `try { state.hookUnregister(); } catch {}` (`config-validator`)
- *   - some use a single inline `if (state.hookUnregister) { … }` block
- *
- * The drift cost: in 4 plugins the prior handle was leaked on reload
- * because the inline `if` check raced with the new registration.
- * This helper centralises the contract.
- *
- * Contract:
- *   `createH1State<T>(initial)` returns
- *     {
- *       state:    T,                    // the user's mutable state
- *       register: (key, unregister) => void,
- *       release:  (key) => void,
- *       releaseAll: () => void,
- *     }
- *
- * - `register(key, unregister)` releases any prior handle at `key`
- *   before storing the new one.
- * - `release(key)` is a no-op if no handle is registered.
- * - `releaseAll()` releases every registered handle and clears the map.
- * - A throwing unregister function is swallowed (best-effort), matching
- *   the existing `releaseHandle` semantics at `runtime/handles.ts`.
- *
- * The state object itself is NOT reset by `releaseAll` — counter
- * reset is the plugin's responsibility (it knows the semantics of its
- * counters). This helper owns the handle lifecycle only.
- */
-export type Unregister = () => void;
-export interface H1State<T> {
-    /** The plugin's mutable state. Owned by the caller; never reset by this helper. */
-    state: T;
-    /**
-     * Register an unregister function under `key`. Any prior handle at
-     * `key` is released first. Throwing unregister functions are
-     * swallowed.
-     */
-    register: (key: string, unregister: Unregister | null | undefined) => void;
-    /**
-     * Release the handle at `key` (if any). Idempotent. Throwing
-     * unregister functions are swallowed.
-     */
-    release: (key: string) => void;
-    /** Release every registered handle. Idempotent. */
-    releaseAll: () => void;
-    /** Number of currently registered handles. Observability for health()/status tools. */
-    size: () => number;
-    /** List the registered keys. Order is insertion order; useful for diagnostics. */
-    keys: () => string[];
-}
-export declare function createH1State<T>(initial: T): H1State<T>;
+/** Shim: implementation moved to @wrongstack/plugin-sdk/runtime. */
+export { createH1State, type H1State } from '@wrongstack/plugin-sdk/runtime';
 //# sourceMappingURL=h1-state.d.ts.map

package/dist/runtime/handles.d.ts

@@ -1,46 +1,3 @@
-/**
- * @wrongstack/plugins — unregister-handle discipline.
- *
- * Plugins keep their hook/listener unregister functions in module-scope
- * state, and every plugin's `setup()` is expected to be idempotent: calling
- * it twice must not leave two live registrations. The house style calls
- * this the "H1 pattern".
- *
- * The failure mode this helper exists to prevent is subtle and was present
- * in ~15 plugins: `setup()` reset the handle with
- *
- * ```ts
- * state.hookUnregister = null;   // WRONG
- * ```
- *
- * which drops the only reference to the *previous* registration without
- * calling it. The old hook stays live in the registry, unreachable, and
- * fires alongside the new one — so counters double, warnings appear twice,
- * and a gate can block on a stale closure holding the previous config.
- *
- * `releaseHandle` makes the correct spelling a one-liner with the same
- * shape as the wrong one, so the two are hard to confuse:
- *
- * ```ts
- * state.hookUnregister = releaseHandle(state.hookUnregister);
- * ```
- */
-/** An unregister function returned by `registerHook`/`onEvent`/etc. */
-export type Unregister = (() => void) | null | undefined;
-/**
- * Invoke `off` if present, swallowing any error, and return `null` so the
- * caller can assign the result straight back to the handle.
- *
- * Unregistering is best-effort by design: a handle whose owner has already
- * been torn down may throw, and that must never prevent the rest of
- * `setup()`/`teardown()` from running.
- */
-export declare function releaseHandle(off: Unregister): null;
-/**
- * Release several handles held on one state object, clearing each in place.
- *
- * @example
- * releaseHandles(state, ['hookUnregister', 'postHookUnregister']);
- */
-export declare function releaseHandles<S extends object, K extends keyof S>(state: S, keys: readonly K[]): void;
+/** Shim: implementation moved to @wrongstack/plugin-sdk/runtime. */
+export { releaseHandle, releaseHandles, type Unregister } from '@wrongstack/plugin-sdk/runtime';
 //# sourceMappingURL=handles.d.ts.map

package/dist/runtime/index.d.ts

@@ -1,182 +1,10 @@
 /**
- * @wrongstack/plugins — Language-agnostic runtime helper.
- *
- * Plugins that need to invoke a build-time or test-time tool
- * (TypeScript's `tsc`, Node's `vitest`, Python's `pytest`, Rust's
- * `cargo`, Go's `go test`, etc.) share this module instead of
- * re-implementing argv/sandbox/allowlist logic.
- *
- * Why one module instead of three plugin-local copies?
- * - One audit surface for security-sensitive code: arg-splitting,
- *   sandboxing, execFile-with-shell-false, maxBuffer, timeout.
- * - Plugins stay focused on their domain (linters, type-checkers,
- *   test runners); the runtime helper owns the cross-cutting concern.
- * - New languages opt in by adding a `LanguageRuntime` entry; the
- *   plugin layer keeps working unchanged.
- *
- * The public API is intentionally small:
- *   - `LanguageRuntime`: declares which language a plugin targets.
- *   - `resolveRunnerCommand(runtime, command, options)`: validate +
- *     split a user-supplied command into a safe argv array.
- *   - `sanitizeRunnerPath(value, options)`: reject paths outside
- *     the project or that start with `-` (option smuggling).
- *   - `runRunnerCommand(argv, options)`: spawn the resolved argv
- *     with `shell:false`, capture stdout/stderr/code, and apply
- *     timeout/abort.
- *   - `probeRunner(runtime, argv, options)`: cheap availability check.
- *
- * Anything language-specific (flag tables, default commands,
- * output parsing) stays in the plugin that owns that language.
- */
-export { parseLlmJsonObject, runOptionalPluginCouncil, runOptionalPluginLlm, stripOuterMarkdownFence, type OptionalCouncilRequest, type OptionalLlmRequest, type OptionalLlmResult, } from './llm.js';
-export { BoundedMap, BoundedSet, type BoundedMapOptions } from './bounded-map.js';
-export { UNSERIALIZABLE, safeJsonStringify } from './safe-json.js';
-export { releaseHandle, releaseHandles, type Unregister } from './handles.js';
-export { withReDoSGuard, guardedMatcher, type ReDoSResult, type ReDoSOptions, } from './redos-guard.js';
-export { safePath, isInsideProject, type SafePathOptions, } from './sandbox.js';
-export { createH1State, type H1State, } from './h1-state.js';
-export { clearLocalBinCache, findOnPath, resolveExecInvocation, resolveFirstNodeBin, resolveNodeBin, resolveWin32Command, type ExecInvocation, type ResolvedNodeBin, } from './local-bin.js';
-export type LanguageId = 'typescript' | 'javascript' | 'python' | 'go' | 'rust' | 'shell' | 'ruby' | 'java' | 'kotlin' | 'dotnet' | 'generic';
-export type PackageManagerId = 'npm' | 'pnpm' | 'yarn' | 'bun' | 'pip' | 'poetry' | 'go' | 'cargo' | 'gem' | 'maven' | 'gradle' | 'dotnet' | 'none';
-export interface LanguageRuntime {
-    /** Stable identifier for diagnostics and logging. */
-    id: LanguageId;
-    /**
-     * Default package manager launcher if the plugin must spawn a tool
-     * (e.g. `npx vitest` or `cargo test`). `none` means the executable
-     * itself is invoked directly (no launcher).
-     */
-    packageManager: PackageManagerId;
-    /**
-     * Executable token that must appear as the second argv element when
-     * a launcher is used (e.g. `vitest` after `pnpm exec`, `test` after
-     * `cargo`). When `subcommands.length === 0` and the package manager
-     * has no subcommand step, this is also accepted as the head token.
-     */
-    executable: string;
-    /**
-     * Allowlisted flag values, in addition to positional arguments and
-     * file paths. `null` means "no flag allowlist enforced" — every
-     * leading-dash token is still rejected, but no flag whitelist applies.
-     */
-    allowedFlags: ReadonlySet<string> | null;
-    /**
-     * Optional list of subcommand tokens that may follow the launcher,
-     * e.g. `['exec']` for `pnpm exec tsc`. Empty array means the runner
-     * executable must appear immediately as the second token (e.g.
-     * `cargo test`, `go test`).
-     */
-    subcommands: readonly string[];
-    /**
-     * Default command spelling for `resolveRunnerCommand` when no
-     * custom command is supplied. Plugins can override via config.
-     */
-    defaultCommand: string;
-}
-export interface ResolvedCommand {
-    cmd: string;
-    args: readonly string[];
-    display: string;
-}
-export interface ResolveOptions {
-    /**
-     * Project root used to sandbox absolute executable paths. Defaults
-     * to `process.cwd()`. Absolute executable paths must resolve inside
-     * this directory; relative basenames must match `LanguageRuntime.executable`.
-     */
-    projectRoot?: string;
-}
-export interface RunOptions extends ResolveOptions {
-    cwd: string;
-    timeoutMs: number;
-    signal?: AbortSignal;
-}
-export interface RunResult {
-    code: number | null;
-    stdout: string;
-    stderr: string;
-    timedOut: boolean;
-    /** True when the executable could not be spawned (ENOENT, EPERM, …). */
-    spawnError: boolean;
-}
-/**
- * Validate `value` as a sandboxed path inside the project. Returns the
- * canonical absolute path on success, `null` on rejection (empty,
- * outside the project, leading-dash, or longer than 4096 bytes).
- */
-export declare function sanitizeRunnerPath(value: string, options?: ResolveOptions): string | null;
-/**
- * Resolve a user-supplied command string into an argv-style invocation
- * using the language runtime's allowlist. Returns `null` if the command
- * fails closed (unknown launcher, unknown subcommand, disallowed flag,
- * metacharacters, leading-dash injection, absolute-path escape).
- */
-export declare function resolveRunnerCommand(runtime: LanguageRuntime, command: string, options?: ResolveOptions): ResolvedCommand | null;
-/**
- * Spawn the resolved argv with `shell:false`. Always uses
- * `execFile` (no shell, argv), captures stdout/stderr with a hard
- * `maxBuffer`, and respects `signal` + `timeoutMs`. Plugins can layer
- * language-specific output parsing on top of `RunResult`.
- */
-export declare function runRunnerCommand(argv: readonly string[], options: RunOptions): Promise<RunResult>;
-/**
- * Cheap availability check. Calls the runner's `--version`-like command
- * with a short timeout; returns true only when exit code is zero.
- */
-export declare function probeRunner(runtime: LanguageRuntime, probeArg: string | undefined, options: RunOptions): Promise<boolean>;
-/**
- * Check whether a file path is inside the project root. Uses
- * `process.cwd()` as the project boundary. Returns `true` for valid
- * paths inside the project, `false` for empty, too-long, outside,
- * or absolute paths that escape.
- *
- * This is the canonical sandbox check that every file-mutating or
- * file-reading plugin should call before touching a path supplied
- * by tool input. It replaces 27 identical copies across plugins.
- *
- * Performance: caches `process.cwd()` per call to avoid redundant
- * syscalls when checking multiple paths in the same tick.
- */
-export declare function withinProject(p: string): boolean;
-/**
- * Convenience: locate the runner binary on disk inside the project.
- * Returns the absolute path or `null`.
- */
-export declare function locateRunnerEntry(runtime: LanguageRuntime, projectRoot: string): string | null;
-export interface CollectOptions {
-    /** File extensions to include (e.g. ['.ts', '.tsx', '.js']). */
-    extensions: string[];
-    /** Directory names to skip entirely. Default skips node_modules, dist, .git, coverage. */
-    excludeDirs?: string[] | undefined;
-    /** Maximum recursion depth. Unlimited when omitted. */
-    maxDepth?: number | undefined;
-}
-/**
- * Recursively collect files under `root` whose extension is in
- * `opts.extensions`. Skips directories named in `opts.excludeDirs`
- * (defaulting to node_modules, dist, .git, coverage) and limits depth
- * when `opts.maxDepth` is set.
- *
- * Shared by 6+ plugin source-scan tools that previously duplicated
- * this implementation identically.
- *
- * Determinism: returns files in sorted order (locale-aware) so
- * scan results are reproducible across platforms and file systems.
- */
-export declare function collectSourceFiles(root: string, opts: CollectOptions): string[];
-/**
- * Async version of `collectSourceFiles` for non-blocking file collection.
- * Uses `fs.promises` to avoid blocking the event loop on large directory trees.
- *
- * Performance: prefer this in hooks and tools that run on every write/edit
- * (e.g., duplicate-code-detector) to keep the agent loop responsive during
- * large scans.
- */
-export declare function collectSourceFilesAsync(root: string, opts: CollectOptions): Promise<string[]>;
-/**
- * Check whether `p` has one of the given extensions (case-insensitive).
- * Replaces a 6-copy helper that was duplicated identically across
- * source-scan plugins.
- */
-export declare function matchesExtension(p: string, exts: string[]): boolean;
+ * Backwards-compatible re-export: the runtime helpers moved to
+ * `@wrongstack/plugin-sdk/runtime` so third-party plugin authors get the
+ * same audit-hardened helpers first-party plugins use, without depending
+ * on the whole @wrongstack/plugins package. This shim keeps the
+ * `@wrongstack/plugins/runtime` subpath (and every in-repo relative
+ * import) working unchanged.
+ */
+export * from '@wrongstack/plugin-sdk/runtime';
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/llm.d.ts

@@ -1,44 +1,3 @@
-/**
- * Small, shared helpers for optional plugin LLM enrichment.
- *
- * The host-owned `api.llm` facade keeps provider credentials and routing out
- * of plugins. These helpers standardise the other half of that contract:
- * bounded prompts, cancellation, defensive response parsing, and an explicit
- * deterministic fallback when no provider is wired or generation fails.
- */
-import type { CouncilOption, PluginAPI, PluginLLMOptions } from '@wrongstack/core/types';
-export interface OptionalLlmResult<T> {
-    used: boolean;
-    value: T | null;
-    fallbackReason: 'not-requested' | 'unavailable' | 'cancelled' | 'provider-error' | 'invalid-response' | null;
-}
-export interface OptionalLlmRequest<T> {
-    requested: boolean;
-    prompt: string;
-    options?: PluginLLMOptions | undefined;
-    parse(text: string): T | null;
-    api: Pick<PluginAPI, 'llm' | 'log'>;
-    label: string;
-}
-export interface OptionalCouncilRequest<T> extends OptionalLlmRequest<T> {
-    context?: string | undefined;
-    profile?: string | undefined;
-    councilOptions?: readonly CouncilOption[] | undefined;
-}
-/** Remove one outer Markdown fence without modifying inner code fences. */
-export declare function stripOuterMarkdownFence(text: string): string;
-/** Parse a JSON object from a plain or fenced provider response. */
-export declare function parseLlmJsonObject(text: string): Record<string, unknown> | null;
-/**
- * Run optional enrichment without turning a provider outage into a tool
- * failure. Abort remains observable as a fallback reason and the caller's
- * deterministic result remains authoritative.
- */
-export declare function runOptionalPluginLlm<T>(request: OptionalLlmRequest<T>): Promise<OptionalLlmResult<T>>;
-/**
- * Prefer the host Council for consequential analysis, then degrade through the
- * same One Shot helper and finally the caller's deterministic result. Council
- * outages therefore never turn an optional enrichment into a tool failure.
- */
-export declare function runOptionalPluginCouncil<T>(request: OptionalCouncilRequest<T>): Promise<OptionalLlmResult<T>>;
+/** Shim: implementation moved to @wrongstack/plugin-sdk/runtime. */
+export { parseLlmJsonObject, runOptionalPluginCouncil, runOptionalPluginLlm, stripOuterMarkdownFence, type OptionalCouncilRequest, type OptionalLlmRequest, type OptionalLlmResult, } from '@wrongstack/plugin-sdk/runtime';
 //# sourceMappingURL=llm.d.ts.map

package/dist/runtime/local-bin.d.ts

@@ -1,120 +1,3 @@
-/**
- * @wrongstack/plugins — project-local binary resolution.
- *
- * Why this module exists
- * ----------------------
- * Several plugins need to run a Node CLI that ships with the project
- * (`biome`, `eslint`, `tsc`, `vitest`, …). The obvious spelling —
- * `execFile('npx', ['biome', …])` — is wrong in three separate ways:
- *
- *  1. **It does not run on Windows at all.** `npx`/`pnpm`/`npm` are
- *     `.cmd` shims there, and `execFile`/`spawn` without a shell do not
- *     consult `PATHEXT`. The call fails `ENOENT`, plugins swallow the
- *     error as "tool not installed", and the feature silently no-ops on
- *     every Windows machine.
- *  2. **It is slow.** `npx` re-resolves the package on each invocation,
- *     and for a missing package it may try to *download* one — on a hook
- *     that fires after every write.
- *  3. **It is a weaker sandbox.** The shim is a shell script; arguments
- *     cross a `cmd.exe` boundary on Windows (the BatBadBut class).
- *
- * `lint-gate` and `test-flake-detector` already solved this locally by
- * resolving the package's `bin` entry through `createRequire` and running
- * it as `process.execPath <entry>`. That is the correct pattern: no shell,
- * no shim, no network, identical on every platform. This module promotes
- * that proven approach to a shared helper so every plugin gets it.
- *
- * Fallback: when the package is genuinely absent from the project,
- * `resolveNodeBin` returns `null` and the caller decides whether to
- * degrade gracefully or fall back to a PATH lookup via
- * `resolveWin32Command` (exported here for that purpose).
- */
-import { resolveWin32Command } from '@wrongstack/tools/win32';
-export { resolveWin32Command };
-/** A spawn-ready invocation, already adjusted for the host platform. */
-export interface ExecInvocation {
-    cmd: string;
-    args: string[];
-    /** Only ever true on the Windows `.cmd`/`.bat` shim path. */
-    windowsVerbatimArguments: boolean;
-}
-/**
- * Turn a `(command, args)` pair into something `execFile`/`spawn` can
- * actually launch on this platform.
- *
- * On Windows, `npx`/`npm`/`pnpm`/`biome`/`tsc`/… ship as `.cmd` wrappers.
- * `execFile` and `spawn` without a shell ignore `PATHEXT`, so a bare
- * `execFile('npx', …)` fails `ENOENT` — and because every plugin treats a
- * spawn failure as "tool not installed", the feature silently no-ops on
- * every Windows machine. This resolves the real path first and, for a
- * `.cmd`/`.bat` shim, routes through `cmd.exe` with per-argument quoting
- * and a metacharacter guard (the BatBadBut argument-injection class), so
- * a dynamic path argument still cannot chain a second command.
- *
- * On non-Windows, and for real `.exe` binaries, this is a passthrough.
- *
- * Throws when an argument carries a `cmd.exe` metacharacter on the shim
- * path — callers should treat that as "skip", never as "run anyway".
- *
- * Prefer {@link resolveNodeBin} when the target is a Node CLI that the
- * project depends on: `node <bin-entry>` needs no shim at all.
- */
-export declare function resolveExecInvocation(command: string, args?: readonly string[]): ExecInvocation;
-/**
- * Locate `cmd` on `PATH`, or return `null` if it is not there.
- *
- * This is the existence check `resolveWin32Command` deliberately does not
- * provide: that function returns its input unchanged when nothing matches,
- * so a caller cannot distinguish "found `biome`" from "gave up and handed
- * back the string `biome`". Treating the passthrough as success makes a
- * missing tool look installed — the caller then spawns it, gets `ENOENT`,
- * and (because plugins read a spawn failure as "not installed") silently
- * does nothing while reporting itself healthy.
- *
- * Returns the resolved path on success. Walks `PATH` directly, applying
- * `PATHEXT` suffixes on Windows for a bare name and checking the execute
- * bit on POSIX.
- */
-export declare function findOnPath(cmd: string): string | null;
-/** A resolved, directly-spawnable invocation. Never a shell or a shim. */
-export interface ResolvedNodeBin {
-    /** Always `process.execPath` — the Node binary running this process. */
-    cmd: string;
-    /** `[binEntryPath, ...extraArgs]`. */
-    args: string[];
-    /** Absolute path of the package's bin entry, for diagnostics. */
-    entry: string;
-}
-/** Drop every cached resolution. Call from `teardown()`. */
-export declare function clearLocalBinCache(): void;
-/**
- * Resolve a project-local Node CLI to a `process.execPath <entry>`
- * invocation.
- *
- * @param packageName npm package to resolve, e.g. `@biomejs/biome`.
- * @param binName     which `bin` key to prefer when the package declares
- *                    several. Falls back to the sole/first entry.
- * @param cwd         project root whose `package.json` anchors resolution.
- * @param extraArgs   arguments appended after the bin entry.
- *
- * Returns `null` when the package is not installed, declares no `bin`, or
- * the declared entry escapes its own package directory (a tampered
- * `package.json` must not become an arbitrary-file execution primitive).
- */
-export declare function resolveNodeBin(packageName: string, binName: string, cwd: string, extraArgs?: readonly string[]): ResolvedNodeBin | null;
-/**
- * Resolve the first installed package from `candidates`.
- *
- * Used by plugins that accept several equivalent tools (biome *or*
- * eslint, vitest *or* jest) and want the first one the project actually
- * has, without probing each with a subprocess.
- */
-export declare function resolveFirstNodeBin(candidates: readonly {
-    packageName: string;
-    binName: string;
-    args?: readonly string[];
-}[], cwd: string): (ResolvedNodeBin & {
-    packageName: string;
-    binName: string;
-}) | null;
+/** Shim: implementation moved to @wrongstack/plugin-sdk/runtime. */
+export { clearLocalBinCache, findOnPath, resolveExecInvocation, resolveFirstNodeBin, resolveNodeBin, resolveWin32Command, type ExecInvocation, type ResolvedNodeBin, } from '@wrongstack/plugin-sdk/runtime';
 //# sourceMappingURL=local-bin.d.ts.map