dsh-plugin-wsl-env 0.7.5 → 0.8.0

package/lib/subprocess.js

@@ -72,34 +72,34 @@
  * composition, not of the Session. A Session whose workspace is a Windows folder
  * gets the same terminal, with that folder mounted at `/mnt/<drive>/…`.
  *
+ * This is a TypeScript source built to `lib/subprocess.js`; edit THIS file and
+ * run `pnpm run build` — the artifact under `lib/` is generated, and `pnpm test`
+ * fails when it drifts.
+ *
  * @module dsh-plugin-wsl/subprocess
  */
-
 import { randomUUID } from "node:crypto";
 import z from "@deepseek-ai/schemastery";
 import { LocalSubprocessRuntime } from "@deepseek-ai/dsh-subprocess-local";
 import { isPosixAbsolute, toLinuxPath, uncToPosix, windowsToLinuxMount } from "./paths.js";
 import { DEFAULT_WSL_PATH, defaultDistro, wslEnvValue, wslTerminalArgv } from "./wsl.js";
 import { searchSpawnRewrite } from "./search-route.js";
+import { gitSpawnRewrite, translateGitEnv } from "./git-route.js";
 import { searchExecutionHandle } from "./search-exec.js";
 import { sharedAgent } from "./agent-shared.js";
 import { parseTerminalActivity, TERMINAL_ID_ENV, terminalActivityProbe, wrapTerminalHandle } from "./terminal-activity.js";
 import { AgentUnavailableError } from "./agent-errors.js";
 import { terminalRoute } from "./terminal-route.js";
-
 /**
  * Env names a terminal launch keeps for the distro. `TERM` rides along because
  * the PTY consumer sets it for the host process, and WSL imports no name that
  * `WSLENV` does not list.
  */
 const SAFE_FORWARD = ["TERM", "NO_COLOR", "PAGER", "GIT_PAGER", "LANG", "LC_ALL"];
-
 /** Namespace of the managed facts; every `DSH_*` name in a terminal request is forwarded. */
 const DSH_ENV_PREFIX = "DSH_";
-
 /** The one program a launch of this provider's does not pass through. */
 const WSL_PROGRAM = "wsl";
