@chronosun/dsh-wsl 0.0.0-stage → 1.5.0

package/cordis.patch.yml

@@ -0,0 +1,79 @@
+# dsh-wsl — M1a slice:
+# 1) a row named after the package: the panel's host routes + the client half;
+# 2) the WSL preset (bash/terminal/jobs run inside a local WSL distribution);
+# 3) a diagnostic preset with no world, to tell a declaration problem from a
+#    world-activation problem.
+- insert:
+    - id: dsh-wsl
+      name: '@chronosun/dsh-wsl'
+    - id: preset-wsl
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: wsl
+        name: WSL
+        description: Linux execution world inside a local WSL distribution.
+        order: 5
+        plugins:
+          - id: persona
+            name: '@deepseek-ai/dsh-persona'
+            config:
+              prefix: You are a coding agent powered by the {{model}} model.
+          - id: time-context
+            name: '@deepseek-ai/dsh-time-context'
+          - id: wsl-world
+            name: cordis:group
+            group: true
+            isolate:
+              subprocess: true
+              shell: true
+              fs: true
+            config:
+              - id: wsl-subprocess
+                name: '@chronosun/dsh-wsl/world'
+              - id: fs-wsl
+                name: '@chronosun/dsh-wsl/fs'
+              - id: bash-local
+                name: '@deepseek-ai/dsh-bash-local'
+              - id: tool-bash
+                name: '@deepseek-ai/dsh-tool-bash'
+              - id: tool-fs
+                name: '@deepseek-ai/dsh-tool-fs'
+                config:
+                  applyPatch: true
+              - id: search-tools
+                name: '@chronosun/dsh-wsl/search'
+              - id: wsl-prompt
+                name: '@chronosun/dsh-wsl/prompt'
+              - id: agent-instructions
+                name: '@deepseek-ai/dsh-agent-instructions'
+                config:
+                  maxBytes: 65536
+              - id: skill-filesystem
+                name: '@deepseek-ai/dsh-skill-filesystem'
+                config:
+                  # The WSL filesystem exposes no watcher, so the catalog is
+                  # collected once instead of being invalidated live.
+                  watch: false
+              - id: tool-skill
+                name: '@deepseek-ai/dsh-tool-skill'
+              - id: tool-todo
+                name: '@deepseek-ai/dsh-tool-todo'
+                config:
+                  allowParallelInProgress: true
+              - id: tool-ask-user
+                name: '@deepseek-ai/dsh-tool-ask-user'
+              - id: tool-web
+                name: '@deepseek-ai/dsh-tool-web'
+                config:
+                  fetch: true
+                  searchTimeoutMs: 60000
+              - id: present
+                name: '@deepseek-ai/dsh-tool-present'
+              - id: command-goal
+                name: '@deepseek-ai/dsh-command-goal'
+              - id: tool-goal
+                name: '@deepseek-ai/dsh-tool-goal'
+              - id: tool-worktree-wsl
+                name: '@chronosun/dsh-wsl/worktree'
+          - id: tool-jobs
+            name: '@deepseek-ai/dsh-tool-jobs'

package/fs-service.mjs

