@heixui/dsh-session-suite 0.4.0 → 0.4.1

package/README.md

@@ -349,6 +349,23 @@ memory, or export paths.
 two-layer agent-memory design, with measured numbers rather than claims — including
 the parts that are deliberately not built and why.
 
+## What changed in 0.4.1
+
+A sidebar entry, plus three fixes for things that looked functional but were not.
+
+| Area | Before | Now |
+|---|---|---|
+| Where to find it | Settings → Snapshots / Long-term memory, three steps away | A **sidebar entry** opens everything in place; the three duplicate Settings sections are removed |
+| Memory count | Panel said 17, Settings said 51 — one question, two answers | The panel walks **every registered workspace**; each figure states what it counts |
+| Archive restore | Clicked, nothing happened, the mark on disk never changed | Fixed an argument-shape mismatch between the two Host services; restore now takes effect |
+| Long lists | The panel clipped its content; the wheel did nothing | The panel scrolls |
+
+**Why the counts disagreed (the real 0.4.0 defect):** long-term memory has a *global*
+store plus one store per workspace. `longterm.list` without a `cwd` returns only the
+global store (17 rows); with a `cwd` it returns global plus that workspace. The panel
+has no workspace of its own, so it showed the 17. It now enumerates every registered
+workspace instead.
+
 ## What changed in 0.4.0
 
 The memory engine was reorganised; the session features are unchanged.

package/README.zh.md

@@ -173,6 +173,21 @@ docs/               需求与 API 笔记
 **embedding 是可选增强，默认不下载任何东西。** 不装模型就是纯词法检索，功能完整；装了才有跨语言与改写召回。
 实测效果与安装方式见 `docs/memory-architecture.md` 和 `tools/download-embedding.mjs`。
 
+## 0.4.1 改了什么
+
+新增侧边栏入口，并修掉三个「看起来能用、实际没生效」的问题。
+
+| 方面 | 改前 | 改后 |
+|---|---|---|
+| 入口位置 | 只能在 设置 → 会话快照 / 长期记忆 里找，三步才能到 | **左侧栏「会话套件」图标**，点开即用；设置页那三个重复入口已移除 |
+| 记忆总数 | 面板显示 17，设置页显示 51 —— 同一句话两个数 | 面板遍历**所有已登记工作区**，与设置页一致；每个数字都写明统计口径 |
+| 归档恢复 | 点了没反应，磁盘上的标记纹丝不动 | 修了参数签名（两个 Host 服务的入参形状不同），恢复真正生效 |
+| 长列表滚动 | 面板内容被裁掉，滚轮无效 | 面板可滚动 |
+
+**为什么数字会不一样（0.4.0 的真实缺陷）**：长期记忆分「全局库」和「各工作区的库」。
+`longterm.list` 不带 `cwd` 时只返回全局库（17 条），带上 `cwd` 才是全局 + 该工作区。
+面板没有工作区概念，于是只显示了全局那 17 条。现在面板不带 `cwd` 时会遍历所有已登记工作区。
+
 ## 测试
 
 全部自测脚本都在临时目录里跑，不会碰真实的 DSH 数据。

package/client.js

