@heixui/dsh-session-suite 0.3.0 → 0.3.2

package/client.js

@@ -2863,9 +2863,55 @@ window.__ModuleLoader__.load({
 
     // ------------------------------------------------------------------ apply
 
+    /**
+     * Report a Client-half failure somewhere a human can find it.
+     *
+     * A throw inside apply() makes the whole module register nothing, and the
+     * symptom is silence: no settings page, no session-menu rows, no buttons.
+     * There is no error surface of its own, so record the failure on a global and
+     * log it loudly. This exists because the failure was invisible for several
+     * rounds of debugging, with only a metadata warning to go on.
+     *
+     * @param {string} stage where it broke
+     * @param {unknown} error what was thrown
+     */
+    function reportClientFailure(stage, error) {
+      const detail = {
+        bundle: 'dsh-session-suite',
+        stage,
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? String(error.stack ?? '').split('\n').slice(0, 6).join('\n') : '',
+        at: new Date().toISOString(),
+      }
+      try {
+        globalThis.__DSH_SESSION_SUITE_ERROR__ = detail
+      } catch {
+        /* a frozen global is not worth failing over */
+      }
+      try {
+        console.error('[dsh-session-suite] client half failed', detail)
+      } catch {
+        /* console may be unavailable in a sandboxed runtime */
+      }
+    }
+
     return {
       inject: ['slots', 'locale'],
       apply(ctx) {
+        try {
+          applyInner(ctx)
+        } catch (error) {
+          reportClientFailure('apply', error)
+          throw error
+        }
+
+        /**
+         * The real body. Split out so one try/catch can cover every registration
+         * without wrapping each line.
+         *
+         * @param {any} ctx client context
+         */
+        function applyInner(ctx) {
         const t = ctx.locale.bind(NS)
         ctx.effect(() => ctx.locale.register(NS, DICTS))
         ctx.effect(installStyles)
@@ -2968,6 +3014,7 @@ window.__ModuleLoader__.load({
             withT(MemorySection),
           ),
         )
+        }
       },
     }
   },

package/cordis.patch.yml

@@ -5,7 +5,12 @@
 # half adds the sidebar rows, the message actions, and the settings pages.
 - insert:
     - id: session-suite
-      name: dsh-session-suite
+      # The row id stays `session-suite` — patches and stored state key off it —
+      # while the package specifier is the published scoped name. They diverged
+      # when the npm name changed: the row still said `dsh-session-suite`, which
+      # no longer resolves, so the module never loaded and the entire Client half
+      # (settings pages, session menu rows, message buttons) was silently absent.
+      name: "@heixui/dsh-session-suite"
       config:
         # ---------- session snapshots ----------
         # Automatic checkpoints kept per session (locked ones do not count).

package/lib/memory-host.js

@@ -110,6 +110,21 @@ export function installMemory({ ctx, root, config, log }) {
    */
   const recallByScope = new Map()
   let lastRecall = ''
+  // Diagnostics for the settings page: "did the last rebuild fail, and why" must
+  // be answerable, because the failure mode is invisible otherwise — the model
+  // simply behaves as if the memory is missing.
+  let lastRecallFailed = false
+  let lastRecallError = ''
+
+  /**
+   * How long a computed recall may be reused before it must be recomputed.
+   *
+   * `agent/pre-step` normally refreshes it every step, so this only matters when
+   * a step does not run the hook (a resumed session, a step served from a cached
+   * decision). Without a bound, a memory written elsewhere could stay invisible
+   * for the life of the process.
+   */
+  const RECALL_TTL_MS = 60_000
 
   // --- 1. Recall into the system prompt -----------------------------------
   const systemPrompt = ctx.get('systemPrompt')
@@ -122,7 +137,11 @@ export function installMemory({ ctx, root, config, log }) {
             order: 900,
             text: context => {
               const scoped = context?.scope ? recallByScope.get(context.scope) : undefined
-              return scoped?.text || lastRecall || ''
+              // Expiry is checked here rather than only at write time: a cached
+              // value outlives its usefulness the moment the library changes
+              // underneath it, and this is the only place that can see the age.
+              if (scoped && Date.now() - scoped.at < RECALL_TTL_MS) return scoped.text
+              return lastRecall || ''
             },
           }),
         'session-suite: memory context',
@@ -160,7 +179,19 @@ export function installMemory({ ctx, root, config, log }) {
           const text = await buildRecallText({ engine, cwd, question, config })
           if (agent) recallByScope.set(agent, { text, at: Date.now() })
           lastRecall = text
+          lastRecallFailed = false
         } catch (error) {
+          // A failed rebuild must not leave the previous answer in place.
+          //
+          // Observed in the wild: one failed rebuild, and every later turn kept
+          // injecting the memory text computed BEFORE it — a memory written after
+          // that point was invisible for the rest of the process, which reads as
+          // "the other workspace does not know". Stale recall is worse than no
+          // recall: empty at least tells the truth.
+          lastRecall = ''
+          if (agent) recallByScope.delete(agent)
+          lastRecallFailed = true
+          lastRecallError = error instanceof Error ? error.message : String(error)
           log('memory recall failed', error)
         }
         return decision
@@ -329,7 +360,19 @@ export function installMemory({ ctx, root, config, log }) {
     }, 'session-suite: memory tool')
   }
 
-  return { engine, dispose: () => {} }
+  return {
+    engine,
+    dispose: () => {},
+    // Exposed so the settings page and the status endpoint can report whether the
+    // last recall rebuild failed. Without this the failure is silent: the model
+    // simply acts as if the memory is not there.
+    recallStatus: () => ({
+      failed: lastRecallFailed,
+      error: lastRecallError,
+      hasText: Boolean(lastRecall) || recallByScope.size > 0,
+      scopes: recallByScope.size,
+    }),
+  }
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heixui/dsh-session-suite",
-  "version": "0.3.0",
+  "version": "0.3.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",
@@ -56,16 +56,19 @@
     "THIRD-PARTY.md"
   ],
   "dsh": {
+    "icon": "./icon.svg",
     "bundle": {
       "patch": "./cordis.patch.yml"
     },
     "client": {
       "platform": "web",
-      "immediately": true,
       "inject": [
         "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-ui-workspace",
+        "@deepseek-ai/dsh-client-ui-session",
         "@deepseek-ai/dsh-client-ui-chat",
+        "@deepseek-ai/dsh-client-ui-conversation",
         "@deepseek-ai/dsh-client-ui-settings"
       ]
     }