@heixui/dsh-session-suite 0.4.1 → 0.4.3

package/README.zh.md

@@ -175,18 +175,21 @@ docs/               需求与 API 笔记
 
 ## 0.4.1 改了什么
 
-新增侧边栏入口，并修掉三个「看起来能用、实际没生效」的问题。
+新增侧边栏入口，修掉几个「看起来能用、实际没生效」的问题，并把界面上说不清的数字说清楚。
 
 | 方面 | 改前 | 改后 |
 |---|---|---|
 | 入口位置 | 只能在 设置 → 会话快照 / 长期记忆 里找，三步才能到 | **左侧栏「会话套件」图标**，点开即用；设置页那三个重复入口已移除 |
-| 记忆总数 | 面板显示 17，设置页显示 51 —— 同一句话两个数 | 面板遍历**所有已登记工作区**，与设置页一致；每个数字都写明统计口径 |
-| 归档恢复 | 点了没反应，磁盘上的标记纹丝不动 | 修了参数签名（两个 Host 服务的入参形状不同），恢复真正生效 |
-| 长列表滚动 | 面板内容被裁掉，滚轮无效 | 面板可滚动 |
-
-**为什么数字会不一样（0.4.0 的真实缺陷）**：长期记忆分「全局库」和「各工作区的库」。
-`longterm.list` 不带 `cwd` 时只返回全局库（17 条），带上 `cwd` 才是全局 + 该工作区。
-面板没有工作区概念，于是只显示了全局那 17 条。现在面板不带 `cwd` 时会遍历所有已登记工作区。
+| 记忆总数 | 面板显示 17，设置页显示 51 —— 同一句话两个数 | 面板遍历**所有已登记工作区**；每个数字都写明统计口径，并给出分工作区明细 |
+| 归档恢复 | 点了没反应，磁盘上的标记纹丝不动 | 修了两个 Host 服务参数形状不一致的问题，恢复真正生效 |
+| 快照数量 | 预算 10 张，列表却有 16 张，无从解释 | 区分「自有 10 张」与「继承 6 张」，继承项打徽章并说明为何不计入预算 |
+| 隐式提取模型 | 只能选「关闭」和「用当前模型」，看不到自己配的模型 | 从 Host 的 llm 服务枚举真实可用模型；**默认关闭，不选就不消耗 token** |
+| 长列表 | 配置区被五十条记忆挤到看不见 | 列表独立滚动，配置区始终可见 |
+| 会话记忆 | 一个从未写入的残缺区块，旁边就是 dsh 自带的轨迹 | 已移除 —— 轨迹是权威且不可改，手写笔记只会误导 |
+
+**关于记忆总数为什么会有多个数字**：长期记忆分「全局库」和「各工作区的库」。
+`longterm.list` 不带 `cwd` 时只返回全局库，带上才是全局 + 该工作区。面板没有工作区概念，
+于是只显示了全局那部分。现在面板会遍历所有已登记工作区，并在界面上直接列出每个库的条数。
 
 ## 测试
 

package/client.js

