@heixui/dsh-session-suite 0.8.1 → 0.8.2

package/client.js

@@ -3437,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()
 
@@ -3785,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/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/service.js

@@ -884,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.1",
+  "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",