feat: adapt to DSH 0.1.7-alpha.1 and yield the read-only previews

DSH 0.1.7-alpha.1 is 1299 commits past 0.1.6-alpha.2 and rewrites four
contracts this plugin was built on. The peer floor moves to
^0.1.7-alpha.1 (semver's prerelease rule means ^0.1.6-alpha.2 can never
match a 0.1.7 prerelease); 0.1.6-alpha.2 and earlier stay on v0.19.1.
Released as 0.21.0-alpha.1 (dist-tag alpha).

Hard breaks:
- dsh-settings was rewritten: register(ns, schema) is gone, a form is
  addressed by the plugin row's Loader entry id and read from the
  module's exported Config. The preferences are merged into Config and
  marked volatile — which requires DSH's own schemastery, because only
  that build wraps a volatile field in the cosmokit reference the
  loader's volatile commit walks. With the public package a settings
  write reports success and revision 1 while the effective value never
  changes.
- ui-primitives renamed its whole icon family (IconXxx14/16 ->
  IconXxxRegular/Medium): 26 imported symbols, 17 files. The failing
  mode is render-time, not load-time. Five call sites that relied on the
  old 14px default now pass size={14} explicitly.
- Session format v4 rejects source.kind === 'plugin'; the side-chat
  boundary injection now writes plugin:dsh-better-sidebar, the same kind
  DSH's own v3->v4 migration produces, so historical threads survive.
  Tool results moved to role 'tool' with top-level content/isError; all
  four parsers accept both shapes.
- The client session snapshot dropped subagentsByParent/jobsBySession
  and the on-demand subagent-catalog observation API. The Tasks page
  reads projectionsBySession and a new jobs.list route.

Yields and convergence:
- The read-only previews go to DSH's documentpreview (Office->PDF, a
  spreadsheet worker, zoom, per-directory refresh); editor.canOpen
  refuses those 26 extensions. Markdown, HTML (with its sandbox
  switches) and the editable code buffer stay.
- The host browser kind is desktop-profile-only now, so the web e2e
  lanes expect no browser entry and assert its absence.
- Link takeover claims only urlTarget links and passes the rest to the
  host, fixing a regression from the 0.1.6 round: the fallback pointed
  at a 'browser' type the plugin no longer registers, so http links in
  its own markdown did nothing.

Also fixed, found along the way:
- The file tree refreshes live (new directory watch over the plugin's
  own socket), since the plugin owns the `files` kind.
- ctx.sessions.list has no `current` field at either tag; the three
  readers were dead. They now use ctx.sidebarRight.mounted.
- package.json.files was missing lib/client-locale.js.
- Two genuinely dead call sites: sessions.openSubagent/open/
  refreshSubagents do not exist on the current baseline, so the
  topology click, the jump-back and the retry were all no-ops.
- The test harness window shim lacked addEventListener, which the 0.1.7
  primitives call at module-evaluation time; and the e2e token exchange
  needs Playwright's request stack, not Node's fetch.

src/fs-watch.ts

@@ -0,0 +1,113 @@
+/**
+ * Directory change watching behind the file tree's live refresh.
+ *
+ * The tree used to go stale the moment anything wrote to disk outside the
+ * plugin (a build, a formatter, the model's own `bash`): a folder was listed
+ * once, when it was expanded, and never again. DSH 0.1.7 gave its own tree
+ * per-directory watching; this plugin owns its tree (it took the `files` kind
+ * over), so it needs its own watcher.
+ *
+ * One connection watches the directories the reader actually has expanded —
+ * not the whole workspace — because `fs.watch` is one OS handle per directory
+ * and a deep tree would exhaust them. Collapsing a folder or closing the
+ * socket releases its handle.
+ * @module dsh-better-sidebar/fs-watch
+ */
+import { watch, type FSWatcher } from 'node:fs'
+
+/** How long a burst of filesystem events is folded into a single push. */
+const DEBOUNCE_MS = 150
+
+/**
+ * Directory watchers one connection may hold. The cap is a resource guard,
+ * not a policy: a reader with more than this many folders expanded simply
+ * stops gaining new watchers, and collapsing any folder frees a slot.
+ */
+const MAX_WATCHES = 64
+
+/** One watched directory reporting that its contents changed. */
+export interface DirectoryWatchEvent {
+  /** The directory's absolute path, as it was registered. */
+  dir: string
+}
+
+/** One connection's set of directory watchers. */
+export interface DirectoryWatchers {
+  /**
+   * Start watching one directory.
+   * @param dir - absolute directory to watch; already-watched paths are a no-op.
+   * @returns true when the directory is now watched (or already was).
+   */
+  add(dir: string): boolean
+  /**
+   * Stop watching one directory; idempotent.
+   * @param dir - absolute directory that was passed to {@link add}.
+   */
+  remove(dir: string): void
+  /** Stop watching everything. */
+  close(): void
+}
+
+/**
+ * Create the watcher set of one connection.
+ *
+ * `fs.watch` reports a directory's own entry list changing, which is exactly
+ * what re-listing that directory needs — file CONTENTS changing inside an
+ * expanded folder is not observable this way and is not what the tree shows.
+ * @param push - called once per debounced burst with the changed directory.
+ * @param onError - called when a directory cannot be watched or its watcher
+ *   fails; the directory is dropped either way, so the caller only reports it.
+ * @returns the connection's watcher set.
+ */
+export function createDirectoryWatchers(
+  push: (event: DirectoryWatchEvent) => void,
+  onError: (dir: string, error: unknown) => void,
+): DirectoryWatchers {
+  const watchers = new Map<string, { watcher: FSWatcher; timer: NodeJS.Timeout | undefined }>()
+
+  const drop = (dir: string): void => {
+    const entry = watchers.get(dir)
+    if (entry === undefined) return
+    watchers.delete(dir)
+    if (entry.timer !== undefined) clearTimeout(entry.timer)
+    entry.watcher.close()
+  }
+
+  const notify = (dir: string): void => {
+    const entry = watchers.get(dir)
+    // A burst is folded into one push: editors emit several events per save,
+    // and the tree re-lists the whole directory either way.
+    if (entry === undefined || entry.timer !== undefined) return
+    entry.timer = setTimeout(() => {
+      entry.timer = undefined
+      if (watchers.has(dir)) push({ dir })
+    }, DEBOUNCE_MS)
+    // A pending re-list must never hold the host process open.
+    entry.timer.unref()
+  }
+
+  return {
+    add(dir) {
+      if (watchers.has(dir)) return true
+      if (watchers.size >= MAX_WATCHES) return false
+      let watcher: FSWatcher
+      try {
+        watcher = watch(dir, { persistent: false })
+      } catch (error) {
+        onError(dir, error)
+        return false
+      }
+      watcher.on('change', () => { notify(dir) })
+      watcher.on('error', (error) => {
+        onError(dir, error)
+        drop(dir)
+      })
+      watchers.set(dir, { watcher, timer: undefined })
+      return true
+    },
+    remove: drop,
+    close() {
+      for (const dir of [...watchers.keys()]) drop(dir)
+    },
+  }
+}