@@ -141,6 +141,15 @@ window.__ModuleLoader__.load({
         'settings.unlock': 'Unlock',
         'settings.locked': 'Locked',
         'settings.budget': 'Keeps the newest {keep} automatic snapshots',
+        'settings.budgetInherited': '+ {n} inherited',
+        'settings.inherited': 'Inherited',
+        'settings.orphansSweep': 'Clean up orphan snapshots',
+        'settings.orphansConfirm': 'Click again to delete',
+        'settings.orphansNone': 'No orphan snapshot directories',
+        'settings.orphansFound': '{n} orphan session(s), {size} reclaimable — click again to delete',
+        'settings.orphansRemoved': 'Removed {n} orphan session(s), freed {size}',
+        'settings.budgetNote':
+          'Only this session\'s own automatic snapshots count against the budget. Snapshots inherited from a parent session (created by a rewind or message delete) are kept separately and are why the list can be longer than {keep}.',
         'settings.usage': 'Snapshots use {size}',
         'settings.files': '{count} files',
         'settings.turn': 'Turn {turn}',
@@ -209,7 +218,16 @@ window.__ModuleLoader__.load({
         'memory.unfreeze': 'Unfreeze',
         'memory.remove': 'Delete',
         'memory.pendingTitle': 'Suggested memories',
-        'memory.pendingHint': 'Extracted from the last turns. Nothing is stored until you accept it.',
+        'memory.statsKind': 'What the library holds',
+        'memory.statsHealth': 'Score distribution',
+        'memory.statsTags': 'Topics',
+        'memory.kind.fact': 'Facts',
+        'memory.kind.rule': 'Rules',
+        'memory.kind.summary': 'Summaries',
+        'memory.kind.episode': 'Episodes',
+        'memory.band.high': 'Strong ≥0.60',
+        'memory.band.mid': 'Fading 0.45–0.60',
+        'memory.band.low': 'Below line <0.45',        '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.',
@@ -234,7 +252,7 @@ window.__ModuleLoader__.load({
         '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.repoLink': 'GitHub source — a small encouragement',
         '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.',
@@ -248,6 +266,8 @@ window.__ModuleLoader__.load({
         'memory.extractionTried': 'tried {n} memory model(s)',
         'memory.extractionQueued': '{n} queued',
         'memory.extractionRejected': '{n} rejected as unusable',
+        'memory.extractionEvents': '{n} session event(s) received',
+        'memory.extractionTurns': '{n} turn(s) ended',
         'memory.accept': 'Keep',
         'memory.reject': 'Discard',
         'memory.accepted': 'Kept',
@@ -260,6 +280,11 @@ window.__ModuleLoader__.load({
         'memory.maintainedCompressed': 'compressed',
         'memory.maintainedRules': 'rules',
         'memory.implicit': 'Suggest memories automatically',
+        'memory.implicitModel': 'Model for automatic extraction',
+        'memory.implicitModelOff': 'Off — no model call, costs nothing',
+        'memory.implicitModelCurrent': 'Use the model this conversation is already using',
+        'memory.implicitModelHint':
+          'Automatic extraction sends one small request at the end of each turn. Choosing a model here is what authorises that spend; "Off" and "Use the current model" are the two ends of the tradeoff.',
         'memory.clearCold': 'Clear cold archive',
         'memory.coldCleared': 'Cold archive cleared',
       },
@@ -359,6 +384,15 @@ window.__ModuleLoader__.load({
         'settings.unlock': '解锁',
         'settings.locked': '已锁定',
         'settings.budget': '每个会话保留最近 {keep} 个自动快照',
+        'settings.budgetInherited': '+ {n} 个继承',
+        'settings.inherited': '继承',
+        'settings.orphansSweep': '清理孤儿快照',
+        'settings.orphansConfirm': '再点一次确认删除',
+        'settings.orphansNone': '没有孤儿快照目录',
+        'settings.orphansFound': '{n} 个会话的孤儿快照，可释放 {size} —— 再点一次删除',
+        'settings.orphansRemoved': '已删除 {n} 个会话的孤儿快照，释放 {size}',
+        'settings.budgetNote':
+          '只有这个会话自己的自动快照计入预算。从父会话继承来的快照（回滚或删除消息时产生）单独保留，所以列表可能比 {keep} 长。',
         'settings.usage': '快照占用 {size}',
         'settings.files': '{count} 个文件',
         'settings.turn': '第 {turn} 轮',
@@ -427,6 +461,16 @@ window.__ModuleLoader__.load({
         'memory.unfreeze': '解冻',
         'memory.remove': '删除',
         'memory.pendingTitle': '待确认的记忆',
+        'memory.statsKind': '库里有什么',
+        'memory.statsHealth': '分数分布',
+        'memory.statsTags': '主题分布',
+        'memory.kind.fact': '事实',
+        'memory.kind.rule': '规则',
+        'memory.kind.summary': '摘要',
+        'memory.kind.episode': '经历',
+        'memory.band.high': '强 ≥0.60',
+        'memory.band.mid': '衰减 0.45-0.60',
+        'memory.band.low': '低于线 <0.45',
         'memory.pendingHint': '从最近几轮里识别出来的，确认前不会入库。',
         'memory.extractionIdle': '当前没有待确认条目。上次检查结果：{reason}',
         'memory.extractionNotYet':
@@ -452,7 +496,7 @@ window.__ModuleLoader__.load({
         'panel.breakdownTitle': '记忆存在哪',
         'panel.breakdownGlobal': '全局（所有工作区共享）',
         'panel.breakdownHint': '每个工作区有独立的库；上面的总数 = 这些之和 + 全局。',
-        'panel.repoLink': 'GitHub 源码',
+        'panel.repoLink': 'GitHub 源码 - 鼓励一下',
         'panel.noSettingsSeam': '这个 Host 版本没有暴露设置导航接口，无法打开对应页面。',
         'archived.title': '归档会话',
         'archived.description': '归档的会话从侧边栏隐藏。恢复后会重新出现，不会删除任何东西。',
@@ -466,6 +510,8 @@ window.__ModuleLoader__.load({
         'memory.extractionTried': '试过 {n} 个记忆模型',
         'memory.extractionQueued': '入队 {n} 条',
         'memory.extractionRejected': '剔除 {n} 条',
+        'memory.extractionEvents': '收到 {n} 个会话事件',
+        'memory.extractionTurns': '结束 {n} 轮',
         'memory.accept': '保留',
         'memory.reject': '丢弃',
         'memory.accepted': '已保留',
@@ -478,6 +524,11 @@ window.__ModuleLoader__.load({
         'memory.maintainedCompressed': '已压缩',
         'memory.maintainedRules': '条规则',
         'memory.implicit': '自动识别并建议记忆',
+        'memory.implicitModel': '自动提取使用的模型',
+        'memory.implicitModelOff': '关闭 —— 不调用模型，零消耗',
+        'memory.implicitModelCurrent': '用当前对话正在使用的模型',
+        'memory.implicitModelHint':
+          '自动提取会在每轮结束时发一次小请求。在这里选定模型才代表你授权了这笔消耗；「关闭」和「用当前模型」是这笔取舍的两端。',
         'memory.clearCold': '清空冷归档',
         'memory.coldCleared': '冷归档已清空',
       },
@@ -793,6 +844,16 @@ window.__ModuleLoader__.load({
 .dss-curate-title { font-size: 13px; color: var(--dsw-alias-label-primary, #1f1f1f); }
 .dss-curate-hint { font-size: 12px; line-height: 18px; color: var(--dsw-alias-label-secondary, #6b6b6b); }
 .dss-curate-inline { margin-top: 0; padding: 6px 10px; border-color: transparent; background: transparent; }
+/* The model picker sits below the toggle as a labelled control, because it is a
+   separate decision from "on/off": one says whether to extract, the other says who
+   pays for it. */
+.dss-curate-field {
+  display: flex; flex-direction: column; gap: 6px; margin-top: 10px;
+  padding: 12px 14px; border-radius: 8px;
+  border: 1px solid var(--dsw-alias-border-l1, rgba(0,0,0,.08));
+  background: var(--dsw-alias-bg-layer-1, #fff);
+}
+.dss-curate-label { font-size: 13px; font-weight: 600; color: var(--dsw-alias-label-primary, #1f1f1f); }
 
 .dss-tabs { display: flex; gap: 4px; flex-wrap: wrap; }
 .dss-tab {
@@ -949,6 +1010,73 @@ window.__ModuleLoader__.load({
   border: 1px solid var(--dsw-alias-border-l1, rgba(0,0,0,.08));
   border-radius: 10px; background: var(--dsw-alias-bg-layer-1, #fff);
 }
+/* A bounded list: the library scrolls, the page does not.
+   Without this the settings below sat below the fold behind fifty rows, so every
+   change meant scrolling past the whole library first. 480px is about eleven rows,
+   picked by looking at it rather than by arithmetic — it was raised from 360px after
+   the first version read as too short. Single number, retune freely. overscroll-behavior
+   contain stops a scroll that reaches the end of the list from continuing into the page,
+   which is what makes the box feel like a box rather than a speed bump. */
+.dss-scroll-box {
+  max-height: 480px;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+}
+/* The summary charts. Two narrow panels for composition and health, one wide panel
+   for tags: composition and health are short lists, tags can run long. Bars are divs,
+   not SVG, so they inherit the theme and stay legible in both palettes. */
+.dss-stats { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 10px; }
+.dss-stats-panel {
+  display: flex; flex-direction: column; gap: 8px;
+  padding: 14px 16px;
+  background: var(--dsw-alias-bg-layer-1, #fff);
+  border: 1px solid var(--dsw-alias-border-l1, rgba(0,0,0,.08));
+  border-radius: 10px;
+}
+.dss-stats-wide { grid-column: 1 / -1; }
+.dss-statbar { display: flex; align-items: center; gap: 10px; font-size: 12px; }
+/* The label was a fixed 76px with nowrap + ellipsis, so anything longer than a
+   couple of Chinese characters was cut off mid-word — 「低于压缩线（<0.45）」
+   rendered as 「低于压缩线…」 and the reader could not tell which band it was.
+   A wider column that wraps is the honest fix: a truncated label still occupies the
+   same space, it just stops being readable. */
+.dss-statbar-label {
+  flex: none; width: 108px;
+  color: var(--dsw-alias-label-primary, #1f1f1f);
+  line-height: 1.35;
+  overflow-wrap: anywhere;
+}
+/* Composition and tag bars get distinct hues.
+   Every bar was the same brand blue, so a chart of five categories read as one
+   repeated object and the only thing distinguishing a row was its length — the eye
+   had to go back to the label each time. Colour-coding by position makes the rows
+   separately trackable while staying inside the theme's palette. */
+.dss-tone-c0 { background: #4d6bfe; }
+.dss-tone-c1 { background: #7b5cf5; }
+.dss-tone-c2 { background: #2aa6c9; }
+.dss-tone-c3 { background: #14a37f; }
+.dss-tone-c4 { background: #e0a03a; }
+.dss-tone-c5 { background: #d9636a; }
+.dss-statbar-track {
+  flex: 1; height: 8px; min-width: 0;
+  background: var(--dsw-alias-bg-layer-2, #f2f3f5);
+  border-radius: 4px; overflow: hidden;
+}
+.dss-statbar-fill {
+  height: 100%; border-radius: 4px;
+  background: var(--dsw-alias-brand-primary, #2563eb);
+  transition: width .2s ease;
+}
+/* Health bands use the semantic colours the rest of the app already uses, so the
+   meaning does not depend on reading the label. */
+.dss-tone-good { background: var(--dsw-alias-state-success-primary, #1a9c50); }
+.dss-tone-warn { background: var(--dsw-alias-state-warning-primary, #d97706); }
+.dss-tone-bad { background: var(--dsw-alias-state-error-primary, #d93025); }
+.dss-statbar-value {
+  flex: none; width: 32px; text-align: right;
+  font-variant-numeric: tabular-nums; font-weight: 600;
+  color: var(--dsw-alias-label-secondary, #6b6b6b);
+}
 .dss-row {
   display: flex; align-items: center; gap: 10px; padding: 10px 12px;
   border-bottom: 1px solid var(--dsw-alias-border-l1, rgba(0,0,0,.06));
@@ -2251,7 +2379,12 @@ window.__ModuleLoader__.load({
       const [detail, setDetail] = useState(null)
       const [error, setError] = useState(null)
       const [busy, setBusy] = useState(null)
+      // Two-step confirm for the orphan sweep: the first click reports, the second
+      // deletes. Held in state so the button label can say which step it is on.
+      const [orphanArmed, setOrphanArmed] = useState(false)
       const [memoryDraft, setMemoryDraft] = useState('')
+      // Kept for the memory.add API path that the long-term screen still uses; the
+      // snapshot panel no longer renders a session-memory editor.
 
       useEffect(() => {
         let alive = true
@@ -2357,15 +2490,69 @@ window.__ModuleLoader__.load({
       )
 
       const stats = detail?.stats
+      // Split the list so the budget makes sense on screen.
+      //
+      // The header said "keeps the newest N automatic snapshots" while the list showed
+      // sixteen, and nothing explained the difference: ten were this session's own and
+      // six were inherited from the parent session by a rewind. Counting inherited
+      // entries against the budget would make a fork delete every snapshot it takes
+      // itself, so they are kept separately — but the user has to be told that, or the
+      // number looks like a bug.
+      const inheritedCount = (detail?.checkpoints ?? []).filter(cp => cp.inheritedFrom).length
       const statsLine = stats
         ? h(
             'div',
             { className: 'dss-row-meta' },
             h('span', null, t('settings.usage', { size: stats.label })),
             h('span', null, t('settings.budget', { keep: stats.budget })),
+            inheritedCount > 0
+              ? h('span', null, t('settings.budgetInherited', { n: inheritedCount }))
+              : null,
             detail.cwd ? h('span', { title: detail.cwd }, detail.cwd) : null,
           )
         : null
+      const budgetNote =
+        inheritedCount > 0
+          ? h('div', { className: 'dss-section-desc' }, t('settings.budgetNote', { keep: stats?.budget ?? 10 }))
+          : null
+
+      // Reclaiming snapshot directories of deleted sessions.
+      //
+      // `#prune` only runs when a session takes another snapshot, so a deleted
+      // session's directory is never revisited and its blobs are never freed. The
+      // first click reports what would go; the second confirms. A destructive action
+      // that also runs on a timer is how people lose data they did not know they had,
+      // so the timer only reports and this control is the only thing that deletes.
+      const orphanLine = h(
+        'div',
+        { className: 'dss-toolbar' },
+        h(
+          'button',
+          {
+            type: 'button',
+            className: 'dss-btn dss-small dss-ghost',
+            disabled: busy === 'orphans',
+            onClick: () =>
+              run('orphans', async () => {
+                const result = await call({ action: 'sweepOrphans', apply: orphanArmed })
+                if (result?.orphans === 0) {
+                  notify(t('settings.orphansNone'))
+                  setOrphanArmed(false)
+                  return
+                }
+                if (!orphanArmed) {
+                  notify(t('settings.orphansFound', { n: result.orphans, size: result.freed }))
+                  setOrphanArmed(true)
+                  return
+                }
+                notify(t('settings.orphansRemoved', { n: result.removed, size: result.freed }))
+                setOrphanArmed(false)
+                bump()
+              }, null),
+          },
+          orphanArmed ? t('settings.orphansConfirm') : t('settings.orphansSweep'),
+        ),
+      )
 
       const checkpoints = detail?.checkpoints ?? []
       const checkpointList =
@@ -2387,6 +2574,10 @@ window.__ModuleLoader__.load({
                       h('span', null, cp.label || cp.id),
                       cp.locked ? h('span', { className: 'dss-badge dss-locked' }, t('settings.locked')) : null,
                       cp.temporary ? h('span', { className: 'dss-badge dss-temp' }, t('settings.temporary')) : null,
+                      // Inherited snapshots are a different thing from this session's
+                      // own: they came from the parent by a rewind, they do not count
+                      // against the budget, and deleting the child does not delete them.
+                      cp.inheritedFrom ? h('span', { className: 'dss-badge' }, t('settings.inherited')) : null,
                     ),
                     h(
                       'div',
@@ -2489,63 +2680,15 @@ window.__ModuleLoader__.load({
             ),
           )
 
-      const memory = detail?.memory ?? []
-      const memoryBlock = h(
-        'div',
-        { style: { display: 'flex', flexDirection: 'column', gap: 8 } },
-        h('div', { className: 'dss-group-title' }, t('settings.memory')),
-        h(
-          'div',
-          { className: 'dss-card' },
-          memory.length === 0
-            ? h('div', { className: 'dss-empty' }, t('settings.memoryEmpty'))
-            : memory.map(entry =>
-                h(
-                  'div',
-                  { className: 'dss-row', key: entry.id },
-                  h('div', { className: 'dss-row-main' }, h('div', { className: 'dss-memory-text' }, entry.text), h('div', { className: 'dss-row-meta' }, h('span', null, new Date(entry.createdAt).toLocaleString()))),
-                  h(
-                    'div',
-                    { className: 'dss-row-actions' },
-                    h(
-                      'button',
-                      {
-                        type: 'button',
-                        className: 'dss-btn dss-small dss-ghost',
-                        title: t('settings.memoryRemove'),
-                        onClick: () => run(`mem:${entry.id}`, () => call({ action: 'memory.remove', sessionId: selected, id: entry.id }), t('toast.memoryRemoved')),
-                      },
-                      h(Icons.trash, { size: 14 }),
-                    ),
-                  ),
-                ),
-              ),
-        ),
-        h(
-          'div',
-          { className: 'dss-toolbar' },
-          h('input', {
-            className: 'dss-input',
-            value: memoryDraft,
-            placeholder: t('settings.memoryPlaceholder'),
-            onChange: event => setMemoryDraft(event.target.value),
-          }),
-          h(
-            'button',
-            {
-              type: 'button',
-              className: 'dss-btn dss-small',
-              disabled: !memoryDraft.trim() || !selected,
-              onClick: () =>
-                run('memory:add', async () => {
-                  await call({ action: 'memory.add', sessionId: selected, text: memoryDraft })
-                  setMemoryDraft('')
-                }, t('toast.memoryAdded')),
-            },
-            t('settings.memorySave'),
-          ),
-        ),
-      )
+      // The session-memory block was removed deliberately.
+      //
+      // It was a per-session list of loose facts, never written to, sitting next to a
+      // real trajectory view that the Host already provides. Two surfaces for "what
+      // happened in this session" — one authoritative and read-only, one a stub that
+      // nobody fed — invites the reader to trust the stub. The trajectory is the
+      // record of what happened and is not meant to be edited; a hand-written note
+      // beside it is a weaker duplicate. Removed rather than hidden so the panel does
+      // not advertise a capability it does not have.
 
       return h(
         'div',
@@ -2553,14 +2696,119 @@ window.__ModuleLoader__.load({
         head,
         picker,
         statsLine,
+        budgetNote,
         checkpointList,
         undoList,
-        memoryBlock,
+        orphanLine,
       )
     }
 
     // ------------------------------------------------------- long-term memory
 
+    /**
+     * One horizontal bar, drawn with a div rather than SVG.
+     *
+     * A bar chart of five rows does not need a charting library: a filled div inside
+     * a track is the whole implementation, it inherits the theme's colours, and it
+     * stays readable in both light and dark without any per-chart configuration. The
+     * value is printed next to the bar, because the bar communicates proportion and
+     * the number communicates quantity — one without the other is guesswork.
+     *
+     * @param {any} props row props
+     * @returns {any} row element
+     */
+    function StatBar(props) {
+      const { label, value, max, tone, hue } = props
+      const ratio = max > 0 ? Math.min(1, value / max) : 0
+      // `tone` is semantic (health bands); `hue` is positional (composition and tags).
+      // They are separate because one means "this is bad" and the other means "this is
+      // a different row" — conflating them would colour a healthy category red just
+      // because it happens to be fifth.
+      const fillClass = tone
+        ? ` dss-tone-${tone}`
+        : typeof hue === 'number'
+          ? ` dss-tone-c${hue % 6}`
+          : ''
+      return h(
+        'div',
+        { className: 'dss-statbar' },
+        h('div', { className: 'dss-statbar-label', title: String(label) }, label),
+        h(
+          'div',
+          { className: 'dss-statbar-track' },
+          h('div', {
+            className: `dss-statbar-fill${fillClass}`,
+            style: { width: `${Math.round(ratio * 100)}%` },
+          }),
+        ),
+        h('div', { className: 'dss-statbar-value' }, String(value)),
+      )
+    }
+
+    /**
+     * The memory summary: what the library is made of, and whether it is healthy.
+     *
+     * Each panel answers one question a reader would actually ask, and each implies a
+     * next action: a high rule count means maintenance is over-producing, a large
+     * "below threshold" band means decay is about to archive things, a lopsided tag
+     * list means one topic is crowding out the rest. Numbers nobody would act on are
+     * decoration; these are not.
+     *
+     * @param {any} props panel props
+     * @returns {any} summary element
+     */
+    function MemoryStats(props) {
+      const t = props.t ?? (key => key)
+      const stats = props.stats
+      if (!stats || typeof stats !== 'object') return null
+
+      const kinds = [
+        ['fact', stats.kind?.fact ?? 0],
+        ['rule', stats.kind?.rule ?? 0],
+        ['summary', stats.kind?.summary ?? 0],
+        ['episode', stats.kind?.episode ?? 0],
+      ].filter(([, count]) => count > 0)
+      const kindMax = Math.max(1, ...kinds.map(([, count]) => count))
+
+      const bands = [
+        ['high', stats.bands?.high ?? 0, 'good'],
+        ['mid', stats.bands?.mid ?? 0, 'warn'],
+        ['low', stats.bands?.low ?? 0, 'bad'],
+      ]
+      const bandMax = Math.max(1, ...bands.map(([, count]) => count))
+
+      const tagMax = Math.max(1, ...(stats.tags ?? []).map(item => item.count))
+
+      return h(
+        'div',
+        { className: 'dss-stats' },
+        h(
+          'div',
+          { className: 'dss-stats-panel' },
+          h('div', { className: 'dss-group-title' }, t('memory.statsKind')),
+          ...kinds.map(([kind, count], index) =>
+            h(StatBar, { key: kind, label: t(`memory.kind.${kind}`), value: count, max: kindMax, hue: index }),
+          ),
+        ),
+        h(
+          'div',
+          { className: 'dss-stats-panel' },
+          h('div', { className: 'dss-group-title' }, t('memory.statsHealth')),
+          ...bands.map(([band, count, tone]) =>
+            h(StatBar, { key: band, label: t(`memory.band.${band}`), value: count, max: bandMax, tone }),
+          ),
+        ),
+        h(
+          'div',
+          { className: 'dss-stats-panel dss-stats-wide' },
+          h('div', { className: 'dss-group-title' }, t('memory.statsTags')),
+          ...(stats.tags ?? []).slice(0, 6).map((item, index) =>
+            h(StatBar, { key: item.tag, label: item.tag, value: item.count, max: tagMax, hue: index }),
+          ),
+        ),
+      )
+    }
+
     function useWorkspacePath() {
       return runtime.resolveCwd?.() ?? runtime.cwd
     }
@@ -2947,6 +3195,9 @@ window.__ModuleLoader__.load({
       const [draftScope, setDraftScope] = useState('workspace')
       const [busy, setBusy] = useState(null)
       const [known, setKnown] = useState([])
+      // Aggregates for the summary charts, fetched separately so a slow list load
+      // never blocks the numbers from appearing.
+      const [stats, setStats] = useState(null)
       // Maintenance bookkeeping, so "did the timer ever run?" is a fact on
       // screen rather than something the user has to take on trust.
       const [maint, setMaint] = useState(null)
@@ -2964,7 +3215,39 @@ window.__ModuleLoader__.load({
       const [tagFilter, setTagFilter] = useState('')
       const [sinceFilter, setSinceFilter] = useState('')
 
+      // Which models can be called, loaded from the Host rather than from config.
+      //
+      // The list used to come from `settings.memoryModels`, which is a patch value —
+      // and this profile has no patch entry, so the picker offered only "off" and
+      // "use current" while the user had several working providers in
+      // Settings → 模型. The Host knows what it can actually call; ask it.
+      const [models, setModels] = useState(null)
+      useEffect(() => {
+        let alive = true
+        call({ action: 'longterm.models' })
+          .then(list => alive && setModels(Array.isArray(list) ? list : []))
+          .catch(() => alive && setModels([]))
+        return () => {
+          alive = false
+        }
+      }, [rev])
+
       const detected = useWorkspacePath()
+
+      // Turn a stored workspace key into a readable name.
+      //
+      // The badge used to say 「本工作区」 for every workspace-scoped row, so a list
+      // filtered to 全部 showed a dozen rows all claiming to be "this workspace" —
+      // including rows from other workspaces. The key is a one-way hash, so the name
+      // has to come from the registry, which is exactly what `longterm.workspaces`
+      // returns.
+      const workspaceLabel = key => {
+        if (!key) return t('memory.workspace')
+        const match = known.find(item => item.key === key)
+        if (!match) return t('memory.workspace')
+        const cwd = String(match.cwd ?? '')
+        return cwd.split(/[\\/]/).filter(Boolean).pop() ?? cwd ?? t('memory.workspace')
+      }
       const cwd = picked !== undefined ? picked : detected
 
       useEffect(() => {
@@ -2972,6 +3255,9 @@ window.__ModuleLoader__.load({
         call({ action: 'longterm.workspaces' })
           .then(list => alive && setKnown(Array.isArray(list) ? list : []))
           .catch(() => alive && setKnown([]))
+        call({ action: 'longterm.stats' })
+          .then(data => alive && setStats(data ?? null))
+          .catch(() => alive && setStats(null))
         return () => {
           alive = false
         }
@@ -3146,7 +3432,7 @@ window.__ModuleLoader__.load({
                     'div',
                     { className: 'dss-row-main' },
                     h('div', { className: 'dss-memory-text' }, item.text),
-                    h('div', { className: 'dss-row-meta' }, h('span', { className: 'dss-badge' }, item.scope === 'global' ? t('memory.global') : t('memory.workspace'))),
+                    h('div', { className: 'dss-row-meta' }, h('span', { className: 'dss-badge' }, item.scope === 'global' ? t('memory.global') : workspaceLabel(item.workspaceKey))),
                   ),
                   h(
                     'div',
@@ -3207,14 +3493,33 @@ window.__ModuleLoader__.load({
                       : null,
                   )
                 : null,
+              // Raw counts of what the Host actually delivered, so "nothing waiting"
+              // can be told apart from "the hook never fired". Without this the two
+              // states look identical on screen.
+              extraction
+                ? h(
+                    'div',
+                    { className: 'dss-row-meta' },
+                    h('span', null, t('memory.extractionEvents', { n: extraction.eventsSeen ?? 0 })),
+                    h('span', null, t('memory.extractionTurns', { n: extraction.turnEndsSeen ?? 0 })),
+                  )
+                : null,
             )
 
+      // The list gets its own scroll box.
+      //
+      // Without one, the whole page scrolled: fifty memories pushed the maintenance
+      // and model controls far below the fold, so changing a setting meant scrolling
+      // past the entire library first. A bounded box keeps the controls in place and
+      // makes the list the only thing that moves. The height is a deliberate starting
+      // point — roughly eight rows — chosen to leave the settings visible on a
+      // laptop screen; it is a single number, easy to retune.
       const listBlock =
         visible.length === 0
           ? h('div', { className: 'dss-empty' }, t('memory.empty'))
           : h(
               'div',
-              { className: 'dss-card' },
+              { className: 'dss-card dss-scroll-box' },
               ...visible.map(entry =>
                 h(
                   'div',
@@ -3226,7 +3531,7 @@ window.__ModuleLoader__.load({
                     h(
                       'div',
                       { className: 'dss-row-meta' },
-                      h('span', { className: 'dss-badge' + (entry.scope === 'global' ? ' dss-locked' : '') }, entry.scope === 'global' ? t('memory.global') : t('memory.workspace')),
+                      h('span', { className: 'dss-badge' + (entry.scope === 'global' ? ' dss-locked' : '') }, entry.scope === 'global' ? t('memory.global') : workspaceLabel(entry.workspaceKey)),
                       entry.kind === 'rule' ? h('span', { className: 'dss-badge dss-temp' }, t('memory.rule')) : null,
                       // An episode is a dated event, not a truth. Labelling it
                       // separately is what lets the user tell "this happened once"
@@ -3331,6 +3636,44 @@ window.__ModuleLoader__.load({
           }),
           h('span', { className: 'dss-curate-title' }, t('memory.implicit')),
         ),
+        // Which model does the background extraction call?
+        //
+        // This has to be an explicit choice. An earlier build silently fell back to
+        // the Host's default model whenever no chain was configured, which spends the
+        // user's tokens once per turn on a model they never picked for this job. A
+        // background cost has to be visible and opt-in, so the choice is a control
+        // with an explicit "off" that costs nothing.
+        h(
+          'div',
+          { className: 'dss-curate-field' },
+          h('label', { className: 'dss-curate-label' }, t('memory.implicitModel')),
+          h(
+            'select',
+            {
+              className: 'dss-select',
+              value: settings?.implicitModel ?? 'off',
+              disabled: busy === 'implicitModel',
+              onChange: event =>
+                run('implicitModel', () =>
+                  call({ action: 'longterm.settings', patch: { implicitModel: event.target.value } }),
+                ),
+            },
+            h('option', { value: 'off' }, t('memory.implicitModelOff')),
+            h('option', { value: 'current' }, t('memory.implicitModelCurrent')),
+            // Real models from the Host, grouped by provider so a long list stays
+            // readable. `models` is null while loading and [] when the Host reports
+            // none — both render no group, which is honest: the two above are the
+            // only choices that exist without a callable model.
+            ...(Array.isArray(models) ? models : []).map(entry =>
+              h(
+                'option',
+                { value: `${entry.provider}/${entry.model}`, key: `${entry.provider}/${entry.model}` },
+                entry.label ?? `${entry.provider}/${entry.model}`,
+              ),
+            ),
+          ),
+          h('div', { className: 'dss-curate-hint' }, t('memory.implicitModelHint')),
+        ),
         h(
           'button',
           {
@@ -3462,6 +3805,7 @@ window.__ModuleLoader__.load({
         { className: 'dss-section' },
         head,
         pendingBlock,
+        h(MemoryStats, { t, stats }),
         explainBlock,
         tabs,
         filterBlock,

package/index.js

@@ -170,8 +170,25 @@ export function apply(ctx, config = {}) {
   const sweepMs = numberOr(config.sweepIntervalMs, 5 * 60 * 1000)
   if (sweepMs > 0) {
     ctx.effect(() => {
+      // Snapshot directories of deleted sessions are never revisited by the
+      // per-session prune, so they accumulate. Checked here rather than deleted:
+      // reclaiming disk on a timer without a record of what went is not something to
+      // do unattended, so this only reports and the settings page applies it. The
+      // check runs a quarter as often as the sweep — it lists sessions, which is
+      // more expensive than expiring a file.
+      let tick = 0
       const timer = setInterval(() => {
         void service.sweep().catch(error => log('sweep failed', error))
+        tick += 1
+        if (tick % 4 !== 0) return
+        void service
+          .sweepOrphanCheckpoints(false)
+          .then(result => {
+            if (result?.orphans > 0) {
+              log(`orphan snapshots: ${result.orphans} session(s), ${result.freed} reclaimable`)
+            }
+          })
+          .catch(error => log('orphan snapshot check failed', error))
       }, sweepMs)
       timer.unref?.()
       return () => clearInterval(timer)

package/lib/api.js

@@ -307,6 +307,25 @@ async function respond(service, deps, action, input) {
       return json({ ok: true, data: await service.longTerm.status() })
     case 'longterm.workspaces':
       return json({ ok: true, data: await service.longTerm.workspaces() })
+    case 'longterm.models':
+      // The models this Host can actually call, straight from the llm service.
+      //
+      // The picker used to render `config.memoryModels`, a list that comes from the
+      // bundle patch — and a profile with no patch entry for this bundle therefore
+      // showed only "off" and "use current", no real models at all. The llm service
+      // is the authoritative source: it knows every provider route with a registered
+      // adapter and what each one advertises. Reading configuration to answer "what
+      // can I call" was the mistake.
+      return json({ ok: true, data: await service.longTermModels() })
+    case 'longterm.stats':
+      // Aggregates for the visual summary. Computed here rather than in the browser
+      // because the browser would have to fetch every row to count them, and the
+      // counts must match what the list shows — one source, one answer.
+      return json({ ok: true, data: await service.longTermStats() })
+    case 'sweepOrphans':
+      // `apply` must be explicit. A dry run is the default so a stray call can never
+      // delete snapshot directories, and the report says how much would be freed.
+      return json({ ok: true, data: await service.sweepOrphanCheckpoints(input.apply === true) })
     case 'longterm.settings':
       return json(
         input.patch

package/lib/checkpoints.js

@@ -652,6 +652,48 @@ export class CheckpointStore {
     }
   }
 
+  /**
+   * Find and remove snapshot directories whose session no longer exists.
+   *
+   * `#prune` only runs when a session takes another snapshot, so a session that is
+   * deleted — or removed by another tool — leaves its whole directory behind: index,
+   * manifests, and blobs. Nothing ever revisits it. The blobs are content-addressed
+   * and can be large, so this is real disk, not just clutter.
+   *
+   * The test for "orphan" is deliberately conservative: a directory is only removed
+   * when the Host has no session log for that id. A session that exists but has no
+   * snapshots yet is not an orphan, and a session whose log is temporarily unreadable
+   * must not be treated as gone — so the caller supplies the set of live ids rather
+   * than this module guessing at the Host's layout.
+   *
+   * @param {object} input input
+   * @param {Set<string>} input.liveSessionIds ids that still exist
+   * @param {boolean} [input.apply] delete for real; false only reports
+   * @returns {Promise<{ orphans: string[], removed: number, bytes: number }>} result
+   */
+  async sweepOrphans({ liveSessionIds, apply = false }) {
+    const ids = await this.#sessionIds()
+    const orphans = ids.filter(id => !liveSessionIds.has(id))
+
+    let bytes = 0
+    for (const id of orphans) {
+      bytes += await dirSize(this.sessionDir(id)).catch(() => 0)
+    }
+
+    let removed = 0
+    if (apply) {
+      for (const id of orphans) {
+        try {
+          await removeDir(this.sessionDir(id))
+          removed += 1
+        } catch {
+          /* one failure must not stop the sweep */
+        }
+      }
+    }
+    return { orphans, removed, bytes }
+  }
+
   async #sessionIds() {
     try {
       const entries = await fs.readdir(path.join(this.root, 'sessions'), { withFileTypes: true })

package/lib/memory-host.js

@@ -205,9 +205,32 @@ export function installMemory({ ctx, root, config, log }) {
     ctx.effect(
       () =>
         ctx.on('session/event', (session, event) => {
+          // Count what arrives, not just what is acted on.
+          //
+          // The queue stayed empty for an entire session and the reason could have
+          // been any of: the listener never fired, it fired but saw no `turn/end`,
+          // `session.id` was not the shape assumed, or extraction ran and refused.
+          // Each has a different fix, so the trace records which one happened.
+          //
+          // These counters are published IMMEDIATELY, not in the finally below. The
+          // first version only published after extraction ran, so a session where the
+          // hook never fired left `lastExtraction` null and the settings page showed
+          // no counters at all — the diagnostic could not report the one case it
+          // existed for.
+          extractionTrace.eventsSeen = (extractionTrace.eventsSeen ?? 0) + 1
+          extractionTrace.at = Date.now()
+          publishExtractionTrace(engine)
           if (!event || event.type !== 'turn/end') return
+          extractionTrace.turnEndsSeen = (extractionTrace.turnEndsSeen ?? 0) + 1
+          publishExtractionTrace(engine)
+          // A branded id is still a string at runtime; accept any non-empty one and
+          // report the actual shape when it is not.
           const sessionId = session?.id
-          if (typeof sessionId !== 'string') return
+          if (typeof sessionId !== 'string' || !sessionId) {
+            extractionTrace.reason = `a turn ended but the session id was ${typeof sessionId}`
+            publishExtractionTrace(engine)
+            return
+          }
           const cwd = resolveCwd(ctx, session)
           void extractAfterTurn({ ctx, engine, sessionId, cwd, log, config })
             // The trace is published in a finally so a thrown error still leaves a
@@ -494,6 +517,12 @@ const extractionTrace = {
 
 /** @param {string} sessionId session being processed */
 function resetExtractionTrace(sessionId) {
+  // The counters survive a reset on purpose. They measure whether the hook is being
+  // called at all, which is a property of the process, not of one extraction attempt:
+  // clearing them here made every attempt look like the first one and erased the
+  // evidence the diagnostic exists to collect.
+  const eventsSeen = extractionTrace.eventsSeen ?? 0
+  const turnEndsSeen = extractionTrace.turnEndsSeen ?? 0
   extractionTrace.sessionId = sessionId
   extractionTrace.at = Date.now()
   extractionTrace.ok = false
@@ -503,6 +532,8 @@ function resetExtractionTrace(sessionId) {
   extractionTrace.produced = 0
   extractionTrace.queued = 0
   extractionTrace.rejected = 0
+  extractionTrace.eventsSeen = eventsSeen
+  extractionTrace.turnEndsSeen = turnEndsSeen
 }
 
 /**
@@ -553,8 +584,14 @@ async function extractAfterTurn({ ctx, engine, sessionId, cwd, log, config }) {
   // The memory model is a fallback chain: a free provider that is rate limited
   // (429) or unreachable must not silently disable extraction for the session,
   // so every candidate is tried in order until one answers.
-  const candidates = memoryCandidates(config)
-  if (candidates.length === 0) return failExtraction('no memoryModels chain is configured')
+  const candidates = memoryCandidates(config, ctx)
+  if (candidates.length === 0) {
+    return failExtraction(
+      config?.implicitModel === 'current'
+        ? 'the Host exposes no default model to fall back to'
+        : 'implicit extraction has no model configured — choose one in Settings → 长期记忆 (隐式提取)',
+    )
+  }
   extractionTrace.candidates = candidates.map(candidate => `${candidate.provider}/${candidate.model}`)
 
   // The prompt asks for two different shapes, because the library stores two
@@ -709,7 +746,7 @@ function numberOr(value, fallback) {
  * @param {any} config plugin config
  * @returns {{ provider: string, model: string }[]} candidates in priority order
  */
-function memoryCandidates(config) {
+function memoryCandidates(config, ctx) {
   const raw = []
   const push = value => {
     if (Array.isArray(value)) raw.push(...value)
@@ -717,6 +754,37 @@ function memoryCandidates(config) {
   }
   push(config?.memoryModels)
   push(config?.memoryModel)
+  // A single explicit pick, stored by the settings UI as "provider/model".
+  //
+  // This is the "one model, chosen here" case: the user picked a specific entry from
+  // the offered chain, and that pick must beat the chain (which is a fallback list,
+  // not a preference). Parsed on the last slash so a model id that itself contains a
+  // slash — "Qwen/Qwen2.5-7B-Instruct" — survives intact.
+  const picked = typeof config?.implicitModel === 'string' ? config.implicitModel : ''
+  if (picked && picked !== 'current' && picked !== 'off') {
+    const at = picked.indexOf('/')
+    if (at > 0 && at < picked.length - 1) {
+      raw.unshift({ provider: picked.slice(0, at), model: picked.slice(at + 1) })
+    }
+  }
+  // Falling back to the Host's own default model is OFF unless the user asks for it.
+  //
+  // An earlier version did this unconditionally, to fix "extraction never runs when
+  // no chain is configured". That traded one bug for a worse one: it spends the
+  // user's tokens on a model they never chose for this purpose, once per turn,
+  // silently. Background spending has to be opted into — so the fallback requires
+  // `implicitModel: 'current'` and otherwise returns nothing, leaving extraction off
+  // with a reason the user can read.
+  if (raw.length === 0 && ctx && picked === 'current') {
+    try {
+      const selection = ctx.get('agentDefaultModel')?.currentSelection?.()
+      if (selection?.provider && selection?.model) {
+        raw.push({ provider: selection.provider, model: selection.model })
+      }
+    } catch {
+      /* a Host without the service just means no fallback */
+    }
+  }
   const out = []
   const seen = new Set()
   for (const entry of raw) {

package/lib/service.js

@@ -159,6 +159,9 @@ export class SessionSuiteService {
         label: formatBytes(stats.bytes),
         checkpoints: stats.checkpoints,
         budget: this.config.keep ?? 10,
+        // Counted here so the UI does not have to re-derive it from the rows it
+        // renders — and so the number exists even if a future change filters rows.
+        inherited: checkpoints.filter(item => item.inheritedFrom).length,
       },
       undos: await this.listUndos(sessionId),
     }
@@ -959,6 +962,149 @@ export class SessionSuiteService {
     return { sessionId, restored: true }
   }
 
+  /**
+   * Remove snapshot directories belonging to sessions that no longer exist.
+   *
+   * The live set comes from the Host's own session listing, not from our own files:
+   * a session that exists but has not snapshotted anything must not be mistaken for a
+   * dead one, and the Host is the only authority on what exists.
+   *
+   * @param {boolean} [apply] delete for real; false only reports
+   * @returns {Promise<{ orphans: number, removed: number, bytes: number, freed: string }>} result
+   */
+  async sweepOrphanCheckpoints(apply = false) {
+    const live = new Set()
+    try {
+      const controller = this.#service('sessionController')
+      const value = await controller?.list?.({})
+      for (const item of Array.isArray(value?.items) ? value.items : []) {
+        if (typeof item?.sessionId === 'string') live.add(item.sessionId)
+      }
+    } catch (error) {
+      // Without a trustworthy live set, doing nothing is the only safe answer: every
+      // directory would look like an orphan and the sweep would delete everything.
+      this.log('could not list live sessions; refusing to sweep', error)
+      throw new Error('could not list live sessions, so the orphan sweep was refused')
+    }
+    const result = await this.store.sweepOrphans({ liveSessionIds: live, apply })
+    return {
+      orphans: result.orphans.length,
+      removed: result.removed,
+      bytes: result.bytes,
+      freed: formatBytes(result.bytes),
+    }
+  }
+
+  /**
+   * Aggregate counts for the memory summary.
+   *
+   * Every figure here answers a question a reader actually asks about their own
+   * library: what is it made of (kind), where does it live (scope), how healthy is it
+   * (state and score bands), what is it about (tags). A dashboard that shows numbers
+   * nobody would act on is decoration; these five all imply a next action — a rule
+   * count too high means maintenance is over-producing, a low score band means decay
+   * is about to archive things, a lopsided tag means one topic is crowding the rest.
+   *
+   * @returns {Promise<any>} aggregates
+   */
+  async longTermStats() {
+    // `this.memory` is the per-session MemoryLedger, NOT the long-term engine — that
+    // one is assigned later as `this.longTerm`. Reading the wrong object is why every
+    // figure came back zero while the list showed 55 rows: the ledger is empty by
+    // design, so the summary was honestly reporting an empty library that the panel
+    // next to it was simultaneously disproving.
+    const engine = this.longTerm
+    if (!engine?.list) {
+      return { total: 0, active: 0, archived: 0, kind: {}, scope: {}, privacy: {}, bands: { high: 0, mid: 0, low: 0 }, tags: [] }
+    }
+    const rows = await engine.list({ scope: 'all' })
+    const active = rows.filter(row => row.archived !== true)
+
+    /** @param {any[]} list @param {(row: any) => string} key @returns {Record<string, number>} */
+    const tally = (list, key) => {
+      const out = {}
+      for (const row of list) {
+        const value = key(row)
+        out[value] = (out[value] ?? 0) + 1
+      }
+      return out
+    }
+
+    // Score bands match the engine's own thresholds so the chart and the behaviour
+    // agree: >=0.6 is comfortably alive, 0.45-0.6 is approaching the compress line,
+    // <0.45 is at or below it and is what maintenance will compress next.
+    const bands = { high: 0, mid: 0, low: 0 }
+    for (const row of active) {
+      const score = Number(row.score ?? 0)
+      if (score >= 0.6) bands.high += 1
+      else if (score >= 0.45) bands.mid += 1
+      else bands.low += 1
+    }
+
+    const tags = Object.entries(tally(active, row => (Array.isArray(row.tags) && row.tags[0]) || '未分类'))
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 10)
+      .map(([tag, count]) => ({ tag, count }))
+
+    return {
+      total: rows.length,
+      active: active.length,
+      archived: rows.length - active.length,
+      kind: tally(rows, row => row.kind ?? 'fact'),
+      scope: tally(rows, row => row.scope ?? 'workspace'),
+      privacy: tally(rows, row => row.privacy ?? 'internal'),
+      bands,
+      tags,
+    }
+  }
+
+  /**
+   * Every model this Host can actually call, for the extraction picker.
+   *
+   * Read from the `llm` service, not from configuration. The picker used to render
+   * `config.memoryModels` — a list supplied by the bundle patch — so a profile with no
+   * patch entry for this bundle offered only "off" and "use current" and no real
+   * models, even though the user had several providers configured and working in
+   * Settings → 模型. What can be called is the llm service's answer to give; a config
+   * file only says what someone once wrote down.
+   *
+   * @returns {Promise<Array<{ provider: string, model: string, label: string }>>} models
+   */
+  async longTermModels() {
+    const llm = this.ctx.get?.('llm')
+    if (!llm) return []
+    const out = []
+    let providers = []
+    try {
+      providers = await llm.listProviders?.() ?? []
+    } catch (error) {
+      this.log('could not list llm providers', error)
+      return []
+    }
+    for (const provider of providers) {
+      const id = provider?.id
+      if (typeof id !== 'string' || !id) continue
+      let models = []
+      try {
+        models = await llm.listModels?.(id) ?? []
+      } catch (error) {
+        // One provider failing to advertise must not empty the whole picker.
+        this.log(`could not list models for ${id}`, error)
+        continue
+      }
+      for (const model of models) {
+        const modelId = model?.id
+        if (typeof modelId !== 'string' || !modelId) continue
+        out.push({
+          provider: id,
+          model: modelId,
+          label: `${provider?.name ?? id} · ${model?.name ?? modelId}`,
+        })
+      }
+    }
+    return out
+  }
+
   /**
    * The set of archived session ids, read from the registry that owns them.
    *
@@ -1082,6 +1228,13 @@ function decorateCheckpoint(checkpoint) {
     temporary: Boolean(checkpoint.expiresAt),
     expiresAt: checkpoint.expiresAt ?? null,
     skipped: checkpoint.skipped ?? 0,
+    // Inherited snapshots came from the parent session by a rewind, and they are
+    // EXEMPT from this session's keep-budget. The UI has to know that: without the
+    // flag it cannot explain why a session with a budget of 10 shows sixteen rows,
+    // which reads as a prune bug rather than as the intended behaviour. This field
+    // was silently dropped by this whitelist — every field not listed here never
+    // reaches the browser.
+    inheritedFrom: checkpoint.inheritedFrom ?? null,
   }
 }
 

package/package.json

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