-
 /**
  * Subprocess provider that serves a WSL distro as the composition's terminal
  * execution world.
@@ -110,273 +110,278 @@ const WSL_PROGRAM = "wsl";
  * literally the shipped implementation.
  */
 export class WslSubprocessRuntime extends LocalSubprocessRuntime {
-  static Config = z.object({
-    /** Distro name; empty means WSL's own default distro. */
-    distro: z.string().default(""),
-    /** Path to `wsl.exe`; overridable for a non-standard install. */
-    wslPath: z.string().default(DEFAULT_WSL_PATH),
+    static Config = z.object({
+        /** Distro name; empty means WSL's own default distro. */
+        distro: z.string().default(""),
+        /** Path to `wsl.exe`; overridable for a non-standard install. */
+        wslPath: z.string().default(DEFAULT_WSL_PATH),
+        /**
+         * A shell to pin inside the distro, as an absolute Linux path. Empty — the
+         * default — leaves the choice to `wsl.exe`, which starts the distro user's
+         * login shell exactly as an interactive `wsl.exe` does.
+         */
+        shell: z.string().default(""),
+        /**
+         * Login-shell semantics for a pinned shell. Ignored when no shell is pinned,
+         * because then the login shell is the shell.
+         */
+        loginShell: z.boolean().default(true),
+        /** Fallback directory when a launch names none; accepts any coordinate system. */
+        cwd: z.string().default(""),
+        /** Windows directory the `wsl.exe` process itself starts in. */
+        hostCwd: z.string().volatile(),
+        /** Extra env names to forward into the distro through WSLENV. */
+        forwardEnv: z.array(z.string()).default([]),
+        /**
+         * Give a session opened on a WINDOWS folder a host shell instead of the
+         * distro's shell started at `/mnt/<drive>/…`. WSL-folder sessions always
+         * get the distro shell — that is this provider's purpose. `false` restores
+         * the composition-owned terminal for every session.
+         */
+        hostSessions: z.boolean().default(true),
+        /**
+         * Let the controller reclaim an idle distro terminal. The terminal is
+         * marked at launch (`DSH_TERMINAL_ID` through the existing `WSLENV`
+         * forwarding) and its handle's `inspectActivity` is replaced with a
+         * distro-side observation: the resident agent scans `/proc` for the
+         * marker — a shell with live children is busy, a shell without children
+         * is idle. The shipped observation can only answer `unknown` for a distro
+         * terminal, and `unknown` never accumulates idle, which is why these
+         * terminals had to be closed by hand. When the agent is out the
+         * observation answers `unknown` (no reclaim) — a probe that cannot answer
+         * must not authorize a close. `false` restores that posture.
+         */
+        terminalIdleReclaim: z.boolean().default(true),
+    });
     /**
-     * A shell to pin inside the distro, as an absolute Linux path. Empty — the
-     * default — leaves the choice to `wsl.exe`, which starts the distro user's
-     * login shell exactly as an interactive `wsl.exe` does.
+     * @param ctx - the cordis context.
+     * @param config - the schema-validated config.
      */
-    shell: z.string().default(""),
+    constructor(ctx, config) {
+        super(ctx);
+        this.config = config;
+        this.resolvedDistro = config.distro;
+    }
     /**
-     * Login-shell semantics for a pinned shell. Ignored when no shell is pinned,
-     * because then the login shell is the shell.
+     * The distro a launch uses when the request's directory does not name one,
+     * resolving WSL's default on first use.
+     *
+     * @returns the distro name.
      */
-    loginShell: z.boolean().default(true),
-    /** Fallback directory when a launch names none; accepts any coordinate system. */
-    cwd: z.string().default(""),
-    /** Windows directory the `wsl.exe` process itself starts in. */
-    hostCwd: z.string().volatile(),
-    /** Extra env names to forward into the distro through WSLENV. */
-    forwardEnv: z.array(z.string()).default([]),
+    async distro() {
+        if (this.resolvedDistro.length === 0)
+            this.resolvedDistro = await defaultDistro({ wslPath: this.config.wslPath });
+        return this.resolvedDistro;
+    }
+    /** Windows directory the `wsl.exe` process is started from. */
+    hostCwd() {
+        return this.config.hostCwd.get() ?? process.env.SystemRoot ?? process.cwd();
+    }
     /**
-     * Give a session opened on a WINDOWS folder a host shell instead of the
-     * distro's shell started at `/mnt/<drive>/…`. WSL-folder sessions always
-     * get the distro shell — that is this provider's purpose. `false` restores
-     * the composition-owned terminal for every session.
+     * The distro and Linux directory one terminal request names.
+     *
+     * The Session workspace the terminal controller passes in is the coordinate
+     * the harness already speaks, and it is also the strongest evidence of the
+     * intended distro: a UNC path names one outright. Anything else — a Windows
+     * drive path or a directory-less request — may legitimately be served by the
+     * configured distro.
+     *
+     * @param cwd - the request's working directory, in any coordinate system.
+     * @returns the distro name and its absolute Linux directory.
      */
-    hostSessions: z.boolean().default(true),
+    async terminalTarget(cwd) {
+        const text = String(cwd ?? "").trim();
+        const named = uncToPosix(text);
+        if (named !== undefined)
+            return { distro: named.distro, linuxCwd: named.linuxPath };
+        const distro = await this.distro();
+        if (isPosixAbsolute(text))
+            return { distro, linuxCwd: text };
+        const mounted = windowsToLinuxMount(text);
+        if (mounted !== undefined)
+            return { distro, linuxCwd: mounted };
+        return { distro, linuxCwd: toLinuxPath(this.config.cwd, { distro }) };
+    }
     /**
-     * Let the controller reclaim an idle distro terminal. The terminal is
-     * marked at launch (`DSH_TERMINAL_ID` through the existing `WSLENV`
-     * forwarding) and its handle's `inspectActivity` is replaced with a
-     * distro-side observation: the resident agent scans `/proc` for the
-     * marker — a shell with live children is busy, a shell without children
-     * is idle. The shipped observation can only answer `unknown` for a distro
-     * terminal, and `unknown` never accumulates idle, which is why these
-     * terminals had to be closed by hand. When the agent is out the
-     * observation answers `unknown` (no reclaim) — a probe that cannot answer
-     * must not authorize a close. `false` restores that posture.
+     * Open one interactive shell inside the distro over the host's PTY.
+     *
+     * Only a `wsl.exe` launch is rewritten. Everything else — a shipped host
+     * shell, the PTY backend's `bash -i`, any other consumer's terminal — is the
+     * shipped implementation's, which is what keeps replacing a root provider
+     * safe.
+     *
+     * The request's remaining arguments are intentionally not forwarded: the
+     * controller's shell profile carries only the program, and a second set of
+     * `wsl.exe` arguments would fight the distro and `--cd` this method derives
+     * from the Session.
+     *
+     * @param spec - the terminal request from the PTY consumer.
+     * @returns the live terminal handle.
      */
-    terminalIdleReclaim: z.boolean().default(true),
-  });
-
-  constructor(ctx, config) {
-    super(ctx);
-    this.config = config;
-    /** Cached default distro, resolved once from `wsl.exe -l -q`. */
-    this.resolvedDistro = config.distro;
-  }
-
-  /**
-   * The distro a launch uses when the request's directory does not name one,
-   * resolving WSL's default on first use.
-   * @returns the distro name.
-   */
-  async distro() {
-    if (this.resolvedDistro.length === 0) this.resolvedDistro = await defaultDistro({ wslPath: this.config.wslPath });
-    return this.resolvedDistro;
-  }
-
-  /** Windows directory the `wsl.exe` process is started from. */
-  hostCwd() {
-    return this.config.hostCwd.get() ?? process.env.SystemRoot ?? process.cwd();
-  }
-
-  /**
-   * The distro and Linux directory one terminal request names.
-   *
-   * The Session workspace the terminal controller passes in is the coordinate
-   * the harness already speaks, and it is also the strongest evidence of the
-   * intended distro: a UNC path names one outright. Anything else — a Windows
-   * drive path or a directory-less request — may legitimately be served by the
-   * configured distro.
-   *
-   * @param cwd - the request's working directory, in any coordinate system.
-   * @returns the distro name and its absolute Linux directory.
-   */
-  async terminalTarget(cwd) {
-    const text = String(cwd ?? "").trim();
-    const named = uncToPosix(text);
-    if (named !== undefined) return { distro: named.distro, linuxCwd: named.linuxPath };
-    const distro = await this.distro();
-    if (isPosixAbsolute(text)) return { distro, linuxCwd: text };
-    const mounted = windowsToLinuxMount(text);
-    if (mounted !== undefined) return { distro, linuxCwd: mounted };
-    return { distro, linuxCwd: toLinuxPath(this.config.cwd, { distro }) };
-  }
-
-  /**
-   * Open one interactive shell inside the distro over the host's PTY.
-   *
-   * Only a `wsl.exe` launch is rewritten. Everything else — a shipped host
-   * shell, the PTY backend's `bash -i`, any other consumer's terminal — is the
-   * shipped implementation's, which is what keeps replacing a root provider
-   * safe.
-   *
-   * The request's remaining arguments are intentionally not forwarded: the
-   * controller's shell profile carries only the program, and a second set of
-   * `wsl.exe` arguments would fight the distro and `--cd` this method derives
-   * from the Session.
-   *
-   * @param spec - the terminal request from the PTY consumer.
-   * @returns the live terminal handle.
-   */
-  async spawnTerminal(spec) {
-    if (!this.launchesDistro(spec.argv)) return super.spawnTerminal(spec);
-    // A session on a Windows folder is a HOST session: it gets the host shell
-    // in its own directory, not the distro's shell at `/mnt/<drive>/…`. The
-    // wsl.exe argv still names this provider's launch, so the substitution
-    // stays inside the override — every other consumer is untouched.
-    if (this.config.hostSessions && terminalRoute(spec.cwd) === "host") {
-      return super.spawnTerminal({ ...spec, argv: ["powershell.exe", "-NoLogo"] });
-    }
-    const target = await this.terminalTarget(spec.cwd);
-    const argv = wslTerminalArgv({
-      wslPath: this.config.wslPath,
-      distro: target.distro,
-      shellPath: this.config.shell,
-      linuxCwd: target.linuxCwd,
-      login: this.config.loginShell,
-    });
-    // The idle-reclaim mark: one env name per terminal, riding the WSLENV
-    // forwarding this launch already does. The distro shell and everything it
-    // spawns carry it in /proc/<pid>/environ — what the activity probe scans.
-    const terminalId = this.config.terminalIdleReclaim ? randomUUID() : undefined;
-    const specWithMark = terminalId === undefined ? spec : { ...spec, env: { ...spec.env, [TERMINAL_ID_ENV]: terminalId } };
-    const handle = await super.spawnTerminal({
-      ...specWithMark,
-      argv,
-      // A Windows CreateProcess cannot use a Linux path as its working
-      // directory; the Linux directory rides on `--cd` instead.
-      cwd: this.hostCwd(),
-      env: this.forwardedEnv(specWithMark),
-    });
-    if (terminalId === undefined) return handle;
-    return wrapTerminalHandle(handle, this.distroActivity(target.distro, terminalId));
-  }
-
-  /**
-   * The replacement `inspectActivity` for one distro terminal: ask the
-   * resident agent whether the marked shell is at its prompt.
-   *
-   * The revision increments only when the reported state changes, so the
-   * controller's retention accumulates idle across consecutive `idle`
-   * observations and restarts the clock on every transition. Any probe
-   * failure — the agent out, the distro stopped, a script error — answers
-   * `unknown`, which the retention reads as "not idle": the probe that cannot
-   * answer never authorizes a close. The first unexpected (non-availability)
-   * failure is logged once, so a broken probe is diagnosable without
-   * spamming the log every poll.
-   *
-   * @param distro - the distro the terminal lives in.
-   * @param terminalId - the launch's `DSH_TERMINAL_ID` mark.
-   * @returns the seam's activity observation.
-   */
-  distroActivity(distro, terminalId) {
-    let revision = 0;
-    let lastState = "";
-    let warned = false;
-    return async () => {
-      try {
-        const probe = terminalActivityProbe(terminalId);
-        const result = await sharedAgent(distro).exec({
-          cwd: probe.cwd,
-          argv: probe.argv,
-          maxOutputBytes: 256,
-          timeoutMs: 10_000,
-        });
-        const state = parseTerminalActivity(result.stdout) ?? "unknown";
-        if (state !== lastState) {
-          revision += 1;
-          lastState = state;
+    async spawnTerminal(spec) {
+        if (!this.launchesDistro(spec.argv))
+            return super.spawnTerminal(spec);
+        // A session on a Windows folder is a HOST session: it gets the host shell
+        // in its own directory, not the distro's shell at `/mnt/<drive>/…`. The
+        // wsl.exe argv still names this provider's launch, so the substitution
+        // stays inside the override — every other consumer is untouched.
+        if (this.config.hostSessions && terminalRoute(spec.cwd) === "host") {
+            return super.spawnTerminal({ ...spec, argv: ["powershell.exe", "-NoLogo"] });
         }
-        return { state, revision };
-      } catch (error) {
-        if (!(error instanceof AgentUnavailableError) && !warned) {
-          warned = true;
-          this.ctx.logger?.warn(`wsl-subprocess: the terminal activity probe failed and idle reclamation is paused (${String(error?.message ?? error)})`);
+        const target = await this.terminalTarget(spec.cwd);
+        const argv = wslTerminalArgv({
+            wslPath: this.config.wslPath,
+            distro: target.distro,
+            shellPath: this.config.shell,
+            linuxCwd: target.linuxCwd,
+            login: this.config.loginShell,
+        });
+        // The idle-reclaim mark: one env name per terminal, riding the WSLENV
+        // forwarding this launch already does. The distro shell and everything it
+        // spawns carry it in /proc/<pid>/environ — what the activity probe scans.
+        const terminalId = this.config.terminalIdleReclaim ? randomUUID() : undefined;
+        const specWithMark = terminalId === undefined ? spec : { ...spec, env: { ...spec.env, [TERMINAL_ID_ENV]: terminalId } };
+        const handle = await super.spawnTerminal({
+            ...specWithMark,
+            argv,
+            // A Windows CreateProcess cannot use a Linux path as its working
+            // directory; the Linux directory rides on `--cd` instead.
+            cwd: this.hostCwd(),
+            // The terminal spec's env is a string record; forwarding adds `WSLENV`.
+            env: this.forwardedEnv(specWithMark),
+        });
+        if (terminalId === undefined)
+            return handle;
+        return wrapTerminalHandle(handle, this.distroActivity(target.distro, terminalId));
+    }
+    /**
+     * The replacement `inspectActivity` for one distro terminal: ask the
+     * resident agent whether the marked shell is at its prompt.
+     *
+     * The revision increments only when the reported state changes, so the
+     * controller's retention accumulates idle across consecutive `idle`
+     * observations and restarts the clock on every transition. Any probe
+     * failure — the agent out, the distro stopped, a script error — answers
+     * `unknown`, which the retention reads as "not idle": the probe that cannot
+     * answer never authorizes a close. The first unexpected (non-availability)
+     * failure is logged once, so a broken probe is diagnosable without
+     * spamming the log every poll.
+     *
+     * @param distro - the distro the terminal lives in.
+     * @param terminalId - the launch's `DSH_TERMINAL_ID` mark.
+     * @returns the seam's activity observation.
+     */
+    distroActivity(distro, terminalId) {
+        let revision = 0;
+        let lastState = "";
+        let warned = false;
+        return async () => {
+            try {
+                const probe = terminalActivityProbe(terminalId);
+                const result = await sharedAgent(distro).exec({
+                    cwd: probe.cwd,
+                    argv: probe.argv,
+                    maxOutputBytes: 256,
+                    timeoutMs: 10_000,
+                });
+                const state = parseTerminalActivity(result.stdout) ?? "unknown";
+                if (state !== lastState) {
+                    revision += 1;
+                    lastState = state;
+                }
+                return { state, revision };
+            }
+            catch (error) {
+                if (!(error instanceof AgentUnavailableError) && !warned) {
+                    warned = true;
+                    this.ctx.logger?.warn(`wsl-subprocess: the terminal activity probe failed and idle reclamation is paused (${String(error?.message ?? error)})`);
+                }
+                return { state: "unknown", revision };
+            }
+        };
+    }
+    /**
+     * Open one host-side process, rewriting two kinds of launches into the
+     * distro: the file-search tool's ripgrep (agent-first, one-shot fallback)
+     * and git snapshot commands (one-shot only — snapshot operations are not
+     * latency-sensitive, and their stdin relay and collected streams are the
+     * shipped handle's). Both decisions are pure coordinate functions
+     * (`search-route.js`, `git-route.js`); a spawn neither names (any other
+     * program, any drive or relative directory) reaches the shipped
+     * implementation verbatim.
+     *
+     * @param spec - the spawn request.
+     * @returns the live search handle.
+     */
+    spawn(spec) {
+        const gitRewrite = gitSpawnRewrite({ argv: spec.argv, cwd: spec.cwd, wslPath: this.config.wslPath });
+        if (gitRewrite !== undefined) {
+            // The snapshot environment (GIT_INDEX_FILE / GIT_OBJECT_DIRECTORY /
+            // GIT_ALTERNATE_OBJECT_DIRECTORIES and the git hygiene flags) is
+            // path-shaped in Windows form; the values are translated into distro
+            // paths and every forwarded name rides WSLENV. The user's real index,
+            // object store, work tree, and refs stay untouched by design — the
+            // snapshot runs in the tool's private scratch.
+            const { env, wslenv } = translateGitEnv(spec.env);
+            return super.spawn({
+                ...spec,
+                argv: gitRewrite.wslArgv,
+                cwd: this.hostCwd(),
+                env: wslenv.length > 0 ? { ...env, WSLENV: wslEnvValue(wslenv) } : env,
+            });
         }
-        return { state: "unknown", revision };
-      }
-    };
-  }
-
-  /**
-   * Open one host-side process, rewriting two kinds of launches into the
-   * distro: the file-search tool's ripgrep (agent-first, one-shot fallback)
-   * and git snapshot commands (one-shot only — snapshot operations are not
-   * latency-sensitive, and their stdin relay and collected streams are the
-   * shipped handle's). Both decisions are pure coordinate functions
-   * (`search-route.js`, `git-route.js`); a spawn neither names (any other
-   * program, any drive or relative directory) reaches the shipped
-   * implementation verbatim.
-   *
-   * @param spec - the spawn request.
-   * @returns the live search handle.
-   */
-  spawn(spec) {
-    const gitRewrite = gitSpawnRewrite({ argv: spec.argv, cwd: spec.cwd, wslPath: this.config.wslPath });
-    if (gitRewrite !== undefined) {
-      // The snapshot environment (GIT_INDEX_FILE / GIT_OBJECT_DIRECTORY /
-      // GIT_ALTERNATE_OBJECT_DIRECTORIES and the git hygiene flags) is
-      // path-shaped in Windows form; the values are translated into distro
-      // paths and every forwarded name rides WSLENV. The user's real index,
-      // object store, work tree, and refs stay untouched by design — the
-      // snapshot runs in the tool's private scratch.
-      const { env, wslenv } = translateGitEnv(spec.env);
-      return super.spawn({
-        ...spec,
-        argv: gitRewrite.wslArgv,
-        cwd: this.hostCwd(),
-        env: wslenv.length > 0 ? { ...env, WSLENV: wslEnvValue(wslenv) } : env,
-      });
+        const rewrite = searchSpawnRewrite({ argv: spec.argv, cwd: spec.cwd, wslPath: this.config.wslPath });
+        if (rewrite === undefined)
+            return super.spawn(spec);
+        // The search handle carries the slice `dsh-tool-fs-search` consumes
+        // (`done`, `collected`, `kill`); the seam's full handle surface is the
+        // one-shot fallback's, so the override's declared return is the cast's.
+        return searchExecutionHandle({
+            agent: sharedAgent(rewrite.distro),
+            cwd: rewrite.linuxCwd,
+            argv: rewrite.rgArgv,
+            // One budget serves both streams; the stdout budget is the binding one,
+            // and a pathological stderr is still bounded by it.
+            maxOutputBytes: spec.stdio.stdout?.maxBytes ?? 0,
+            signal: spec.signal,
+            spawnFallback: () => super.spawn({
+                ...spec,
+                argv: rewrite.wslArgv,
+                // `wsl.exe --cd` carries the Linux directory; the host process itself
+                // must start in a Windows directory, as with a terminal launch.
+                cwd: this.hostCwd(),
+                env: this.forwardedEnv(spec),
+            }),
+        });
+    }
+    /**
+     * The environment one `wsl.exe` launch forwards: the safe list plus every
+     * managed `DSH_*` name, admitted through `WSLENV` and never `PATH` — see the
+     * WSLENV note in the recipes.
+     *
+     * @param spec - the launch request whose env is forwarded.
+     * @returns the environment the host launch carries.
+     */
+    forwardedEnv(spec) {
+        const forward = new Set([...SAFE_FORWARD, ...this.config.forwardEnv]);
+        const imported = Object.keys(spec.env ?? {}).filter((name) => forward.has(name) || name.startsWith(DSH_ENV_PREFIX));
+        return imported.length > 0 ? { ...spec.env, WSLENV: wslEnvValue(imported) } : spec.env;
+    }
+    /**
+     * Whether a terminal request is a `wsl.exe` launch.
+     *
+     * A bare `argv[0]` is judged by its own name, so the shipped program name and
+     * an operator-pinned absolute path both match.
+     *
+     * @param argv - the request's program and arguments.
+     * @returns true when this provider owns the launch.
+     */
+    launchesDistro(argv) {
+        const program = argv?.[0];
+        if (typeof program !== "string" || program.length === 0)
+            return false;
+        const base = program.slice(Math.max(program.lastIndexOf("/"), program.lastIndexOf("\\")) + 1);
+        return base.toLowerCase().replace(/\.exe$/u, "") === WSL_PROGRAM;
     }
-    const rewrite = searchSpawnRewrite({ argv: spec.argv, cwd: spec.cwd, wslPath: this.config.wslPath });
-    if (rewrite === undefined) return super.spawn(spec);
-    return searchExecutionHandle({
-      agent: sharedAgent(rewrite.distro),
-      cwd: rewrite.linuxCwd,
-      argv: rewrite.rgArgv,
-      // One budget serves both streams; the stdout budget is the binding one,
-      // and a pathological stderr is still bounded by it.
-      maxOutputBytes: spec.stdio?.stdout?.maxBytes ?? 0,
-      signal: spec.signal,
-      spawnFallback: () =>
-        super.spawn({
-          ...spec,
-          argv: rewrite.wslArgv,
-          // `wsl.exe --cd` carries the Linux directory; the host process itself
-          // must start in a Windows directory, as with a terminal launch.
-          cwd: this.hostCwd(),
-          env: this.forwardedEnv(spec),
-        }),
-    });
-  }
-
-  /**
-   * The environment one `wsl.exe` launch forwards: the safe list plus every
-   * managed `DSH_*` name, admitted through `WSLENV` and never `PATH` — see the
-   * WSLENV note in the recipes.
-   * @param spec - the launch request whose env is forwarded.
-   * @returns the environment the host launch carries.
-   */
-  forwardedEnv(spec) {
-    const forward = new Set([...SAFE_FORWARD, ...this.config.forwardEnv]);
-    const imported = Object.keys(spec.env ?? {}).filter(
-      (name) => forward.has(name) || name.startsWith(DSH_ENV_PREFIX),
-    );
-    return imported.length > 0 ? { ...spec.env, WSLENV: wslEnvValue(imported) } : spec.env;
-  }
-
-  /**
-   * Whether a terminal request is a `wsl.exe` launch.
-   *
-   * A bare `argv[0]` is judged by its own name, so the shipped program name and
-   * an operator-pinned absolute path both match.
-   *
-   * @param argv - the request's program and arguments.
-   * @returns true when this provider owns the launch.
-   */
-  launchesDistro(argv) {
-    const program = argv?.[0];
-    if (typeof program !== "string" || program.length === 0) return false;
-    const base = program.slice(Math.max(program.lastIndexOf("/"), program.lastIndexOf("\\")) + 1);
-    return base.toLowerCase().replace(/\.exe$/u, "") === WSL_PROGRAM;
-  }
 }
-
 export default WslSubprocessRuntime;