@heixui/dsh-session-suite 0.8.0 → 0.8.2

package/client.js

@@ -56,6 +56,14 @@ window.__ModuleLoader__.load({
         'share.hint': 'Choose the turns to include.',
         'share.all': 'Select all',
         'share.none': 'Clear',
+        'share.recentLabel': 'Newest',
+        'share.recentApply': 'Select',
+        'share.searchPlaceholder': 'Search a turn number or text…',
+        'share.searchHit': '{n} of {total} turns match',
+        'share.pageFirst': 'First',
+        'share.pagePrev': 'Prev',
+        'share.pageNext': 'Next',
+        'share.pageLast': 'Last',
         'share.selected': '{count} of {total} turns selected',
         'share.image': 'Image',
         'share.html': 'Web page',
@@ -305,6 +313,14 @@ window.__ModuleLoader__.load({
         'share.hint': '选择要包含的对话轮次。',
         'share.all': '全选',
         'share.none': '清空',
+        'share.recentLabel': '最近',
+        'share.recentApply': '选中',
+        'share.searchPlaceholder': '搜索轮次号或文字…',
+        'share.searchHit': '匹配 {n} / {total} 轮',
+        'share.pageFirst': '首页',
+        'share.pagePrev': '上一页',
+        'share.pageNext': '下一页',
+        'share.pageLast': '末页',
         'share.selected': '已选 {count} / {total} 轮',
         'share.image': '生成图片',
         'share.html': '网页文件',
@@ -1115,6 +1131,26 @@ window.__ModuleLoader__.load({
 .dss-badge.dss-temp { background: color-mix(in srgb, var(--dsw-alias-state-warn-primary, #b07b00) 16%, transparent); color: var(--dsw-alias-state-warn-primary, #b07b00); }
 .dss-empty { padding: 18px 12px; font-size: 13px; color: var(--dsw-alias-label-secondary, #6b6b6b); }
 .dss-toolbar { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
+/* "Newest N" shortcut: sits at the end of the selection toolbar. The box is small on
+   purpose — it takes a turn count, not free text. */
+.dss-recent { display: flex; align-items: center; gap: 6px; margin-left: auto; }
+.dss-recent-label { font-size: 12px; color: var(--dsw-alias-label-secondary, #6b6b6b); white-space: nowrap; }
+.dss-recent-input { width: 72px; flex: 0 0 auto; text-align: right; }
+/* Turn picker: search box, a fixed 10-row page, and a pager. The picker itself keeps
+   its own scroll as a fallback for short viewports, but the page is bounded so the
+   dialog height no longer depends on how long the conversation is. */
+.dss-picker-wrap { display: flex; flex-direction: column; gap: 8px; min-height: 0; }
+.dss-picker-filter { display: flex; align-items: center; gap: 8px; }
+.dss-picker-search { flex: 1 1 auto; min-width: 0; }
+.dss-picker-hit { font-size: 12px; color: var(--dsw-alias-label-secondary, #6b6b6b); white-space: nowrap; }
+.dss-pager {
+  display: flex; align-items: center; justify-content: center; gap: 6px;
+  padding-top: 4px; font-size: 12px;
+  color: var(--dsw-alias-label-secondary, #6b6b6b);
+}
+.dss-pager-pos { display: flex; align-items: center; gap: 4px; }
+.dss-pager-input { width: 56px; text-align: center; }
+.dss-pager-total { font-variant-numeric: tabular-nums; }
 .dss-select {
   height: 30px; border-radius: 8px; padding: 0 8px; font-size: 13px;
   border: 1px solid var(--dsw-alias-border-l2, rgba(0,0,0,.12));
@@ -1362,7 +1398,21 @@ window.__ModuleLoader__.load({
       }, [])
       const all = useCallback(() => setSelected(new Set((outline?.turns ?? []).map(row => row.turn))), [outline])
       const none = useCallback(() => setSelected(new Set()), [])
-      return { selected, toggle, all, none }
+      // Select the newest N turns. Turn numbers ascend with the conversation, so
+      // "recent" means the highest N — sorting rather than slicing by array position,
+      // because the outline order is not guaranteed to be the turn order.
+      const recent = useCallback(
+        count => {
+          const rows = outline?.turns ?? []
+          const keep = [...rows]
+            .sort((a, b) => b.turn - a.turn)
+            .slice(0, Math.max(1, count))
+            .map(row => row.turn)
+          setSelected(new Set(keep))
+        },
+        [outline],
+      )
+      return { selected, toggle, all, none, recent }
     }
 
     function rangesOf(outline, selected) {
@@ -1371,37 +1421,149 @@ window.__ModuleLoader__.load({
         .map(row => ({ startSeq: row.startSeq, endSeq: row.endSeq }))
     }
 
+    const TURNS_PER_PAGE = 10
+
     function TurnPicker({ outline, selected, onToggle, t }) {
-      const turns = outline?.turns ?? []
+      const raw = outline?.turns ?? []
+      // Newest first. Turn numbers ascend with the conversation, so sorting descending
+      // puts the turn you just had on page 1 — which is what anyone opening this dialog
+      // expects. The outline itself arrives oldest-first because that is the log order.
+      const turns = [...raw].sort((a, b) => b.turn - a.turn)
+      // Page + filter state live here, so paging does not reset when a box is ticked.
+      const [page, setPage] = useState(1)
+      const [query, setQuery] = useState('')
+
       if (turns.length === 0) return h('div', { className: 'dss-empty' }, t('settings.empty'))
+
+      // Search matches the turn number or either side's text. Matching the NUMBER as a
+      // string is deliberate: typing "141" is how a user names a specific turn, and a
+      // substring match finds it alongside any turn whose text mentions 141.
+      const needle = query.trim().toLowerCase()
+      const matched = needle
+        ? turns.filter(row => {
+            if (String(row.turn).includes(needle)) return true
+            const hay = `${row.preview ?? ''} ${row.answerPreview ?? ''}`.toLowerCase()
+            return hay.includes(needle)
+          })
+        : turns
+
+      const pageCount = Math.max(1, Math.ceil(matched.length / TURNS_PER_PAGE))
+      // Clamp rather than store a valid page: the filter can shrink the list under the
+      // current page, and showing an empty page would look like the search found nothing.
+      const current = Math.min(Math.max(1, page), pageCount)
+      const from = (current - 1) * TURNS_PER_PAGE
+      const visible = matched.slice(from, from + TURNS_PER_PAGE)
+
+      const go = next => setPage(Math.min(Math.max(1, next), pageCount))
+
       return h(
         'div',
-        { className: 'dss-picker' },
-        ...turns.map(row => {
-          const checked = selected.has(row.turn)
-          return h(
-            'label',
-            { key: row.turn, className: 'dss-pick' + (checked ? ' dss-pick-on' : '') },
-            h('input', { type: 'checkbox', checked, onChange: () => onToggle(row.turn) }),
-            h(
-              'span',
-              { className: 'dss-pick-main' },
-              h('span', { className: 'dss-pick-title' }, `${t('settings.turn', { turn: row.turn })} · ${row.preview || '—'}`),
-              row.answerPreview ? h('span', { className: 'dss-pick-sub' }, row.answerPreview) : null,
-            ),
-          )
-        }),
+        { className: 'dss-picker-wrap' },
+        h(
+          'div',
+          { className: 'dss-picker-filter' },
+          h('input', {
+            type: 'search',
+            className: 'dss-input dss-picker-search',
+            value: query,
+            placeholder: t('share.searchPlaceholder'),
+            onChange: event => {
+              setQuery(event.target.value)
+              setPage(1)
+            },
+          }),
+          needle
+            ? h('span', { className: 'dss-picker-hit' }, t('share.searchHit', { n: matched.length, total: turns.length }))
+            : null,
+        ),
+        h(
+          'div',
+          { className: 'dss-picker' },
+          ...visible.map(row => {
+            const checked = selected.has(row.turn)
+            return h(
+              'label',
+              { key: row.turn, className: 'dss-pick' + (checked ? ' dss-pick-on' : '') },
+              h('input', { type: 'checkbox', checked, onChange: () => onToggle(row.turn) }),
+              h(
+                'span',
+                { className: 'dss-pick-main' },
+                h(
+                  'span',
+                  { className: 'dss-pick-title' },
+                  `${t('settings.turn', { turn: row.turn })} · ${row.preview || '—'}`,
+                ),
+                row.answerPreview ? h('span', { className: 'dss-pick-sub' }, row.answerPreview) : null,
+              ),
+            )
+          }),
+        ),
+        // Paging controls. A page number input rather than only prev/next, because
+        // scrolling 146 rows to reach turn 3 is exactly what the user objected to.
+        pageCount > 1
+          ? h(
+              'div',
+              { className: 'dss-pager' },
+              h('button', { type: 'button', className: 'dss-btn dss-small dss-ghost', disabled: current <= 1, onClick: () => go(1) }, t('share.pageFirst')),
+              h('button', { type: 'button', className: 'dss-btn dss-small dss-ghost', disabled: current <= 1, onClick: () => go(current - 1) }, t('share.pagePrev')),
+              h(
+                'span',
+                { className: 'dss-pager-pos' },
+                h('input', {
+                  type: 'number',
+                  min: 1,
+                  max: pageCount,
+                  className: 'dss-input dss-pager-input',
+                  value: current,
+                  onChange: event => {
+                    const value = Number.parseInt(event.target.value, 10)
+                    if (Number.isFinite(value)) go(value)
+                  },
+                }),
+                h('span', { className: 'dss-pager-total' }, `/ ${pageCount}`),
+              ),
+              h('button', { type: 'button', className: 'dss-btn dss-small dss-ghost', disabled: current >= pageCount, onClick: () => go(current + 1) }, t('share.pageNext')),
+              h('button', { type: 'button', className: 'dss-btn dss-small dss-ghost', disabled: current >= pageCount, onClick: () => go(pageCount) }, t('share.pageLast')),
+            )
+          : null,
       )
     }
 
-    function SelectionToolbar({ t, outline, selected, onAll, onNone }) {
+    function SelectionToolbar({ t, outline, selected, onAll, onNone, onRecent }) {
       const total = outline?.turns?.length ?? 0
+      // A "last N turns" box, because "select all" then unticking forty checkboxes is
+      // not a workflow. The number is a shortcut into the SAME selection set — it does
+      // not change what gets exported, only which rows start ticked.
+      const [recent, setRecent] = useState('')
+      const apply = () => {
+        const count = Number.parseInt(recent, 10)
+        if (!Number.isFinite(count) || count <= 0) return
+        onRecent(count)
+      }
       return h(
         'div',
         { className: 'dss-toolbar' },
         h('span', { className: 'dss-group-title' }, t('share.selected', { count: selected.size, total })),
         h('button', { type: 'button', className: 'dss-btn dss-small dss-ghost', onClick: onAll }, t('share.all')),
         h('button', { type: 'button', className: 'dss-btn dss-small dss-ghost', onClick: onNone }, t('share.none')),
+        h(
+          'div',
+          { className: 'dss-recent' },
+          h('span', { className: 'dss-recent-label' }, t('share.recentLabel')),
+          h('input', {
+            type: 'number',
+            min: 1,
+            max: total,
+            className: 'dss-input dss-recent-input',
+            value: recent,
+            placeholder: String(Math.min(10, total || 10)),
+            onChange: event => setRecent(event.target.value),
+            onKeyDown: event => {
+              if (event.key === 'Enter') apply()
+            },
+          }),
+          h('button', { type: 'button', className: 'dss-btn dss-small', onClick: apply }, t('share.recentApply')),
+        ),
       )
     }
 
@@ -1857,7 +2019,7 @@ window.__ModuleLoader__.load({
     function ShareDialog({ state, onClose }) {
       const t = state.t ?? (key => key)
       const { loading, outline, error } = useOutline(state.sessionId)
-      const { selected, toggle, all, none } = useTurnSelection(outline)
+      const { selected, toggle, all, none, recent } = useTurnSelection(outline)
       const [busy, setBusy] = useState(null)
       const [note, setNote] = useState(null)
       const [finalOnly, setFinalOnly] = useState(true)
@@ -1923,7 +2085,7 @@ window.__ModuleLoader__.load({
             : h(
                 React.Fragment,
                 null,
-                h(SelectionToolbar, { t, outline, selected, onAll: all, onNone: none }),
+                h(SelectionToolbar, { t, outline, selected, onAll: all, onNone: none, onRecent: recent }),
                 h('div', { className: 'dss-dialog-scroll dss-picker-scroll' }, h(TurnPicker, { outline, selected, onToggle: toggle, t })),
                 h(
                   'label',
@@ -1979,7 +2141,7 @@ window.__ModuleLoader__.load({
     function SegmentDialog({ state, onClose }) {
       const t = state.t ?? (key => key)
       const { loading, outline, error } = useOutline(state.sessionId)
-      const { selected, toggle, all, none } = useTurnSelection(outline)
+      const { selected, toggle, all, none, recent } = useTurnSelection(outline)
       const [busy, setBusy] = useState(false)
       const [problem, setProblem] = useState(null)
 
@@ -2020,7 +2182,7 @@ window.__ModuleLoader__.load({
             : h(
                 React.Fragment,
                 null,
-                h(SelectionToolbar, { t, outline, selected, onAll: all, onNone: none }),
+                h(SelectionToolbar, { t, outline, selected, onAll: all, onNone: none, onRecent: recent }),
                 h('div', { className: 'dss-dialog-scroll dss-picker-scroll' }, h(TurnPicker, { outline, selected, onToggle: toggle, t })),
                 partial ? h('div', { className: 'dss-warn' }, t('segment.warning')) : null,
                 picked.length === turns.length && turns.length > 0 ? h('div', { className: 'dss-warn' }, t('segment.whole')) : null,
@@ -3103,8 +3265,10 @@ window.__ModuleLoader__.load({
           'div',
           { className: 'dss-nav' },
           row('snapshots', t('panel.snapshots'), t('panel.snapshotsHint'), counts?.snapshots),
-          // The memory screen is omitted entirely when the engine is off: it would
-          // open onto a disabled backend and report LONGTERM_DISABLED in red.
+          // The memory screen is shown whenever the engine is running. It was hidden
+          // for a while when the engine was off by default; now that the engine is on
+          // by default again, the row belongs here unconditionally — the engine is
+          // this bundle's own long-term memory, not a competing plugin's.
           counts?.memoryEnabled === true
             ? row('memory', t('panel.memory'), t('panel.memoryHint'), counts?.memories)
             : null,
@@ -3245,7 +3409,6 @@ window.__ModuleLoader__.load({
       const rev = useStore(revision)
       const [tab, setTab] = useState('all')
       const [items, setItems] = useState(null)
-      const [pending, setPending] = useState([])
       const [settings, setSettings] = useState(null)
       const [error, setError] = useState(null)
       const [draft, setDraft] = useState('')
@@ -3274,20 +3437,12 @@ window.__ModuleLoader__.load({
 
       // 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])
+      // The model list is no longer fetched.
+      //
+      // It existed only to populate the "model for automatic extraction" picker, which
+      // is gone along with the background extraction pipeline. Asking the Host for the
+      // full model catalogue on every panel refresh was a real cost for a control that
+      // no longer exists.
 
       const detected = useWorkspacePath()
 
@@ -3331,14 +3486,12 @@ window.__ModuleLoader__.load({
             ...(tagFilter ? { tag: tagFilter } : {}),
             ...(sinceFilter ? { sinceDays: Number(sinceFilter) } : {}),
           }),
-          call({ action: 'longterm.pending', cwd }),
           call({ action: 'longterm.settings' }),
           call({ action: 'longterm.status' }).catch(() => null),
         ])
-          .then(([list, waiting, config, status]) => {
+          .then(([list, config, status]) => {
             if (!alive) return
             setItems(list)
-            setPending(waiting)
             setSettings(config)
             setMaint(status)
           })
@@ -3478,141 +3631,17 @@ window.__ModuleLoader__.load({
       // because a hook that never installed cannot write a trace — that is the whole
       // point: "no trace" has two causes and this separates them.
       const installStatus = Array.isArray(status?.install) ? status.install : []
-      const pendingBlock =
-        pending.length > 0
-          ? h(
-              'div',
-              { className: 'dss-mem-pending' },
-              h('div', { className: 'dss-group-title' }, t('memory.pendingTitle')),
-              h('div', { className: 'dss-mem-pending-hint' }, t('memory.pendingHint')),
-              ...pending.map(item =>
-                h(
-                  'div',
-                  { className: 'dss-row', key: item.id },
-                  h(
-                    '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') : workspaceLabel(item.workspaceKey))),
-                  ),
-                  h(
-                    'div',
-                    { className: 'dss-row-actions' },
-                    h(
-                      'button',
-                      {
-                        type: 'button',
-                        className: 'dss-btn dss-small dss-primary',
-                        disabled: busy === `keep:${item.id}`,
-                        onClick: () => run(`keep:${item.id}`, () => call({ action: 'longterm.settle', id: item.id, accept: true }), t('memory.accepted')),
-                      },
-                      t('memory.accept'),
-                    ),
-                    h(
-                      'button',
-                      {
-                        type: 'button',
-                        className: 'dss-btn dss-small dss-ghost',
-                        disabled: busy === `drop:${item.id}`,
-                        onClick: () => run(`drop:${item.id}`, () => call({ action: 'longterm.settle', id: item.id, accept: false }), t('memory.rejected')),
-                      },
-                      t('memory.reject'),
-                    ),
-                  ),
-                ),
-              ),
-            )
-          : 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-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,
-              // 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.
-              //
-              // `registered` is the third state: the hook was never installed at all
-              // (the optional registration threw), which is a different bug from
-              // "installed but never called".
-              //
-              // This block renders even when `extraction` is null, and says so. The
-              // previous version was gated on `extraction` being present — so a Host
-              // that never recorded a trace (registration failed, or the status
-              // endpoint reads a different engine) showed nothing at all, which is
-              // exactly the case the diagnostic existed to expose.
-              //
-              // Rendered at a readable size rather than in the row-meta micro type:
-              // it is a diagnostic, and a diagnostic nobody can find is the same as
-              // no diagnostic. The 11px meta line was reported as "I don't see it".
-              h(
-                'div',
-                { className: 'dss-extraction-diag' },
-                h('span', { className: 'dss-diag-title' }, t('memory.diagTitle')),
-                h(
-                  'span',
-                  null,
-                  extraction
-                    ? t('memory.extractionEvents', { n: extraction.eventsSeen ?? 0 })
-                    : t('memory.extractionNoTrace'),
-                ),
-                extraction
-                  ? h('span', null, t('memory.extractionTurns', { n: extraction.turnEndsSeen ?? 0 }))
-                  : null,
-                extraction
-                  ? h(
-                      'span',
-                      null,
-                      extraction.registered
-                        ? t('memory.extractionRegistered')
-                        : t('memory.extractionNotRegistered'),
-                    )
-                  : null,
-                // The registration ledger: which optional hooks installed and which
-                // threw. This is the only way to see a step that never ran, because the
-                // code that would have reported it is the code that failed.
-                installStatus.length > 0
-                  ? h(
-                      'span',
-                      { className: 'dss-diag-steps' },
-                      t('memory.diagSteps', {
-                        ok: installStatus.filter(step => step.ok).length,
-                        total: installStatus.length,
-                      }),
-                      installStatus
-                        .filter(step => !step.ok)
-                        .map(step => ` · ${step.label}: ${step.error ?? 'failed'}`)
-                        .join(''),
-                    )
-                  : null,
-              ),
-            )
+      // The "suggested memories" panel is REMOVED.
+      //
+      // It existed to review suggestions produced by a per-turn extraction pipeline —
+      // a background model call that never once produced a suggestion across seven
+      // attempts, and whose replacement crashed the Host. Memories are now written
+      // directly by the model calling the `remember` tool, so there is nothing to
+      // "confirm": a stored memory is already a memory, visible in the list below.
+      //
+      // Kept as a null constant rather than deleted outright so the render site below
+      // stays untouched and the diff stays small.
+      const pendingBlock = null
 
       // The list gets its own scroll box.
       //
@@ -3748,40 +3777,13 @@ window.__ModuleLoader__.load({
         //
         // 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')),
-        ),
+        // The "model for automatic extraction" selector is REMOVED.
+        //
+        // It configured which model a background per-turn extraction call would use.
+        // That pipeline no longer exists: memories are written by the model calling the
+        // `remember` tool mid-conversation, so there is no separate model to choose and
+        // no background cost to authorise. A control that configures nothing is worse
+        // than no control — it implies a cost that is not being incurred.
         h(
           'button',
           {

package/cordis.patch.yml

@@ -34,19 +34,14 @@
         stripStepTags: true
 
         # ---------- long-term memory ----------
-        # OFF by default. The session half of this bundle (snapshots, rewind,
-        # delete, share, export, archive) does not need it and is always on.
+        # ON. This bundle owns its own long-term memory: the recall injection, the
+        # memory tool, the workspace+global stores, and the management UI.
         #
-        # Why off: dsh-fish-memory registers the SAME injection point —
-        # `systemPrompt.context({ order: 900 })` — so with both plugins enabled
-        # every request carries two memory blocks. That doubles the injected
-        # tokens and hands the model two possibly-contradictory fact sets.
-        # fish-memory's implicit extraction demonstrably works; ours never
-        # produced a single suggestion across seven fix attempts and, in the
-        # last one, crashed the Host with a 500ms polling timer. The memory
-        # engine therefore stays available but dormant: set this to true only
-        # after disabling fish-memory's injection.
-        longTermMemory: false
+        # dsh-fish-memory also registers `systemPrompt.context({ order: 900 })`, so
+        # running BOTH with injection enabled puts two memory blocks in every request.
+        # fish-memory is installed for architectural reference only and is not enabled
+        # in this profile, so there is no collision to avoid.
+        longTermMemory: true
         # Model chain used for implicit extraction (one cheap call per turn).
         # Tried in order until one answers; a 429 or an unreachable provider just
         # moves on to the next entry. All of these are free tiers.

package/lib/memory-engine.js

@@ -1725,6 +1725,70 @@ export class MemoryEngine {
     return { removed }
   }
 
+  /**
+   * Remove every durable fact that came from one session.
+   *
+   * Deleting a session used to leave its long-term memories behind: the per-session
+   * ledger was purged (lib/memory.js) but the durable library was not, because the two
+   * are different stores. A fact carries `sessionId` of the conversation that produced
+   * it, so those rows survived as orphans — invisible in the session, still injected
+   * into later prompts, and impossible to attribute once the session was gone.
+   *
+   * Scope matters: only entries whose `sessionId` matches are removed. Facts the user
+   * promoted to `global` deliberately, and facts with no sessionId at all (imported, or
+   * written by the tool outside a session), are left alone.
+   *
+   * @param {string} sessionId session whose facts should go
+   * @returns {Promise<{ removed: number, workspaces: number }>} what was deleted
+   */
+  async purgeSession(sessionId) {
+    const target = String(sessionId ?? '')
+    if (!target) return { removed: 0, workspaces: 0 }
+
+    let removed = 0
+    let workspaces = 0
+
+    /** @param {string} scope @param {string} key @returns {Promise<number>} rows removed */
+    const purgeOne = async (scope, key) => {
+      const store = await this.#readStore(scope, key)
+      if (!Array.isArray(store.entries) || store.entries.length === 0) return 0
+      const kept = store.entries.filter(entry => String(entry.sessionId ?? '') !== target)
+      const dropped = store.entries.length - kept.length
+      if (dropped === 0) return 0
+      store.entries = kept
+      await this.#writeStore(scope, key, store)
+
+      // The cold store holds compressed/archived rows; they belong to the same fact and
+      // must go too, or the session's content survives in a quieter place.
+      const cold = await this.#readCold(scope, key)
+      if (Array.isArray(cold.entries) && cold.entries.length > 0) {
+        const coldKept = cold.entries.filter(entry => String(entry.sessionId ?? '') !== target)
+        if (coldKept.length !== cold.entries.length) {
+          await this.#writeCold(scope, key, { version: 2, scope, entries: coldKept })
+        }
+      }
+      return dropped
+    }
+
+    // Global store first: a fact written from this session may have been promoted.
+    removed += await purgeOne('global', 'global')
+
+    // Then every registered workspace. Enumerating them (rather than purging only the
+    // caller's cwd) is deliberate: the session may have written into another workspace.
+    const registered = await this.workspaces().catch(() => [])
+    for (const workspace of registered) {
+      const key = typeof workspace?.key === 'string' ? workspace.key : undefined
+      if (!key) continue
+      const dropped = await purgeOne('workspace', key)
+      if (dropped > 0) {
+        removed += dropped
+        workspaces += 1
+      }
+    }
+
+    return { removed, workspaces }
+  }
+
   /**
    * @param {object} [input] export input
    * @param {string} [input.cwd] workspace

package/lib/memory-host.js

@@ -336,8 +336,43 @@ export function installMemory({ ctx, root, config, log }) {
       try {
         return tools.register({
           name: 'memory',
-          description:
-            'Manage long-term memory. `remember` stores a durable fact or preference (scope: workspace by default, or global). `recall` searches memory. `list` shows scores and decay state. `forget` deletes one entry. Use it when the user states a lasting rule, preference, or convention.',
+          // The description IS the extraction policy.
+          //
+          // There is no background model call: nothing else decides what to remember.
+          // The main conversation model reads this text and decides whether to call
+          // `remember` at all, so every rule about WHAT is worth keeping has to live
+          // here. dsh-fish-memory works the same way — its "implicit memory" is a tool
+          // description the model acts on, not a pipeline — and that is why its version
+          // works while a per-turn timer never did.
+          //
+          // Three rules matter most and all three were missing:
+          //   • one memory = one fact (a packed sentence becomes unsearchable);
+          //   • record silently, without announcing it in the reply;
+          //   • record the user's durable facts, not your own actions.
+          description: [
+            'Long-term memory that survives across sessions. Call `remember` when the',
+            'user states something durable; use `recall` to search, `list` to inspect,',
+            '`forget` to delete, `freeze` to pin.',
+            '',
+            'WHEN TO REMEMBER (decide yourself, every turn — the user will not ask):',
+            '- a stated preference, habit, or dislike ("I prefer X", "never do Y")',
+            '- a durable fact about the user, their work, or their environment',
+            '- a rule or convention they set for how you should behave',
+            '- a decision that was reached, with its reason',
+            '- a mistake that was made and the lesson that came out of it',
+            '',
+            'WHEN NOT TO: small talk, one-off requests, anything already in the library,',
+            'and anything you merely did yourself. Your own actions are not memories.',
+            '',
+            'HOW TO WRITE ONE:',
+            '- ONE memory = ONE fact. "She is 170cm, weighs 52kg, sleeps on her side" is',
+            '  THREE memories, not one — packed entries cannot be matched individually.',
+            '- Under 300 characters. If it is longer, split it.',
+            '- Write it so a future search will find it: keep the concrete nouns.',
+            '- Do NOT say "I noted that" or "got it, remembered" in your reply. Record',
+            '  quietly; announcing it reads like a status report.',
+            '- Prefer workspace scope; use global only for things true everywhere.',
+          ].join('\n'),
           parameters: {
             type: 'object',
             properties: {

package/lib/service.js

@@ -77,31 +77,44 @@ export class SessionSuiteService {
       // "Cannot read properties of undefined (reading 'throwIfAborted')" rather than
       // defaulting to "no cancellation". Pass a real AbortSignal.
       //
-      // A single call returns ONE PAGE, not the whole session. The share dialog showed
-      // "3/3 turns" for a conversation with 129 — the reader had been given the last
-      // page and nothing else. Page backwards until the reader reports no more, so
-      // callers get the complete history they were always promised.
+      // A single call returns ONE PAGE. Read the Host implementation
+      // (dsh-api-session-controller/lib/index.js) to get this exactly right:
+      //
+      //   resolveHistoryRequest: maxMessages defaults to 50.
+      //   history():  cursor = throughSeq ?? observation.cursor   // the LOG END, not a page edge
+      //   paginate(): end = min(throughSeq + 1, beforeSeq ?? throughSeq + 1)
+      //               scans backward, stops once maxMessages messages are collected,
+      //               cut = the seq of this page's FIRST message,
+      //               returns { events: slice(cut, end), hasMore: cut > 0 }
+      //
+      // The trap: `page.cursor` is the log end, NOT the page boundary. Stepping
+      // `beforeSeq = cursor - 1` therefore asks for almost the same window again — which
+      // is why a 145-turn session showed 9 turns. The correct next cursor is the seq of
+      // the page's FIRST event: everything at or above it has been read.
       const signal = new AbortController().signal
       const collected = []
+      const maxMessages = 200
       let beforeSeq
       let guard = 0
       while (guard < 400) {
         guard += 1
-        const request = { address: { kind: 'session', sessionId } }
+        const request = { address: { kind: 'session', sessionId }, maxMessages }
         if (typeof beforeSeq === 'number') request.beforeSeq = beforeSeq
         const page = await controller.events(request, signal)
         const records = Array.isArray(page?.records) ? page.records : []
         const events = records
           .map(record => (record?.type === 'event' ? record.event : record?.event ?? record))
           .filter(Boolean)
-        // Pages arrive newest-first or oldest-first depending on the cursor; collecting
-        // in order and de-duplicating by seq at the end keeps this independent of which.
         collected.push(...events)
         if (!page?.hasMore || records.length === 0) break
-        // The cursor is the inclusive boundary of the page just read.
-        const next = typeof page?.cursor === 'number' ? page.cursor : undefined
-        if (next === undefined || next === beforeSeq) break
-        beforeSeq = next
+        // The oldest seq in this page is the new exclusive upper bound.
+        const lowest = events.reduce(
+          (min, event) => (typeof event?.seq === 'number' && event.seq < min ? event.seq : min),
+          Number.POSITIVE_INFINITY,
+        )
+        if (!Number.isFinite(lowest)) break
+        if (typeof beforeSeq === 'number' && lowest >= beforeSeq) break
+        beforeSeq = lowest
       }
       const seen = new Map()
       for (const event of collected) {
@@ -871,6 +884,18 @@ export class SessionSuiteService {
     removed.checkpoints = true
     await this.memory.purge(sessionId).catch(() => {})
     removed.memory = true
+    // The durable library is a SEPARATE store from the per-session ledger above, and it
+    // was never purged — so deleting a session left its long-term facts behind as
+    // orphans: still injected into later prompts, and unattributable once the session
+    // was gone. Facts carry `sessionId`, so they can be removed precisely.
+    //
+    // Guarded separately: a Host without the long-term engine must still be able to
+    // delete a session.
+    try {
+      removed.durableMemory = await this.longTerm?.purgeSession?.(sessionId)
+    } catch (error) {
+      this.log(`could not purge durable memory for ${sessionId}`, error)
+    }
     for (const undo of await this.listUndos(sessionId)) await this.#discardUndo(undo.id).catch(() => {})
 
     // Finally, drop the archive mark itself.

package/package.json

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