@@ -128,8 +128,7 @@ window.__ModuleLoader__.load({
         'dialog.deleteSubagents': 'This will also delete {n} subagent session(s) started by it.',
         'dialog.deleteWouldRefuse': 'Something here is still running. Stop it first — nothing has been deleted.',
         'dialog.sessionRunning': 'This session is running. Stop it before deleting.',
-        'settings.title': 'Session snapshots',
-        'settings.description': 'Workspace checkpoints captured for a session, with disk usage, locking, and restore controls.',
+        'settings.title': 'Session snapshots',        'settings.description': 'Workspace checkpoints captured for a session, with disk usage, locking, and restore controls.',
         'settings.empty': 'No snapshots yet. A checkpoint is captured at the start of each turn.',
         'settings.capture': 'Capture now',
         'settings.capturing': 'Capturing…',
@@ -212,7 +211,40 @@ window.__ModuleLoader__.load({
         'memory.pendingTitle': 'Suggested memories',
         'memory.pendingHint': 'Extracted from the last turns. Nothing is stored until you accept it.',
         'memory.extractionIdle': 'Nothing is waiting. Last check: {reason}',
+        'memory.extractionNotYet':
+          'Nothing is waiting yet. Extraction runs at the end of each turn, and this Host has not completed one since it started — have a short exchange and come back.',
         'memory.extractionUnknown': 'no attempt recorded since this Host started',
+        'panel.title': 'Session suite',
+        'panel.description': 'Snapshots, long-term memory, and archived sessions. Each row opens its own page.',
+        'panel.snapshots': 'Session snapshots',
+        'panel.snapshotsHint': 'Workspace checkpoints taken when each turn finishes',
+        'panel.memory': 'Long-term memory',
+        'panel.memoryHint': 'Facts, rules, preferences, and past events kept across sessions',
+        'panel.archived': 'Archived sessions',
+        'panel.archivedHint': 'Sessions hidden from the sidebar; restore them here',
+        'panel.sessionsCount': '{n} session(s) with snapshots',
+        'panel.statSessions': 'Sessions',
+        'panel.statSnapshots': 'Snapshots',
+        'panel.statMemories': 'Memories',
+        'panel.statArchived': 'Archived',
+        'panel.statSessionsHint': 'Every workspace, subagents excluded',
+        'panel.statSnapshotsHint': 'Automatic checkpoints across all sessions',
+        'panel.statMemoriesHint': 'Global plus every workspace, archived included',
+        'panel.statArchivedHint': 'Hidden from the sidebar, restorable',
+        'panel.breakdownTitle': 'Where the memories live',
+        'panel.breakdownGlobal': 'Global (shared by every workspace)',
+        'panel.breakdownHint': 'Each workspace keeps its own store; the total above is the sum of these plus the global one.',
+        'panel.repoLink': 'Source on GitHub',
+        'panel.noSettingsSeam': 'This Host build does not expose the settings navigation seam, so this row cannot open its page.',
+        'archived.title': 'Archived sessions',
+        'archived.description': 'Archived sessions are hidden from the sidebar. Restoring one puts it back; nothing is deleted.',
+        'archived.empty': 'No archived sessions.',
+        'archived.restore': 'Restore',
+        'archived.restored': 'Restored',
+        'archived.restoreFailed': 'Could not restore this session',
+        'settings.archived': 'Archived',
+        'settings.checkpointCount': '{n} snapshot(s)',
+        'settings.working': 'Working…',
         'memory.extractionTried': 'tried {n} memory model(s)',
         'memory.extractionQueued': '{n} queued',
         'memory.extractionRejected': '{n} rejected as unusable',
@@ -397,7 +429,40 @@ window.__ModuleLoader__.load({
         'memory.pendingTitle': '待确认的记忆',
         'memory.pendingHint': '从最近几轮里识别出来的，确认前不会入库。',
         'memory.extractionIdle': '当前没有待确认条目。上次检查结果：{reason}',
+        'memory.extractionNotYet':
+          '暂时还没有待确认条目。提取在每轮对话结束时运行，而本次启动后还没完成过任何一轮——聊一两句再回来看。',
         'memory.extractionUnknown': '本次运行还没有执行过提取',
+        'panel.title': '会话套件',
+        'panel.description': '会话快照、长期记忆、归档会话。每行点开就是对应的页面。',
+        'panel.snapshots': '会话快照',
+        'panel.snapshotsHint': '每轮结束时自动记录的工作区状态',
+        'panel.memory': '长期记忆',
+        'panel.memoryHint': '跨会话保留的事实、规则、偏好与经历',
+        'panel.archived': '归档会话',
+        'panel.archivedHint': '已从侧边栏隐藏的会话，可以在这里恢复',
+        'panel.sessionsCount': '{n} 个会话有快照',
+        'panel.statSessions': '会话',
+        'panel.statSnapshots': '快照',
+        'panel.statMemories': '记忆',
+        'panel.statArchived': '已归档',
+        'panel.statSessionsHint': '所有工作区，不含子代理会话',
+        'panel.statSnapshotsHint': '所有会话的自动快照总数',
+        'panel.statMemoriesHint': '全局 + 各工作区，含已归档',
+        'panel.statArchivedHint': '从侧边栏隐藏，可恢复',
+        'panel.breakdownTitle': '记忆存在哪',
+        'panel.breakdownGlobal': '全局（所有工作区共享）',
+        'panel.breakdownHint': '每个工作区有独立的库；上面的总数 = 这些之和 + 全局。',
+        'panel.repoLink': 'GitHub 源码',
+        'panel.noSettingsSeam': '这个 Host 版本没有暴露设置导航接口，无法打开对应页面。',
+        'archived.title': '归档会话',
+        'archived.description': '归档的会话从侧边栏隐藏。恢复后会重新出现，不会删除任何东西。',
+        'archived.empty': '没有归档的会话。',
+        'archived.restore': '恢复',
+        'archived.restored': '已恢复',
+        'archived.restoreFailed': '恢复失败',
+        'settings.archived': '已归档',
+        'settings.checkpointCount': '{n} 张快照',
+        'settings.working': '处理中…',
         'memory.extractionTried': '试过 {n} 个记忆模型',
         'memory.extractionQueued': '入队 {n} 条',
         'memory.extractionRejected': '剔除 {n} 条',
@@ -568,6 +633,9 @@ window.__ModuleLoader__.load({
           h('path', { key: 'd', d: 'M10.2 10.2 4.8 2.6' }),
         ]),
       lock: () => icon([h('rect', { key: 'a', x: 3.4, y: 7, width: 9.2, height: 6.4, rx: 1.4 }), h('path', { key: 'b', d: 'M5.6 7V5.4a2.4 2.4 0 0 1 4.8 0V7' })]),
+      // A right-pointing chevron: these rows navigate somewhere, so the row's
+      // affordance is "go", not "expand".
+      chevron: () => icon([h('path', { key: 'a', d: 'M6.2 3.6 10.6 8l-4.4 4.4' })]),
       unlock: () => icon([h('rect', { key: 'a', x: 3.4, y: 7, width: 9.2, height: 6.4, rx: 1.4 }), h('path', { key: 'b', d: 'M5.6 7V5.4a2.4 2.4 0 0 1 4.6-.8' })]),
       restore: () => icon([h('path', { key: 'a', d: 'M3 8a5 5 0 1 1 1.6 3.7' }), h('path', { key: 'b', d: 'M2.6 2.8v3h3' })]),
       close: () => icon([h('path', { key: 'a', d: 'M4 4l8 8' }), h('path', { key: 'b', d: 'M12 4l-8 8' })]),
@@ -760,6 +828,118 @@ window.__ModuleLoader__.load({
 .dss-toast.dss-error { background: var(--dsw-alias-state-error-primary, #d93025); }
 
 .dss-section { display: flex; flex-direction: column; gap: 12px; max-width: 720px; }
+/* A screen opened from the sidebar panel inherits the panel's scroll container, so it
+   must not impose its own height. The settings dialog still renders these sections
+   directly and relies on the dialog's own scrolling. */
+/* The sidebar panel is a main-column surface. It must scroll: the memory list is
+   dozens of rows, and without an explicit overflow the page clipped at the viewport
+   with no way to reach the rest — reported as "no scroll wheel, there are already
+   a dozen entries". The min-height 0 is required for the child flex column to shrink
+   below its content size, otherwise overflow never triggers. */
+.dss-panel {
+  display: flex; flex-direction: column; gap: 14px;
+  padding: 24px 28px; max-width: 760px; margin: 0 auto;
+  height: 100%; min-height: 0;
+  overflow-y: auto; overscroll-behavior: contain;
+}
+.dss-panel h2 { margin: 0; font-size: 17px; font-weight: 600; color: var(--dsw-alias-label-primary, #1f1f1f); }
+.dss-nav { display: flex; flex-direction: column; gap: 10px; }
+/* Rows follow the shipped card idiom: the same border and background tokens
+   dsh-connect-trae uses (--dsw-alias-border-l2 / --dsw-alias-bg-l2), so the panel
+   looks like part of the app rather than a bolt-on. A left accent bar appears on
+   hover and focus instead of a colour swap, which keeps the text readable in both
+   themes and gives keyboard users the same affordance as mouse users. */
+.dss-nav-row {
+  position: relative;
+  display: flex; align-items: center; gap: 14px; width: 100%;
+  padding: 14px 16px; text-align: left; cursor: pointer;
+  font: inherit; color: inherit;
+  background: var(--dsw-alias-bg-l2, #fff);
+  border: 1px solid var(--dsw-alias-border-l2, #e3e4e6);
+  border-radius: 12px;
+  transition: border-color .14s ease, background .14s ease, transform .14s ease;
+}
+.dss-nav-row::before {
+  content: ''; position: absolute; left: 0; top: 12px; bottom: 12px; width: 3px;
+  border-radius: 0 3px 3px 0;
+  background: var(--dsw-alias-brand, #4d6bfe);
+  opacity: 0; transition: opacity .14s ease;
+}
+.dss-nav-row:hover, .dss-nav-row:focus-visible {
+  border-color: var(--dsw-alias-brand, #4d6bfe);
+  background: var(--dsw-alias-bg-l3, #f7f8fa);
+  outline: none;
+}
+.dss-nav-row:hover::before, .dss-nav-row:focus-visible::before { opacity: 1; }
+.dss-nav-row:active { transform: translateY(1px); }
+.dss-nav-row > svg { flex: none; color: var(--dsw-alias-label-tertiary, #9a9a9a); }
+.dss-nav-main { display: flex; flex-direction: column; gap: 3px; flex: 1; min-width: 0; }
+.dss-nav-title { font-size: 13.5px; font-weight: 600; color: var(--dsw-alias-label-primary, #1f1f1f); }
+.dss-nav-hint { font-size: 12px; line-height: 1.5; color: var(--dsw-alias-label-secondary, #6b6b6b); }
+.dss-nav-meta {
+  flex: none; min-width: 28px; text-align: center;
+  font-size: 12px; font-weight: 600; font-variant-numeric: tabular-nums;
+  color: var(--dsw-alias-label-secondary, #6b6b6b);
+  background: var(--dsw-alias-bg-l3, #f2f3f5);
+  border: 1px solid var(--dsw-alias-border-l2, #e3e4e6);
+  border-radius: 999px; padding: 2px 9px;
+}
+.dss-panel-footer {
+  display: flex; align-items: center; justify-content: space-between; gap: 12px;
+  font-size: 12px; color: var(--dsw-alias-label-tertiary, #9a9a9a);
+  padding-top: 8px; border-top: 1px solid var(--dsw-alias-border-l3, #f0f0f0);
+}
+.dss-panel-link {
+  color: var(--dsw-alias-brand, #4d6bfe);
+  text-decoration: none; font-size: 12px;
+}
+.dss-panel-link:hover, .dss-panel-link:focus-visible { text-decoration: underline; }
+/* A four-up summary strip. It fills the column with information rather than
+   decoration, and the numbers match the badges on the rows below. */
+.dss-stat-strip {
+  display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 10px;
+}
+.dss-stat {
+  display: flex; flex-direction: column; gap: 3px;
+  padding: 14px 16px;
+  background: var(--dsw-alias-bg-l2, #fff);
+  border: 1px solid var(--dsw-alias-border-l2, #e3e4e6);
+  border-radius: 12px;
+}
+.dss-stat-value {
+  font-size: 22px; font-weight: 650; line-height: 1.15;
+  font-variant-numeric: tabular-nums;
+  color: var(--dsw-alias-label-primary, #1f1f1f);
+}
+.dss-stat-label {
+  font-size: 11.5px; color: var(--dsw-alias-label-secondary, #6b6b6b);
+}
+/* The caption under each figure. Small and tertiary: it explains the number without
+   competing with it. */
+.dss-stat-hint {
+  font-size: 10.5px; line-height: 1.4;
+  color: var(--dsw-alias-label-tertiary, #9a9a9a);
+}
+.dss-breakdown {
+  display: flex; flex-direction: column; gap: 6px;
+  padding: 14px 16px;
+  background: var(--dsw-alias-bg-l3, #f7f8fa);
+  border: 1px solid var(--dsw-alias-border-l2, #e3e4e6);
+  border-radius: 12px;
+}
+.dss-breakdown-row { display: flex; align-items: baseline; gap: 10px; font-size: 12.5px; }
+.dss-breakdown-key {
+  flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  color: var(--dsw-alias-label-primary, #1f1f1f);
+}
+.dss-breakdown-value {
+  flex: none; font-variant-numeric: tabular-nums; font-weight: 600;
+  color: var(--dsw-alias-label-secondary, #6b6b6b);
+}
+.dss-breakdown-hint { font-size: 11px; line-height: 1.5; color: var(--dsw-alias-label-tertiary, #9a9a9a); }
+/* The way back from a screen. Left-aligned and small: it is an escape hatch, not
+   an action competing with the page's own controls. */
+.dss-panel-nav { display: flex; align-items: center; margin-bottom: -2px; }
 .dss-section.dss-embedded { max-width: none; gap: 10px; }
 .dss-section h2 { margin: 0; font-size: 15px; font-weight: 600; color: var(--dsw-alias-label-primary, #1f1f1f); }
 .dss-section-head { display: flex; flex-direction: column; gap: 4px; }
@@ -2392,6 +2572,369 @@ window.__ModuleLoader__.load({
       return cut >= 0 ? text.slice(cut + 1) || text : text
     }
 
+    // --------------------------------------------------------- sidebar panel
+
+    /**
+     * The sidebar icon.
+     *
+     * The owner supplies `size` and `active`, so the glyph has to inherit both
+     * rather than carry its own colour — a tinted icon reads as branding and
+     * clashes with the selected state the shell already draws around it.
+     *
+     * @param {any} props owner props
+     * @returns {any} icon element
+     */
+    function SuiteIcon(props) {
+      const size = typeof props?.size === 'number' ? props.size : 18
+      return h(
+        'svg',
+        {
+          width: size,
+          height: size,
+          viewBox: '0 0 16 16',
+          fill: 'none',
+          stroke: 'currentColor',
+          strokeWidth: 1.4,
+          strokeLinecap: 'round',
+          strokeLinejoin: 'round',
+          'aria-hidden': 'true',
+        },
+        // Two stacked frames: this bundle is about sessions kept as snapshots, so
+        // the mark is layers rather than the clock-like arc a "history" icon would
+        // use (and which already means rewind in the action row).
+        h('rect', { key: 'a', x: 2.6, y: 4.4, width: 8.4, height: 8.2, rx: 1.6 }),
+        h('path', { key: 'b', d: 'M5.4 4.3V3.4a1.2 1.2 0 0 1 1.2-1.2h5.4a1.2 1.2 0 0 1 1.2 1.2v6.4' }),
+      )
+    }
+
+    /**
+     * The panel shown when the sidebar icon is selected.
+     *
+     * It renders the three screens IN PLACE rather than navigating to Settings.
+     *
+     * That is not the first design. The first version was a navigation menu whose
+     * rows called the settings shell's `openSection(id)`, copied from a comment in
+     * dsh-connect-trae. It did nothing, and reading the shipped bundles explains why:
+     *
+     *   • `createSettingsShellStore()` is created inside
+     *     `dsh-client-ui-settings-general` and never published — no `reflect.provide`,
+     *     no service name — so no other client plugin can reach `openSection`.
+     *   • `pluginNavigation` (the one real navigation service) offers only
+     *     `openList()` and `openBundle(name)`, and `openBundle` lands on the bundle
+     *     page (`view: { kind: 'package' }`), which renders `plugins.bundle.config`
+     *     and bundle rows — it does not render `settings.section` pages at all.
+     *
+     * So "click a row, land on a settings page" cannot be built from outside the
+     * settings package. The honest fix is to put the screens here, where they are
+     * reachable, and keep the settings pages as a second way in. Both render the same
+     * components, so there is one implementation of each screen and nothing to sync.
+     *
+     * @param {any} props slot props
+     * @returns {any} panel element
+     */
+    function SuitePanel(props) {
+      const t = props.t ?? (key => key)
+      const rev = useStore(revision)
+      // Which screen is open. `null` shows the three-entry list.
+      const [open, setOpen] = useState(null)
+      const [counts, setCounts] = useState(null)
+      const [error, setError] = useState(null)
+
+      // The three numbers that tell the user whether there is anything behind each
+      // row. A panel whose entries all look identical regardless of content is just
+      // a menu; showing counts is what makes it worth opening.
+      //
+      // Two shape facts this relies on, both of which cost a round of debugging when
+      // guessed wrong: the action is `list` (not `listSessions` — the Host method is
+      // named that, the action is not), and it answers with a bare ARRAY.
+      //
+      // `scope: 'all'` is passed deliberately. The panel has no workspace of its own,
+      // and calling `longterm.list` with no scope returned only the GLOBAL store —
+      // 17 rows for a library of 51 — which is why the panel said 17 while the
+      // settings page said something else entirely. 'all' now means every store.
+      useEffect(() => {
+        let alive = true
+        Promise.all([
+          call({ action: 'longterm.list', scope: 'all' }).catch(() => []),
+          call({ action: 'list' }).catch(() => []),
+          // Per-workspace breakdown, so the totals can be explained rather than
+          // merely displayed. The counts above are sums; without this the user
+          // cannot tell which workspace contributes what — the exact question that
+          // made the earlier 17/21/27/51 mismatch look like a bug.
+          call({ action: 'longterm.workspaces' }).catch(() => []),
+        ])
+          .then(([memories, sessions, workspaces]) => {
+            if (!alive) return
+            const items = Array.isArray(sessions) ? sessions : []
+            const stores = Array.isArray(workspaces) ? workspaces : []
+            const memoryRows = Array.isArray(memories) ? memories : []
+            // The global store's size, so the breakdown adds up to the total instead
+            // of leaving the difference unexplained.
+            const globalRows = memoryRows.filter(row => row.scope === 'global').length
+            setCounts({
+              memories: memoryRows.length,
+              memoryActive: memoryRows.filter(row => row.archived !== true).length,
+              memoryArchived: memoryRows.filter(row => row.archived === true).length,
+              memoryGlobal: globalRows,
+              sessions: items.length,
+              snapshots: items.reduce((sum, item) => sum + (item.checkpoints ?? 0), 0),
+              archived: items.filter(item => item.archived === true).length,
+              // Each store's own size, so the total has a visible decomposition.
+              stores: stores.map(store => ({
+                cwd: store.cwd ?? store.key,
+                entries: store.entries ?? 0,
+              })),
+            })
+          })
+          .catch(failure => alive && setError(failure?.message ?? String(failure)))
+        return () => {
+          alive = false
+        }
+      }, [rev])
+
+      // One screen is open: render it, with a way back.
+      if (open) {
+        const screens = {
+          snapshots: SnapshotSection,
+          memory: MemorySection,
+          archived: ArchivedSection,
+        }
+        const Screen = screens[open]
+        return h(
+          'div',
+          { className: 'dss-panel' },
+          h(
+            'div',
+            { className: 'dss-panel-nav' },
+            h(
+              'button',
+              { type: 'button', className: 'dss-btn dss-small dss-ghost', onClick: () => setOpen(null) },
+              `‹ ${t('panel.title')}`,
+            ),
+          ),
+          Screen ? h(Screen, { t }) : null,
+        )
+      }
+
+      /** @param {string} key screen key @param {string} title row title @param {string} hint row hint */
+      const row = (key, title, hint, meta) =>
+        h(
+          'button',
+          {
+            key,
+            type: 'button',
+            className: 'dss-nav-row',
+            onClick: () => setOpen(key),
+          },
+          h(
+            'div',
+            { className: 'dss-nav-main' },
+            h('div', { className: 'dss-nav-title' }, title),
+            h('div', { className: 'dss-nav-hint' }, hint),
+          ),
+          meta === undefined ? h(Icons.chevron, null) : h('div', { className: 'dss-nav-meta' }, String(meta)),
+        )
+
+      return h(
+        'div',
+        { className: 'dss-panel' },
+        h(
+          'div',
+          { className: 'dss-section-head' },
+          h('h2', null, t('panel.title')),
+          h('div', { className: 'dss-section-desc' }, t('panel.description')),
+        ),
+        error ? h('div', { className: 'dss-dialog-error' }, error) : null,
+        // A summary strip, because three rows alone left most of the column empty.
+        // The numbers are the same ones the rows carry, so it adds orientation
+        // without inventing a second source of truth.
+        //
+        // Each figure states what it counts. Showing bare numbers is how the earlier
+        // mismatch became a bug report: the user saw 17 here and 21 there, both
+        // labelled "memory", with nothing on screen saying one was the global store
+        // and the other was global plus one workspace.
+        h(
+          'div',
+          { className: 'dss-stat-strip' },
+          ...[
+            ['panel.statSessions', counts?.sessions, 'panel.statSessionsHint'],
+            ['panel.statSnapshots', counts?.snapshots, 'panel.statSnapshotsHint'],
+            ['panel.statMemories', counts?.memories, 'panel.statMemoriesHint'],
+            ['panel.statArchived', counts?.archived, 'panel.statArchivedHint'],
+          ].map(([label, value, hint]) =>
+            h(
+              'div',
+              { className: 'dss-stat', key: label, title: t(hint) },
+              h('div', { className: 'dss-stat-value' }, value === undefined ? '—' : String(value)),
+              h('div', { className: 'dss-stat-label' }, t(label)),
+              h('div', { className: 'dss-stat-hint' }, t(hint)),
+            ),
+          ),
+        ),
+        // The decomposition, so the total is checkable rather than a number to trust.
+        counts?.stores?.length
+          ? h(
+              'div',
+              { className: 'dss-breakdown' },
+              h('div', { className: 'dss-group-title' }, t('panel.breakdownTitle')),
+              h(
+                'div',
+                { className: 'dss-breakdown-row' },
+                h('span', { className: 'dss-breakdown-key' }, t('panel.breakdownGlobal')),
+                h('span', { className: 'dss-breakdown-value' }, String(counts.memoryGlobal ?? '—')),
+              ),
+              ...counts.stores.map(store =>
+                h(
+                  'div',
+                  { className: 'dss-breakdown-row', key: store.cwd },
+                  h(
+                    'span',
+                    { className: 'dss-breakdown-key', title: store.cwd },
+                    String(store.cwd).split(/[\\/]/).filter(Boolean).pop() ?? store.cwd,
+                  ),
+                  h('span', { className: 'dss-breakdown-value' }, String(store.entries)),
+                ),
+              ),
+              h('div', { className: 'dss-breakdown-hint' }, t('panel.breakdownHint')),
+            )
+          : null,
+        h(
+          'div',
+          { className: 'dss-nav' },
+          row('snapshots', t('panel.snapshots'), t('panel.snapshotsHint'), counts?.snapshots),
+          row('memory', t('panel.memory'), t('panel.memoryHint'), counts?.memories),
+          row('archived', t('panel.archived'), t('panel.archivedHint'), counts?.archived),
+        ),
+        h(
+          'div',
+          { className: 'dss-panel-footer' },
+          h('span', null, t('panel.sessionsCount', { n: counts?.sessions ?? 0 })),
+          // A way to find the source. dsh-connect-trae puts a GitHub link in the same
+          // place, and it is the one line in a panel like this that answers "who made
+          // this and where do I report a problem".
+          h(
+            'a',
+            {
+              className: 'dss-panel-link',
+              href: 'https://github.com/heixiua/dsh-session-suite',
+              target: '_blank',
+              rel: 'noreferrer noopener',
+            },
+            t('panel.repoLink'),
+          ),
+        ),
+      )
+    }
+
+    // --------------------------------------------------- archived sessions
+
+    /**
+     * Archived sessions, with a way back.
+     *
+     * Archiving existed as a Host command but had no surface here, so a session
+     * could be archived and then be unreachable — the sidebar hides it and the only
+     * way back was the Host's own menu, which is disabled in the context where the
+     * archive happened. This page is the missing half: it lists what the sidebar is
+     * hiding and offers restore.
+     *
+     * Restore, not delete, is the primary action. Archived rows are still complete
+     * sessions; the common mistake is to treat "hidden" as "gone" and destroy data
+     * to tidy a list.
+     *
+     * @param {any} props slot props
+     * @returns {any} section element
+     */
+    function ArchivedSection(props) {
+      const t = props.t ?? (key => key)
+      const rev = useStore(revision)
+      const [rows, setRows] = useState(null)
+      const [error, setError] = useState(null)
+      const [busy, setBusy] = useState(null)
+
+      useEffect(() => {
+        let alive = true
+        // `list` answers with a bare array; see the note in SuitePanel.
+        call({ action: 'list' })
+          .then(result => {
+            if (!alive) return
+            const items = Array.isArray(result) ? result : []
+            setRows(items.filter(item => item.archived === true))
+          })
+          .catch(failure => alive && setError(failure?.message ?? String(failure)))
+        return () => {
+          alive = false
+        }
+      }, [rev])
+
+      /** @param {string} sessionId session to restore */
+      const restore = async sessionId => {
+        setBusy(sessionId)
+        setError(null)
+        try {
+          await call({ action: 'restoreSession', sessionId })
+          notify(t('archived.restored'))
+          bump()
+        } catch (failure) {
+          setError(failure?.message ?? t('archived.restoreFailed'))
+        } finally {
+          setBusy(null)
+        }
+      }
+
+      const head = h(
+        'div',
+        { className: 'dss-section-head' },
+        h('h2', null, t('archived.title')),
+        h('div', { className: 'dss-section-desc' }, t('archived.description')),
+      )
+
+      if (error) return h('div', { className: 'dss-section' }, head, h('div', { className: 'dss-dialog-error' }, error))
+      if (!rows) return h('div', { className: 'dss-section' }, head, h('div', { className: 'dss-empty' }, t('settings.loading')))
+
+      const body =
+        rows.length === 0
+          ? h('div', { className: 'dss-empty' }, t('archived.empty'))
+          : h(
+              'div',
+              { className: 'dss-card' },
+              ...rows.map(entry =>
+                h(
+                  'div',
+                  { className: 'dss-row', key: entry.sessionId },
+                  h(
+                    'div',
+                    { className: 'dss-row-main' },
+                    h('div', { className: 'dss-memory-text' }, entry.title || entry.sessionId),
+                    h(
+                      'div',
+                      { className: 'dss-row-meta' },
+                      h('span', { className: 'dss-badge dss-temp' }, t('settings.archived')),
+                      typeof entry.checkpoints === 'number'
+                        ? h('span', null, t('settings.checkpointCount', { n: entry.checkpoints }))
+                        : null,
+                    ),
+                  ),
+                  h(
+                    'div',
+                    { className: 'dss-row-actions' },
+                    h(
+                      'button',
+                      {
+                        type: 'button',
+                        className: 'dss-btn dss-small',
+                        disabled: busy === entry.sessionId,
+                        onClick: () => restore(entry.sessionId),
+                      },
+                      busy === entry.sessionId ? t('settings.working') : t('archived.restore'),
+                    ),
+                  ),
+                ),
+              ),
+            )
+
+      return h('div', { className: 'dss-section' }, head, body)
+    }
+
     function MemorySection(props) {
       const t = props.t
       const rev = useStore(revision)
@@ -2632,33 +3175,39 @@ window.__ModuleLoader__.load({
                 ),
               ),
             )
-          : extraction
-            ? h(
+          : h(
+              // Always render this block, even when extraction has never run.
+              //
+              // It used to render only when a trace existed, so a freshly started
+              // Host showed NOTHING here — indistinguishable from a broken feature,
+              // and exactly the question the user then asked. An empty state has to
+              // say why it is empty.
+              'div',
+              { className: 'dss-mem-pending' },
+              h('div', { className: 'dss-group-title' }, t('memory.pendingTitle')),
+              h(
                 'div',
-                { className: 'dss-mem-pending' },
-                h('div', { className: 'dss-group-title' }, t('memory.pendingTitle')),
-                h(
-                  'div',
-                  { className: 'dss-mem-pending-hint' },
-                  t('memory.extractionIdle', {
-                    reason: extraction.reason || t('memory.extractionUnknown'),
-                  }),
-                ),
-                extraction.candidates?.length
-                  ? h(
-                      'div',
-                      { className: 'dss-row-meta' },
-                      h('span', null, t('memory.extractionTried', { n: extraction.candidates.length })),
-                      extraction.queued !== undefined
-                        ? h('span', null, t('memory.extractionQueued', { n: extraction.queued }))
-                        : null,
-                      extraction.rejected !== undefined
-                        ? h('span', null, t('memory.extractionRejected', { n: extraction.rejected }))
-                        : null,
-                    )
-                  : null,
-              )
-            : null
+                { className: 'dss-mem-pending-hint' },
+                extraction
+                  ? t('memory.extractionIdle', {
+                      reason: extraction.reason || t('memory.extractionUnknown'),
+                    })
+                  : t('memory.extractionNotYet'),
+              ),
+              extraction?.candidates?.length
+                ? h(
+                    'div',
+                    { className: 'dss-row-meta' },
+                    h('span', null, t('memory.extractionTried', { n: extraction.candidates.length })),
+                    extraction.queued !== undefined
+                      ? h('span', null, t('memory.extractionQueued', { n: extraction.queued }))
+                      : null,
+                    extraction.rejected !== undefined
+                      ? h('span', null, t('memory.extractionRejected', { n: extraction.rejected }))
+                      : null,
+                  )
+                : null,
+            )
 
       const listBlock =
         visible.length === 0
@@ -3034,6 +3583,29 @@ window.__ModuleLoader__.load({
           )
         }
 
+        // ---------------------------------------------------- sidebar entry
+        //
+        // A first-class sidebar entry, matching how dsh-connect-trae,
+        // dsh-connect-workbuddy and dsh-context present themselves: an icon in
+        // `sidebar.panellist` plus a panel under the same key in `main`. Both are
+        // additive (`replaceRisk: none` on the list, and the key is one only this
+        // plugin claims), so nothing shipped is shadowed.
+        //
+        // Why a panel at all: the features already existed but were reachable only
+        // through Settings → one of two sections, three steps from anywhere. The
+        // panel is pure navigation — it does not reimplement the sections, it opens
+        // them, so there is one implementation of every screen.
+        ctx.slots.inject('sidebar.panellist', () =>
+          ctx.slots.register(
+            { name: 'sidebar.panellist', id: 'session-suite', order: 25, locale: NS },
+            withT(SuiteIcon),
+          ),
+        )
+
+        ctx.slots.inject('main', () =>
+          ctx.slots.register({ name: 'main', key: 'session-suite' }, withT(SuitePanel)),
+        )
+
         ctx.slots.inject('conversation.chat.assistant-actions', () =>
           ctx.slots.register(
             { name: 'conversation.chat.assistant-actions', id: 'session-suite-rewind', order: 20, locale: NS },
@@ -3052,31 +3624,15 @@ window.__ModuleLoader__.load({
           ctx.slots.register({ name: 'shell.overlay', id: 'session-suite-overlay', order: 40 }, SuiteOverlay),
         )
 
-        ctx.slots.inject('settings.section', () =>
-          ctx.slots.register(
-            {
-              name: 'settings.section',
-              id: 'session-snapshots',
-              order: 500,
-              locale: NS,
-              label: () => t('settings.title'),
-            },
-            withT(SnapshotSection),
-          ),
-        )
-
-        ctx.slots.inject('settings.section', () =>
-          ctx.slots.register(
-            {
-              name: 'settings.section',
-              id: 'long-term-memory',
-              order: 520,
-              locale: NS,
-              label: () => t('memory.title'),
-            },
-            withT(MemorySection),
-          ),
-        )
+        // The three settings sections are gone on purpose.
+        //
+        // They were the only way in before the sidebar panel existed, so the same
+        // three screens appeared twice: once under Settings and once behind the
+        // sidebar icon. Two entry points for one screen is not convenience, it is
+        // two places to keep consistent and two places for the user to wonder about.
+        // The panel is the primary surface now; these registrations were removed
+        // rather than hidden behind a flag, because a dead section in Settings is
+        // worse than an absent one.
         }
       },
     }

package/lib/api.js

@@ -144,6 +144,11 @@ async function respond(service, deps, action, input) {
           { cascade: input.cascade !== false },
         ),
       })
+    case 'restoreSession':
+      // The inverse of archiving. Kept separate from any delete path on purpose:
+      // un-hiding a session and destroying one are different intents and must not
+      // share a control.
+      return json({ ok: true, data: await service.restoreSession(requireSession(input)) })
     case 'deleteSession':
       return json({
         ok: true,

package/lib/memory-engine.js

@@ -1599,11 +1599,39 @@ export class MemoryEngine {
   async list(input = {}) {
     const settings = await this.settings()
     const out = []
-    const scopes = input.scope ? [input.scope] : SCOPES
+    // `'all'` is a legitimate request meaning "every scope". Treating it as a scope
+    // NAME selected a store called `all`, which does not exist, so the answer came
+    // back as whatever stray rows happened to be there — the settings page showed
+    // 「共 5 条」 for a library of 51. Any unrecognised value falls back to every
+    // scope for the same reason: an unknown scope must not silently narrow the list.
+    const requested = input.scope
+    const scopes =
+      requested === 'workspace' || requested === 'global'
+        ? [requested]
+        : SCOPES
+    // Which workspace stores to read.
+    //
+    // A caller without a workspace — the sidebar panel has none — used to get only
+    // the global store, because `workspaceKey(undefined)` hashes the empty string and
+    // reads a store that never exists. That is why the panel showed 17 for a library
+    // of 51 while the settings page showed 51. When no cwd is supplied, read every
+    // REGISTERED workspace instead of pretending there is one unnamed store: the
+    // registry is the only place that knows which keys exist.
+    const workspaceKeys = await (async () => {
+      // Only asked for global: no workspace stores at all.
+      if (requested === 'global') return []
+      // A caller that names its workspace gets exactly that one.
+      if (typeof input.cwd === 'string' && input.cwd) return [MemoryEngine.workspaceKey(input.cwd)]
+      // A caller with no workspace gets every registered one.
+      const registered = await this.workspaces()
+      return registered.map(item => item.key).filter(key => typeof key === 'string' && key)
+    })()
     for (const scope of scopes) {
-      const key = scope === 'workspace' ? MemoryEngine.workspaceKey(input.cwd) : 'global'
-      const store = await this.#readStore(scope, key)
-      const cold = await this.#readCold(scope, key)
+      // The workspace scope may cover several keys; global covers exactly one.
+      const keys = scope === 'workspace' ? workspaceKeys : ['global']
+      for (const key of keys) {
+        const store = await this.#readStore(scope, key)
+        const cold = await this.#readCold(scope, key)
       const maxAccess = Math.max(1, ...store.entries.map(entry => entry.accessCount ?? 0))
       for (const entry of store.entries) {
         const own = shingles(entry.text)
@@ -1621,6 +1649,7 @@ export class MemoryEngine {
         out.push({ ...entry, scope, score, factors })
       }
       for (const entry of cold.entries) out.push({ ...entry, scope, score: 0, factors: {}, state: 'archived', archived: true })
+      }
     }
     // Filtering happens here rather than in the caller so the settings page and
     // the export both see the same set for the same query. A library that grows

package/lib/service.js

@@ -70,6 +70,9 @@ export class SessionSuiteService {
     if (!controller?.list) return []
     const value = await controller.list({})
     const items = Array.isArray(value?.items) ? value.items : []
+    // Whether a session is archived is read once for the whole call rather than per
+    // row: it is one file, and a per-row read would open it twelve times.
+    const archivedIds = await this.#archivedIds()
     const out = []
     for (const item of items) {
       // Hide subagent children only. They are not conversations of their own —
@@ -100,6 +103,12 @@ export class SessionSuiteService {
         checkpoints: checkpoints.length,
         checkpointBytes: stats?.bytes ?? 0,
         checkpointLabel: formatBytes(stats?.bytes ?? 0),
+        // Archived is a property the caller has to ASK about, because the sidebar
+        // hides these rows and the archive page is the only place that wants them
+        // back. Reported here rather than filtered out, so one list serves both
+        // screens: the archive page selects the archived ones, everything else
+        // ignores the flag and gets exactly the old behaviour.
+        archived: archivedIds.has(item.sessionId),
       })
     }
     return out
@@ -921,34 +930,104 @@ export class SessionSuiteService {
     await fs.rm(path.join(this.undoDir, `${undoId}.json`), { force: true })
   }
 
-  /** @param {string} sessionId session @param {boolean} stop stop its running work */
-  async #archive(sessionId, stop) {
-    const controllers = [this.#service('workspaceController'), this.#service('workspaceRegistry')]
+  /**
+   * Bring an archived session back into the sidebar.
+   *
+   * Archiving hides a session without destroying it, so restore is the inverse and
+   * needs nothing more than clearing the archive mark. It is a separate operation
+   * from deleteSession on purpose: a list of hidden rows is not a list of things to
+   * destroy, and offering only "delete" would teach the user that hiding equals
+   * losing.
+   *
+   * @param {string} sessionId session to restore
+   * @returns {Promise<{ sessionId: string, restored: boolean }>} result
+   */
+  async restoreSession(sessionId) {
+    if (typeof sessionId !== 'string' || !sessionId) throw new Error('sessionId is required')
+    this.#require('sessionController')
+    const restored = await this.#unarchive(sessionId)
+    if (!restored) {
+      throw new Error('this Host build does not expose a way to unarchive a session')
+    }
+    // Tell the live layer so the sidebar redraws without a restart — the same
+    // signal deleteSession emits in the opposite direction.
+    try {
+      this.ctx.emit?.('api-session/restored', sessionId)
+    } catch (error) {
+      this.log('could not announce the restored session', error)
+    }
+    return { sessionId, restored: true }
+  }
+
+  /**
+   * The set of archived session ids, read from the registry that owns them.
+   *
+   * Read from `workspace.json` rather than through a controller because the
+   * controller offers archive/unarchive as WRITE operations and no read — and the
+   * list endpoint this feeds does not project the flag, so a page built on it could
+   * only ever show zero. This is the same file `#archive` ultimately writes through
+   * the registry controller, so the two cannot disagree about what "archived" means.
+   *
+   * @returns {Promise<Set<string>>} archived ids
+   */
+  async #archivedIds() {
+    try {
+      const registry = await readJson(path.join(this.dshHome, 'storages', 'workspace.json'))
+      const ids = registry?.global?.archivedSessionIds
+      return new Set(Array.isArray(ids) ? ids.filter(id => typeof id === 'string') : [])
+    } catch (error) {
+      // A missing or malformed registry means "nothing is known to be archived",
+      // which renders as an empty page rather than an error — the archive list is
+      // advisory and must never block the panel from loading.
+      this.log('could not read the archived session marks', error)
+      return new Set()
+    }
+  }
+
+  /**
+   * Call an archive/unarchive operation on whichever controller is mounted.
+   *
+   * The two candidate services take DIFFERENT argument shapes, and picking the wrong
+   * one fails silently — which is why the Restore button appeared to do nothing:
+   * `workspaceRegistry.unarchiveSession(sessionId)` takes the id directly, while
+   * `workspaceController.unarchiveSession(request)` is a generated Remote that takes
+   * a request OBJECT (`{ sessionId }`). Passing a bare string to the latter throws,
+   * the throw was caught and logged, and the caller only saw `false`.
+   *
+   * Both shapes are attempted rather than guessed: try the plain argument first
+   * (registry), then the request object (controller), and treat success as whichever
+   * one resolves.
+   *
+   * @param {string} method archiveSession | unarchiveSession
+   * @param {string} sessionId session
+   * @param {any} [extra] extra options for the plain-argument shape
+   * @returns {Promise<boolean>} whether it took effect
+   */
+  async #sessionFlag(method, sessionId, extra) {
+    const controllers = [this.#service('workspaceRegistry'), this.#service('workspaceController')]
     for (const controller of controllers) {
-      if (!controller?.archiveSession) continue
-      try {
-        await controller.archiveSession(sessionId, { stopActivity: stop === true })
-        return true
-      } catch (error) {
-        this.log('archiveSession failed', error)
+      if (!controller || typeof controller[method] !== 'function') continue
+      // Registry shape: (sessionId, options). Controller shape: ({ sessionId, ... }).
+      for (const args of [[sessionId, extra].filter(Boolean), [{ sessionId, ...(extra ?? {}) }]]) {
+        try {
+          await controller[method](...args)
+          return true
+        } catch (error) {
+          this.log(`${method} attempt failed with ${args.length} argument(s)`, error)
+        }
       }
     }
     return false
   }
 
+  /** @param {string} sessionId session @param {boolean} stop stop its running work */
+  async #archive(sessionId, stop) {
+    return this.#sessionFlag('archiveSession', sessionId, { stopActivity: stop === true })
+  }
+
   /** @param {string} sessionId session */
   async #unarchive(sessionId) {
-    const controllers = [this.#service('workspaceController'), this.#service('workspaceRegistry')]
-    for (const controller of controllers) {
-      if (!controller?.unarchiveSession) continue
-      try {
-        await controller.unarchiveSession(sessionId)
-        return true
-      } catch (error) {
-        this.log('unarchiveSession failed', error)
-      }
-    }
-    return false
+    return this.#sessionFlag('unarchiveSession', sessionId)
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heixui/dsh-session-suite",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Session checkpoints for DSH: rewind a conversation with its files and memory, permanent session deletion, and shareable exports",
   "type": "module",
   "main": "./index.js",