@@ -0,0 +1,57 @@
+// `ctx.fs` for the WSL world. Mirrors world.js: the host's FileSystem base is
+// used when resolvable, otherwise the service is registered through Context.
+// Delegation (not inheritance) keeps the factory free of host imports and
+// avoids `#private` brand checks through Cordis' service proxy.
+import { registry } from './src/registry.mjs'
+import { createWslFileSystem } from './src/fs.mjs'
+
+let Base = null
+try {
+  const mod = await import('@deepseek-ai/dsh-fs')
+  Base = mod.FileSystem ?? mod.default ?? null
+} catch {
+  Base = null
+}
+
+class ServiceShim {
+  constructor(ctx) {
+    this.ctx = ctx
+    if (typeof ctx.set !== 'function') {
+      throw new Error('fs-wsl: this Harness build exposes neither the FileSystem base class nor ctx.set')
+    }
+    ctx.provide?.('fs')
+    ctx.set('fs', this)
+  }
+}
+
+const Parent = Base ?? ServiceShim
+const METHODS = [
+  'resolve', 'processPath', 'processPathFromHostPath', 'fileUrl', 'contains', 'stat', 'lstat',
+  'readText', 'streamText', 'readBytes', 'readByteRange', 'listDir', 'writeText', 'editText',
+  'patchText', 'deleteFile', 'moveFile', 'watch',
+]
+
+export default class WslFileSystemService extends Parent {
+  constructor(ctx, config = {}) {
+    super(ctx)
+    if (!this.ctx) this.ctx = ctx
+    const user = config.user ?? ''
+    // One provider for every distribution: each target carries its own, so a
+    // workspace in another distro resolves through that distro's broker.
+    this.impl = createWslFileSystem({
+      brokerFor: (distro) => registry.get(distro ?? '', user),
+      defaultDistro: config.distro ?? '',
+      defaultCwd: config.defaultCwd ?? '/',
+    })
+  }
+}
+
+for (const method of METHODS) {
+  Object.defineProperty(WslFileSystemService.prototype, method, {
+    configurable: true,
+    writable: true,
+    value: function delegate(...args) {
+      return this.impl[method](...args)
+    },
+  })
+}

package/host.js

