dsh-wsl-desktop 0.3.4 → 0.3.6

package/lib/client.js

@@ -20,6 +20,9 @@
 window.__ModuleLoader__.load({
   id: 'dsh-wsl-desktop',
   factory() {
+    // MUST stay equal to the host half's Config.routePath default (lib/index.js).
+    // Nothing derives one from the other: a deployment that mounts the route
+    // elsewhere loses the picker silently.
     const ENDPOINT = '/wsl-desktop/api'
 
     /**
@@ -268,12 +271,10 @@ window.__ModuleLoader__.load({
        * workspace be created and a session opened after the operator cancelled.
        */
       function close() {
+        // The guard is the ONLY difference from forceClose(); the teardown itself is
+        // that function's, so the two cannot drift apart.
         if (state.closed || state.working) return
-        state.closed = true
-        state.token += 1
-        document.removeEventListener('keydown', onKey)
-        overlay.remove()
-        teardown = null
+        forceClose()
       }
 
       /** Close the picker regardless of an in-flight commit, once it settles. */

package/lib/icon.svg

@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64" role="img" aria-label="DSH WSL Desktop">
+  <!-- W monogram. The polyline's apex/valleys are chosen so the STROKED bounds
+       (8.5..55.5 x 13.5..50.5) center on (32,32): the mark is optically centered,
+       not merely its path data. Keep the 7px stroke when editing the path, and
+       re-center against those bounds rather than the raw vertices. -->
+  <defs>
+    <linearGradient id="wsl-base" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0" stop-color="#151D31"/>
+      <stop offset="1" stop-color="#0B111E"/>
+    </linearGradient>
+    <radialGradient id="wsl-glow" gradientUnits="userSpaceOnUse" cx="52" cy="4" r="44">
+      <stop offset="0" stop-color="#38BDF8" stop-opacity=".32"/>
+      <stop offset="1" stop-color="#38BDF8" stop-opacity="0"/>
+    </radialGradient>
+    <linearGradient id="wsl-mark" x1="12" y1="17" x2="52" y2="47" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#38BDF8"/>
+      <stop offset="1" stop-color="#4D6BFE"/>
+    </linearGradient>
+  </defs>
+  <rect width="64" height="64" rx="15" fill="url(#wsl-base)"/>
+  <rect width="64" height="64" rx="15" fill="url(#wsl-glow)"/>
+  <path d="M12 17 L22.5 47 L32 25 L41.5 47 L52 17" fill="none" stroke="url(#wsl-mark)" stroke-width="7" stroke-linecap="round" stroke-linejoin="round"/>
+  <rect x=".75" y=".75" width="62.5" height="62.5" rx="14.25" fill="none" stroke="#7DD3FC" stroke-opacity=".22" stroke-width="1.5"/>
+</svg>

package/lib/index.js

@@ -5,9 +5,11 @@
  *
  * 1. Answer the browser's WSL questions over the same-origin route — the
  *    browser cannot run `wsl.exe`.
- * 2. Materialize the WSL agent presets into the user preset root. A session's
- *    execution world is chosen by its preset, so this is what lets one Desktop
- *    instance run Windows workspaces and WSL workspaces side by side.
+ * 2. Derive and register the WSL agent presets in the runtime preset registry. A
+ *    session's execution world is chosen by its preset, so this is what lets one
+ *    Desktop instance run Windows workspaces and WSL workspaces side by side.
+ *    (Before 0.1.7 this half MATERIALIZED them into the user preset root; the
+ *    registry owns them now, and nothing under $DSH_HOME is written.)
  * @module dsh-wsl-desktop
  */
 
@@ -44,6 +46,9 @@ export const Config = z.object({
    * generation can be mounted beside a running one, which is how the host half
    * is exercised without restarting the application.
    */
+  // MUST stay equal to the browser half's ENDPOINT (lib/client.js): nothing derives
+  // one from the other, and a deployment that mounts the route elsewhere loses the
+  // picker silently — the failure this default is the only record of.
   routePath: z.string().default('/wsl-desktop/api'),
   /**
    * Path to `wsl.exe`. Every probe this half runs spawns it — discovery, directory
@@ -78,6 +83,20 @@ const SELF_MODULE = fileURLToPath(import.meta.url)
 /** Prefix of every preset this plugin owns; its own outputs are never sources. */
 const GENERATED_PREFIX = 'wsl-'
 
+/**
+ * The generated variant id for a resolved base preset.
+ *
+ * A preset that is already a variant keeps its id; anything else gets the prefix. The
+ * selftest and createWorkspace both derived it this way — the second site's own comment
+ * admitted it resolved exactly like the first — so a change to the prefix rule had two
+ * homes.
+ * @param {{ id: string }} preset - the resolved base preset.
+ * @returns {string} the variant id.
+ */
+function variantIdFor(preset) {
+  return preset.id.startsWith(GENERATED_PREFIX) ? preset.id : `${GENERATED_PREFIX}${preset.id}`
+}
+
 /**
  * Module specifiers of the WSL providers, as the preset rows must name them.
  * The 0.1.7 loader imports row names via `new URL(name, baseUrl)` or a bare
@@ -203,6 +222,24 @@ function basePluginsOf(presets, id) {
  *   refuses duplicates).
  * @returns {Promise<object>} the registration outcome for the route.
  */
+/**
+ * Run a shell spec through whichever seam the host exposes, and always hand back a
+ * handle whose `result()` is awaitable.
+ *
+ * 0.1.7 hosts expose `execute`, which resolves with a live handle; older ones have
+ * only `run`, whose settled result carries no `result()` projection. Both selftest
+ * steps used to spell that dual dispatch themselves, and the second one called
+ * `.result()` on `run`'s settled result — a TypeError on exactly the hosts that
+ * branch exists to support. One owner, so the two steps cannot drift again.
+ * @param {object} shell - the realm's shell service.
+ * @param {object} spec - the resolved spec to run.
+ * @returns {Promise<{ result: () => Promise<object> }>} a result()-able handle.
+ */
+function runShellSpec(shell, spec) {
+  if (typeof shell.execute === 'function') return shell.execute(spec)
+  return shell.run(spec).then((settled) => ({ result: async () => settled }))
+}
+
 async function materializePresets(ctx, distro, generation, previous) {
   const presets = ctx.get('agentPresets')
   if (presets === undefined) throw new Error('agentPresets 服务不可用')
@@ -213,9 +250,16 @@ async function materializePresets(ctx, distro, generation, previous) {
   if (hostCompat.registry07 !== true) {
     throw new Error('需要 DSH Desktop 0.1.7+：当前宿主的 agentPresets 缺少 readDocument（0.1.6 及以下不受支持）。请升级桌面，或使用 0.1.6 兼容的插件版本。')
   }
-  if (generation?.disposed) return { status: 'ready', hostCompat, written: [], skipped: [{ id: '-', reason: '插件已卸载，放弃本轮注册' }] }
+  /**
+   * The answer a round gives when its generation was torn down mid-flight: the preset
+   * surface stays READY (the previous generation is still registered), nothing is
+   * written, and the skip says why. Spelled once — it stood three times, so the
+   * wording and the shape each had three homes.
+   */
+  const abandonedRound = () => ({ status: 'ready', hostCompat, written: [], skipped: [{ id: '-', reason: '插件已卸载，放弃本轮注册' }] })
+  if (generation?.disposed) return abandonedRound()
   const roster = await presets.list()
-  if (generation?.disposed) return { status: 'ready', hostCompat, written: [], skipped: [{ id: '-', reason: '插件已卸载，放弃本轮注册' }] }
+  if (generation?.disposed) return abandonedRound()
   const written = []
   const skipped = []
 
@@ -223,7 +267,7 @@ async function materializePresets(ctx, distro, generation, previous) {
   for (const [id, dispose] of previous?.disposers ?? []) {
     try { await dispose() } catch { /* already gone */ }
     previous?.disposers.delete(id)
-    if (generation?.disposed) return { status: 'ready', hostCompat, written: [], skipped: [{ id: '-', reason: '插件已卸载，放弃本轮注册' }] }
+    if (generation?.disposed) return abandonedRound()
   }
 
   for (const preset of roster) {
@@ -410,9 +454,7 @@ const METHODS = {
     const presets = hostCtx?.get('agentPresets')
     if (presets === undefined) throw new Error('agent presets 尚不可用')
     const resolved = await presets.resolve(base)
-    const agentPreset = resolved.id.startsWith(GENERATED_PREFIX)
-      ? resolved.id
-      : `${GENERATED_PREFIX}${resolved.id}`
+    const agentPreset = variantIdFor(resolved)
     const roster = await presets.list()
     const variant = roster.find((preset) => preset.id === agentPreset)
     if (variant === undefined) throw new Error(`WSL 预设 ${agentPreset} 尚未生成`)
@@ -550,8 +592,9 @@ const METHODS = {
         // failure would abort the whole selftest.
         const spec = shell.resolve({ command: 'uname -s; pwd; id -un; echo "$WSL_DISTRO_NAME"', workdir: workspaceCwd })
         // 0.1.7: execute resolves with a live handle; the settled result is
-        // its memoized result() projection. Dual-dispatch for older hosts.
-        const execution = await (typeof shell.execute === 'function' ? shell.execute(spec) : (async () => { const r = await shell.run(spec); return { result: async () => r } })())
+        // its memoized result() projection. Dual-dispatch for older hosts — one
+        // owner, runShellSpec, shared with the confined step below.
+        const execution = await runShellSpec(shell, spec)
         const result = await execution.result()
         record('shell.run', {
           exitCode: result?.exitCode,
@@ -609,8 +652,8 @@ const METHODS = {
       }
 
       if (shell !== undefined) {
-        const exec = typeof shell.execute === 'function' ? shell.execute.bind(shell) : shell.run.bind(shell)
-        const execution = await exec(
+        const execution = await runShellSpec(
+          shell,
           shell.resolve({ command: 'echo blocked > /dsh-wsl-forbidden.txt', workdir: workspaceCwd }),
         ).catch((error) => ({ result: async () => ({ exitCode: null, stderr: { text: String(error?.message ?? error) }, sandbox: null }) }))
         const confined = await execution.result()
@@ -816,9 +859,7 @@ const METHODS = {
       const presets = hostCtx.get('agentPresets')
       if (presets !== undefined) {
         const resolved = await presets.resolve()
-        const candidate = resolved.id.startsWith(GENERATED_PREFIX)
-          ? resolved.id
-          : `${GENERATED_PREFIX}${resolved.id}`
+        const candidate = variantIdFor(resolved)
         const roster = await presets.list()
         if (roster.some((preset) => preset.id === candidate && preset.broken === undefined)) presetId = candidate
       }
@@ -961,7 +1002,7 @@ async function isDeveloperCaller(req, config) {
 /**
  * Register the WSL route and generate the WSL presets.
  * @param {import('@deepseek-ai/cordis').Context} ctx - the plugin context.
- * @param {{ routePath: string, developerTools: boolean }} config - resolved plugin config.
+ * @param {{ routePath: string, developerTools: boolean, wslPath?: string }} config - resolved plugin config.
  */
 export function apply(ctx, config) {
   hostCtx = ctx

package/lib/wsl/confinement.js

@@ -20,11 +20,6 @@
  */
 
 import { shellQuote } from './paths.js'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
-
-/** Shipped helper script, installed by the operator (see docs/CONFINEMENT.md). */
-export const HELPER_SOURCE = join(dirname(fileURLToPath(import.meta.url)), 'dsh-wsl-confine.sh')
 
 /** The direct runner: sudo-wrapped unshare with the fence built in-process. */
 export const RUNNER_SUDO_UNSHARE = 'sudo-unshare'
@@ -207,9 +202,9 @@ function helperGateScript(helperPath) {
     'u=$(stat -c %u "$f" 2>/dev/null) || u=',
     'm=$(stat -c %a "$f" 2>/dev/null) || m=',
     '[ "$u" = 0 ] || ok=no',
-    '[ -n "$m" ] || ok=no',
     // A mode stat cannot report (or one that is not octal) must refuse, not
-    // error out silently: the arithmetic parse is guarded by the non-empty test.
+    // error out silently: the arithmetic parse is guarded by its own non-empty
+    // test, which is why no separate [ -n "$m" ] refusal stands above it.
     '[ -n "$m" ] && (( (8#$m & 022) == 0 )) || ok=no',
     '[ -w "$f" ] && ok=no',
     'd=$(dirname "$f")',
@@ -317,7 +312,9 @@ export async function detectRunner({ distro, username, run }) {
 }
 
 /**
- * Forget cached probe results. Used by tests and by a settings change.
+ * Forget cached probe results. Used by the verification suites — no settings change
+ * calls it (the doc claimed one did; the only caller in the tree is
+ * scripts/verify-confinement.mjs).
  */
 export function resetConfinementCache() {
   identityCache.clear()
@@ -421,7 +418,7 @@ export async function detectNoNewPrivs({ distro, username, run }) {
  * unconditionally (dsh-wsl-confine.sh), so on a setpriv without the flag setpriv
  * rejects the unknown option and exits 1 — the confined command simply does not
  * run, and that is an ordinary COMMAND failure, not the setup-failure marker
- * that reports an unavailable runner. docs/CONFINEMENT.md:33 records the measured exit 1;
+ * that reports an unavailable runner. docs/CONFINEMENT.md:31 records the measured exit 1;
  * this text previously contradicted it by recommending the helper as a remedy.
  *
  * The remedy names the PROBEABLE requirement, not a version: the util-linux release
@@ -668,7 +665,10 @@ function postConditions(keep) {
  * @param {string} options.linuxCwd - absolute Linux working directory.
  * @param {'read-only' | 'workspace-write'} options.mode - the confined mode.
  * @param {string | undefined} options.workspaceLinuxRoot - writable root for `workspace-write`.
- * @param {{ uid: string, gid: string }} options.identity - identity to drop back to.
+ * @param {{ uid: string, gid: string, home: string, name?: string }} options.identity -
+ *   identity to drop back to; `home` and `name` are read for the environment.
+ * @param {boolean | undefined} options.noNewPrivs - whether the runner supports
+ *   `setpriv --no-new-privs`; adds the flag to the drop-back when true.
  * @returns {string} the script to run inside the namespace.
  */
 export function buildNamespaceScript({ command, linuxCwd, mode, workspaceLinuxRoot, identity, noNewPrivs }) {
@@ -726,7 +726,8 @@ export function buildNamespaceScript({ command, linuxCwd, mode, workspaceLinuxRo
  * @param {string} options.linuxCwd - absolute Linux working directory.
  * @param {'read-only' | 'workspace-write'} options.mode - the confined mode.
  * @param {string | undefined} options.workspaceLinuxRoot - writable root for `workspace-write`.
- * @param {{ uid: string, gid: string }} options.identity - identity to drop back to.
+ * @param {{ uid: string, gid: string, home: string, name?: string }} options.identity -
+ *   identity to drop back to; `home` and `name` are read for the environment.
  * @param {boolean} [options.noNewPrivs] - set NO_NEW_PRIVS on the drop when the
  *   distro's setpriv supports it (blocks setuid elevation inside the fence).
  * @param {string} [options.runner] - the resolved runner: 'helper' routes the

package/lib/wsl/fs.js

@@ -83,11 +83,24 @@ export function toHostPath(value, cwd, fallbackDistro) {
  * @returns {string} the Linux spelling when one exists, else the input.
  */
 export function toLinuxPath(value) {
+  return toLinuxPathOrNull(value) ?? value
+}
+
+/**
+ * The Linux spelling of a host path, or undefined when one does not exist.
+ *
+ * The ONE place the UNC/drive translation is written: `toLinuxPath` and the fs
+ * backend's `processPathFromHostPath` differ only in the sentinel they answer for an
+ * unrepresentable path (the input vs undefined), and spelling the translation twice
+ * meant a fix could land in one copy only.
+ * @param {string} value - a host path on the share or a drive path.
+ * @returns {string | undefined} the normalized Linux path, or undefined.
+ */
+function toLinuxPathOrNull(value) {
   const unc = parseWslUnc(value)
   if (unc !== null) return posix.normalize(unc.linuxPath)
   const drive = windowsToMntPath(value)
-  if (drive !== null) return posix.normalize(drive)
-  return value
+  return drive === null ? undefined : posix.normalize(drive)
 }
 
 /**
@@ -288,10 +301,7 @@ export class WslFileSystem extends LocalFileSystem {
    */
   processPathFromHostPath(hostPath) {
     if (typeof hostPath !== 'string' || hostPath.length === 0) return undefined
-    const unc = parseWslUnc(hostPath)
-    if (unc !== null) return posix.normalize(unc.linuxPath)
-    const drive = windowsToMntPath(hostPath)
-    return drive === null ? undefined : posix.normalize(drive)
+    return toLinuxPathOrNull(hostPath)
   }
 
   /**

package/lib/wsl/preset.js

@@ -49,6 +49,48 @@ export const WORLD_MODULE_NAMES = new Set([
   '@deepseek-ai/dsh-terminal',
 ])
 
+/**
+ * Tool-family modules whose survival in a WSL preset is a RECORDED VERDICT.
+ *
+ * The complement of WORLD_MODULE_NAMES inside the tool family, and the reason it
+ * exists: the removal rule is a closed list, so a tool-family row this plugin had
+ * never seen was neither removed NOR reported — it was copied into the WSL variant
+ * in silence, which is the leak shape this transform exists to prevent. A future
+ * DSH release that adds a host-execution tool row would have leaked exactly there,
+ * with every suite still green.
+ *
+ * Every name here was read off a shipped preset and judged world-agnostic: it
+ * neither runs host commands nor reaches host files on the model's behalf. A row
+ * outside BOTH sets is kept — the transform must not guess a row away from a preset
+ * — but reported through `unclassified`, so the next upstream tool row is a
+ * decision somebody makes rather than a leak nobody sees.
+ */
+export const VERDICTED_KEPT_MODULES = new Set([
+  '@deepseek-ai/dsh-tool-jobs',
+  '@deepseek-ai/dsh-tool-schedule',
+  '@deepseek-ai/dsh-tool-skill',
+  '@deepseek-ai/dsh-skill-filesystem',
+  '@deepseek-ai/dsh-command-goal',
+  '@deepseek-ai/dsh-tool-goal',
+  '@deepseek-ai/dsh-tool-subagent-control',
+  '@deepseek-ai/dsh-tool-subagent',
+  '@deepseek-ai/dsh-tool-workflow',
+  '@deepseek-ai/dsh-tool-ask-user',
+  '@deepseek-ai/dsh-tool-todo',
+  '@deepseek-ai/dsh-tool-web',
+  '@deepseek-ai/dsh-tool-cordis',
+  '@deepseek-ai/dsh-tool-present',
+])
+
+/**
+ * The tool / execution family, by package name.
+ *
+ * Narrow on purpose: it decides which rows need a VERDICT, and a family wide enough
+ * to catch the persona, instruction, plan-mode or compaction rows would redden the
+ * acceptance gate over rows whose survival was never in question.
+ */
+const TOOL_FAMILY = /^@deepseek-ai\/dsh-(?:tool-[a-z0-9-]+|terminal[a-z0-9-]*|skill-filesystem)$/u
+
 /** Module extensions a specifier may carry where it names the package itself. */
 const MODULE_SUFFIX = /\.(?:[cm]?js)$/u
 
@@ -76,6 +118,26 @@ function specifierSegments(specifier) {
   return readings.flatMap((reading) => reading.split(/[\\/]/u))
 }
 
+/**
+ * Every `@scope/name` package reading a specifier carries.
+ *
+ * The one place the package identity is derived, shared by the removal predicate
+ * and the verdict predicate so the two cannot disagree about which package a
+ * spelling names — the drift that made the earlier basename match miss a subpath.
+ * @param {unknown} specifier - the row's module name.
+ * @returns {string[]} each scoped pair the specifier carries, in path order.
+ */
+function scopedPackages(specifier) {
+  if (typeof specifier !== 'string' || specifier.length === 0) return []
+  const segments = specifierSegments(specifier)
+  const out = []
+  for (let index = 0; index + 1 < segments.length; index += 1) {
+    if (!segments[index].startsWith('@')) continue
+    out.push(`${segments[index]}/${segments[index + 1].replace(MODULE_SUFFIX, '')}`)
+  }
+  return out
+}
+
 /**
  * Whether one row `name` loads a host-execution-world module.
  *
@@ -100,13 +162,33 @@ function specifierSegments(specifier) {
 export function isHostWorldModule(name) {
   if (typeof name !== 'string' || name.length === 0) return false
   if (WORLD_MODULE_NAMES.has(name)) return true
-  const segments = specifierSegments(name)
-  for (let index = 0; index + 1 < segments.length; index += 1) {
-    if (!segments[index].startsWith('@')) continue
-    const scoped = `${segments[index]}/${segments[index + 1].replace(MODULE_SUFFIX, '')}`
-    if (WORLD_MODULE_NAMES.has(scoped)) return true
-  }
-  return false
+  return scopedPackages(name).some((pkg) => WORLD_MODULE_NAMES.has(pkg))
+}
+
+/**
+ * Whether a row's module belongs to the family that needs a verdict.
+ * @param {unknown} name - the row's module name.
+ * @returns {boolean} true when the module is a tool-family package.
+ */
+export function isToolFamilyModule(name) {
+  if (typeof name !== 'string' || name.length === 0) return false
+  return [name, ...scopedPackages(name)].some((candidate) => TOOL_FAMILY.test(candidate))
+}
+
+/**
+ * Whether this plugin holds an explicit verdict for a row's module.
+ *
+ * True for both verdicts — removed (WORLD_MODULE_NAMES) and deliberately kept
+ * (VERDICTED_KEPT_MODULES) — because the question it answers is "has this row been
+ * decided?", not "is it dropped?".
+ * @param {unknown} name - the row's module name.
+ * @returns {boolean} true when the module carries a verdict.
+ */
+export function hasClassifierVerdict(name) {
+  if (typeof name !== 'string' || name.length === 0) return false
+  return [name, ...scopedPackages(name)].some((candidate) => (
+    WORLD_MODULE_NAMES.has(candidate) || VERDICTED_KEPT_MODULES.has(candidate)
+  ))
 }
 
 /**
@@ -177,18 +259,20 @@ export const WSL_PERSONA_SENTENCE = 'Paths under \\\\wsl.localhost\\<distro> are
 /**
  * Append the WSL path-dialect sentence to a persona row OBJECT.
  * @param {object} row - the persona entry.
- * @returns {boolean} whether the row was amended.
+ *
+ * The row is ALWAYS amended — a string field is extended when one exists and `suffix`
+ * is created when none does — so this returns nothing. It used to document and return
+ * "whether the row was amended" (always true, and its only caller discards it).
  */
 function appendPersonaSuffixObject(row) {
   const config = row.config ?? (row.config = {})
   for (const field of ['suffix', 'text', 'prefix']) {
     if (typeof config[field] === 'string' && config[field].length > 0) {
       config[field] = `${config[field]} ${WSL_PERSONA_SENTENCE}`
-      return true
+      return
     }
   }
   config.suffix = WSL_PERSONA_SENTENCE
-  return true
 }
 
 /**
@@ -224,12 +308,12 @@ function cloneRow(row) {
  * @param {string} options.fsPath - module specifier of the WSL filesystem provider.
  * @param {string | undefined} options.distro - distribution for paths that do not name one.
  * @param {string | undefined} options.sourceDir - directory the source preset lives in.
- * @returns {{ plugins: object[], removed: string[], unclassified: { id: string | null, name: unknown }[] }} the variant rows, what was dropped, and the rows kept without a classifier verdict.
+ * @returns {{ plugins: object[], removed: string[], unclassified: { id: string | null, name: unknown }[] }} the variant rows, what was dropped, and the rows kept without a classifier verdict — an unreadable specifier, or a tool-family module that is neither removed nor verdicted-kept.
  */
 export function buildVariantPlugins(basePlugins, { subprocessPath, shellPath, fsPath, distro, sourceDir }) {
   const kept = []
   const removed = []
-  /** Rows kept without a classifier verdict — see the module-name branch in prune(). */
+  /** Rows kept without a classifier verdict — both shapes the prune() branches record. */
   const unclassified = []
   let includeEditor = false
   /** Config carried by the pruned host-world tool rows, keyed by row id. */
@@ -262,11 +346,22 @@ export function buildVariantPlugins(basePlugins, { subprocessPath, shellPath, fs
       unclassified.push({ id: row.id ?? null, name: row.name ?? null })
     } else if (isHostWorldModule(row.name)) {
       removed.push(row.id ?? row.name)
-      if (row.name.includes('str-replace-editor')) includeEditor = true
-      if (row.name.includes('str-replace-editor') && row.config !== undefined) {
+      // One evaluation, two uses: the predicate stood on adjacent lines, so a future
+      // edit to one of them would silently leave the other behind.
+      const isEditor = row.name.includes('str-replace-editor')
+      if (isEditor) includeEditor = true
+      if (isEditor && row.config !== undefined) {
         toolConfig.set('str-replace-editor', cloneRow({ config: row.config }).config)
       }
       return null
+    } else if (isToolFamilyModule(row.name) && !hasClassifierVerdict(row.name)) {
+      // Readable specifier, tool family, NO verdict: kept and reported. The removal
+      // rule is a closed list, so without this branch a tool row this plugin has
+      // never seen was copied into the WSL variant in silence — the leak shape this
+      // transform exists to prevent, and the one a new upstream tool row would have
+      // taken. Kept rather than removed for the same reason as the unreadable case
+      // above: the transform must not guess a row away from a preset.
+      unclassified.push({ id: row.id ?? null, name: row.name })
     }
     // The registry stores the caller's objects BY REFERENCE — mutating a row
     // here would pollute the shared base definition. Clone per row;

package/lib/wsl/pty.js

@@ -318,7 +318,22 @@ export async function spawnWslTerminal({
   }
 
   const stderr = data.stderr
-  if (stderr === undefined) throw new Error('wsl-pty: 数据进程没有 stderr，无法承载控制应答')
+  if (stderr === undefined) {
+    // This guard throws BEFORE the allocation try below, so it used to escape with
+    // the data process still running — the very leak that try's catch exists to
+    // prevent. Same cleanup, minus `control`: it is not spawned yet at this point,
+    // and `control` is not even in scope here.
+    try {
+      data.terminate()
+    } catch {
+      // Already gone.
+    }
+    await Promise.allSettled([waitForHandle(data)])
+    // The bridge may already have created its FIFO before this check; rm -f is a
+    // no-op when it did not.
+    await cleanupFifo()
+    throw new Error('wsl-pty: 数据进程没有 stderr，无法承载控制应答')
+  }
   stderr.setEncoding('utf8')
   stderr.on('data', (chunk) => {
     replyBuffer += chunk
@@ -481,7 +496,7 @@ export async function spawnWslTerminal({
         control.terminate()
         data.terminate()
         failPending('wsl-pty: 会话已终止')
-        await Promise.allSettled([data.waitForExit?.() ?? waitForHandle(data), waitForHandle(control)])
+        await Promise.allSettled([waitForHandle(data), waitForHandle(control)])
         // AFTER both processes have settled, from the host side: the bridge's
         // own finally lost this race often enough to leave orphans behind.
         await cleanupFifo()

package/lib/wsl/shell.js

@@ -428,10 +428,13 @@ export class WslShellExecutor extends ShellExecutor {
       }
     }
     const emptyReader = { readFrom: () => ({ text: '', lossy: false, nextOffset: 0 }) }
-    /** The failure note the READ PATH must serve; filled in when a spawn fails. */
-    const spawnFailure = {
-      note: spawnError === undefined ? undefined : `subprocess failed before reporting an outcome: ${String(spawnError)}`,
-    }
+    /**
+     * The failure note the READ PATH must serve; assigned by settle() when a spawn
+     * fails. The holder starts bare on purpose: servesNote stays false until settle()
+     * has written note, so an initializer here could never reach a reader — the
+     * ternary that stood here built a string no branch could observe.
+     */
+    const spawnFailure = { note: undefined }
     const providerReaders = handle === undefined ? undefined : WslShellExecutor.readers(handle)
     const stdout = providerReaders?.stdout ?? emptyReader
     const baseStderr = providerReaders?.stderr ?? emptyReader

package/lib/wsl/subprocess.js

@@ -34,7 +34,7 @@ import { LoginShellUnresolvedError, WSL_CHILD_ENV, buildWslExecArgv, planWsl, re
 /**
  * The executable lookup's ceiling, on the documented probe policy.
  *
- * Was 15s and the shortest ceiling in the plugin. docs/CONFINEMENT.md:36 names
+ * Was 15s and the shortest ceiling in the plugin. docs/CONFINEMENT.md:34 names
  * `resolveExecutable` in the same sentence as 探针超时 60s + 超时后一次透明重试, and it is an
  * output-parsed probe like the siblings that sentence lists (the comment on the probe below
  * says so), so it gets the same 60s as `listLinuxDir`/`checkLinuxPath`/`resolveDistroHome`
@@ -46,6 +46,20 @@ const LOOKUP_TIMEOUT_MS = 60_000
 /** Windows shells whose names the terminal controller may probe inside the distribution. */
 const WINDOWS_SHELLS = new Set(['powershell', 'pwsh', 'cmd'])
 
+/**
+ * The basename a Windows-shell test compares: directories stripped, lowercased, a
+ * trailing `.exe` removed.
+ *
+ * ONE owner: the candidate lookup and the terminal-argv translation each spelled this
+ * pipeline, so a fix to either (a Windows path separator, a new extension) could land in
+ * one copy only. `value ?? ''` because one caller passes an optional argv element.
+ * @param {unknown} value - a program spelling.
+ * @returns {string} the comparable basename, or '' when there is nothing to compare.
+ */
+function shellBaseName(value) {
+  return String(value ?? '').split(/[\\/]/).pop()?.toLowerCase().replace(/\.exe$/, '') ?? ''
+}
+
 /** The PTY bridge shipped beside this module. */
 const BRIDGE_PATH = join(dirname(fileURLToPath(import.meta.url)), 'terminal-bridge.py')
 
@@ -167,7 +181,7 @@ export class WslSubprocessRuntime extends SubprocessRuntime {
       // shell (PowerShell on a Windows deployment) through THIS provider; in
       // the distribution that dialect-translates to the session user's login
       // shell. Absent any Windows shell, the login shell is the honest answer.
-      const base = String(command).split(/[\\/]/).pop()?.toLowerCase().replace(/\.exe$/, '') ?? ''
+      const base = shellBaseName(command)
       if (WINDOWS_SHELLS.has(base)) {
         try {
           return await resolveLoginShell(plan.distro, this.config.username, { wslPath: this.config.wslPath })
@@ -261,7 +275,7 @@ export class WslSubprocessRuntime extends SubprocessRuntime {
       // (PowerShell on Windows) through THIS provider; in the distribution
       // that dialect-translates to the session user's login shell — a lone
       // '-NoLogo' arg would kill bash, so the whole argv is translated.
-      const base0 = String(spec.argv?.[0] ?? '').split(/[\\/]/).pop()?.toLowerCase().replace(/\.exe$/, '') ?? ''
+      const base0 = shellBaseName(spec.argv?.[0])
       // Deliberately NOT translated into SubprocessExecutableNotFoundError the
       // way the candidate lookup above is. There is no candidate list here to
       // skip down — this spec named exactly ONE program — so the translation

package/lib/wsl/terminal-bridge.py

@@ -200,7 +200,12 @@ class Bridge:
     def activity(self):
         """Report busy when the foreground group is not the shell itself."""
         pgrp = self.foreground_pgrp()
-        state = "unknown" if pgrp is None else ("idle" if pgrp == self.shell_pgrp else "busy")
+        if pgrp is None:
+            state = "unknown"
+        elif pgrp == self.shell_pgrp:
+            state = "idle"
+        else:
+            state = "busy"
         if state != self.last_state:
             self.last_state = state
             self.revision += 1

package/lib/wsl/world.js

@@ -225,6 +225,37 @@ export async function listDistros({ wslPath = 'wsl.exe' } = {}) {
     .filter((line) => line.length > 0)
 }
 
+/**
+ * The Lxss registry values and the two REG_SZ lines the default-distribution read needs.
+ *
+ * The patterns live HERE, once, because the async and the sync reader each carried their
+ * own copy: a registry-format change had two homes, and only one of them was exercised by
+ * whichever caller the operator happened to hit.
+ */
+const DEFAULT_DISTRIBUTION_VALUE = 'DefaultDistribution'
+const DISTRIBUTION_NAME_VALUE = 'DistributionName'
+const GUID_PATTERN = /DefaultDistribution\s+REG_SZ\s+(\{[0-9a-fA-F-]+\})/iu
+const NAME_PATTERN = /DistributionName\s+REG_SZ\s+(.+)/iu
+
+/**
+ * The distribution a `DistributionName` line names.
+ * @param {unknown} output - the registry query's stdout.
+ * @returns {string | undefined} the name, or undefined when the line names none.
+ */
+function distroFromRegistryOutput(output) {
+  const distro = NAME_PATTERN.exec(String(output))?.[1]?.trim()
+  return distro === undefined || distro === '' ? undefined : distro
+}
+
+/**
+ * The Lxss subkey a `DefaultDistribution` line names.
+ * @param {unknown} output - the registry query's stdout.
+ * @returns {string | undefined} the GUID, or undefined when the line names none.
+ */
+function guidFromRegistryOutput(output) {
+  return GUID_PATTERN.exec(String(output))?.[1]
+}
+
 /**
  * Read the user's default distribution from the Lxss registry. Non-fatal:
  * `undefined` when the value is absent or unreadable.
@@ -232,16 +263,15 @@ export async function listDistros({ wslPath = 'wsl.exe' } = {}) {
  */
 export async function defaultDistro() {
   try {
-    const value = await execFileAsync('reg.exe', ['query', LXSS_KEY, '/v', 'DefaultDistribution'], {
+    const value = await execFileAsync('reg.exe', ['query', LXSS_KEY, '/v', DEFAULT_DISTRIBUTION_VALUE], {
       timeout: DISCOVERY_TIMEOUT_MS,
     })
-    const guid = /DefaultDistribution\s+REG_SZ\s+(\{[0-9a-fA-F-]+\})/i.exec(String(value.stdout))?.[1]
+    const guid = guidFromRegistryOutput(value.stdout)
     if (guid === undefined) return undefined
-    const name = await execFileAsync('reg.exe', ['query', `${LXSS_KEY}\\${guid}`, '/v', 'DistributionName'], {
+    const name = await execFileAsync('reg.exe', ['query', `${LXSS_KEY}\\${guid}`, '/v', DISTRIBUTION_NAME_VALUE], {
       timeout: DISCOVERY_TIMEOUT_MS,
     })
-    const distro = /DistributionName\s+REG_SZ\s+(.+)/i.exec(String(name.stdout))?.[1]?.trim()
-    return distro === undefined || distro === '' ? undefined : distro
+    return distroFromRegistryOutput(name.stdout)
   } catch {
     // A missing or unreadable registry value leaves the caller its own fallback.
     return undefined
@@ -261,16 +291,15 @@ export function defaultDistroSync() {
   if (syncDefaultResolved) return syncDefault
   syncDefaultResolved = true
   try {
-    const value = execFileSync('reg.exe', ['query', LXSS_KEY, '/v', 'DefaultDistribution'], {
+    const value = execFileSync('reg.exe', ['query', LXSS_KEY, '/v', DEFAULT_DISTRIBUTION_VALUE], {
       timeout: DISCOVERY_TIMEOUT_MS,
     })
-    const guid = /DefaultDistribution\s+REG_SZ\s+(\{[0-9a-fA-F-]+\})/i.exec(String(value))?.[1]
+    const guid = guidFromRegistryOutput(value)
     if (guid === undefined) return undefined
-    const name = execFileSync('reg.exe', ['query', `${LXSS_KEY}\\${guid}`, '/v', 'DistributionName'], {
+    const name = execFileSync('reg.exe', ['query', `${LXSS_KEY}\\${guid}`, '/v', DISTRIBUTION_NAME_VALUE], {
       timeout: DISCOVERY_TIMEOUT_MS,
     })
-    const distro = /DistributionName\s+REG_SZ\s+(.+)/i.exec(String(name))?.[1]?.trim()
-    syncDefault = distro === undefined || distro === '' ? undefined : distro
+    syncDefault = distroFromRegistryOutput(name)
   } catch {
     // An unreadable registry leaves the caller its own fail-loud path.
     syncDefault = undefined
@@ -353,15 +382,31 @@ function bridgeEnv(extra) {
  * @returns {{ distro: string, linuxCwd: string, windowsCwd: string }} the execution plan.
  * @throws Error when the directory belongs to neither world.
  */
+/**
+ * The distribution a plan runs in: the caller's fallback, else the machine default.
+ * @param {string} workdir - the directory being planned, named in the failure.
+ * @param {string|undefined} fallbackDistro - the configured distro, when there is one.
+ * @returns {string} the distribution name.
+ * @throws {Error} when neither source names one.
+ */
+function wslUserOption(username) {
+  return username !== undefined && username !== '' ? ['-u', username] : []
+}
+
+function planDistro(workdir, fallbackDistro) {
+  const distro = fallbackDistro ?? defaultDistroSync()
+  if (distro === undefined) {
+    throw new Error(`wsl: 无法确定 "${workdir}" 所属的发行版，请配置 distro`)
+  }
+  return distro
+}
+
 export function planWsl(workdir, fallbackDistro) {
   const windowsCwd = process.env.SystemRoot ?? process.cwd()
   const unc = parseWslUnc(workdir)
   if (unc !== null) return { distro: unc.distro, linuxCwd: unc.linuxPath, windowsCwd }
   if (workdir.startsWith('/')) {
-    const distro = fallbackDistro ?? defaultDistroSync()
-    if (distro === undefined) {
-      throw new Error(`wsl: 无法确定 "${workdir}" 所属的发行版，请配置 distro`)
-    }
+    const distro = planDistro(workdir, fallbackDistro)
     // A drive mount is also addressable from the Windows side; keep that as the
     // spawn directory so a failure still names a real path.
     return { distro, linuxCwd: workdir, windowsCwd: mntToWindowsPath(workdir) ?? windowsCwd }
@@ -370,10 +415,7 @@ export function planWsl(workdir, fallbackDistro) {
   if (mnt === null) {
     throw new Error(`wsl: 工作目录 "${workdir}" 不在 WSL 执行世界里`)
   }
-  const distro = fallbackDistro ?? defaultDistroSync()
-  if (distro === undefined) {
-    throw new Error(`wsl: 无法确定 "${workdir}" 所属的发行版，请配置 distro`)
-  }
+  const distro = planDistro(workdir, fallbackDistro)
   return { distro, linuxCwd: mnt, windowsCwd }
 }
 
@@ -399,7 +441,7 @@ export function buildWslExecArgv(plan, argv, options = {}) {
   return [
     options.wslPath ?? 'wsl.exe',
     '-d', plan.distro,
-    ...(options.username !== undefined && options.username !== '' ? ['-u', options.username] : []),
+    ...wslUserOption(options.username),
     '--cd', plan.linuxCwd,
     '-e',
     ...argv,
@@ -486,7 +528,7 @@ export function runWslShell({ distro, linuxCwd, command, username, loginShell =
   const script = loginShell ? `cd ${shellQuote(linuxCwd)} && ${command}` : command
   const argv = [
     '-d', distro,
-    ...(username !== undefined && username !== '' ? ['-u', username] : []),
+    ...wslUserOption(username),
     '--cd', linuxCwd,
     '-e', 'bash', loginShell ? '-lc' : '-c', script,
   ]
@@ -592,12 +634,14 @@ const PROBE_TIMEOUT_MS = 60_000
  * probe follows: repeat the SAME probe once, immediately, and let a persistent stall
  * still fail loudly with the second attempt's evidence.
  *
- * Retrying is safe here because all three probes are READS: the listing protocol frames
+ * Retrying is safe here because all FOUR probes are READS: the listing protocol frames
  * its own output and the check prints one of three tokens, so a repeat cannot duplicate
- * a side effect. The trigger is deliberately `timedOut` alone and not "any bad answer":
- * a non-zero exit from the listing script is the ordinary answer for a directory that is
- * not there, and doubling the latency of that case would slow the interactive picker for
- * no measured benefit.
+ * a side effect; `resolveLoginShell` runs a read-only `getent` and answers the same way.
+ * (This comment said "three" while four probes already consumed the runner — scripts/
+ * wsl-probe.mjs counts the same four.) The trigger is deliberately `timedOut` alone and
+ * not "any bad answer": a non-zero exit from the listing script is the ordinary answer
+ * for a directory that is not there, and doubling the latency of that case would slow
+ * the interactive picker for no measured benefit.
  * @param {(request: object) => Promise<object>} run - the probe runner.
  * @param {object} request - the probe, without its ceiling.
  * @returns {Promise<object>} the first conclusive attempt, or the second after a timeout.
@@ -612,7 +656,7 @@ async function probeWithRetry(run, request) {
  * List one directory inside a distribution.
  * @param {string} distro - distribution name.
  * @param {string} linuxPath - absolute Linux directory.
- * @param {{ wslPath?: string, run?: (options: object) => Promise<object> }} [options] - the configured `wsl.exe` path, and the probe runner (injectable so the retry policy below can be driven without a distribution — the same seam `resolveIdentity`/`detectRunner` expose).
+ * @param {{ wslPath?: string, run?: (options: object) => Promise<object> }} [options] - the configured `wsl.exe` path, and the probe runner (injectable so the retry policy above can be driven without a distribution — the same seam `resolveIdentity`/`detectRunner` expose).
  * @returns {Promise<{ path: string, parent: string | null, entries: Array<{ name: string, kind: 'directory' | 'file' }> }>} the listing.
  */
 export async function listLinuxDir(distro, linuxPath, { wslPath, run = runWslShell } = {}) {
@@ -651,7 +695,7 @@ export async function listLinuxDir(distro, linuxPath, { wslPath, run = runWslShe
  * Check whether one Linux path exists.
  * @param {string} distro - distribution name.
  * @param {string} linuxPath - absolute Linux path.
- * @param {{ wslPath?: string, run?: (options: object) => Promise<object> }} [options] - the configured `wsl.exe` path, and the probe runner (injectable so the retry policy below can be driven without a distribution).
+ * @param {{ wslPath?: string, run?: (options: object) => Promise<object> }} [options] - the configured `wsl.exe` path, and the probe runner (injectable so the retry policy above can be driven without a distribution).
  * @returns {Promise<{ exists: boolean, isDirectory: boolean }>} existence facts.
  */
 export async function checkLinuxPath(distro, linuxPath, { wslPath, run = runWslShell } = {}) {
@@ -707,7 +751,7 @@ export function probeEvidence(entry) {
  * exactly one path.
  * @param {string} distro - distribution name.
  * @param {string} [username] - user to resolve; absent resolves the default user.
- * @param {{ wslPath?: string, run?: (options: object) => Promise<object> }} [options] - the configured `wsl.exe` path, and the probe runner (injectable so the retry policy below can be driven without a distribution).
+ * @param {{ wslPath?: string, run?: (options: object) => Promise<object> }} [options] - the configured `wsl.exe` path, and the probe runner (injectable so the retry policy above can be driven without a distribution).
  * @returns {Promise<{ user: string, home: string }>} the user and their home.
  * @throws Error when the user or a usable home cannot be resolved.
  */
@@ -842,7 +886,7 @@ export class LoginShellUnresolvedError extends Error {
  * own evidence instead of answering.
  * @param {string} distro - distribution name.
  * @param {string} [username] - Linux user; omitted uses the distribution default.
- * @param {{ wslPath?: string, run?: (options: object) => Promise<object> }} [options] - the configured `wsl.exe` path, and the probe runner (injectable so the retry policy below can be driven without a distribution — the same seam the sibling probes expose).
+ * @param {{ wslPath?: string, run?: (options: object) => Promise<object> }} [options] - the configured `wsl.exe` path, and the probe runner (injectable so the retry policy above can be driven without a distribution — the same seam the sibling probes expose).
  * @returns {Promise<string>} the login shell path.
  * @throws {LoginShellUnresolvedError} when the probe timed out twice, could not
  *   run, or `getent` did not answer. The one value returned without the probe (an

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "dsh-wsl-desktop",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "type": "module",
   "main": "lib/index.js",
+  "icon": "./lib/icon.svg",
   "exports": {
     ".": "./lib/index.js",
     "./client": "./lib/client.js",