@heixui/dsh-session-suite 0.4.0 → 0.4.2

package/lib/api.js

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

package/lib/memory-engine.js

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

package/lib/memory-host.js

@@ -205,9 +205,26 @@ 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 —
+          // "nothing waiting" with no counts is indistinguishable from "the hook is
+          // never called at all", which is exactly the state that wasted several
+          // rounds of guessing.
+          extractionTrace.eventsSeen = (extractionTrace.eventsSeen ?? 0) + 1
           if (!event || event.type !== 'turn/end') return
+          extractionTrace.turnEndsSeen = (extractionTrace.turnEndsSeen ?? 0) + 1
+          // 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
@@ -553,8 +570,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 +732,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 +740,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

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