@@ -0,0 +1,262 @@
+// Host half: the WSL panel's data routes.
+// Each endpoint is an exact route: prefix matching was measured to not cover
+// sub-paths here, and exact routes are unambiguous. Handler routes (not
+// resources) are used because resources answer GET/HEAD only.
+import { spawn } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { registry } from './src/registry.mjs'
+import { installModelCwdTranslation, installSessionPresetDefault, WSL_PRESET } from './src/preset-default.mjs'
+import { installWslFileReferences } from './src/file-references.mjs'
+import { installWorkspaceChangesPaths } from './src/changes-paths.mjs'
+import { installWslDiff } from './src/wsl-diff-v2.mjs'
+import { readSettings, userFor, writeSettings } from './src/settings.mjs'
+import { runDoctor, runFix, detectUsers, listWslDistros } from './src/doctor.mjs'
+
+const BASE = '/dsh-wsl'
+const VERSION = (() => {
+  try { return JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version ?? '' } catch { return '' }
+})()
+
+// A live profile reconcile starts the new row before the previous incarnation
+// is always gone; its exact routes then still sit in webServer. Reinstalling
+// during development must not fail with `duplicate exact route` and must not
+// leave the panel on the old handler, so take the route over when the exact
+// path is already owned. Our disposer removes the path only while it still
+// holds this route, so a later reload cannot delete a successor's handler.
+const ORIGINAL = Symbol.for('cordis.original')
+
+function registerExactRoute(webServer, route) {
+  try {
+    return webServer.register(route)
+  } catch (error) {
+    const message = String(error?.message ?? error)
+    if (!message.includes('duplicate')) throw error
+    const raw = webServer?.[ORIGINAL] ?? webServer
+    const table = raw?.exact
+    if (!(table instanceof Map)) throw error
+    table.set(route.path, route)
+    console.warn(`[dsh-wsl] took over ${route.path} from a previous plugin instance`)
+    return () => { if (table.get(route.path) === route) table.delete(route.path) }
+  }
+}
+
+function send(res, status, body) {
+  res.statusCode = status
+  res.setHeader('content-type', 'application/json; charset=utf-8')
+  res.setHeader('cache-control', 'no-store')
+  res.end(JSON.stringify(body))
+}
+
+function readBody(req) {
+  return new Promise((resolve) => {
+    let data = ''
+    req.on('data', (chunk) => { data += chunk; if (data.length > 1 << 20) req.destroy() })
+    req.on('end', () => { try { resolve(data ? JSON.parse(data) : {}) } catch { resolve({}) } })
+    req.on('error', () => resolve({}))
+  })
+}
+
+function listDistros() {
+  return new Promise((resolve) => {
+    const child = spawn('wsl.exe', ['-l', '-q'], { windowsHide: true })
+    let out = ''
+    child.stdout.on('data', (d) => (out += d.toString('utf16le')))
+    child.on('error', () => resolve([]))
+    child.on('close', () => {
+      const names = out
+        .replace(/\0/g, '')
+        .split(/\r?\n/)
+        .map((s) => s.trim())
+        .filter(Boolean)
+      resolve([...new Set(names)])
+    })
+  })
+}
+
+export const name = 'dsh-wsl'
+export const inject = ['webServer']
+
+// Must be an arrow function: Cordis treats a `function` declaration as a
+// constructible class (`new apply(ctx)`), and then discards the cleanup this
+// function returns. Without that cleanup the exact routes survive a reload and
+// every reinstall fails with `duplicate exact route`.
+export const apply = (ctx) => {
+  const webServer = ctx.webServer
+  if (!webServer) return
+
+  // Every New Session / Workspace-open request in a WSL workspace omits the
+  // preset; without this patch those sessions run on Windows. Installed before
+  // the routes so `/state` can report whether the seam is live.
+  const presetDefault = installSessionPresetDefault(ctx)
+  // Keep the durable UNC cwd for Host features, but show the model the Linux
+  // directory its tools actually use. No-op for non-WSL sessions.
+  const modelCwd = installModelCwdTranslation(ctx)
+  // `@file` discovery: WSL Agents index the distribution instead of the UNC
+  // share. Diff labels translate absolute UNC display paths to Linux while the
+  // underlying Host summary/diff still serves the open/compare coordinates.
+  const fileReferences = installWslFileReferences(ctx)
+  const changesPaths = installWorkspaceChangesPaths(ctx)
+  const wslDiff = installWslDiff(ctx)
+
+  const bootSettings = readSettings()
+  registry.idleMinutes = bootSettings.idleDays * 24 * 60
+
+  const hasService = (name) => {
+    try { return ctx.get(name) !== undefined } catch { return false }
+  }
+  const capabilities = () => ({
+    webServer: true,
+    sessionController: hasService('sessionController'),
+    workingDirectory: hasService('workingDirectory'),
+    workspaceRegistry: hasService('workspaceRegistry'),
+    agentPresets: hasService('agentPresets'),
+    fileReferences: hasService('fileReferences'),
+    workspaceChanges: hasService('workspaceChanges'),
+    agents: hasService('agents'),
+  })
+
+  const routes = [
+    ['GET', BASE, async (req, res) => send(res, 200, { ok: true, name, version: VERSION })],
+    ['GET', `${BASE}/distros`, async (req, res) => send(res, 200, { distros: await listDistros() })],
+    ['GET', `${BASE}/state`, async (req, res) => send(res, 200, {
+      version: VERSION,
+      idleMinutes: registry.idleMinutes,
+      idleDays: readSettings().idleDays,
+      brokers: registry.list(),
+      settings: readSettings(),
+      capabilities: capabilities(),
+      presetDefault: { installed: presetDefault.installed, preset: WSL_PRESET },
+      modelCwd: { installed: modelCwd.installed },
+      fileReferences: { installed: fileReferences.installed },
+      changesPaths: { installed: changesPaths.installed },
+      wslDiff: { installed: wslDiff.installed, stats: wslDiff.stats },
+    })],
+    ['*', `${BASE}/settings`, async (req, res) => {
+      if ((req.method ?? 'GET') === 'GET') return send(res, 200, readSettings())
+      const body = await readBody(req)
+      send(res, 200, writeSettings(body))
+    }],    ['GET', `${BASE}/doctor`, async (req, res) => send(res, 200, await runDoctor(ctx, {
+      version: VERSION,
+      capabilities: capabilities(),
+      flags: {
+        presetDefault: presetDefault.installed,
+        modelCwd: modelCwd.installed,
+        fileReferences: fileReferences.installed,
+        changesPaths: changesPaths.installed,
+        wslDiff: wslDiff.installed,
+      },
+    }))],
+    ['POST', `${BASE}/doctor/fix`, async (req, res) => {
+      const body = await readBody(req)
+      send(res, 200, await runFix(body.distro ?? '', body.action ?? '', body.user ?? '', body.name ?? ''))
+    }],
+    ['GET', `${BASE}/changes`, async (req, res) => {
+      const url = new URL(req.url, 'http://localhost')
+      const sessionId = url.searchParams.get('sessionId') ?? ''
+      const seq = Number(url.searchParams.get('seq') ?? -1)
+      const summary = ctx.get('workspaceChanges')?.summary(sessionId, seq)
+      if (summary === undefined) return send(res, 404, { error: 'change summary unavailable' })
+      send(res, 200, summary)
+    }],
+    ['GET', `${BASE}/changes/diff`, async (req, res) => {
+      const url = new URL(req.url, 'http://localhost')
+      const sessionId = url.searchParams.get('sessionId') ?? ''
+      const seq = Number(url.searchParams.get('seq') ?? -1)
+      const index = Number(url.searchParams.get('index') ?? -1)
+      const diff = await ctx.get('workspaceChanges')?.diff(sessionId, seq, index, AbortSignal.timeout(30_000))
+      if (diff === undefined) return send(res, 404, { error: 'change comparison unavailable' })
+      send(res, 200, diff)
+    }],
+    ['GET', `${BASE}/workspaces`, async (req, res) => {
+      // `ctx.get` does not require an inject declaration, unlike `ctx.<name>`;
+      // this row only injects webServer and must not fail at request time.
+      const list = ctx.get('workspaceRegistry')?.list?.() ?? []
+      send(res, 200, {
+        workspaces: list.map((w) => ({
+          id: w.id ?? w.workspaceId,
+          path: w.path ?? w.directory ?? '',
+          title: w.title ?? w.name ?? '',
+        })),
+      })
+    }],
+    ['GET', `${BASE}/browse`, async (req, res) => {
+      const url = new URL(req.url, 'http://localhost')
+      const distro = url.searchParams.get('distro') ?? ''
+      const user = url.searchParams.get('user') ?? userFor(distro)
+      const wanted = url.searchParams.get('path') ?? ''
+      const broker = registry.get(distro, user)
+      const hello = await broker.connect().then(() => broker.hello)
+      const target = wanted || hello.home
+      const listing = await broker.call('list', { path: target })
+      const dirs = listing.entries
+        .filter((e) => e.dir)
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((e) => ({ name: e.name, path: target.replace(/\/$/, '') + '/' + e.name }))
+      const parent = target.replace(/\/+$/, '').replace(/\/[^/]*$/, '') || '/'
+      send(res, 200, { distro, user, path: target, parent, home: hello.home, dirs })
+    }],
+    ['POST', `${BASE}/connect`, async (req, res) => {
+      const body = await readBody(req)
+      const distro = body.distro ?? ''
+      const broker = registry.get(distro, body.user ?? userFor(distro))
+      await broker.connect()
+      send(res, 200, { ok: true, broker: broker.info, hello: broker.hello })
+    }],
+    ['POST', `${BASE}/disconnect`, async (req, res) => {
+      const body = await readBody(req)
+      await registry.peek(body.distro ?? '', body.user ?? userFor(body.distro ?? ''))?.disconnect('panel')
+      send(res, 200, { ok: true })
+    }],
+    ['POST', `${BASE}/idle`, async (req, res) => {
+      const body = await readBody(req)
+      const days = body.days !== undefined ? Number(body.days) : Number(body.minutes) / (24 * 60)
+      if (!Number.isFinite(days) || days < 0) return send(res, 400, { error: 'days must be a non-negative number' })
+      const saved = writeSettings({ idleDays: days })
+      registry.idleMinutes = days * 24 * 60
+      send(res, 200, { ok: true, idleDays: saved.idleDays, idleMinutes: registry.idleMinutes })
+    }],
+  ]
+
+  const disposers = routes.map(([method, path, run]) => registerExactRoute(webServer, {
+    kind: 'exact',
+    path,
+    handler: async (req, res) => {
+      if (method !== '*' && (req.method ?? 'GET') !== method) return send(res, 405, { error: 'method not allowed', method: req.method })
+      try {
+        await run(req, res)
+      } catch (error) {
+        send(res, 500, { error: String(error?.message ?? error) })
+      }
+    },
+  }))
+
+  // A distro whose default user is root should not silently run the Agent as
+  // root. Detect the first normal user at Host boot and persist it as the
+  // default for that distro (no-op when the distro default is already normal).
+  const applyDefaultUsers = async () => {
+    try {
+      const settings = readSettings()
+      let changed = false
+      for (const distro of await listWslDistros()) {
+        if (settings.users[distro]) continue
+        const info = await detectUsers(distro)
+        if (info.root && info.users.length > 0 && !settings.users[distro]) {
+          settings.users[distro] = info.users[0].name
+          changed = true
+        }
+      }
+      if (changed) writeSettings({ users: settings.users })
+    } catch {}
+  }
+  void applyDefaultUsers()
+
+  return () => {
+    presetDefault.dispose()
+    modelCwd.dispose()
+    fileReferences.dispose()
+    changesPaths.dispose()
+    wslDiff.dispose()
+    for (const dispose of disposers) dispose()
+  }
+}
+

