dsh-plugin-session-cleaner 0.0.0-stage → 0.3.2

package/lib/client.js

@@ -0,0 +1,1845 @@
+// Generated by build/client.mjs — do not edit. Source lives in ../client/.
+window.__ModuleLoader__.load({id:"dsh-plugin-session-cleaner",factory:function(require){
+const __modules = {};
+__modules["src/contract.cjs"] = (() => {
+const module = { exports: {} };
+const exports = module.exports;
+/**
+ * The Remote contract, shared verbatim by both halves.
+ *
+ * The Host's typert manifest and the Web client's mounted descriptors are both
+ * built from this file, so the two halves cannot drift.
+ *
+ * Written as CommonJS on purpose: the Web client bundles this file into a
+ * single self-contained `client.js`, and Node's ESM interop exposes these
+ * `exports.*` assignments to the Host half as named imports, so one file
+ * serves both without a build-time transform.
+ *
+ * dsh-typert-loader requires EVERY codec — parameters and results — to be
+ * `strict` (a string typeSymbol plus a create() factory), and the gateway's
+ * boundary check only calls `codec.create().parse(value)`. A pass-through
+ * parser therefore satisfies the wire contract exactly: the payloads are plain
+ * JSON projection data, and the gateway's own assertJsonValue still guards the
+ * boundary, so hand-rolling one line of validation beats shipping a schema
+ * library inside the client bundle.
+ */
+
+/** Pass-through boundary schema: whatever crosses is already lossless JSON. */
+const passthrough = () => ({ parse: (value) => value })
+
+/** The one schema entry both halves register for their codecs. */
+const SESSION_CLEANER_JSON_SCHEMA = Object.freeze({
+  name: 'SessionCleanerJson',
+  create: passthrough,
+})
+
+/** Strict JSON codec, valid on both the Host manifest and the client mount. */
+const JSON_CODEC = Object.freeze({
+  mode: 'strict',
+  typeSymbol: 'dsh-plugin-session-cleaner#SessionCleanerJson',
+  create: passthrough,
+})
+
+/** One ordered business parameter. */
+const param = (name, wire = name) => Object.freeze({
+  name,
+  wire,
+  source: 'json',
+  codec: JSON_CODEC,
+})
+
+const SESSION_CLEANER_LIST = Object.freeze({
+  id: 'dsh-plugin-session-cleaner#sessionCleaner/list',
+  service: 'sessionCleaner',
+  namespace: 'sessionCleaner',
+  method: 'list',
+  invocation: { kind: 'direct' },
+  parameters: [],
+  result: JSON_CODEC,
+})
+
+const SESSION_CLEANER_PREVIEW = Object.freeze({
+  id: 'dsh-plugin-session-cleaner#sessionCleaner/preview',
+  service: 'sessionCleaner',
+  namespace: 'sessionCleaner',
+  method: 'preview',
+  invocation: { kind: 'direct' },
+  parameters: [param('sessionIds')],
+  result: JSON_CODEC,
+})
+
+const SESSION_CLEANER_READ = Object.freeze({
+  id: 'dsh-plugin-session-cleaner#sessionCleaner/read',
+  service: 'sessionCleaner',
+  namespace: 'sessionCleaner',
+  method: 'read',
+  invocation: { kind: 'direct' },
+  parameters: [param('sessionId'), param('options')],
+  result: JSON_CODEC,
+})
+
+const SESSION_CLEANER_DELETE = Object.freeze({
+  id: 'dsh-plugin-session-cleaner#sessionCleaner/delete',
+  service: 'sessionCleaner',
+  namespace: 'sessionCleaner',
+  method: 'delete',
+  invocation: { kind: 'direct' },
+  parameters: [param('sessionIds'), param('options')],
+  result: JSON_CODEC,
+})
+
+const TYPERT_REMOTE = Object.freeze({
+  package: 'dsh-plugin-session-cleaner',
+  descriptors: [SESSION_CLEANER_LIST, SESSION_CLEANER_PREVIEW, SESSION_CLEANER_READ, SESSION_CLEANER_DELETE],
+})
+
+exports.SESSION_CLEANER_JSON_SCHEMA = SESSION_CLEANER_JSON_SCHEMA
+exports.SESSION_CLEANER_LIST = SESSION_CLEANER_LIST
+exports.SESSION_CLEANER_PREVIEW = SESSION_CLEANER_PREVIEW
+exports.SESSION_CLEANER_READ = SESSION_CLEANER_READ
+exports.SESSION_CLEANER_DELETE = SESSION_CLEANER_DELETE
+exports.TYPERT_REMOTE = TYPERT_REMOTE
+exports.default = TYPERT_REMOTE
+
+return module.exports;
+})();
+__modules["client/panel-page.js"] = (() => {
+const module = { exports: {} };
+const exports = module.exports;
+/**
+ * The global Session-cleanup page: list every session grouped by workspace,
+ * filter, multi-select, delete — and preview a conversation before deleting it
+ * (a Preview button on each row, or a double-click anywhere on the row).
+ *
+ * Rows are titled (the id only appears inside the preview dialog, under the
+ * title). Workspace groups collapse by default; subagent sessions nest under
+ * their parent row, with an expand caret of their own, and orphaned subagents
+ * (their parent is gone) root themselves so they stay visible.
+ *
+ * Registered as a top-level main panel (the `main` keyed slot) with its own
+ * sidebar entry, next to Plugins and Automation Tasks. The session menu row
+ * calls the same Host service, so the page adds reach without a second
+ * deletion path.
+ *
+ * The page chrome follows the shipped global pages (ui-schedule, ui-plugin-
+ * manager): a full-height scroll area whose content is centered at 960px with
+ * a page heading; on macOS the heading also yields to the traffic-light
+ * clearance the layout publishes as `--dsh-frame-top-clearance`.
+ */
+
+/** Format a byte count for compact display. */
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return '0 B'
+  const units = ['B', 'KiB', 'MiB', 'GiB']
+  let value = bytes
+  let unit = 0
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024
+    unit += 1
+  }
+  return `${value >= 10 || unit === 0 ? Math.round(value) : value.toFixed(1)} ${units[unit]}`
+}
+
+/** Read a service result defensively: RPC may settle unwrapped or wrapped. */
+function unwrap(result) {
+  if (result !== null && typeof result === 'object' && 'ok' in result && 'value' in result) {
+    return result.ok ? result.value : { ok: false, error: result.error?.message ?? 'remote call failed' }
+  }
+  return result
+}
+
+/**
+ * One checkbox flip in the panel, kept aligned with the deletion closure:
+ * the Host deletes a session's descendants together with it, so the checked
+ * set (and the "N sessions (X)" totals built from it) must match that
+ * closure exactly.
+ *
+ * - Selecting a session selects its whole descendant subtree.
+ * - Deselecting one drops its subtree AND every selected ancestor: a checked
+ *   ancestor would drag the subtree back into the delete set on the Host
+ *   side, and the panel totals would understate what actually gets removed.
+ *
+ * Children link upward through `parent`; the subtree is walked breadth-first
+ * so grandchildren join even when their parent is missing from the list.
+ */
+function toggleWithDescendants(sessions, selected, id) {
+  const childrenOf = new Map()
+  const parentOf = new Map()
+  for (const session of sessions) {
+    if (session.parent !== undefined) {
+      parentOf.set(session.id, session.parent)
+      const list = childrenOf.get(session.parent)
+      if (list === undefined) childrenOf.set(session.parent, [session.id])
+      else list.push(session.id)
+    }
+  }
+
+  const next = new Set(selected)
+  if (!next.has(id)) {
+    next.add(id)
+    const queue = [id]
+    while (queue.length > 0) {
+      for (const child of childrenOf.get(queue.shift()) ?? []) {
+        next.add(child)
+        queue.push(child)
+      }
+    }
+  } else {
+    next.delete(id)
+    const queue = [id]
+    while (queue.length > 0) {
+      for (const child of childrenOf.get(queue.shift()) ?? []) {
+        next.delete(child)
+        queue.push(child)
+      }
+    }
+    // Un-check every ancestor still selected: keeping one would re-include
+    // this subtree in its deletion closure.
+    let ancestor = parentOf.get(id)
+    while (ancestor !== undefined && next.has(ancestor)) {
+      next.delete(ancestor)
+      ancestor = parentOf.get(ancestor)
+    }
+  }
+  return next
+}
+
+/**
+ * Drive a set of session ids toward a wanted checked state through the row
+ * cascade, so bulk affordances ("select all" of the toolbar, of a workspace
+ * group) keep the checked set aligned with the Host's deletion closure.
+ */
+function setSelection(sessions, selected, ids, wanted) {
+  let next = new Set(selected)
+  for (const id of ids) {
+    if (next.has(id) !== wanted) next = toggleWithDescendants(sessions, next, id)
+  }
+  return next
+}
+
+/** Last path segment of a Windows or POSIX path; '' when there is none. */
+function baseName(value) {
+  const parts = String(value).split(/[\\/]/).filter((part) => part.length > 0)
+  return parts.length > 0 ? parts[parts.length - 1] : ''
+}
+
+/**
+ * Group sessions by workspace and nest subagents under their parents.
+ *
+ * A group's display path is the most common `cwd` among its sessions (each
+ * session reports its own; they agree within a workspace), its name the path's
+ * last segment, falling back to the raw workspace key when no session reports
+ * a cwd. A session whose parent is missing from the group roots its own tree
+ * — an orphaned subagent stays visible instead of vanishing from the list.
+ * Roots sort newest first; subagents sort oldest first (spawn order). Groups
+ * sort by total bytes, largest first.
+ */
+function buildWorkspaceGroups(sessions) {
+  const byWorkspace = new Map()
+  for (const session of sessions) {
+    const list = byWorkspace.get(session.workspaceKey)
+    if (list === undefined) byWorkspace.set(session.workspaceKey, [session])
+    else list.push(session)
+  }
+
+  const groups = []
+  for (const [workspaceKey, list] of byWorkspace) {
+    const cwdCounts = new Map()
+    for (const session of list) {
+      if (typeof session.cwd === 'string' && session.cwd !== '') {
+        cwdCounts.set(session.cwd, (cwdCounts.get(session.cwd) ?? 0) + 1)
+      }
+    }
+    let path
+    let best = 0
+    for (const [cwd, count] of cwdCounts) {
+      if (count > best) {
+        best = count
+        path = cwd
+      }
+    }
+    const name = baseName(path ?? '') || workspaceKey
+
+    const ids = new Set(list.map((session) => session.id))
+    const childrenOf = new Map()
+    for (const session of list) {
+      if (session.parent === undefined) continue
+      const siblings = childrenOf.get(session.parent)
+      if (siblings === undefined) childrenOf.set(session.parent, [session])
+      else siblings.push(session)
+    }
+    const buildNode = (session) => ({
+      session,
+      orphan: session.parent !== undefined && !ids.has(session.parent),
+      children: (childrenOf.get(session.id) ?? []).map(buildNode),
+    })
+    const roots = list
+      .filter((session) => session.parent === undefined || !ids.has(session.parent))
+      .map(buildNode)
+    const sortTree = (nodes) => {
+      nodes.sort((left, right) => (left.session.createdAt ?? 0) - (right.session.createdAt ?? 0))
+      for (const node of nodes) sortTree(node.children)
+      return nodes
+    }
+    roots.sort((left, right) => (right.session.createdAt ?? 0) - (left.session.createdAt ?? 0))
+    for (const node of roots) sortTree(node.children)
+
+    groups.push({
+      key: workspaceKey,
+      name,
+      path,
+      roots,
+      count: list.length,
+      childCount: list.filter((session) => session.parent !== undefined).length,
+      bytes: list.reduce((sum, session) => sum + (session.bytes ?? 0), 0),
+    })
+  }
+  groups.sort((left, right) => right.bytes - left.bytes)
+  return groups
+}
+
+/** Flatten a display forest back into its sessions, parents before children. */
+function collectSessions(nodes, out = []) {
+  for (const node of nodes) {
+    out.push(node.session)
+    collectSessions(node.children, out)
+  }
+  return out
+}
+
+/**
+ * The descendant subagent sessions of one id, breadth-first over the loaded
+ * `parent` links — the ids the Host would delete together with it.
+ */
+function collectDescendants(sessions, sessionId) {
+  const childrenOf = new Map()
+  for (const session of sessions) {
+    if (session.parent === undefined) continue
+    const list = childrenOf.get(session.parent)
+    if (list === undefined) childrenOf.set(session.parent, [session])
+    else list.push(session)
+  }
+  const out = []
+  const queue = [sessionId]
+  while (queue.length > 0) {
+    for (const child of childrenOf.get(queue.shift()) ?? []) {
+      out.push(child)
+      queue.push(child.id)
+    }
+  }
+  return out
+}
+
+/** Does a session match the filter needle across its display fields? */
+function sessionMatches(session, needle) {
+  return session.id.toLowerCase().includes(needle)
+    || (session.title ?? '').toLowerCase().includes(needle)
+    || session.workspaceKey.toLowerCase().includes(needle)
+    || (session.cwd ?? '').toLowerCase().includes(needle)
+}
+
+/**
+ * Keep the nodes a filter still shows. A matching node keeps its whole subtree
+ * (the user matched the parent, the children come along); a non-matching node
+ * survives only through matching descendants, which keeps the tree shape
+ * intact when only a subagent matches.
+ */
+function filterNodes(nodes, needle) {
+  const out = []
+  for (const node of nodes) {
+    const children = filterNodes(node.children, needle)
+    if (sessionMatches(node.session, needle)) out.push(node)
+    else if (children.length > 0) out.push({ session: node.session, orphan: node.orphan, children })
+  }
+  return out
+}
+
+/** A group survives a filter through its name/path or any surviving session. */
+function filterGroup(group, needle) {
+  if (group.name.toLowerCase().includes(needle) || (group.path ?? '').toLowerCase().includes(needle)) return group
+  const roots = filterNodes(group.roots, needle)
+  if (roots.length === 0) return undefined
+  return { ...group, roots }
+}
+
+// The shipped global pages pad their heading for the macOS traffic lights
+// only ([data-platform='darwin']); on Windows the titlebar already sits above
+// the content area, so the clearance must not be added twice.
+const isDarwin = typeof document === 'object' && document !== null
+  && document.documentElement?.getAttribute?.('data-platform') === 'darwin'
+
+/** Locale date-time for a message stamp; '' when the value is not a date. */
+function formatTime(time) {
+  try {
+    const date = new Date(time)
+    if (Number.isNaN(date.getTime())) return ''
+    return date.toLocaleString()
+  } catch {
+    return ''
+  }
+}
+
+/** Locale date for a session's creation stamp; '' when unknown. */
+function formatDay(time) {
+  try {
+    const date = new Date(time)
+    if (Number.isNaN(date.getTime())) return ''
+    return date.toLocaleDateString()
+  } catch {
+    return ''
+  }
+}
+
+/** Render transcript messages as read-only rows (badge, stamp, text). */
+function renderMessages(React, t, messages) {
+  return messages.map((message, index) => {
+    const meta = []
+    if (typeof message.time === 'number') {
+      const stamp = formatTime(message.time)
+      if (stamp !== '') meta.push(stamp)
+    }
+    if (typeof message.model === 'string') meta.push(message.model)
+    return React.createElement('div', { key: index, style: messageStyle }, [
+      React.createElement('div', { key: 'head', style: messageHeadStyle }, [
+        React.createElement('span', {
+          key: 'role',
+          style: message.role === 'assistant' ? assistantBadgeStyle : userBadgeStyle,
+        }, t(message.role === 'assistant' ? 'preview.assistant' : 'preview.user')),
+        meta.length === 0 ? null : React.createElement('span', { key: 'meta', style: messageMetaStyle }, meta.join(' · ')),
+      ]),
+      React.createElement('div', { key: 'text', style: messageTextStyle }, message.text),
+    ])
+  })
+}
+
+module.exports = function createPanelPage(React, t, acquire, readFailure, primitives) {
+  const { useState, useEffect, useMemo, useRef } = React
+  // Optional: called after a successful batch deletion so the client can
+  // re-pull its session list and drop the deleted rows from the sidebar.
+  const afterDelete = primitives?.afterDelete
+  // Optional: fires when a deletion happens OUTSIDE this panel (the sidebar
+  // menu dialog). This page's list is a scan snapshot taken on mount, so it
+  // subscribes and re-scans — otherwise deleted rows would linger here while
+  // the sidebar has already dropped them.
+  const deletionSignal = primitives?.deletionSignal
+
+  return function SessionCleanerPage() {
+    const [state, setState] = useState({ phase: 'loading' })
+    const [query, setQuery] = useState('')
+    const [selected, setSelected] = useState(() => new Set())
+    const [busy, setBusy] = useState(false)
+    const [notice, setNotice] = useState(undefined)
+    // Workspace groups and parent rows the user has expanded; both default to
+    // collapsed, and a text filter overrides them (matches must be visible).
+    const [openWorkspaces, setOpenWorkspaces] = useState(() => new Set())
+    const [openSessions, setOpenSessions] = useState(() => new Set())
+    // The pending conversation preview: { phase: 'loading'|'ready'|'error',
+    // sessionId, data?, error? } — undefined while no dialog is open.
+    const [preview, setPreview] = useState(undefined)
+    const previewSeq = useRef(0)
+    // The preview dialog's user-chosen size; undefined = the responsive
+    // default. The state lives in the page (which outlives the dialog), so a
+    // chosen size survives closing and reopening.
+    const [previewSize, setPreviewSize] = useState(undefined)
+    const previewPanelRef = useRef(null)
+
+    /**
+     * (Re)scan the Host's disk. The quiet variant is the post-delete
+     * reconciliation: it keeps the current list, notice and dshHome on screen
+     * while the scan is in flight, and on failure keeps them too — the rows
+     * dropped optimistically after the delete are a better guess than a
+     * loading flash over an empty list.
+     */
+    const load = async ({ quiet = false } = {}) => {
+      if (!quiet) {
+        setState({ phase: 'loading' })
+        setNotice(undefined)
+      }
+      const service = await acquire()
+      if (service === undefined) {
+        if (!quiet) {
+          const reason = readFailure?.()
+          setState({ phase: 'error', error: reason === undefined ? t('panel.serviceMissing') : t('panel.service.mountFailed', { reason }) })
+        }
+        return
+      }
+      try {
+        const data = unwrap(await service.list())
+        setState({ phase: 'ready', sessions: data?.sessions ?? [], dshHome: data?.dshHome })
+        setSelected(new Set())
+      } catch (reason) {
+        if (!quiet) setState({ phase: 'error', error: String(reason?.message ?? reason) })
+      }
+    }
+
+    useEffect(() => { load() }, [])
+
+    // Deletions from the sidebar menu invalidate this snapshot: re-scan when
+    // signaled. The cleanup happens through the subscription's disposer.
+    useEffect(() => {
+      if (deletionSignal === undefined) return undefined
+      return deletionSignal.subscribe(() => { load() })
+    }, [])
+
+    // Escape closes the preview, matching the platform Modal's behaviour.
+    useEffect(() => {
+      if (preview === undefined || typeof document?.addEventListener !== 'function') return undefined
+      const onKeyDown = (event) => { if (event.key === 'Escape') closePreview() }
+      document.addEventListener('keydown', onKeyDown)
+      return () => { document.removeEventListener('keydown', onKeyDown) }
+    }, [preview === undefined])
+
+    const sessions = state.phase === 'ready' ? state.sessions : []
+    const filtering = query.trim() !== ''
+    const groups = useMemo(() => buildWorkspaceGroups(sessions), [sessions])
+    const visibleGroups = useMemo(() => {
+      const needle = query.trim().toLowerCase()
+      if (needle === '') return groups
+      return groups
+        .map((group) => filterGroup(group, needle))
+        .filter((group) => group !== undefined)
+    }, [groups, query])
+    const visibleSessions = useMemo(
+      () => visibleGroups.flatMap((group) => collectSessions(group.roots)),
+      [visibleGroups],
+    )
+
+    const allVisibleSelected = visibleSessions.length > 0 && visibleSessions.every((session) => selected.has(session.id))
+    const selectedSessions = sessions.filter((session) => selected.has(session.id))
+    const selectedBytes = selectedSessions.reduce((sum, session) => sum + session.bytes, 0)
+
+    const toggle = (id) => {
+      setSelected(toggleWithDescendants(sessions, selected, id))
+    }
+    const toggleAll = () => {
+      if (allVisibleSelected) {
+        setSelected(new Set())
+        return
+      }
+      // Select-each-visible carries each one's descendants in, including
+      // descendants a text filter currently hides from the list.
+      setSelected(setSelection(sessions, selected, visibleSessions.map((session) => session.id), true))
+    }
+    /** The group header checkbox: drive every session under the group toward one state. */
+    const toggleGroup = (groupSessions) => {
+      const wanted = !(groupSessions.length > 0 && groupSessions.every((session) => selected.has(session.id)))
+      setSelected(setSelection(sessions, selected, groupSessions.map((session) => session.id), wanted))
+    }
+
+    const remove = async () => {
+      const ids = [...selected]
+      if (ids.length === 0) return
+      setBusy(true)
+      setNotice(undefined)
+      const service = await acquire()
+      if (service === undefined) {
+        setBusy(false)
+        const reason = readFailure?.()
+        setNotice({ kind: 'error', text: reason === undefined ? t('panel.serviceMissing') : t('service.mountFailed', { reason }) })
+        return
+      }
+      try {
+        const result = unwrap(await service.delete(ids, {}))
+        const deletedIds = new Set(
+          (Array.isArray(result?.deleted) ? result.deleted : [])
+            .map((entry) => entry?.id)
+            .filter((id) => typeof id === 'string'),
+        )
+        if (deletedIds.size > 0) {
+          // Optimistic removal: the Host confirmed these deletions, so the
+          // rows drop the moment the RPC returns instead of after the
+          // reconciliation scan below (a full disk walk that flashes the
+          // loading state on large profiles). A refused or partially failed
+          // delete never reaches here with the un-deleted ids included, so
+          // surviving rows stay on screen until the scan reconciles them.
+          setState((current) => (current.phase === 'ready'
+            ? { ...current, sessions: current.sessions.filter((session) => !deletedIds.has(session.id)) }
+            : current))
+          const without = (current) => {
+            const next = new Set(current)
+            for (const id of deletedIds) next.delete(id)
+            return next
+          }
+          setSelected(without)
+          setOpenSessions(without)
+          // Hand the CONFIRMED ids to the client regardless of the batch
+          // outcome — a partially failed delete still deleted these, and
+          // leaving them on the sidebar (see forgetSessions) parks them in
+          // Ungrouped until the next restart.
+          try { afterDelete?.([...deletedIds]) } catch { /* best effort */ }
+        }
+        if (result?.ok === false) {
+          setNotice({ kind: 'error', text: t('panel.failed', { reason: result.error ?? 'unknown' }) })
+        } else {
+          setNotice({
+            kind: 'done',
+            text: t('panel.deleted', {
+              count: result?.summary?.sessionsDeleted ?? 0,
+              size: formatBytes(result?.summary?.bytesDeleted ?? 0),
+            }),
+          })
+        }
+        // Reconcile behind the optimistic update: the scan replaces the
+        // snapshot (and picks up deletions made elsewhere) without a loading
+        // flash, and the quiet path leaves the report above on screen.
+        await load({ quiet: true })
+      } catch (reason) {
+        setNotice({ kind: 'error', text: t('panel.failed', { reason: String(reason?.message ?? reason) }) })
+      } finally {
+        setBusy(false)
+      }
+    }
+
+    /** Flip one membership in an expansion Set (workspaces, parent rows). */
+    const toggleSet = (setter, value) => setter((previous) => {
+      const next = new Set(previous)
+      if (next.has(value)) next.delete(value)
+      else next.add(value)
+      return next
+    })
+
+    /**
+     * Open the read-only transcript dialog for a session. Only the most
+     * recent request may settle: a fast double-click on two different rows
+     * would otherwise race, and the older read could overwrite the newer
+     * dialog after it opened.
+     */
+    const openPreview = async (sessionId) => {
+      const requestId = previewSeq.current + 1
+      previewSeq.current = requestId
+      setPreview({ phase: 'loading', sessionId })
+      const service = await acquire()
+      if (previewSeq.current !== requestId) return
+      if (service === undefined) {
+        const reason = readFailure?.()
+        setPreview({ phase: 'error', sessionId, error: reason === undefined ? t('panel.serviceMissing') : t('service.mountFailed', { reason }) })
+        return
+      }
+      try {
+        const data = unwrap(await service.read(sessionId, {}))
+        if (previewSeq.current !== requestId) return
+        if (data?.ok === false) {
+          setPreview({ phase: 'error', sessionId, error: t('preview.failed', { reason: data.error ?? 'unknown' }) })
+        } else {
+          setPreview({ phase: 'ready', sessionId, data })
+        }
+      } catch (reason) {
+        if (previewSeq.current !== requestId) return
+        setPreview({ phase: 'error', sessionId, error: t('preview.failed', { reason: String(reason?.message ?? reason) }) })
+      }
+    }
+
+    const closePreview = () => {
+      previewSeq.current += 1
+      setPreview(undefined)
+    }
+
+    /**
+     * Drag-resize the preview dialog from its corner grip: pointer deltas
+     * become an explicit size, clamped to the viewport. A double-click on the
+     * grip returns to the responsive default.
+     */
+    const startPreviewResize = (event) => {
+      event.preventDefault?.()
+      event.stopPropagation?.()
+      const panel = previewPanelRef.current
+      if (panel == null || typeof window?.addEventListener !== 'function') return
+      const startX = event.clientX
+      const startY = event.clientY
+      const startWidth = panel.offsetWidth
+      const startHeight = panel.offsetHeight
+      const onMove = (moveEvent) => {
+        const width = Math.round(Math.min(Math.max(480, startWidth + moveEvent.clientX - startX), window.innerWidth - 48))
+        const height = Math.round(Math.min(Math.max(320, startHeight + moveEvent.clientY - startY), window.innerHeight - 48))
+        setPreviewSize({ width, height })
+      }
+      const onUp = () => {
+        window.removeEventListener('pointermove', onMove)
+        window.removeEventListener('pointerup', onUp)
+      }
+      window.addEventListener('pointermove', onMove)
+      window.addEventListener('pointerup', onUp)
+    }
+
+    /**
+     * The transcript dialog: a wide, user-resizable card.
+     *
+     * The platform Modal is fixed at min(380px, 100%) wide with no size
+     * override, so a transcript — the one dialog that wants screen real
+     * estate — renders through this own card instead, dressed in the same
+     * design aliases (layer-2 fill, prominent elevation, blurred mask) to
+     * stay indistinguishable from the shipped dialogs. The page is a
+     * long-lived `main` slot component, so the dialog can live in its tree
+     * directly — unlike the session-menu rows, whose dialogs must ride the
+     * frame-wide `shell.overlay` because the row unmounts with its menu.
+     */
+    const renderPreview = () => {
+      if (preview === undefined) return null
+      const data = preview.phase === 'ready' ? preview.data : undefined
+
+      const body = []
+      // The id sits directly under the title in every phase: the dialog's
+      // subject stays identifiable even while the transcript is loading.
+      body.push(React.createElement('p', { key: 'sessionid', style: previewIdStyle }, [
+        React.createElement('span', { key: 'label', style: previewIdLabelStyle }, `${t('preview.sessionId')}: `),
+        preview.sessionId,
+      ]))
+      const descendants = collectDescendants(sessions, preview.sessionId)
+      if (descendants.length > 0) {
+        body.push(React.createElement('div', { key: 'children', style: previewChildrenStyle }, [
+          React.createElement('p', { key: 'head', style: previewChildrenHeadStyle },
+            t('preview.children', { count: descendants.length })),
+          ...descendants.map((session) => React.createElement('div', { key: session.id, style: previewChildRowStyle }, [
+            React.createElement('span', { key: 'badge', style: childBadgeStyle }, t('panel.child')),
+            React.createElement('span', {
+              key: 'id',
+              style: previewChildIdStyle,
+              title: session.title ?? session.id,
+            }, session.id),
+          ])),
+        ]))
+      }
+      if (data !== undefined) {
+        // The workspace arrives as its encoded key; the cwd is the same place
+        // in human form, so only size and cwd are shown.
+        const meta = [data.humanBytes, data.cwd]
+          .filter((part) => typeof part === 'string' && part !== '')
+        if (meta.length > 0) {
+          body.push(React.createElement('p', { key: 'meta', style: previewMetaStyle }, meta.join(' · ')))
+        }
+        if (data.truncated === true) {
+          body.push(React.createElement('p', { key: 'truncated', style: hintStyle },
+            t('preview.truncated', { shown: data.messages.length, total: data.totalMessages })))
+        }
+        body.push(React.createElement('div', { key: 'messages', style: messageListStyle },
+          data.messages.length === 0
+            ? React.createElement('p', { key: 'empty', style: hintStyle }, t('preview.empty'))
+            : renderMessages(React, t, data.messages)))
+      } else if (preview.phase === 'loading') {
+        body.push(React.createElement('p', { key: 'loading', style: hintStyle }, t('preview.loading')))
+      } else {
+        body.push(React.createElement('p', { key: 'error', style: errorStyle }, preview.error))
+      }
+
+      const panelStyle = previewSize === undefined
+        ? previewPanelStyle
+        : { ...previewPanelStyle, width: `${previewSize.width}px`, height: `${previewSize.height}px` }
+
+      return React.createElement('div', { style: previewOverlayStyle }, [
+        React.createElement('div', {
+          key: 'mask',
+          style: previewMaskStyle,
+          onClick: () => { closePreview() },
+        }),
+        React.createElement('div', {
+          key: 'panel',
+          ref: previewPanelRef,
+          role: 'dialog',
+          'aria-modal': 'true',
+          'aria-label': t('preview.title'),
+          style: panelStyle,
+        }, [
+          React.createElement('div', { key: 'header', style: previewHeaderStyle }, [
+            React.createElement('h2', { key: 'title', style: previewHeadingStyle }, t('preview.title')),
+            React.createElement('button', {
+              key: 'close',
+              type: 'button',
+              style: previewCloseStyle,
+              'aria-label': t('dialog.close'),
+              onClick: closePreview,
+            }, '×'),
+          ]),
+          React.createElement('p', { key: 'subject', style: previewSubjectStyle }, data?.title || preview.sessionId),
+          React.createElement('div', { key: 'body', style: previewBodyStyle }, body),
+          React.createElement('div', { key: 'footer', style: previewFooterStyle },
+            React.createElement('button', { key: 'close', type: 'button', onClick: closePreview, style: buttonStyle }, t('dialog.close'))),
+          React.createElement('div', {
+            key: 'resize',
+            style: resizeGripStyle,
+            'aria-label': t('preview.resize'),
+            title: t('preview.resize'),
+            onPointerDown: startPreviewResize,
+            onDoubleClick: (event) => {
+              event.stopPropagation()
+              setPreviewSize(undefined)
+            },
+          }, '◢'),
+        ]),
+      ])
+    }
+
+    /** One workspace group card: header row, then its session forest when open. */
+    const renderGroup = (group) => {
+      const open = filtering || openWorkspaces.has(group.key)
+      const groupSessions = collectSessions(group.roots)
+      const allSelected = groupSessions.length > 0 && groupSessions.every((session) => selected.has(session.id))
+      const someSelected = groupSessions.some((session) => selected.has(session.id))
+
+      const rows = [
+        React.createElement('div', {
+          key: 'header',
+          style: groupHeaderStyle,
+          role: 'group',
+          'aria-label': group.name,
+          onClick: () => { toggleSet(setOpenWorkspaces, group.key) },
+        }, [
+          React.createElement('button', {
+            key: 'expander',
+            type: 'button',
+            style: expanderStyle,
+            'aria-expanded': open,
+            'aria-label': t(open ? 'panel.collapse' : 'panel.expand'),
+            onClick: (event) => {
+              event.stopPropagation()
+              toggleSet(setOpenWorkspaces, group.key)
+            },
+            onDoubleClick: (event) => event.stopPropagation(),
+          }, open ? '▼' : '▶'),
+          React.createElement('input', {
+            key: 'check',
+            type: 'checkbox',
+            checked: allSelected,
+            // A partial selection reads as indeterminate; React has no prop
+            // for it, so the ref callback owns that DOM state.
+            ref: (element) => { if (element != null) element.indeterminate = someSelected && !allSelected },
+            onClick: (event) => event.stopPropagation(),
+            onChange: () => toggleGroup(groupSessions),
+          }),
+          React.createElement('span', {
+            key: 'name',
+            style: groupNameStyle,
+            title: group.path ?? group.key,
+          }, group.name),
+          React.createElement('span', { key: 'path', style: groupPathStyle }, group.path ?? ''),
+          React.createElement('span', { key: 'stats', style: groupStatsStyle },
+            t(group.childCount > 0 ? 'panel.groupStatsChildren' : 'panel.groupStats',
+              { count: group.count, children: group.childCount, size: formatBytes(group.bytes) })),
+        ]),
+      ]
+      if (open) {
+        for (const node of group.roots) rows.push(...renderNode(node, 0))
+      }
+      return React.createElement('div', { key: group.key, style: listStyle }, rows)
+    }
+
+    /** One session row (a checkbox label) plus, when expanded, its subagents. */
+    const renderNode = (node, depth) => {
+      const { session } = node
+      const hasChildren = node.children.length > 0
+      const open = filtering || openSessions.has(session.id)
+      const label = session.title ?? session.id
+
+      return [
+        React.createElement('label', {
+          key: session.id,
+          style: { ...rowStyle, paddingLeft: `${10 + depth * 20}px` },
+          // A double-click toggles the checkbox twice on the way in (net no
+          // change) and then opens the preview.
+          onDoubleClick: () => { void openPreview(session.id) },
+        }, [
+          // The caret column leads so the checkboxes of the group header, of
+          // parent rows and of leaf rows all share one vertical line.
+          hasChildren
+            ? React.createElement('button', {
+              key: 'expander',
+              type: 'button',
+              style: expanderStyle,
+              'aria-expanded': open,
+              'aria-label': t(open ? 'panel.collapse' : 'panel.expand'),
+              // Inside the row label: without these the click would reach the
+              // label's checkbox instead of the caret.
+              onClick: (event) => {
+                event.preventDefault()
+                event.stopPropagation()
+                toggleSet(setOpenSessions, session.id)
+              },
+              onDoubleClick: (event) => event.stopPropagation(),
+            }, open ? '▼' : '▶')
+            : React.createElement('span', { key: 'spacer', style: expanderSpacerStyle }),
+          React.createElement('input', {
+            key: 'check',
+            type: 'checkbox',
+            checked: selected.has(session.id),
+            onChange: () => toggle(session.id),
+            // Inside the row label: rapid check/uncheck clicks end in a
+            // dblclick that would bubble to the label's preview handler —
+            // the checkbox's only duty is to check and uncheck.
+            onDoubleClick: (event) => event.stopPropagation(),
+          }),
+          React.createElement('span', {
+            key: 'title',
+            // An untitled session falls back to its id, dimmed.
+            style: session.title === undefined ? { ...titleStyle, opacity: 0.55 } : titleStyle,
+            title: label,
+          }, label),
+          session.parent === undefined ? null : React.createElement('span', { key: 'child', style: childBadgeStyle }, t('panel.child')),
+          hasChildren ? React.createElement('span', { key: 'count', style: childBadgeStyle }, t('panel.childCount', { count: node.children.length })) : null,
+          session.createdAt === undefined ? null : React.createElement('span', { key: 'day', style: metaStyle }, formatDay(session.createdAt)),
+          React.createElement('span', { key: 'size', style: sizeStyle }, session.humanBytes),
+          React.createElement('button', {
+            key: 'preview',
+            type: 'button',
+            style: previewButtonStyle,
+            // Inside the row label: without these the click would reach the
+            // label's checkbox instead of the preview.
+            onClick: (event) => {
+              event.preventDefault()
+              event.stopPropagation()
+              void openPreview(session.id)
+            },
+          }, t('panel.preview')),
+        ]),
+        ...(hasChildren && open ? node.children.flatMap((child) => renderNode(child, depth + 1)) : []),
+      ]
+    }
+
+    const body = []
+    body.push(React.createElement('p', { key: 'hint', style: hintStyle }, t('panel.hint')))
+
+    if (state.phase === 'loading') {
+      body.push(React.createElement('p', { key: 'loading', style: hintStyle }, t('panel.loading')))
+    } else if (state.phase === 'error') {
+      body.push(React.createElement('p', { key: 'error', style: errorStyle }, state.error))
+      body.push(React.createElement('button', {
+        key: 'retry', type: 'button', onClick: load, style: buttonStyle,
+      }, t('panel.retry')))
+    } else {
+      body.push(React.createElement('div', { key: 'toolbar', style: toolbarStyle }, [
+        React.createElement('input', {
+          key: 'query',
+          type: 'search',
+          value: query,
+          placeholder: t('panel.search'),
+          onChange: (event) => setQuery(event.target.value),
+          style: inputStyle,
+        }),
+        React.createElement('button', {
+          key: 'toggle', type: 'button', onClick: toggleAll, style: buttonStyle,
+        }, allVisibleSelected ? t('panel.clear') : t('panel.selectAll')),
+        React.createElement('button', {
+          // The list is a snapshot; a manual re-scan also picks up deletions
+          // made through the model Tool, which no client sees happen.
+          key: 'refresh', type: 'button', disabled: busy, onClick: load, style: buttonStyle,
+        }, t('panel.refresh')),
+        React.createElement('button', {
+          key: 'delete',
+          type: 'button',
+          disabled: busy || selected.size === 0,
+          onClick: remove,
+          style: selected.size === 0 ? disabledDangerStyle : dangerButtonStyle,
+        }, busy
+          ? t('panel.deleting')
+          : t('panel.delete', { count: selected.size, size: formatBytes(selectedBytes) })),
+      ]))
+
+      if (notice !== undefined) {
+        body.push(React.createElement('p', {
+          key: 'notice',
+          style: notice.kind === 'error' ? errorStyle : doneStyle,
+        }, notice.text))
+      }
+
+      if (visibleGroups.length === 0) {
+        body.push(React.createElement('p', { key: 'empty', style: hintStyle }, t('panel.empty')))
+      } else {
+        body.push(React.createElement('div', { key: 'groups', style: groupsStyle },
+          visibleGroups.map((group) => renderGroup(group))))
+      }
+
+      body.push(React.createElement('p', { key: 'root', style: hintStyle }, t('panel.root', { path: state.dshHome ?? '' })))
+    }
+
+    return React.createElement('section', { style: pageStyle, 'aria-label': t('panel.title') },
+      React.createElement('div', { style: scrollStyle },
+        React.createElement('div', { style: contentStyle }, [
+          React.createElement('h1', { key: 'title', style: headingStyle }, t('panel.title')),
+          ...body,
+        ])),
+      renderPreview())
+  }
+}
+
+const pageStyle = Object.freeze({
+  width: '100%', minWidth: 0, height: '100%', minHeight: 0,
+  display: 'flex', flexDirection: 'column', overflow: 'hidden',
+  background: 'var(--dsw-alias-bg-base, transparent)',
+  color: 'var(--dsw-alias-label-primary, inherit)',
+  fontSize: '14px', lineHeight: '1.6',
+})
+const scrollStyle = Object.freeze({ flex: '1 1 auto', minHeight: 0, overflowY: 'auto', scrollbarGutter: 'stable' })
+const contentStyle = Object.freeze({
+  maxWidth: '960px', margin: '0 auto',
+  padding: '0 clamp(24px, 4vw, 48px) 48px',
+  display: 'flex', flexDirection: 'column', gap: '10px',
+})
+const headingStyle = Object.freeze({
+  margin: '0',
+  fontSize: '20px', fontWeight: 500, lineHeight: '28px',
+  paddingTop: isDarwin ? 'calc(28px + var(--dsh-frame-top-clearance, 0px))' : '28px',
+})
+const hintStyle = Object.freeze({ margin: '0', fontSize: '12px', opacity: 0.7, lineHeight: '18px' })
+const errorStyle = Object.freeze({ margin: '0', fontSize: '12px', color: 'light-dark(#b42318, #ff9c94)', wordBreak: 'break-word' })
+const doneStyle = Object.freeze({ margin: '0', fontSize: '12px', color: 'light-dark(#067647, #75e0a7)' })
+const toolbarStyle = Object.freeze({ display: 'flex', gap: '8px', alignItems: 'center', flexWrap: 'wrap' })
+const inputStyle = Object.freeze({
+  flex: '1 1 180px', minWidth: '140px', padding: '6px 10px', borderRadius: '8px', font: 'inherit',
+  border: '1px solid var(--dsw-alias-border-l3, light-dark(rgba(0,0,0,.12), rgba(255,255,255,.16)))',
+  background: 'transparent', color: 'inherit',
+})
+const buttonStyle = Object.freeze({
+  padding: '6px 12px', borderRadius: '8px', cursor: 'pointer', font: 'inherit', whiteSpace: 'nowrap',
+  border: '1px solid var(--dsw-alias-border-l3, light-dark(rgba(0,0,0,.12), rgba(255,255,255,.16)))',
+  background: 'transparent', color: 'inherit',
+})
+const dangerButtonStyle = Object.freeze({
+  ...buttonStyle, border: 'none', background: 'light-dark(#d92d20, #f04438)', color: '#ffffff',
+})
+const disabledDangerStyle = Object.freeze({
+  ...dangerButtonStyle, opacity: 0.45, cursor: 'not-allowed',
+})
+const groupsStyle = Object.freeze({ display: 'flex', flexDirection: 'column', gap: '12px' })
+const listStyle = Object.freeze({
+  display: 'flex', flexDirection: 'column',
+  border: '1px solid var(--dsw-alias-border-l2, light-dark(rgba(0,0,0,.08), rgba(255,255,255,.12)))',
+  borderRadius: '10px',
+})
+const groupHeaderStyle = Object.freeze({
+  display: 'flex', gap: '8px', alignItems: 'center', padding: '8px 10px', cursor: 'pointer', userSelect: 'none',
+  background: 'var(--dsw-alias-interactive-bg-hover, light-dark(rgba(38,49,72,.05), rgba(255,255,255,.06)))',
+  borderBottom: '1px solid var(--dsw-alias-border-l1, light-dark(rgba(0,0,0,.05), rgba(255,255,255,.08)))',
+})
+const groupNameStyle = Object.freeze({
+  fontSize: '13px', fontWeight: 600, whiteSpace: 'nowrap',
+  maxWidth: '45%', overflow: 'hidden', textOverflow: 'ellipsis',
+})
+const groupPathStyle = Object.freeze({
+  flex: '1 1 auto', minWidth: 0, fontSize: '11px', opacity: 0.55,
+  whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',
+})
+const groupStatsStyle = Object.freeze({
+  marginLeft: 'auto', fontSize: '11px', opacity: 0.65, whiteSpace: 'nowrap',
+  fontVariantNumeric: 'tabular-nums',
+})
+const rowStyle = Object.freeze({
+  display: 'flex', gap: '8px', alignItems: 'center', padding: '6px 10px', cursor: 'pointer',
+  userSelect: 'none',
+  borderBottom: '1px solid var(--dsw-alias-border-l1, light-dark(rgba(0,0,0,.05), rgba(255,255,255,.08)))',
+})
+const titleStyle = Object.freeze({ flex: '1 1 auto', minWidth: 0, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' })
+const metaStyle = Object.freeze({ fontSize: '11px', opacity: 0.6, whiteSpace: 'nowrap' })
+const expanderStyle = Object.freeze({
+  flexShrink: 0, width: '20px', height: '20px', padding: 0,
+  display: 'inline-flex', alignItems: 'center', justifyContent: 'center',
+  fontSize: '10px', lineHeight: 1, opacity: 0.8,
+  cursor: 'pointer', border: 'none', background: 'transparent', color: 'inherit',
+})
+const expanderSpacerStyle = Object.freeze({ flexShrink: 0, width: '20px' })
+const childBadgeStyle = Object.freeze({
+  fontSize: '10px', padding: '1px 6px', borderRadius: '999px', whiteSpace: 'nowrap',
+  background: 'var(--dsw-alias-interactive-bg-hover, light-dark(rgba(38,49,72,.06), rgba(255,255,255,.08)))',
+})
+const sizeStyle = Object.freeze({ fontSize: '11px', opacity: 0.7, fontVariantNumeric: 'tabular-nums', whiteSpace: 'nowrap' })
+const previewButtonStyle = Object.freeze({
+  flexShrink: 0, padding: '2px 10px', borderRadius: '6px', font: 'inherit', fontSize: '11px',
+  whiteSpace: 'nowrap', cursor: 'pointer',
+  border: '1px solid var(--dsw-alias-border-l3, light-dark(rgba(0,0,0,.12), rgba(255,255,255,.16)))',
+  background: 'transparent', color: 'inherit',
+})
+const previewOverlayStyle = Object.freeze({
+  position: 'fixed', inset: '0', zIndex: 1000, display: 'flex',
+  alignItems: 'center', justifyContent: 'center', padding: '24px',
+  // An overlay host usually disables hit-testing on its container so it cannot
+  // block the app beneath it; the dialog has to opt back in.
+  pointerEvents: 'auto',
+})
+const previewMaskStyle = Object.freeze({
+  position: 'absolute', inset: '0',
+  background: 'var(--dsw-alias-bg-mask-1, light-dark(rgba(15,17,21,.32), rgba(0,0,0,.5)))',
+  backdropFilter: 'var(--dsw-mask-blur, blur(2px))',
+})
+// Wide by default (a transcript wants real estate) and resizable through the
+// corner grip; the same design aliases the platform Modal card uses keep the
+// look identical while the size stays under our control.
+const previewPanelStyle = Object.freeze({
+  position: 'relative', zIndex: 1,
+  display: 'flex', flexDirection: 'column',
+  width: 'min(92vw, 920px)',
+  height: 'min(84vh, 680px)',
+  borderRadius: '24px', overflow: 'hidden',
+  background: 'var(--dsw-alias-bg-layer-2, light-dark(#ffffff, #353638))',
+  color: 'var(--dsw-alias-label-primary, light-dark(#0f1115, #f9fafb))',
+  boxShadow: 'var(--dsw-elevation-prominent, 0 8px 32px rgba(0,0,0,.24))',
+  font: 'inherit', pointerEvents: 'auto',
+})
+const previewHeaderStyle = Object.freeze({
+  display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: '8px',
+  padding: '22px 14px 12px 24px',
+})
+const previewCloseStyle = Object.freeze({
+  flex: 'none', display: 'inline-flex', alignItems: 'center', justifyContent: 'center',
+  width: '28px', height: '28px', border: 'none', borderRadius: '8px',
+  background: 'transparent', cursor: 'pointer', font: 'inherit', fontSize: '14px',
+  color: 'var(--dsw-alias-label-secondary, inherit)',
+})
+const previewHeadingStyle = Object.freeze({ margin: '0', fontSize: '16px', fontWeight: 500, lineHeight: '24px' })
+const previewSubjectStyle = Object.freeze({
+  margin: '0', padding: '0 24px', fontSize: '14px', lineHeight: '22px',
+  opacity: 0.85, wordBreak: 'break-all',
+})
+const previewBodyStyle = Object.freeze({
+  display: 'flex', flexDirection: 'column', minWidth: 0,
+  flex: '1 1 auto', minHeight: 0,
+  marginTop: '12px', padding: '0 24px 4px', overflow: 'hidden',
+})
+const previewIdStyle = Object.freeze({
+  margin: '0 0 8px', fontSize: '12px', opacity: 0.75, wordBreak: 'break-all',
+  fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Consolas, monospace',
+})
+const previewIdLabelStyle = Object.freeze({ opacity: 0.6, fontFamily: 'inherit' })
+const previewChildrenStyle = Object.freeze({ margin: '0 0 8px', display: 'flex', flexDirection: 'column', gap: '4px' })
+const previewChildrenHeadStyle = Object.freeze({ margin: '0', fontSize: '11px', opacity: 0.6 })
+const previewChildRowStyle = Object.freeze({ display: 'flex', gap: '6px', alignItems: 'center', fontSize: '11px', opacity: 0.85 })
+const previewChildIdStyle = Object.freeze({
+  wordBreak: 'break-all',
+  fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Consolas, monospace',
+})
+const previewMetaStyle = Object.freeze({ margin: '0 0 8px', fontSize: '12px', opacity: 0.7, wordBreak: 'break-all' })
+const previewFooterStyle = Object.freeze({
+  display: 'flex', alignItems: 'center', justifyContent: 'flex-end', gap: '8px',
+  padding: '12px 24px 20px',
+})
+const resizeGripStyle = Object.freeze({
+  position: 'absolute', right: '0', bottom: '0', width: '22px', height: '22px',
+  display: 'flex', alignItems: 'flex-end', justifyContent: 'flex-end',
+  padding: '2px 4px', fontSize: '11px', lineHeight: 1, opacity: 0.45,
+  cursor: 'nwse-resize', touchAction: 'none', userSelect: 'none', zIndex: 1,
+})
+const messageListStyle = Object.freeze({
+  display: 'flex', flexDirection: 'column', gap: '12px',
+  flex: '1 1 auto', minHeight: 0, overflowY: 'auto', padding: '2px',
+})
+const messageStyle = Object.freeze({ display: 'flex', flexDirection: 'column', gap: '4px' })
+const messageHeadStyle = Object.freeze({ display: 'flex', gap: '8px', alignItems: 'baseline' })
+const messageMetaStyle = Object.freeze({ fontSize: '11px', opacity: 0.55, whiteSpace: 'nowrap' })
+const userBadgeStyle = Object.freeze({
+  fontSize: '10px', padding: '1px 6px', borderRadius: '999px', whiteSpace: 'nowrap',
+  background: 'light-dark(rgba(38,49,72,.08), rgba(255,255,255,.14))',
+})
+const assistantBadgeStyle = Object.freeze({
+  fontSize: '10px', padding: '1px 6px', borderRadius: '999px', whiteSpace: 'nowrap',
+  background: 'light-dark(rgba(12,123,220,.14), rgba(56,132,255,.24))',
+})
+const messageTextStyle = Object.freeze({
+  fontSize: '13px', lineHeight: '1.6', whiteSpace: 'pre-wrap', wordBreak: 'break-word',
+})
+
+// Attached after the main export so the factory assignment above cannot
+// overwrite it; the bundle itself only ever uses the factory.
+module.exports.toggleWithDescendants = toggleWithDescendants
+module.exports.renderMessages = renderMessages
+module.exports.setSelection = setSelection
+module.exports.buildWorkspaceGroups = buildWorkspaceGroups
+module.exports.collectSessions = collectSessions
+module.exports.collectDescendants = collectDescendants
+
+return module.exports;
+})();
+__modules["client/client.js"] = (() => {
+const module = { exports: {} };
+const exports = module.exports;
+/**
+ * session-cleaner Web client half.
+ *
+ * Adds a "delete session" row to the sidebar Session menu — the one place a
+ * user already looks for per-session actions — and confirms before deleting.
+ * It also contributes a top-level Session-cleanup page (sidebar entry next to
+ * Plugins and Automation Tasks) for listing and batch-deleting every session
+ * on disk.
+ *
+ * The Host half owns deletion; this file only presents it. DSH's client module
+ * system loads one self-contained bundle and hands it a `require`, so React and
+ * react-dom come from the platform module table rather than from package
+ * resolution.
+ */
+
+const { TYPERT_REMOTE } = __modules["src/contract.cjs"]
+const createPanelPage = __modules["client/panel-page.js"]
+
+/**
+ * The panel id. It addresses both the `main` keyed-slot entry (the page) and
+ * the `sidebar.panellist` entry (the row that selects it): the layout's
+ * `selectPanel(id)` resolves the same key, so the two must never diverge.
+ * The shipped pages use "plugins" (order 0) and "schedules" (order 10).
+ */
+const PANEL_ID = 'session-cleaner'
+
+const MESSAGES = Object.freeze({
+  en: Object.freeze({
+    'menu.delete': 'Delete session',
+    'dialog.title': 'Delete this session permanently?',
+    'dialog.body': 'The session log, its projection cache and its workspace entry will be removed. Descendant subagent sessions are removed too.',
+    'dialog.warning': 'This cannot be undone. DSH keeps no recycle bin and no backup.',
+    'dialog.bytes': 'Will free {size}.',
+    'dialog.more': '{count} sessions on disk (including descendant subagent sessions).',
+    'dialog.loading': 'Checking what would be removed…',
+    'dialog.confirm': 'Delete permanently',
+    'dialog.cancel': 'Cancel',
+    'dialog.close': 'Close',
+    'dialog.deleting': 'Deleting…',
+    'dialog.failed': 'Deletion failed: {reason}',
+    'service.missing': 'The session-cleaner service did not become reachable. Retry the click; if it persists, reload the page.',
+    'service.mountFailed': 'Remote mount failed: {reason}',
+    'panel.nav': 'Session cleanup',
+    'panel.title': 'Session cleanup',
+    'panel.hint': 'Every session found on disk, grouped by workspace. Selecting a session also selects its descendant subagent sessions — they are deleted together; a session running in this app cannot be removed and will be refused. Double-click a row (or use its Preview button) to read the conversation and see the session ids before deleting.',
+    'panel.loading': 'Scanning sessions…',
+    'panel.retry': 'Retry',
+    'panel.search': 'Filter by title, id, workspace or path',
+    'panel.selectAll': 'Select all shown',
+    'panel.clear': 'Clear selection',
+    'panel.refresh': 'Rescan',
+    'panel.delete': 'Delete {count} selected ({size})',
+    'panel.deleting': 'Deleting…',
+    'panel.deleted': 'Deleted {count} session(s), freed {size}.',
+    'panel.failed': 'Deletion failed: {reason}',
+    'panel.empty': 'No session matches the filter.',
+    'panel.child': 'subagent',
+    'panel.childCount': 'subagents ×{count}',
+    'panel.groupStats': '{count} sessions · {size}',
+    'panel.groupStatsChildren': '{count} sessions · {children} subagents · {size}',
+    'panel.expand': 'Expand',
+    'panel.collapse': 'Collapse',
+    'panel.preview': 'Preview',
+    'panel.root': 'Data root: {path}',
+    'panel.serviceMissing': 'The session-cleaner service is unavailable. Check the network panel and reload the page.',
+    'preview.title': 'Conversation preview',
+    'preview.sessionId': 'Session ID',
+    'preview.children': 'Subagent sessions ({count}) — deleted together with the session above:',
+    'preview.resize': 'Resize (double-click to reset)',
+    'preview.loading': 'Reading the conversation…',
+    'preview.empty': 'No text messages in this session.',
+    'preview.truncated': 'Showing the first {shown} of {total} messages.',
+    'preview.failed': 'Failed to read the conversation: {reason}',
+    'preview.user': 'User',
+    'preview.assistant': 'Assistant',
+  }),
+  zh: Object.freeze({
+    'menu.delete': '删除会话',
+    'dialog.title': '永久删除这个会话？',
+    'dialog.body': '会话日志、投影缓存与工作区中的记录都会被移除；由它派生的子代理会话也会一并删除。',
+    'dialog.warning': '此操作不可撤销。DSH 没有回收站，也没有备份。',
+    'dialog.bytes': '将释放 {size}。',
+    'dialog.more': '磁盘上共 {count} 个会话（含派生的子代理会话）。',
+    'dialog.loading': '正在统计将要删除的内容…',
+    'dialog.confirm': '永久删除',
+    'dialog.cancel': '取消',
+    'dialog.close': '关闭',
+    'dialog.deleting': '正在删除…',
+    'dialog.failed': '删除失败：{reason}',
+    'service.missing': '会话清理服务未能在 5 秒内就绪。请再点一次「删除会话」；若反复出现，请重新加载页面。',
+    'service.mountFailed': 'Remote 契约挂载失败：{reason}',
+    'panel.nav': '会话清理',
+    'panel.title': '会话清理',
+    'panel.hint': '磁盘上的全部会话，按工作区分组。勾选主会话会自动带上其派生的子代理会话（它们会被一并删除）；本应用中正在运行的会话无法删除，会被拒绝。双击会话行（或点「预览」）可先查看对话内容和会话 ID 再决定删除。',
+    'panel.loading': '正在扫描会话…',
+    'panel.retry': '重试',
+    'panel.search': '按标题、id、工作区或路径筛选',
+    'panel.selectAll': '全选当前列表',
+    'panel.clear': '清空选择',
+    'panel.refresh': '重新扫描',
+    'panel.delete': '删除选中的 {count} 个（{size}）',
+    'panel.deleting': '正在删除…',
+    'panel.deleted': '已删除 {count} 个会话，释放 {size}。',
+    'panel.failed': '删除失败：{reason}',
+    'panel.empty': '没有符合条件的会话。',
+    'panel.child': '子代理',
+    'panel.childCount': '子代理 ×{count}',
+    'panel.groupStats': '{count} 个会话 · {size}',
+    'panel.groupStatsChildren': '{count} 个会话 · 子代理 {children} 个 · {size}',
+    'panel.expand': '展开',
+    'panel.collapse': '收起',
+    'panel.preview': '预览',
+    'panel.root': '数据根目录：{path}',
+    'panel.serviceMissing': '会话清理服务不可用。请检查连接后重新加载页面。',
+    'preview.title': '对话预览',
+    'preview.sessionId': '会话 ID',
+    'preview.children': '子代理会话（{count} 个，随上方会话一并删除）：',
+    'preview.resize': '调整大小（双击恢复默认）',
+    'preview.loading': '正在读取会话内容…',
+    'preview.empty': '此会话没有可显示的文本消息。',
+    'preview.truncated': '仅显示前 {shown} 条消息（共 {total} 条）。',
+    'preview.failed': '读取会话失败：{reason}',
+    'preview.user': '用户',
+    'preview.assistant': '助手',
+  }),
+})
+
+/** Pick a locale from the DSH locale service, falling back to English. */
+function detectLocale(ctx) {
+  try {
+    // The LocaleRuntime snapshot carries the active locale as `active`, which is
+    // either the lowercase id itself or a locale record holding it under `id`.
+    const snapshot = ctx.locale?.getLocale?.() ?? ctx.locale?.getSnapshot?.()
+    const active = snapshot?.active
+    const id = typeof active === 'string' ? active : active?.id ?? ''
+    return String(id).toLowerCase().startsWith('zh') ? 'zh' : 'en'
+  } catch {
+    return 'en'
+  }
+}
+
+/** Read a service result defensively: RPC may settle unwrapped or wrapped. */
+function unwrap(result) {
+  if (result !== null && typeof result === 'object' && 'ok' in result && 'value' in result) {
+    return result.ok ? result.value : { ok: false, error: result.error?.message ?? 'remote call failed' }
+  }
+  return result
+}
+
+/**
+ * A menu row cannot own the dialog it opens. Choosing the row closes the menu,
+ * and the row unmounts in that very commit — so a dialog rendered inside it is
+ * dropped before it can paint, and the click looks like it did nothing at all.
+ *
+ * The row therefore publishes a request here and returns; a frame-wide
+ * `shell.overlay` entry, which outlives every menu, renders the dialog. The
+ * shipped rename and archive dialogs use the same split.
+ */
+function createConfirmStore() {
+  let state = { request: undefined }
+  const listeners = new Set()
+  const publish = (next) => {
+    state = next
+    for (const listener of [...listeners]) listener()
+  }
+  return {
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => { listeners.delete(listener) }
+    },
+    get() {
+      return state
+    },
+    request(sessionId, displayTitle) {
+      publish({ request: { sessionId, displayTitle } })
+    },
+    dismiss() {
+      publish({ request: undefined })
+    },
+  }
+}
+
+/**
+ * A deletion happened somewhere outside the panel (the sidebar menu dialog).
+ *
+ * The panel's list is a scan snapshot taken on mount; without this signal the
+ * rows of sessions deleted through the menu would linger in an open panel
+ * until it is reopened. The panel subscribes on mount and re-scans.
+ */
+function createDeletionSignal() {
+  const listeners = new Set()
+  return {
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => { listeners.delete(listener) }
+    },
+    emit() {
+      for (const listener of [...listeners]) listener()
+    },
+  }
+}
+
+module.exports = function createPlugin(require) {
+  const React = require('react')
+
+  // Implicit baseline external of the module-loader lane: resolved through the
+  // frozen platform module table like React, never bundled (see the
+  // ui-workspace README's "动态客户端包" note). Absent only on stand-alone
+  // stubs, where the plain-button fallback below keeps the row working.
+  let MenuItemButton
+  let IconTrashOutlineRegular
+  let Modal
+  let Button
+  try {
+    const primitives = require('@deepseek-ai/dsh-client-ui-primitives')
+    MenuItemButton = primitives.MenuItemButton
+    IconTrashOutlineRegular = primitives.IconTrashOutlineRegular
+    Modal = primitives.Modal
+    Button = primitives.Button
+  } catch { /* optional in this composition */ }
+
+  /** One live dialog per activation; the overlay entry reads it. */
+  const confirmStore = createConfirmStore()
+
+  /** Broadcasts deletions performed outside the panel (see createDeletionSignal). */
+  const deletionSignal = createDeletionSignal()
+
+  /** Subscribe a component to the pending confirm request. */
+  function useConfirmRequest() {
+    const [state, setState] = React.useState(confirmStore.get)
+    React.useEffect(() => confirmStore.subscribe(() => setState(confirmStore.get())), [])
+    return state.request
+  }
+
+  return {
+    name: 'sessionCleanerClient',
+    // The shell publishes `slots` only once its layout has mounted, and the
+    // Remote face is a Cordis service the same way. Reading an undeclared
+    // service on a Cordis context THROWS ("cannot get property "remote"
+    // without inject"): acquire() used to swallow that rejection, resolve to
+    // undefined forever, and leave the dialog stuck on "checking…". `typert`
+    // is required in turn because $mount() registers the contribution through
+    // the CALLER's context (`callerCtx.typert.remotes.register`).
+    inject: ['slots', 'locale', 'remote', 'typert'],
+    apply(ctx) {
+      const t = (key, vars) => {
+        const table = MESSAGES[detectLocale(ctx)] ?? MESSAGES.en
+        const template = table[key] ?? MESSAGES.en[key] ?? key
+        if (vars === undefined) return template
+        return template.replace(/\{(\w+)\}/g, (_match, name) => String(vars[name] ?? ''))
+      }
+
+      let mountPromise
+      let servicePromise
+      /** Human-readable reason from the most recent acquire failure, if any. */
+      let acquireFailure
+
+      /**
+       * The client's session-list snapshot, when this composition publishes
+       * one. The sidebar renders its rows from that snapshot, which the shell
+       * only re-pulls on connect — so after a deletion the rows would linger
+       * until the next restart even though the files are gone. Dynamic
+       * injection: a composition without the service simply keeps the
+       * restart-based behavior.
+       */
+      let sessionList
+      try {
+        if (typeof ctx.inject === 'function') {
+          ctx.inject(['sessions'], (scope) => { sessionList = scope.sessions })
+        }
+      } catch { /* optional service: nothing to refresh */ }
+
+      /**
+       * Drop deleted sessions from the client snapshot and re-pull the
+       * baseline. Ordering is load-bearing: `handleSessionRemoved` must run
+       * AFTER the refresh settles. `refreshList()` swaps in a fresh mutation
+       * array the moment it starts, so a removal recorded earlier — from the
+       * forwarded `api-session/removed` event — is discarded when the pull
+       * lands, and the Host's session/list keeps returning a deleted session
+       * that is still attached live (cancelling its agent never detaches it;
+       * only its creator's disposer can), so the merged baseline resurrects
+       * the row into Ungrouped. Calling `handleSessionRemoved` after the
+       * refresh removes the row now AND leaves the removal mutation in the
+       * array the NEXT refresh replays against the baseline — one round of
+       * protection for as long as the session stays attached.
+       */
+      const forgottenIds = new Set()
+
+      /** Remove one deleted session's row from the client snapshot, if the snapshot service is present. */
+      const forgetSession = (id) => {
+        try { sessionList?.handleSessionRemoved?.(id) } catch { /* snapshot-only repair */ }
+      }
+
+      const forgetSessions = (sessionIds) => {
+        const ids = Array.isArray(sessionIds) ? sessionIds.filter((id) => typeof id === 'string') : []
+        for (const id of ids) forgottenIds.add(id)
+        const forget = () => {
+          for (const id of ids) forgetSession(id)
+        }
+        try {
+          const pending = sessionList?.refresh?.()
+          if (pending && typeof pending.then === 'function') pending.then(forget, forget)
+          else forget()
+        } catch {
+          forget()
+        }
+      }
+
+      try {
+        if (sessionList && typeof sessionList.subscribe === 'function' && typeof sessionList.getListSnapshot === 'function') {
+          // Last line of defense against snapshot resurrections. Any baseline
+          // rebuild (a reconnect's handleConnected, a refresh we did not
+          // trigger) drops the mutation array and re-merges the Host list —
+          // which still contains a deleted-but-attached session. Whenever the
+          // snapshot changes, re-remove every known-deleted id it still
+          // carries. Gating on actual presence keeps this convergent: the
+          // removal drops the row, so the next pass has nothing to do.
+          sessionList.subscribe(() => {
+            if (forgottenIds.size === 0) return
+            let snapshot
+            try { snapshot = sessionList.getListSnapshot() } catch { return }
+            const items = Array.isArray(snapshot?.items) ? snapshot.items : []
+            if (items.length === 0) return
+            for (const entry of items) {
+              if (forgottenIds.has(entry?.sessionId)) forgetSession(entry.sessionId)
+            }
+          })
+        }
+      } catch { /* without a subscribable snapshot, the call-side forget is the only repair */ }
+
+      const readFailure = () => acquireFailure
+
+      /**
+       * Mount the contract once, then resolve the Host namespace.
+       *
+       * Two independently cached steps, because they fail differently:
+       *
+       * - `$mount` registers the contribution under the package name in the
+       *   Typert Remote store, which REJECTS a second registration ("Remote
+       *   package … is already registered"). It must run at most once and its
+       *   success is cached forever; only a failed mount may be retried.
+       * - The namespace itself is a Cordis service provided under the property
+       *   name `remote.<namespace>` (the gateway composes the key with
+       *   `remoteServiceKey()` and the Service base class registers the
+       *   instance via `ctx.provide(name, this)`). It is therefore read as
+       *   `scope['remote.sessionCleaner']` — NOT as `scope.remote.sessionCleaner`,
+       *   which would be a property lookup on the mount manager and always
+       *   `undefined`. A click can land before the namespace fiber has
+       *   published, so the inject waits inside a settle window; a window that
+       *   lapses may be re-entered by the next click (the mount stays cached).
+       */
+      const mount = async () => {
+        try {
+          // Reading `ctx.remote` without the service in `inject` throws; the
+          // try keeps a mis-declared inject visible as a reported reason
+          // instead of an uncaught rejection out of the dialog effect.
+          const remote = ctx.remote
+          if (remote === undefined || typeof remote.$mount !== 'function') {
+            acquireFailure = 'ctx.remote is not available in this composition'
+            return false
+          }
+          await remote.$mount(TYPERT_REMOTE)
+          acquireFailure = undefined
+          return true
+        } catch (reason) {
+          acquireFailure = String(reason?.message ?? reason)
+          return false
+        }
+      }
+
+      const acquire = async () => {
+        if (mountPromise === undefined) mountPromise = mount()
+        const mounted = await mountPromise
+        if (!mounted) {
+          // The mount itself failed (or no remote yet): a later click retries it.
+          mountPromise = undefined
+          return undefined
+        }
+        if (servicePromise === undefined) {
+          servicePromise = new Promise((resolve) => {
+            let settled = false
+            const timer = setTimeout(() => {
+              if (settled) return
+              settled = true
+              resolve(undefined)
+            }, 5000)
+            try {
+              ctx.inject(['remote.sessionCleaner'], (scope) => {
+                if (settled) return
+                settled = true
+                clearTimeout(timer)
+                resolve(scope['remote.sessionCleaner'])
+              })
+            } catch (reason) {
+              settled = true
+              clearTimeout(timer)
+              acquireFailure = String(reason?.message ?? reason)
+              resolve(undefined)
+            }
+          })
+        }
+        const service = await servicePromise
+        if (service === undefined) {
+          if (acquireFailure === undefined) {
+            acquireFailure = 'the remote.sessionCleaner namespace did not publish within the settle window'
+          }
+          servicePromise = undefined
+          return undefined
+        }
+        acquireFailure = undefined
+        return service
+      }
+
+      /**
+       * The sidebar menu row. It only closes the menu and publishes the request:
+       * it must not hold dialog state, because it unmounts as the menu closes.
+       */
+      function DeleteSessionRow(props) {
+        const { sessionId, displayTitle } = props
+        // Slot-level hook: it returns the menu's [open, setOpen] pair, so the
+        // setter has to be destructured. Calling the pair itself threw a
+        // TypeError before the request below ever ran — which is why the row
+        // appeared but did nothing when clicked.
+        const menuOpenState = typeof props.useMenuOpenState === 'function' ? props.useMenuOpenState() : undefined
+        const setMenuOpen = Array.isArray(menuOpenState) && typeof menuOpenState[1] === 'function'
+          ? menuOpenState[1]
+          : () => {}
+
+        const onSelect = () => {
+          setMenuOpen(false)
+          confirmStore.request(sessionId, displayTitle)
+        }
+
+        // The shipped rows render through the platform's MenuItemButton: same
+        // typography, spacing, hover and keyboard walk as pin/rename/fork/
+        // archive, with the leading icon slot every shipped row uses. The
+        // default 16px Regular stroke matches the pin/rename/fork icons.
+        if (MenuItemButton !== undefined && IconTrashOutlineRegular !== undefined) {
+          return React.createElement(MenuItemButton, {
+            icon: React.createElement(IconTrashOutlineRegular),
+            onSelect,
+          }, t('menu.delete'))
+        }
+
+        return React.createElement('button', {
+          type: 'button',
+          role: 'menuitem',
+          style: menuItemStyle,
+          onClick: onSelect,
+        }, t('menu.delete'))
+      }
+
+      /**
+       * The confirmation dialog, mounted once into `shell.overlay`. Rendering
+       * nothing while no request is pending keeps the overlay list inert.
+       */
+      function ConfirmDialog() {
+        const request = useConfirmRequest()
+        const sessionId = request?.sessionId
+        const displayTitle = request?.displayTitle
+        const [preview, setPreview] = React.useState(undefined)
+        const [busy, setBusy] = React.useState(false)
+        const [error, setError] = React.useState(undefined)
+
+        React.useEffect(() => {
+          if (sessionId === undefined) return undefined
+          let cancelled = false
+          setPreview(undefined)
+          setError(undefined)
+          setBusy(false)
+          void (async () => {
+            const service = await acquire()
+            if (cancelled) return
+            if (service === undefined) {
+              const reason = readFailure()
+              setError(reason === undefined ? t('service.missing') : t('service.mountFailed', { reason }))
+              return
+            }
+            try {
+              const value = unwrap(await service.preview([sessionId]))
+              if (!cancelled) setPreview(value)
+            } catch (reason) {
+              if (!cancelled) setError(String(reason?.message ?? reason))
+            }
+          })()
+          return () => { cancelled = true }
+        }, [sessionId])
+
+        // A frame-wide list entry is always mounted: returning a hidden node
+        // rather than null keeps the idle state from reading as "no entry".
+        if (request === undefined) return React.createElement('span', { hidden: true })
+
+        const confirm = async () => {
+          const service = await acquire()
+          if (service === undefined) {
+            const reason = readFailure()
+            setError(reason === undefined ? t('service.missing') : t('service.mountFailed', { reason }))
+            return
+          }
+          setBusy(true)
+          setError(undefined)
+          try {
+            const result = unwrap(await service.delete([sessionId], {}))
+            if (result?.ok === false) {
+              setError(result.error ?? 'unknown failure')
+              return
+            }
+            // The files are gone: drop the rows from the client snapshot (see
+            // forgetSessions) and tell an open cleanup panel to re-scan, since
+            // its list is a mount snapshot.
+            forgetSessions([sessionId])
+            deletionSignal.emit()
+            confirmStore.dismiss()
+          } catch (reason) {
+            setError(String(reason?.message ?? reason))
+          } finally {
+            setBusy(false)
+          }
+        }
+
+        const body = []
+        body.push(React.createElement('p', { key: 'body', style: bodyStyle }, t('dialog.body')))
+        body.push(React.createElement('p', { key: 'warn', style: warnStyle }, t('dialog.warning')))
+        // While an error is shown the loading line is dropped: "checking…"
+        // next to a failure reads as if something were still in flight.
+        if (preview === undefined && error === undefined) {
+          body.push(React.createElement('p', { key: 'size', style: metaStyle }, t('dialog.loading')))
+        } else if (preview !== undefined) {
+          body.push(React.createElement('p', { key: 'size', style: metaStyle }, t('dialog.bytes', { size: preview.humanBytes })))
+          if (preview.targetCount > 1) {
+            body.push(React.createElement('p', { key: 'more', style: metaStyle }, t('dialog.more', { count: preview.targetCount })))
+          }
+        }
+        if (error !== undefined) {
+          body.push(React.createElement('p', { key: 'error', style: errorStyle }, t('dialog.failed', { reason: error })))
+        }
+
+        // The shipped rename / stop-and-archive / risk dialogs all render
+        // through the platform Modal + Button pair (the same implicit baseline
+        // external as the menu row): backdrop blur, card, header with a close
+        // affordance, footer actions and control metrics then match the host
+        // dialogs exactly. The action pairing follows RiskConfirmation:
+        // outline for cancel, primary for the confirm action.
+        if (Modal !== undefined && Button !== undefined) {
+          return React.createElement(Modal, {
+            open: true,
+            onClose: () => { if (!busy) confirmStore.dismiss() },
+            title: t('dialog.title'),
+            closeLabel: t('dialog.close'),
+            description: displayTitle || sessionId,
+            footer: React.createElement(React.Fragment, null,
+              React.createElement(Button, {
+                key: 'cancel',
+                variant: 'outline',
+                disabled: busy,
+                onClick: () => confirmStore.dismiss(),
+              }, t('dialog.cancel')),
+              React.createElement(Button, {
+                key: 'confirm',
+                variant: 'primary',
+                disabled: busy || preview === undefined,
+                onClick: confirm,
+              }, busy ? t('dialog.deleting') : t('dialog.confirm'))),
+          }, body)
+        }
+
+        // Stand-alone fallback (no primitives lane): the hand-rolled card.
+        const rows = []
+        rows.push(React.createElement('h2', { key: 'title', style: titleStyle }, t('dialog.title')))
+        rows.push(React.createElement('p', { key: 'subject', style: subjectStyle }, displayTitle || sessionId))
+        rows.push(...body)
+        rows.push(React.createElement('div', { key: 'actions', style: actionsStyle }, [
+          React.createElement('button', {
+            key: 'cancel',
+            type: 'button',
+            disabled: busy,
+            onClick: () => confirmStore.dismiss(),
+            style: buttonStyle,
+          }, t('dialog.cancel')),
+          React.createElement('button', {
+            key: 'confirm',
+            type: 'button',
+            disabled: busy || preview === undefined,
+            onClick: confirm,
+            style: dangerButtonStyle,
+          }, busy ? t('dialog.deleting') : t('dialog.confirm')),
+        ]))
+
+        return React.createElement('div', {
+          role: 'dialog',
+          'aria-modal': 'true',
+          'aria-label': t('dialog.title'),
+          style: overlayStyle,
+          onClick: (event) => { if (event.target === event.currentTarget && !busy) confirmStore.dismiss() },
+        }, React.createElement('div', { style: panelStyle }, rows))
+      }
+
+      try {
+        ctx.slots.inject('sidebar.workspaces.session.menu.item', () => ctx.slots.register({
+          name: 'sidebar.workspaces.session.menu.item',
+          id: 'session-cleaner.delete',
+          order: 500,
+        }, DeleteSessionRow))
+      } catch { /* the slot is optional: the Host half stays usable without it */ }
+
+      try {
+        // Frame-wide, so the dialog survives the menu that opened it.
+        ctx.slots.inject('shell.overlay', () => ctx.slots.register({
+          name: 'shell.overlay',
+          id: 'session-cleaner.confirm',
+          order: 90,
+        }, ConfirmDialog))
+      } catch { /* no overlay host in this composition: deletion stays available through the panel page */ }
+
+      /**
+       * The sidebar glyph for the panel entry. The sidebar shell renders the
+       * row itself — button, tooltip, label, selected state — and hands the
+       * entry `{ size, active }`. The same trash glyph the menu row uses
+       * keeps the two entries recognizable as one feature.
+       */
+      function PanelIcon({ size }) {
+        if (IconTrashOutlineRegular === undefined) return null
+        return React.createElement(IconTrashOutlineRegular, { size })
+      }
+
+      try {
+        // The page itself: a `main` keyed-slot entry under the panel id, next
+        // to the shipped Plugins and Automation Tasks pages. `selectPanel(id)`
+        // dispatches on this key, so a missing entry would make the sidebar
+        // row throw on click — the two registrations below are one unit.
+        const page = createPanelPage(React, t, acquire, readFailure, {
+          Modal,
+          Button,
+          afterDelete: forgetSessions,
+          deletionSignal,
+        })
+        ctx.slots.inject('main', () => ctx.slots.register({
+          name: 'main',
+          key: PANEL_ID,
+        }, page))
+      } catch { /* the layout panel seat is optional in this composition */ }
+
+      try {
+        // The sidebar entry, at the same level as Plugins (order 0) and
+        // Automation Tasks (order 10). A `label` thunk is re-read on every
+        // projection, so the row text follows a live locale change without
+        // re-registering.
+        ctx.slots.inject('sidebar.panellist', () => ctx.slots.register({
+          name: 'sidebar.panellist',
+          id: PANEL_ID,
+          order: 20,
+          label: () => t('panel.nav'),
+        }, PanelIcon))
+      } catch { /* without the sidebar list the page stays reachable through the menu rows */ }
+    },
+  }
+}
+
+const overlayStyle = Object.freeze({
+  position: 'fixed', inset: '0', zIndex: 1000, display: 'flex',
+  alignItems: 'center', justifyContent: 'center',
+  // An overlay host usually disables hit-testing on its container so it cannot
+  // block the app beneath it; the dialog has to opt back in.
+  pointerEvents: 'auto',
+  background: 'light-dark(rgba(15,17,21,.32), rgba(0,0,0,.5))',
+})
+const panelStyle = Object.freeze({
+  minWidth: '320px', maxWidth: '440px', padding: '20px', borderRadius: '16px',
+  background: 'var(--dsw-alias-bg-module-platform, light-dark(#ffffff, #353638))',
+  color: 'var(--dsw-alias-label-primary, light-dark(#0f1115, #f9fafb))',
+  boxShadow: '0 8px 32px rgba(0,0,0,.24)', font: 'inherit',
+})
+const titleStyle = Object.freeze({ margin: '0 0 8px', fontSize: '15px', fontWeight: 600 })
+const subjectStyle = Object.freeze({ margin: '0 0 12px', fontSize: '13px', opacity: 0.75, wordBreak: 'break-all' })
+const bodyStyle = Object.freeze({ margin: '0 0 8px', fontSize: '13px', lineHeight: '20px' })
+const warnStyle = Object.freeze({ margin: '0 0 8px', fontSize: '13px', lineHeight: '20px', color: 'light-dark(#b42318, #ff9c94)' })
+const metaStyle = Object.freeze({ margin: '0 0 8px', fontSize: '12px', opacity: 0.7 })
+const errorStyle = Object.freeze({ margin: '0 0 8px', fontSize: '12px', color: 'light-dark(#b42318, #ff9c94)', wordBreak: 'break-word' })
+const actionsStyle = Object.freeze({ display: 'flex', gap: '8px', justifyContent: 'flex-end', marginTop: '16px' })
+const buttonStyle = Object.freeze({
+  padding: '6px 14px', borderRadius: '8px', cursor: 'pointer', font: 'inherit',
+  border: '1px solid var(--dsw-alias-border-l3, light-dark(rgba(0,0,0,.12), rgba(255,255,255,.16)))',
+  background: 'transparent', color: 'inherit',
+})
+const dangerButtonStyle = Object.freeze({
+  ...buttonStyle, border: 'none', background: 'light-dark(#d92d20, #f04438)', color: '#ffffff',
+})
+const menuItemStyle = Object.freeze({
+  display: 'block', width: '100%', padding: '6px 12px', textAlign: 'left',
+  border: 'none', background: 'transparent', color: 'inherit', cursor: 'pointer', font: 'inherit',
+})
+
+return module.exports;
+})();
+return __modules["client/client.js"](require);
+}});