dsh-wsl-workspace 0.4.3 → 0.7.2

package/lib/index.js

@@ -1,5 +1,6 @@
-import { defaultDistro, isAbsoluteLinuxPath, isValidWslUsername, joinUnc, listDistros, mntToWindowsPath, normalizeLinuxPath, parseWslUnc } from "./wsl-6VcgOvF9.js";
-import { canonicalWslUnc, getWindowsWorkspace, getWorkspaceUsername, listWorkspaceKeys, registerWindowsWorkspace, setWorkspaceUsername } from "./wsl-credentials-B6wIXsKt.js";
+import { defaultDistro, isAbsoluteLinuxPath, isValidWslUsername, joinUnc, listDistros, mntToWindowsPath, normalizeLinuxPath, parseWslUnc, uncToLinux } from "./wsl-CECXiGZH.js";
+import { canonicalWslUnc, getWindowsWorkspace, getWorkspaceUsername, listWorkspaceKeys, registerWindowsWorkspace, setWorkspaceUsername } from "./wsl-credentials-BJXc9tfi.js";
+import { resolveLinuxSymlinks } from "./links-BQxdJOMy.js";
 import z from "@deepseek-ai/schemastery";
 import { cpSync, existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -28,41 +29,151 @@ const WORLD_ROWS = new Set([
 	"tool-fs",
 	"tool-fs-search",
 	"str-replace-editor",
+	"tool-str-replace-editor",
+	"wsl-world",
 	"filesystem",
 	"persistent-shell",
+	"persistent-bash",
+	"persistent-pwsh",
+	"terminal-bash",
+	"terminal-pwsh",
 	"custom-bash",
 	"bootstrap-filesystem"
 ]);
+/** Execution-world rows that register the model-facing editor tool. */
+const EDITOR_ROWS = new Set(["str-replace-editor", "tool-str-replace-editor"]);
+/** The row ids this generator mounts inside its own world group. */
+const WSL_WORLD_PROVIDER_IDS = ["shell-wsl", "fs-wsl"];
+/**
+* Whether a top-level row is this generator's own WSL world group.
+*
+* A preset copied from a generated variant (a user renaming `wsl-standard` to
+* their own mode, say) carries the group under whatever id the copy kept, so
+* the mounted provider ids identify it even when the row id changed. Without
+* that check the variant would carry two world groups and the loader refuses
+* the whole preset with `duplicate loader entry id: wsl-world`.
+* @param block - the row's lines.
+* @returns true when the row mounts this generator's WSL providers.
+*/
+function isWslWorldGroup(block) {
+	const text = block.join("\n");
+	return WSL_WORLD_PROVIDER_IDS.some((id) => new RegExp(`^\\s+- id: ${id}$`, "m").test(text));
+}
+/**
+* The persistent-shell rows: the host's own PTY registry and its config-driven
+* backend, told to run this plugin's relay (so the shell is a WSL one), plus
+* the persistent tool that consumes them.
+*
+* Two shapes matter here. The registry is an agent-owned service — the shipped
+* `persistent-shell` group keeps it in its own `terminals` realm for that
+* reason — so this is a nested group of the world rather than three flat rows.
+* And the persistent tool registers the tool name **`bash`**, exactly like the
+* one-shot `dsh-tool-bash` row it replaces: both cannot be mounted (the tools
+* registry rejects the duplicate and the whole preset fails to load), which is
+* also why DSH's own Minimal mode describes itself as "a single-tool agent with
+* a persistent shell". So a world with the relay paths swaps the shell tool
+* instead of adding one, and a world without them keeps the one-shot row.
+*/
+function persistentShellRows(relayPath, nodePath) {
+	return [
+		"    # Persistent shell: the host PTY registry and its backend, running",
+		"    # this plugin's relay, which hands the PTY to `wsl.exe … bash`",
+		"    # (distribution and user come from the session). It registers the",
+		"    # `bash` tool, so it takes the place of the one-shot row above.",
+		"    - id: persistent-shell",
+		"      name: cordis:group",
+		"      group: true",
+		"      isolate:",
+		"        terminals: true",
+		"      config:",
+		"        - id: pty",
+		"          name: '@deepseek-ai/dsh-terminal'",
+		"        - id: terminal-wsl",
+		"          name: '@deepseek-ai/dsh-terminal-bash'",
+		"          config:",
+		"            backendType: wsl",
+		"            shellDialect: bash",
+		`            shellPath: '${nodePath.replace(/'/g, "''")}'`,
+		"            shellArgs:",
+		`              - '${relayPath.replace(/'/g, "''")}'`,
+		"        - id: persistent-bash",
+		"          name: '@deepseek-ai/dsh-tool-bash-persistent'",
+		"          config:",
+		"            backendType: wsl",
+		...SHELL_DESCRIPTION_ROWS
+	];
+}
+/**
+* The persistent tool's model-facing description, replacing the host default.
+*
+* The host tool's default says only that state persists, and its own Minimal
+* preset goes further in the wrong direction by suggesting `sleep 10 &`. Both
+* facts a WSL session needs are missing, and both were learned the hard way:
+*
+*  - The shell is one process for the whole Agent, so a `cd` in one call decides
+*    where the *next* call starts. A model that read the one-shot tool's contract
+*    ("each call runs in a fresh shell — pass `workdir` instead of using `cd`")
+*    will be surprised, and a probe left in `/tmp` makes every later relative path
+*    resolve somewhere it never named.
+*  - The host wraps each command as `eval -- $'…'`. A trailing `&` therefore
+*    backgrounds the *whole* wrapped command: the tool's completion marker is
+*    printed before the work runs, so the call reports no output and exit code 0
+*    while the real output arrives later and can land inside the next call's
+*    output window. `( … ) &` on its own line keeps the `&` on the subshell and
+*    leaves the wrapper's sequencing intact.
+*
+* `description` is a supported key on every declared release (its `Config` schema
+* carries it from 0.1.0-rc.7 on), so the override is version-safe.
+*/
+const SHELL_DESCRIPTION_ROWS = [
+	"            description: |-",
+	"              Run commands in a persistent bash shell inside this WSL distribution. State, including",
+	"              the current directory and exported environment variables, persists across calls: use",
+	"              absolute paths or an explicit `cd` at the start of a command instead of relying on where",
+	"              the previous call left the shell. The shell runs as the workspace's Linux user; Windows",
+	"              files are reachable as /mnt/<drive>, and no toolchain install is required.",
+	"              * This tool takes `command` only. It has no `run_in_background` parameter, and passing",
+	"              one is ignored - use the `bash_background` tool when the mode provides it, or background",
+	"              a subshell as below.",
+	"              * To leave work running without a tracked job, put it in a subshell with the `&` on its",
+	"              own line: `( long-job > log 2>&1 ) &`. Then poll the log file in a later call.",
+	"              * Never end a `&&` chain with `&`. That backgrounds the whole command, so the call",
+	"              returns immediately with no output and exit code 0, and the real output arrives later,",
+	"              possibly inside the next call's output.",
+	"              * Avoid commands that wait for stdin: an interactive foreground child can run until the",
+	"              command timeout, and a timeout resets the shell and discards its state."
+];
 /** The injected WSL world group: providers + the bash/fs consumers, entry-local. */
-function wslWorldGroup(shellPath, fsPath, includeEditor) {
+function wslWorldGroup(shellPath, fsPath, includeEditor, persistent, searchPath, jobsPath, sawJobs = false) {
 	return [
 		"# ── WSL execution world (dsh-wsl-workspace variant) ─────────────────────",
 		"# The shell and fs services are provided entry-locally (the isolate",
 		"# realm); host services (tools registry, shell-env, jobs) fall through.",
-		"# tool-fs-search is intentionally absent: the packaged ripgrep runs on",
-		"# the Windows host and cannot open Linux paths; WSL sessions search with",
-		"# shell tools instead.",
 		"- id: wsl-world",
 		"  name: cordis:group",
 		"  group: true",
 		"  isolate:",
 		"    shell: true",
 		"    fs: true",
+		...persistent === void 0 ? [] : ["    sandbox: true"],
 		"  config:",
 		`    - id: shell-wsl`,
 		`      name: '${shellPath.replace(/'/g, "''")}'`,
 		"    - id: fs-wsl",
 		`      name: '${fsPath.replace(/'/g, "''")}'`,
-		"    - id: tool-bash",
-		"      name: '@deepseek-ai/dsh-tool-bash'",
+		...persistent === void 0 ? [] : ["    - id: sandbox-wsl", `      name: '${persistent.sandboxPath.replace(/'/g, "''")}'`],
+		...persistent === void 0 ? ["    - id: tool-bash", "      name: '@deepseek-ai/dsh-tool-bash'"] : [],
 		"    - id: tool-fs",
 		"      name: '@deepseek-ai/dsh-tool-fs'",
+		...searchPath === void 0 ? [] : ["    - id: search-wsl", `      name: '${searchPath.replace(/'/g, "''")}'`],
+		...jobsPath === void 0 || persistent === void 0 || !sawJobs ? [] : ["    - id: jobs-wsl", `      name: '${jobsPath.replace(/'/g, "''")}'`],
 		...includeEditor ? [
 			"    - id: str-replace-editor",
 			"      name: '@deepseek-ai/dsh-tool-str-replace-editor'",
 			"      config:",
 			"        maxOutputChars: 16000"
 		] : [],
+		...persistent === void 0 ? [] : persistentShellRows(persistent.relayPath, persistent.nodePath),
 		""
 	].join("\n");
 }
@@ -228,24 +339,38 @@ function appendPersona(lines, span) {
 /**
 * Transform one source preset composition into its WSL variant: drop the
 * execution-world rows, keep everything else verbatim, and append the WSL
-* world group. The persistent-shell group is NOT re-added: it registers the
-* same `bash` tool name as the WSL world's `dsh-tool-bash`, and the tools
-* registry rejects duplicates within one preset layer — the whole variant
-* fails to mount and the session falls back to another preset. Its PTY
-* backend additionally cannot run on this plugin's Windows host
-* (`dsh-subprocess-local`: "terminal inspection is unsupported on platform
-* win32"), so the group could never spawn a shell here anyway. The WSL
-* world's ordinary `bash` tool covers command execution for every variant.
+* world group. A row id that appears twice in the source is kept once, and a
+* world group the source already carries (a preset copied from a generated
+* variant) is replaced rather than duplicated, so the variant always mounts
+* exactly one world pointing at this installation's providers.
+*
+* The source's own persistent-shell group is not re-added as such: it registers
+* the same `bash` tool name as the WSL world's `dsh-tool-bash`, and the tools
+* registry rejects duplicates within one preset layer — the whole variant fails
+* to mount and the session falls back to another preset. Its PTY *backend*, on
+* the other hand, is exactly what a stateful WSL shell needs, and it is
+* config-driven: given the relay in {@link persistentShellRows} it runs
+* `wsl.exe … bash` under the host's PTY, and its tool registers the separate
+* `persistent-bash` name, so the one-shot `bash` above stays as it is.
 * @param source - the source composition text.
 * @param shellPath - absolute path of the plugin's built WSL shell provider.
 * @param fsPath - absolute path of the plugin's built WSL fs provider.
+* @param persistent - the relay, interpreter and sandbox provider a stateful
+*   shell needs; omit to generate a world without the persistent-shell rows.
+* @param searchPath - absolute path of the plugin's built in-distribution
+*   `grep`/`glob` tools; mounted only for a source that had `tool-fs-search`.
+* @param jobsPath - absolute path of the plugin's built background-job producer
+*   for the persistent shell; mounted only alongside that shell.
 * @returns the variant composition text.
 */
-function transformPresetForWsl(source, shellPath, fsPath) {
+function transformPresetForWsl(source, shellPath, fsPath, persistent, searchPath, jobsPath) {
 	const lines = source.split("\n");
 	const spans = topLevelSpans(lines);
 	const kept = [];
+	const seen = /* @__PURE__ */ new Set();
 	let sawEditor = false;
+	let sawSearch = false;
+	let sawJobs = false;
 	let personaAppended = false;
 	for (const span of spans) {
 		const id = spanId(lines, span);
@@ -253,9 +378,16 @@ function transformPresetForWsl(source, shellPath, fsPath) {
 			kept.push(...lines.slice(span.start, span.end));
 			continue;
 		}
-		if (WORLD_ROWS.has(id)) continue;
+		if (seen.has(id)) continue;
+		seen.add(id);
+		const block = lines.slice(span.start, span.end);
+		if (WORLD_ROWS.has(id) || isWslWorldGroup(block)) {
+			if (EDITOR_ROWS.has(id)) sawEditor = true;
+			if (id === "tool-fs-search") sawSearch = true;
+			continue;
+		}
 		if (id === SKILL_FILESYSTEM_ROW) {
-			kept.push(...disableSkillWatch(lines.slice(span.start, span.end)));
+			kept.push(...disableSkillWatch(block));
 			continue;
 		}
 		if (id === "persona" && !personaAppended && appendablePersona(lines, span)) {
@@ -263,13 +395,14 @@ function transformPresetForWsl(source, shellPath, fsPath) {
 			personaAppended = true;
 			continue;
 		}
-		kept.push(...lines.slice(span.start, span.end));
-		if (id === "str-replace-editor") sawEditor = true;
+		kept.push(...block);
 	}
 	if (source.includes("str-replace-editor")) sawEditor = true;
+	if (source.includes("tool-fs-search")) sawSearch = true;
+	if (source.includes("tool-jobs")) sawJobs = true;
 	const result = [...kept];
 	if (result.length > 0 && result[result.length - 1] !== "") result.push("");
-	result.push(wslWorldGroup(shellPath, fsPath, sawEditor));
+	result.push(wslWorldGroup(shellPath, fsPath, sawEditor, persistent, sawSearch ? searchPath : void 0, jobsPath, sawJobs));
 	return result.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\n+$/, "\n");
 }
 /** Whether an id is one of this plugin's own preset directories. */
@@ -292,12 +425,41 @@ const MAX_SCAN_DEPTH = 4;
 const MAX_SKILL_ROOTS = 64;
 /** Maximum directories visited per lookup (an absolute blast-radius cap). */
 const MAX_VISITED_DIRECTORIES = 4096;
+/**
+* How many Linux symlinks one lookup may hand to the distribution (a second
+* blast-radius cap, and a latency cap: each resolution is a short `wsl.exe`
+* call, so a tree with hundreds of links cannot stall the catalog).
+*/
+const MAX_LINK_RESOLUTIONS = 32;
 /** How many parent levels above the session cwd are searched for a `.git` project marker. */
 const MAX_ANCESTOR_WALK = 64;
-/** How long a completed lookup is served from cache before the next rescan. */
-const CACHE_TTL_MS = 1e4;
+/**
+* How many directories one discovery layer may probe at once.
+*
+* A `readdir` over the `\\wsl.localhost\…` share measured 15.6 ms against 1.6 ms
+* for a `stat`, and a budget-sized walk is 4096 directories: probing one
+* directory at a time costs 20-30 s, which is what a turn in a large workspace
+* used to wait for. The layer stays bounded so the share is never flooded; node's
+* own filesystem thread pool is what ultimately caps the real parallelism.
+*/
+const WALK_CONCURRENCY = 16;
 /** Maximum cached lookups (one entry per distinct scan root across sessions). */
 const CACHE_MAX_ENTRIES = 32;
+/**
+* How often a served scan root is re-checked for catalog changes: the skills
+* directories it published, plus one modification stamp per skill file. This is
+* the pass that makes a skill added — or a description edited — mid-session
+* visible on the model's next request.
+*/
+const REFRESH_POLL_MS = 3e3;
+/**
+* How often the full re-discovery walk runs for a served scan root. Only a walk
+* can find a skills directory that did not exist before (a new nested project,
+* say), and it costs one `readdir` per visited directory, so it runs on its own
+* slower cadence instead of on every poll. It used to be the only pass, at
+* {@link REFRESH_POLL_MS}'s old value of 10 s.
+*/
+const DISCOVERY_POLL_MS = 3e4;
 /** Kebab-case skill names, matching the host grammar. */
 const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 /** Directory names that never contain project skill roots (safe to prune while walking). */
@@ -333,7 +495,8 @@ const PRUNED_DIRECTORY_NAMES = new Set([
 const nodeSkillIo = {
 	readdir: async (path, options) => readdir(path, options),
 	readFile: async (path, options) => readFile(path, options),
-	stat: async (path) => stat(path)
+	stat: async (path) => stat(path),
+	resolveLinks: async (uncPaths) => resolveLinuxSymlinks(uncPaths)
 };
 /**
 * Locate the nearest ancestor of `linuxDir` (the directory itself included)
@@ -359,7 +522,56 @@ async function nearestGitAncestor(distro, linuxDir, io) {
 	return void 0;
 }
 /**
+* Everything the walk learns from one directory, in the order the round trips
+* are worth paying for: the listing first — it also says which skill markers can
+* exist there at all — then the markers it showed.
+* @param distro - the WSL distribution name.
+* @param dir - the directory's Linux path.
+* @param depth - its depth below the scan root.
+* @param io - filesystem face.
+* @returns the directory's roots, child directories and unresolved links.
+*/
+async function probeDirectory(distro, dir, depth, io) {
+	let entries;
+	if (depth < MAX_SCAN_DEPTH) try {
+		entries = await io.readdir(joinUnc(distro, dir), { withFileTypes: true });
+	} catch {}
+	const listed = entries ?? [];
+	const allMarkers = PROJECT_SKILL_MARKERS.map(([marker]) => marker);
+	const markers = entries === void 0 ? allMarkers : allMarkers.filter((marker) => listed.some((entry) => entry.name === marker));
+	const roots = await skillRootsOfDirectory(distro, dir, io, markers);
+	const children = [];
+	const links = [];
+	for (const entry of listed) {
+		if (PRUNED_DIRECTORY_NAMES.has(entry.name)) continue;
+		if (entry.name.startsWith(".") && entry.name !== ".dsh" && entry.name !== ".agents") continue;
+		if (entry.name === ".dsh" || entry.name === ".agents") continue;
+		const childPath = posix.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			children.push([childPath, depth + 1]);
+			continue;
+		}
+		if (!entry.isSymbolicLink()) continue;
+		try {
+			const target = await io.stat(joinUnc(distro, childPath));
+			if (target.isDirectory()) children.push([childPath, depth + 1]);
+			continue;
+		} catch {}
+		links.push([childPath, depth + 1]);
+	}
+	return {
+		roots,
+		children,
+		links
+	};
+}
+/**
 * Scan a WSL workspace root for nested skill directories.
+*
+* A layer is probed concurrently but published in frontier order, so the
+* catalog never depends on which probe happened to finish first, and the budget
+* is claimed before any probe starts: concurrency must not change what is
+* visited, only how long it takes.
 * @param distro - the WSL distribution name.
 * @param linuxRoot - the workspace's absolute Linux path.
 * @param io - filesystem face.
@@ -368,62 +580,77 @@ async function nearestGitAncestor(distro, linuxDir, io) {
 async function discoverSkillRoots(distro, linuxRoot, io) {
 	const roots = [];
 	const visited = /* @__PURE__ */ new Set();
+	let linksResolved = 0;
 	let frontier = [[linuxRoot, 0]];
 	while (frontier.length > 0 && roots.length < MAX_SKILL_ROOTS) {
-		const next = [];
-		for (const [dir, depth] of frontier) {
-			if (visited.size >= MAX_VISITED_DIRECTORIES) return roots;
-			if (visited.has(dir)) continue;
-			visited.add(dir);
-			if (roots.length < MAX_SKILL_ROOTS) {
-				const directoryRoots = await skillRootsOfDirectory(distro, dir, io);
-				roots.push(...directoryRoots.slice(0, MAX_SKILL_ROOTS - roots.length));
-			}
-			if (depth >= MAX_SCAN_DEPTH) continue;
-			let entries;
-			try {
-				entries = await io.readdir(joinUnc(distro, dir), { withFileTypes: true });
-			} catch {
-				continue;
+		const layer = [];
+		for (const item of frontier) {
+			if (visited.size >= MAX_VISITED_DIRECTORIES) break;
+			if (visited.has(item[0])) continue;
+			visited.add(item[0]);
+			layer.push(item);
+		}
+		if (layer.length === 0) return roots;
+		const probes = new Array(layer.length);
+		let next = 0;
+		await Promise.all(Array.from({ length: Math.min(WALK_CONCURRENCY, layer.length) }, async () => {
+			for (let index = next; index < layer.length; index = next) {
+				next += 1;
+				const [dir, depth] = layer[index];
+				probes[index] = await probeDirectory(distro, dir, depth, io);
 			}
-			for (const entry of entries) {
-				if (PRUNED_DIRECTORY_NAMES.has(entry.name)) continue;
-				if (entry.name.startsWith(".") && entry.name !== ".dsh" && entry.name !== ".agents") continue;
-				if (entry.name === ".dsh" || entry.name === ".agents") continue;
-				const childPath = posix.join(dir, entry.name);
-				if (entry.isDirectory()) {
-					next.push([childPath, depth + 1]);
-					continue;
-				}
-				if (entry.isSymbolicLink()) try {
-					const target = await io.stat(joinUnc(distro, childPath));
-					if (target.isDirectory()) next.push([childPath, depth + 1]);
+		}));
+		const nextLayer = [];
+		const links = [];
+		for (const probe of probes) {
+			if (probe === void 0) continue;
+			if (roots.length < MAX_SKILL_ROOTS) roots.push(...probe.roots.slice(0, MAX_SKILL_ROOTS - roots.length));
+			nextLayer.push(...probe.children);
+			links.push(...probe.links);
+		}
+		if (visited.size >= MAX_VISITED_DIRECTORIES) return roots;
+		if (links.length > 0 && io.resolveLinks !== void 0 && linksResolved < MAX_LINK_RESOLUTIONS) {
+			const batch = links.slice(0, MAX_LINK_RESOLUTIONS - linksResolved);
+			linksResolved += batch.length;
+			const resolved = await io.resolveLinks(batch.map(([path]) => joinUnc(distro, path)));
+			for (let index = 0; index < batch.length; index += 1) {
+				const real = resolved[index];
+				if (real === void 0) continue;
+				try {
+					const info = await io.stat(real);
+					if (info.isDirectory()) nextLayer.push([uncToLinux(real), batch[index][1]]);
 				} catch {}
 			}
 		}
-		frontier = next;
+		frontier = nextLayer;
 	}
 	return roots;
 }
+/** The two project skill markers, with the source and rank each publishes. */
+const PROJECT_SKILL_MARKERS = [[
+	".dsh",
+	"project-dsh",
+	PROJECT_DSH_RANK
+], [
+	".agents",
+	"project-agents",
+	PROJECT_AGENTS_RANK
+]];
 /**
 * Publish the skill roots of one scanned directory (its `.dsh/skills` and
 * `.agents/skills`, each with the host's project ranks).
 * @param distro - the WSL distribution name.
 * @param linuxDir - the scanned directory's Linux path.
 * @param io - filesystem face.
+* @param markers - the markers worth probing. The walk narrows this to the ones
+*   its listing actually showed, because each probe is a round trip and a
+*   directory without a `.dsh` entry cannot hold `.dsh/skills`.
 * @returns the directory's skill roots that exist.
 */
-async function skillRootsOfDirectory(distro, linuxDir, io) {
+async function skillRootsOfDirectory(distro, linuxDir, io, markers = PROJECT_SKILL_MARKERS.map(([marker]) => marker)) {
 	const result = [];
-	for (const [marker, source, rank] of [[
-		".dsh",
-		"project-dsh",
-		PROJECT_DSH_RANK
-	], [
-		".agents",
-		"project-agents",
-		PROJECT_AGENTS_RANK
-	]]) {
+	for (const [marker, source, rank] of PROJECT_SKILL_MARKERS) {
+		if (!markers.includes(marker)) continue;
 		const path = joinUnc(distro, posix.join(linuxDir, marker, "skills"));
 		try {
 			const info = await io.stat(path);
@@ -457,6 +684,32 @@ async function listSkillEntries(root, io) {
 	});
 	return entries.sort((a, b) => a.name.localeCompare(b.name));
 }
+/**
+* The published shape of one skills directory: its path, then each skill's name,
+* kind and modification stamp.
+*
+* The stamp is what makes an edit to an *existing* skill visible: the catalog the
+* model sees is rebuilt only when the registry's revision moves, and a directory
+* listing alone cannot tell a rewritten `SKILL.md` from an untouched one. One
+* `stat` per skill file (never a read) is the whole cost, and a file that cannot
+* be stamped reports the same `gone` marker on every pass, so a substrate that
+* does not expose modification times simply never triggers on content.
+* @param root - the skills directory.
+* @param entries - its entries, as just listed.
+* @param io - filesystem face.
+* @returns the deterministic shape string for this directory.
+*/
+async function shapeOfRoot(root, entries, io) {
+	const stamps = await Promise.all(entries.map(async (entry) => {
+		try {
+			const info = await io.stat(entry.path);
+			return `${entry.name}:${entry.kind}:${info.mtimeMs ?? 0}:${info.size ?? 0}`;
+		} catch {
+			return `${entry.name}:${entry.kind}:gone`;
+		}
+	}));
+	return `${root.path}\u0001${stamps.sort().join(",")}`;
+}
 /** Read and parse one skill file; `undefined` when missing or unparsable. */
 async function readSkill(path, io, signal) {
 	signal?.throwIfAborted();
@@ -589,22 +842,37 @@ function frontmatterBoolean(fields, key, dflt = false) {
 * The WSL workspace skill provider. Registered on the host's `ctx.skills`
 * registry; serves only lookups whose cwd is a WSL UNC workspace path.
 *
-* Completed `list()` lookups are cached per scan root for CACHE_TTL_MS so
-* repeated catalog builds over the slow 9P share do not rescan the tree;
-* `get()` always re-reads the skill file so body edits are picked up
-* immediately. `control.invalidate` remains reserved for host-driven
-* invalidation; the provider self-invalidates through the TTL.
+* Completed `list()` lookups are cached per scan root and served as-is: a lookup
+* is on the session's request path, and re-walking the tree there is what made
+* every turn in a large workspace wait for a 4096-directory scan of the 9P
+* share. `get()` always re-reads the skill file so body edits are picked up
+* immediately.
+*
+* A scan root that has been served is re-checked every REFRESH_POLL_MS: the
+* host cannot watch a `\\wsl.localhost\…` path (which is why the generated
+* preset pins `watch: false`), so this provider watches for it instead. A
+* changed directory listing clears the cache and calls `control.invalidate()`,
+* which bumps the registry's revision; the catalog middleware re-collects on
+* the session's next request, so a skill added mid-session reaches the model
+* without starting a new session, and the cache is only ever refilled by a
+* lookup the detector has already invalidated.
 */
 var WslSkillsProvider = class {
 	name = "wsl-workspace";
 	control;
 	io;
-	now;
+	refreshMs;
+	/** Cheap polls between two full discovery walks (at least one). */
+	walkEveryPolls;
+	/** The published catalog per scan root, served until its detector drops it. */
 	cache = /* @__PURE__ */ new Map();
-	constructor(control, io = nodeSkillIo, now = Date.now) {
+	/** One change detector per served scan root, keyed like {@link cache}. */
+	detectors = /* @__PURE__ */ new Map();
+	constructor(control, io = nodeSkillIo, refreshMs = REFRESH_POLL_MS, discoveryMs = DISCOVERY_POLL_MS) {
 		this.control = control;
 		this.io = io;
-		this.now = now;
+		this.refreshMs = refreshMs;
+		this.walkEveryPolls = Math.max(1, Math.round(discoveryMs / refreshMs));
 	}
 	/**
 	* Discover nested project skills for a WSL UNC session workspace.
@@ -621,16 +889,18 @@ var WslSkillsProvider = class {
 		const scanRoot = await nearestGitAncestor(unc.distro, unc.linuxPath, this.io) ?? unc.linuxPath;
 		const cacheKey = `${unc.distro}\u0000${scanRoot}`;
 		const cached = this.cache.get(cacheKey);
-		if (cached !== void 0 && cached.expiresAt > this.now()) {
+		if (cached !== void 0) {
 			this.cache.delete(cacheKey);
 			this.cache.set(cacheKey, cached);
-			return [...cached.candidates];
+			return [...cached];
 		}
 		const roots = await discoverSkillRoots(unc.distro, scanRoot, this.io);
 		const candidates = [];
 		const seenSkills = /* @__PURE__ */ new Set();
+		const signature = [];
 		for (const root of roots) {
 			const entries = await listSkillEntries(root, this.io);
+			signature.push(await shapeOfRoot(root, entries, this.io));
 			for (const entry of entries) {
 				options.signal?.throwIfAborted();
 				const parsed = await readSkill(entry.path, this.io, options.signal);
@@ -654,16 +924,83 @@ var WslSkillsProvider = class {
 				});
 			}
 		}
-		this.cache.set(cacheKey, {
-			expiresAt: this.now() + CACHE_TTL_MS,
-			candidates
-		});
+		this.cache.set(cacheKey, candidates);
 		while (this.cache.size > CACHE_MAX_ENTRIES) {
 			const oldest = this.cache.keys().next().value;
 			if (oldest === void 0) break;
 			this.cache.delete(oldest);
 		}
-		return candidates;
+		this.watch(cacheKey, unc.distro, scanRoot, signature.join(""), roots);
+		return [...candidates];
+	}
+	/**
+	* Keep one scan root's catalog honest for as long as this provider is
+	* registered: the host cannot watch a UNC workspace, so the provider polls the
+	* shape it just published and, on any difference, drops its own cache and asks
+	* the registry to re-collect for the session's next request.
+	*
+	* Two passes keep that affordable: the cheap one (every
+	* {@link REFRESH_POLL_MS}) re-reads the skills directories already published
+	* and re-stats their skill files, so an added, removed or edited skill is
+	* noticed on its own; the full re-discovery walk (every
+	* {@link DISCOVERY_POLL_MS}) is what can find a skills directory that did not
+	* exist before. Neither pass reads a skill file: the description the catalog
+	* shows changes only through the registry's revision.
+	* @param cacheKey - this provider's key for the scan root.
+	* @param distro - the WSL distribution.
+	* @param scanRoot - the Linux path the lookup scanned.
+	* @param signature - the shape the lookup just published.
+	* @param roots - the skills directories that lookup found.
+	*/
+	watch(cacheKey, distro, scanRoot, signature, roots) {
+		const existing = this.detectors.get(cacheKey);
+		if (existing !== void 0) {
+			existing.signature = signature;
+			existing.roots = roots;
+			return;
+		}
+		const detector = {
+			timer: setInterval(() => void this.detect(cacheKey, distro, scanRoot), this.refreshMs),
+			signature,
+			roots,
+			polls: 0,
+			busy: false
+		};
+		if (typeof detector.timer.unref === "function") detector.timer.unref();
+		this.detectors.set(cacheKey, detector);
+		this.control.signal.addEventListener("abort", () => {
+			clearInterval(detector.timer);
+			this.detectors.delete(cacheKey);
+		}, { once: true });
+	}
+	/** One poll: the cheap pass always, the discovery walk on its own cadence. */
+	async detect(cacheKey, distro, scanRoot) {
+		const detector = this.detectors.get(cacheKey);
+		if (detector === void 0 || this.control.signal.aborted) return;
+		if (detector.busy) return;
+		detector.busy = true;
+		try {
+			detector.polls += 1;
+			const walk = detector.polls % this.walkEveryPolls === 0;
+			let signature;
+			try {
+				signature = await this.shape(distro, walk ? await discoverSkillRoots(distro, scanRoot, this.io) : detector.roots);
+			} catch {
+				return;
+			}
+			if (signature === detector.signature) return;
+			detector.signature = signature;
+			this.cache.delete(cacheKey);
+			this.control.invalidate();
+		} finally {
+			detector.busy = false;
+		}
+	}
+	/** The shape of one root set: paths, entry names, kinds and file stamps. */
+	async shape(distro, roots) {
+		const parts = [];
+		for (const root of roots) parts.push(await shapeOfRoot(root, await listSkillEntries(root, this.io), this.io));
+		return parts.join("");
 	}
 	/**
 	* Load a complete skill body for a previously listed candidate.
@@ -972,8 +1309,76 @@ function publishVariant(staging, dest) {
 		force: true
 	});
 }
+/**
+* Whether a host's terminal stack can allocate a PTY process *on this platform*.
+*
+* The world's `bash` is the host's persistent-shell stack, and on Windows that
+* stack needs a platform process inspector. `@deepseek-ai/dsh-subprocess-local`
+* only grew one in `0.1.0-rc.8`: in `0.1.0-rc.7` `spawnTerminal` throws
+* `subprocess-local: terminal inspection is unsupported on platform win32`
+* before the process is started, so *every* persistent shell fails there — a
+* real session shows the model getting that error for each `bash` call while
+* grep/glob (which never touch the PTY) keep working. The host itself ships the
+* same gap: that release's Minimal preset mounts `persistent-bash` with no
+* `disabled:` guard for Windows.
+*
+* The probe asks the substrate the question directly instead of pattern-matching
+* a version: `spawnTerminal` builds its inspector before `node-pty` starts the
+* program, so handing it a program that cannot exist reaches that check and
+* nothing else — no process is created either way, and the failure message says
+* which half failed. A release that can build the inspector reports an ordinary
+* spawn failure instead, which is the "supported" answer.
+* @param ctx - plugin context; the `subprocess` service is looked up with `get`
+*   and waited for briefly, because the world is generated during profile boot.
+* @returns true when the persistent shell may be mounted.
+*/
+async function supportsPersistentShell(ctx) {
+	if (process.platform !== "win32") return true;
+	const subprocess = await waitForSubprocess(ctx);
+	if (subprocess?.spawnTerminal === void 0) return true;
+	try {
+		const handle = await subprocess.spawnTerminal({
+			argv: ["dsh-wsl-workspace-pty-probe-does-not-exist"],
+			cwd: process.cwd(),
+			rows: 24,
+			cols: 80,
+			graceMs: 1e3
+		});
+		await handle?.terminate?.();
+		return true;
+	} catch (error) {
+		return !isTerminalInspectionUnsupported(error);
+	}
+}
+/**
+* Whether one spawn failure is the missing-platform-inspector error.
+* @param error - the rejection from `spawnTerminal`.
+* @returns true when the host cannot inspect terminal processes here.
+*/
+function isTerminalInspectionUnsupported(error) {
+	return /terminal inspection is unsupported on platform/i.test(messageOf(error));
+}
+/**
+* Look up the `subprocess` service, giving profile boot a moment to publish it.
+*
+* Bounded: the world is generated in a fire-and-forget effect, so this wait never
+* blocks profile boot, and the service is normally already published by the base
+* bundles the web app mounts before this plugin's own injection resolves. An
+* absent service is answered as "supported" by the caller, which is the
+* behaviour this plugin shipped before the probe existed.
+* @param ctx - plugin context.
+* @returns the service, or undefined when this deployment has none yet.
+*/
+async function waitForSubprocess(ctx) {
+	for (let attempt = 0; attempt < 20; attempt += 1) {
+		const service = ctx.get("subprocess");
+		if (service !== void 0) return service;
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	return void 0;
+}
 /** Materialize one WSL variant per healthy source preset. */
-async function materializeVariants(agentPresets, dshHome, shellPath, fsPath) {
+async function materializeVariants(agentPresets, dshHome, paths, persistentShell) {
 	const presets = await agentPresets.list();
 	const userRoot = join(dshHome, ".agent-presets");
 	const generated = /* @__PURE__ */ new Set();
@@ -982,7 +1387,11 @@ async function materializeVariants(agentPresets, dshHome, shellPath, fsPath) {
 		if (isWslVariantId(preset.id)) continue;
 		const variantId = variantIdFor(preset.id);
 		const source = await agentPresets.read(preset.id);
-		const transformed = transformPresetForWsl(source, shellPath, fsPath);
+		const transformed = transformPresetForWsl(source, paths.shell, paths.fs, persistentShell ? {
+			relayPath: paths.relay,
+			nodePath: paths.node,
+			sandboxPath: paths.sandbox
+		} : void 0, paths.search, paths.jobs);
 		const dir = join(userRoot, variantId);
 		const staging = `${dir}.staging`;
 		rmSync(staging, {
@@ -1001,7 +1410,7 @@ async function materializeVariants(agentPresets, dshHome, shellPath, fsPath) {
 			const meta = readFileSync(join(dirname(preset.path), "preset.yml"), "utf8");
 			if (labels === void 0) {
 				const match = /^name:\s*(.+)$/m.exec(meta);
-				if (match?.[1] !== void 0 && match[1].trim() !== "") name$1 = variantName(preset.id, match[1].trim());
+				if (match?.[1] !== void 0 && match[1].trim() !== "") name$1 = variantName(preset.id, unquoteScalar(match[1].trim()));
 			}
 			const orderMatch = /^order:\s*(\d+)\s*$/m.exec(meta);
 			if (orderMatch?.[1] !== void 0) orderLine = `order: ${orderMatch[1]}\n`;
@@ -1047,9 +1456,25 @@ function apply(ctx, config) {
 	const packageRoot = fileURLToPath(new URL("..", import.meta.url));
 	const shellPath = join(packageRoot, "lib", "shell.js").replace(/\\/g, "/");
 	const fsPath = join(packageRoot, "lib", "fs.js").replace(/\\/g, "/");
+	const relayPath = join(packageRoot, "lib", "wsl-relay.js").replace(/\\/g, "/");
+	const sandboxPath = join(packageRoot, "lib", "wsl-sandbox.js").replace(/\\/g, "/");
+	const searchPath = join(packageRoot, "lib", "wsl-search.js").replace(/\\/g, "/");
+	const jobsPath = join(packageRoot, "lib", "wsl-jobs.js").replace(/\\/g, "/");
+	const nodePath = process.execPath.replace(/\\/g, "/");
 	const agentPresets = ctx.get("agentPresets");
 	if (agentPresets !== void 0) ctx.effect(() => {
-		materializeVariants(agentPresets, dshHome, shellPath, fsPath).catch((error) => {
+		(async () => {
+			const persistentShell = await supportsPersistentShell(ctx);
+			await materializeVariants(agentPresets, dshHome, {
+				shell: shellPath,
+				fs: fsPath,
+				relay: relayPath,
+				node: nodePath,
+				sandbox: sandboxPath,
+				search: searchPath,
+				jobs: jobsPath
+			}, persistentShell);
+		})().catch((error) => {
 			console.error(`dsh-wsl-workspace: WSL preset-variant generation failed: ${messageOf(error)}`);
 		});
 		return () => {};
@@ -1138,5 +1563,5 @@ function apply(ctx, config) {
 }
 
 //#endregion
-export { Config, DEFAULT_ROUTE, apply, inject, name };
+export { Config, DEFAULT_ROUTE, apply, inject, isTerminalInspectionUnsupported, name };
 //# sourceMappingURL=index.js.map