package/icon.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="256" height="256" role="img" aria-label="WSL penguin outline">
+  <g fill="none" stroke="#334155" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M12 2.5c-2.3 0-4.1 1.9-4.1 4.2 0 1.4.6 2.6 1.6 3.4-1.1 1.2-1.9 2.9-2.2 4.7-.4 2.5.1 4.6 1.8 5.5 1.6.9 4.3.9 5.9 0 1.7-.9 2.2-3 1.8-5.5-.3-1.8-1.1-3.5-2.2-4.7 1-.8 1.6-2 1.6-3.4 0-2.3-1.8-4.2-4.2-4.2Z" fill="#ffffff"/>
+    <path d="M7.4 11.3c-1.5 1-2.4 2.7-2.3 4.5.1 1 .6 1.7 1.3 2.1"/>
+    <path d="M16.6 11.3c1.5 1 2.4 2.7 2.3 4.5-.1 1-.6 1.7-1.3 2.1"/>
+    <path d="M8.4 21.2c-.8 0-1.5.3-2 .8M15.6 21.2c.8 0 1.5.3 2 .8"/>
+  </g>
+  <circle cx="10.2" cy="7.8" r="0.7" fill="#334155"/>
+  <circle cx="13.8" cy="7.8" r="0.7" fill="#334155"/>
+  <path d="M10.9 9.1l1.1 1.5 1.1-1.5z" fill="#334155"/>
+</svg>

