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/client/subagent-catalog.ts

@@ -0,0 +1,104 @@
+/**
+ * The plugin's view of DSH 0.1.7's host-computed session projections — the
+ * subagent catalog the Tasks page's topology renders, plus the two facts the
+ * projection row does not carry.
+ *
+ * 0.1.6 published a per-parent lazy catalog through the sessions snapshot
+ * (`subagentsByParent`, entries carrying `activity` / `hasChildren`) and the
+ * page had to OBSERVE every parent it drew, releasing them when it hid. 0.1.7
+ * replaced that whole handshake: the client loads every session's projections
+ * once per connection, `SessionListState.projectionsBySession` publishes the
+ * finished values, and a row is exactly `{ id, createdAt, mode, label? }`
+ * (see the subagent catalog projection's `viewSchema`). So this module is a
+ * pure adapter — no request, no subscription, no per-parent bookkeeping.
+ *
+ * The two dropped facts are derived, not invented:
+ *
+ * - a row HAS CHILDREN unless the child's own catalog is known-empty
+ *   ({@link isKnownLeaf} — upstream's own disclosure rule, which keeps a
+ *   branch open while its catalog is still loading instead of flapping it
+ *   into a leaf);
+ * - `activity` comes from the live channel (`subagents.live`, which folds the
+ *   host's RUNNING children): a child the live map does not mention is not
+ *   running ({@link childActivity}).
+ *
+ * What the projection genuinely does not carry any more is the 0.1.6
+ * `diagnostic` row (a child whose descriptor was corrupt / unsupported /
+ * unavailable): the host's fold publishes healthy identities only, so an
+ * unreadable child is not a row at all and the page has nothing to show for
+ * it. See the module report — no local equivalent exists.
+ */
+import type {
+  SidebarSessionList,
+  SidebarSubagentCatalogEntry,
+} from '../context-types.ts'
+import type { LastActivity } from '../subagent-activity.ts'
+
+/** One parent's direct-child catalog, as the topology consumes it. */
+export interface SubagentCatalogView {
+  entries: readonly SidebarSubagentCatalogEntry[]
+  state: 'loading' | 'ready' | 'error'
+  error: { code?: string; message?: string } | null
+}
+
+/**
+ * Fold the snapshot's projection values into per-parent catalog views.
+ *
+ * An `idle` row has been published but not read yet (the manager seeds rows
+ * from the persisted checkpoint before the connection's read lands): it is
+ * `loading` when it carries no value at all and `ready` when a value is
+ * already there — the same reading upstream's own catalog view uses.
+ *
+ * @param projections - `SessionListState.projectionsBySession` (optional: a
+ *   host without the projection store leaves every catalog empty).
+ * @returns one view per session the snapshot knows about.
+ */
+export function subagentCatalogs(
+  projections: SidebarSessionList['projectionsBySession'],
+): Readonly<Record<string, SubagentCatalogView>> {
+  const views: Record<string, SubagentCatalogView> = {}
+  for (const [sessionId, snapshot] of Object.entries(projections ?? {})) {
+    const entries = snapshot.values.subagentCatalog
+    views[sessionId] = {
+      entries: entries ?? [],
+      state: snapshot.state === 'idle'
+        ? entries === undefined ? 'loading' : 'ready'
+        : snapshot.state,
+      error: snapshot.error ?? null,
+    }
+  }
+  return views
+}
+
+/**
+ * Whether a child is a KNOWN LEAF: its own catalog finished loading and holds
+ * no children. Everything else (a catalog still loading, one that failed, or
+ * one this snapshot does not carry yet) keeps its disclosure — the topology
+ * then draws the child's own level, whose rows hydrate when the projection
+ * lands.
+ *
+ * @param catalogs - the views of one snapshot ({@link subagentCatalogs}).
+ * @param childSessionId - the child row whose own catalog decides.
+ */
+export function isKnownLeaf(
+  catalogs: Readonly<Record<string, SubagentCatalogView>>,
+  childSessionId: string,
+): boolean {
+  const catalog = catalogs[childSessionId]
+  return catalog?.state === 'ready' && catalog.entries.length === 0
+}
+
+/**
+ * The child's live state. The `subagents.live` route folds only RUNNING
+ * children (a Side Chat thread and an idle child are absent), so absence is
+ * the inactive answer rather than missing data.
+ *
+ * @param live - the batch live map (`child id → latest activity`).
+ * @param childSessionId - the child row being drawn.
+ */
+export function childActivity(
+  live: Readonly<Record<string, LastActivity>>,
+  childSessionId: string,
+): 'running' | 'inactive' {
+  return live[childSessionId] === undefined ? 'inactive' : 'running'
+}