package/index.js

@@ -0,0 +1,5 @@
+// Bundle entry: the patch mounts a row named after this package, which is how
+// the client scanner discovers `dsh.client` and how the panel's host routes
+// come up. The WSL execution world lives in ./world.js and is mounted by the
+// preset instead.
+export { name, inject, apply } from './host.js'

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "WSL",
+    "description": "Run a DeepSeek Harness session inside a local WSL distribution: Linux tools, Linux paths, a clean login PATH, WSL-native search and @ references, and a doctor for Node, SSH and networking."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "WSL",
+    "description": "让 DeepSeek Harness 会话在本地 WSL 发行版里运行：Linux 工具与路径、干净的登录 PATH、WSL 原生搜索与 @ 引用，以及 Node/SSH/网络的诊断面板。"
+  }
+}

package/package.json

@@ -1,6 +1,88 @@
 {
   "name": "@chronosun/dsh-wsl",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.5.0",
+  "type": "module",
+  "description": "WSL execution world for DeepSeek Harness: a Linux bash/terminal/fs world inside a local WSL distribution, plus a connection panel, Doctor, and a WSL workspace picker.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "wsl",
+    "wsl2",
+    "linux",
+    "agent",
+    "coding-agent"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./host": "./host.js",
+    "./world": "./world.js",
+    "./fs": "./fs-service.mjs",
+    "./search": "./search-tools.mjs",
+    "./prompt": "./prompt.mjs",
+    "./terminal-launcher": "./terminal-launcher.mjs",
+    "./worktree": "./worktree-tool-v2.mjs",
+    "./client": "./client.js",
+    "./icon": "./icon.svg",
+    "./locale/*.json": "./locale/*.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "host.js",
+    "world.js",
+    "fs-service.mjs",
+    "search-tools.mjs",
+    "prompt.mjs",
+    "terminal-launcher.mjs",
+    "worktree-tool-v2.mjs",
+    "client.js",
+    "README.md",
+    "LICENSE",
+    "cordis.patch.yml",
+    "icon.svg",
+    "locale/*.json",
+    "src/"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-sidebar"
+      ]
+    },
+    "compatibility": {
+      "dshReleases": {
+        "0.2.2-rc.1": "compatible"
+      }
+    }
+  },
+  "engines": {
+    "dsh": ">=0.2.2-rc.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "*",
+    "@deepseek-ai/dsh-subprocess": "*"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-subprocess": {
+      "optional": true
+    }
+  }
+}

package/prompt.mjs

@@ -0,0 +1,25 @@
+// Prompt section: tell the model it is in Linux, and how to translate the
+// Windows-shaped working directory it is still shown.
+//
+// A stable system section (not per-turn context) so the cached prefix is not
+// perturbed; the text is static, so it never invalidates mid-session.
+export const name = 'dsh-wsl/prompt'
+export const inject = ['systemPrompt']
+
+export function apply(ctx, config = {}) {
+  const distro = config.distro ? ` (distribution: ${config.distro})` : ''
+  const text = [
+    '# Execution environment',
+    `This session executes inside a WSL distribution${distro} on the user's machine, so the execution world is **Linux, not Windows**.`,
+    '',
+    '- **Every tool takes Linux paths.** `Current working directory` is a Linux path such as `/home/me/proj`. If a Windows view shows the same directory as `\\\\wsl.localhost\\<distro>\\...`, the Linux equivalent is that path with the prefix removed and backslashes turned into slashes; always use the Linux form in tool calls and in code you write.',
+    '- Windows drives are mounted at `/mnt/<drive>`, so `C:\\Users\\me` is `/mnt/c/Users/me`.',
+    '- `bash` runs `/bin/bash` inside the distribution with a PATH that contains no `/mnt/*` entries, so Windows binaries are deliberately unreachable; use the distribution\'s own `node`, `npm`, `git`, `python3`.',
+    '- `ssh`, `scp`, `rsync` and `curl` are the distribution\'s own binaries; keys and `~/.ssh/config` are the distribution user\'s. The Agent has no TTY, so use key-based auth (`ssh -o BatchMode=yes host \'command\'`) or `ControlMaster` instead of an interactive password prompt; use the sidebar terminal for interactive logins.',
+    '- `read`, `write`, `edit`, `glob` and `grep` operate directly on the Linux filesystem. `glob` and `grep` require an explicit `path`.',
+    '- `web_fetch` / `web_search` run on the host but share the network. A service started inside the distribution is reachable at `http://localhost:<port>` (WSL2 localhost forwarding); use `curl` in `bash` when it must run from Linux or through an SSH tunnel.',
+    '- Quote shell variables (`"$VAR"`): this Harness build parses some commands twice, and an unquoted value containing spaces or parentheses can break the command.',
+  ].join('\n')
+
+  return ctx.systemPrompt.section({ name: 'wsl-world', order: 820, text })
+}

package/search-tools.mjs

@@ -0,0 +1,91 @@
+// `grep` and `glob` inside the WSL world.
+//
+// The host's own search package spawns a bundled **Windows** ripgrep, which a
+// Linux world cannot run. These tools walk the tree inside the distribution
+// instead, through the broker, with no external binary at all.
+import { registry } from './src/registry.mjs'
+import { userFor } from './src/settings.mjs'
+import { userFromLinuxPath } from './src/path-user.mjs'
+
+const text = (value) => [{ type: 'text', text: value }]
+
+/** The model still sees a UNC cwd, so a host path may arrive here. */
+function toLinuxPath(value, fallback) {
+  const raw = String(value ?? '')
+  if (!raw) return fallback ?? '/'
+  if (raw.startsWith('/')) return raw
+  const unc = /^\\\\[?]?(?:wsl\.localhost|wsl\$)\\([^\\]+)\\(.*)$/i.exec(raw)
+  if (unc) return `/${unc[2].replace(/\\/g, '/')}`
+  const drive = /^([A-Za-z]):[\\/](.*)$/.exec(raw)
+  if (drive) return `/mnt/${drive[1].toLowerCase()}/${drive[2].replace(/\\/g, '/')}`
+  return fallback ?? raw
+}
+
+function brokerFor(config, cwd = '') {
+  const distro = config?.distro ?? ''
+  return registry.get(distro, config?.user || userFromLinuxPath(cwd) || userFor(distro))
+}
+
+export const name = 'dsh-wsl/search'
+export const inject = ['tools']
+
+export function apply(ctx, config = {}) {
+  const disposers = []
+
+  disposers.push(ctx.tools.register({
+    name: 'glob',
+    description: 'Find files by glob pattern inside the WSL distribution. Returns paths, oldest-first is not guaranteed; hidden files are included. In a Git worktree, files ignored by .gitignore are skipped; otherwise .git and node_modules are pruned. A pattern without "/" matches basenames at any depth.',
+    parameters: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Glob such as "**/*.ts" or "*.json".' },
+        path: { type: 'string', description: 'Directory to search (Linux path). Required: pass the session working directory.' },
+      },
+      required: ['pattern', 'path'],
+      additionalProperties: false,
+    },
+    output: {
+      schema: { type: 'object', properties: { paths: { type: 'array' }, truncated: { type: 'boolean' } }, additionalProperties: true },
+      render: (_args, value) => text((value.paths ?? []).join('\n') || 'no files matched'),
+    },
+    async execute(args, exec) {
+      const cwd = exec?.agent?.cwd ?? config.defaultCwd ?? '/'
+      const root = toLinuxPath(args.path, cwd)
+      return brokerFor(config, cwd).call('glob', { path: root, pattern: args.pattern, max: 1000 })
+    },
+  }))
+
+  disposers.push(ctx.tools.register({
+    name: 'grep',
+    description: 'Search file contents with a JavaScript regular expression inside the WSL distribution. Results are grouped by file with line numbers. In a Git worktree, files ignored by .gitignore are skipped; otherwise .git and node_modules are pruned; files over 2 MiB are skipped.',
+    parameters: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'JavaScript regular expression.' },
+        path: { type: 'string', description: 'Directory to search (Linux path). Required: pass the session working directory.' },
+        include: { type: 'string', description: 'Optional file-name glob filter, such as "*.ts".' },
+      },
+      required: ['pattern', 'path'],
+      additionalProperties: false,
+    },
+    output: {
+      schema: { type: 'object', properties: { files: { type: 'array' }, truncated: { type: 'boolean' } }, additionalProperties: true },
+      render: (_args, value) => {
+        const lines = []
+        for (const file of value.files ?? []) {
+          for (const match of file.matches ?? []) lines.push(`${file.path}:${match.lineNumber}: ${match.line}`)
+        }
+        if (value.truncated) lines.push('[truncated]')
+        return text(lines.join('\n') || 'no matches')
+      },
+    },
+    async execute(args, exec) {
+      const cwd = exec?.agent?.cwd ?? config.defaultCwd ?? '/'
+      const root = toLinuxPath(args.path, cwd)
+      return brokerFor(config, cwd).call('grep', { path: root, pattern: args.pattern, include: args.include, max: 250 })
+    },
+  }))
+
+  return () => { for (const dispose of disposers) dispose() }
+}
+