@heixui/dsh-session-suite 0.6.2 → 0.8.0

package/client.js

@@ -2937,8 +2937,18 @@ window.__ModuleLoader__.load({
       // settings page said something else entirely. 'all' now means every store.
       useEffect(() => {
         let alive = true
+        // Whether the long-term memory engine is running at all.
+        //
+        // It is OFF by default because it collides with dsh-fish-memory: both inject at
+        // `systemPrompt.context({ order: 900 })`, so two memory blocks per request and
+        // double the tokens. When it is off the API answers LONGTERM_DISABLED and the
+        // panel must show only the session half — a memory row that opens onto a
+        // disabled engine is worse than no row.
         Promise.all([
-          call({ action: 'longterm.list', scope: 'all' }).catch(() => []),
+          call({ action: 'longterm.list', scope: 'all' }).then(
+            value => ({ enabled: true, value }),
+            error => ({ enabled: error?.code !== 'LONGTERM_DISABLED', value: [] }),
+          ),
           call({ action: 'list' }).catch(() => []),
           // Per-workspace breakdown, so the totals can be explained rather than
           // merely displayed. The counts above are sums; without this the user
@@ -2946,15 +2956,16 @@ window.__ModuleLoader__.load({
           // made the earlier 17/21/27/51 mismatch look like a bug.
           call({ action: 'longterm.workspaces' }).catch(() => []),
         ])
-          .then(([memories, sessions, workspaces]) => {
+          .then(([memory, sessions, workspaces]) => {
             if (!alive) return
             const items = Array.isArray(sessions) ? sessions : []
             const stores = Array.isArray(workspaces) ? workspaces : []
-            const memoryRows = Array.isArray(memories) ? memories : []
+            const memoryRows = Array.isArray(memory?.value) ? memory.value : []
             // The global store's size, so the breakdown adds up to the total instead
             // of leaving the difference unexplained.
             const globalRows = memoryRows.filter(row => row.scope === 'global').length
             setCounts({
+              memoryEnabled: memory?.enabled === true,
               memories: memoryRows.length,
               memoryActive: memoryRows.filter(row => row.archived !== true).length,
               memoryArchived: memoryRows.filter(row => row.archived === true).length,
@@ -3042,8 +3053,14 @@ window.__ModuleLoader__.load({
           ...[
             ['panel.statSessions', counts?.sessions, 'panel.statSessionsHint'],
             ['panel.statSnapshots', counts?.snapshots, 'panel.statSnapshotsHint'],
-            ['panel.statMemories', counts?.memories, 'panel.statMemoriesHint'],
-            ['panel.statArchived', counts?.archived, 'panel.statArchivedHint'],
+            // Memory figures only exist when the engine is on. Showing a zero here
+            // would claim "you have no memories" when the truth is "memory is off".
+            ...(counts?.memoryEnabled === true
+              ? [
+                  ['panel.statMemories', counts?.memories, 'panel.statMemoriesHint'],
+                  ['panel.statArchived', counts?.archived, 'panel.statArchivedHint'],
+                ]
+              : [['panel.statArchived', counts?.archived, 'panel.statArchivedHint']]),
           ].map(([label, value, hint]) =>
             h(
               'div',
@@ -3055,7 +3072,8 @@ window.__ModuleLoader__.load({
           ),
         ),
         // The decomposition, so the total is checkable rather than a number to trust.
-        counts?.stores?.length
+        // Only when memory is on: it explains the memory total.
+        counts?.memoryEnabled === true && counts?.stores?.length
           ? h(
               'div',
               { className: 'dss-breakdown' },
@@ -3085,7 +3103,11 @@ window.__ModuleLoader__.load({
           'div',
           { className: 'dss-nav' },
           row('snapshots', t('panel.snapshots'), t('panel.snapshotsHint'), counts?.snapshots),
-          row('memory', t('panel.memory'), t('panel.memoryHint'), counts?.memories),
+          // The memory screen is omitted entirely when the engine is off: it would
+          // open onto a disabled backend and report LONGTERM_DISABLED in red.
+          counts?.memoryEnabled === true
+            ? row('memory', t('panel.memory'), t('panel.memoryHint'), counts?.memories)
+            : null,
           row('archived', t('panel.archived'), t('panel.archivedHint'), counts?.archived),
         ),
         h(

package/cordis.patch.yml

@@ -34,8 +34,19 @@
         stripStepTags: true
 
         # ---------- long-term memory ----------
-        # Turn the whole memory engine on or off.
-        longTermMemory: true
+        # OFF by default. The session half of this bundle (snapshots, rewind,
+        # delete, share, export, archive) does not need it and is always on.
+        #
+        # 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
         # 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/api.js

@@ -10,6 +10,31 @@
 /** Absolute path Connection registers. */
 export const API_PATH = '/api/session-suite'
 
+/**
+ * Every action that needs the long-term memory engine.
+ *
+ * Kept as an explicit set rather than an `action.startsWith('longterm.')` test so that a
+ * misspelled action still fails as an unknown action (400) instead of being reported as
+ * "memory is disabled" — the second answer would hide a typo.
+ */
+export const LONGTERM_ACTIONS = new Set([
+  'longterm.list',
+  'longterm.remember',
+  'longterm.update',
+  'longterm.remove',
+  'longterm.recall',
+  'longterm.explain',
+  'longterm.pending',
+  'longterm.settle',
+  'longterm.maintain',
+  'longterm.status',
+  'longterm.workspaces',
+  'longterm.models',
+  'longterm.stats',
+  'longterm.settings',
+  'longterm.export',
+])
+
 const MAX_BODY_BYTES = 256 * 1024
 
 /**
@@ -63,6 +88,30 @@ async function handle(service, deps, request) {
  * @returns {Promise<Response>} response
  */
 async function respond(service, deps, action, input) {
+  // The long-term memory engine is OPTIONAL and off by default.
+  //
+  // It is off because it collides with dsh-fish-memory: both register
+  // `systemPrompt.context({ order: 900 })`, so with both installed every request
+  // carries two memory blocks — double the tokens and two possibly-contradictory
+  // sets of facts. fish-memory's implicit extraction works and ours never did, so
+  // the memory half of this bundle is opt-in and the session half is always on.
+  //
+  // When the engine is absent every longterm.* action must answer cleanly rather
+  // than throw. `service.longTerm` is undefined in that case, and `await
+  // undefined.list(...)` would surface as an opaque 500 in the panel.
+  //
+  // The guard checks the action against a KNOWN list first: an action that does
+  // not exist is still a 400 (a typo must be loud), and only a real action is
+  // reported as disabled. Returning "disabled" for a nonexistent action would
+  // silently hide a wrong action name.
+  if (!service.longTerm && LONGTERM_ACTIONS.has(action)) {
+    return json({
+      ok: false,
+      error: 'long-term memory is disabled in this profile',
+      code: 'LONGTERM_DISABLED',
+    })
+  }
+
   switch (action) {
     case 'ping':
       return json({ ok: true, data: { ready: true, version: 1 } })

package/lib/memory-host.js

@@ -143,12 +143,29 @@ export function installMemory({ ctx, root, config, log }) {
           systemPrompt.context({
             name: 'session-suite-memory',
             order: 900,
+            // Memory text is PLAIN TEXT and must not be parsed as a prompt template.
+            //
+            // The Host's context/section helpers interpolate by default: a `{{name}}`
+            // anywhere in the injected text is treated as a variable, and an unknown one
+            // throws `unknown prompt variable`. Our memories come from user conversations,
+            // so they routinely contain double braces — code snippets, templates, logs.
+            // Without this flag ONE such memory would fail every turn of every session
+            // until the plugin was disabled.
+            //
+            // Learned from dsh-fish-memory, which added the same flag after hitting it
+            // (its source records the failure mode: "the user could only turn the plugin
+            // off"). We are not copying its code, only the fact that the switch exists.
+            interpolate: false,
             text: context => {
               const scoped = context?.scope ? recallByScope.get(context.scope) : undefined
               // 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
+              // No fresh entry for this scope: fall back to the last text computed for
+              // ANY scope. That is deliberate — the context provider can run for a scope
+              // the pre-step hook did not resolve (a resumed session, a step served from
+              // a cached decision), and returning '' there would inject nothing at all.
               return lastRecall || ''
             },
           }),
@@ -191,56 +208,22 @@ export function installMemory({ ctx, root, config, log }) {
             turns: typeof config?.contextQueryTurns === 'number' ? config.contextQueryTurns : undefined,
           })
           const text = await buildRecallText({ engine, cwd, question, config })
-          if (agent) recallByScope.set(agent, { text, at: Date.now() })
+          // Cache key includes the QUESTION, not just the agent.
+          //
+          // `systemPrompt.context`'s text() is called several times per request (the
+          // equivalent plugin measured 5.9 on average, up to 24 during long reasoning),
+          // so caching is necessary. But caching by agent alone means a changed question
+          // inside the same window reuses the previous answer — the injected memory then
+          // describes a question the model is no longer asking. Keying on agent+question
+          // keeps the reuse and drops the wrongness.
+          if (agent) recallByScope.set(agent, { text, at: Date.now(), question })
           lastRecall = text
           lastRecallFailed = false
 
-          // Implicit extraction, driven from HERE rather than from session/event.
-          //
-          // The event listener was registered successfully — installStatus reports
-          // `implicit extraction: ok` — and the log demonstrably contains 123 `turn/end`
-          // events, yet the handler never ran: `lastExtraction` stayed null across five
-          // fixes. Rather than keep chasing why an event listener does not receive
-          // events on a context where a sibling listener does, use the hook that is
-          // known to fire every step. `agent/pre-step` runs before each step and is
-          // where the memory injection already happens, so its liveness is proven by
-          // the feature working at all.
-          //
-          // The timing is one step later than turn/end would be: this extracts the
-          // PREVIOUS turn, because at pre-step the current turn's transcript is not
-          // complete yet. That is acceptable — a memory becomes available one step
-          // later, and the alternative is a feature that never runs.
-          //
-          // The model choice is read from ENGINE SETTINGS, not from `config`.
-          //
-          // This was the actual reason extraction never ran: the settings UI writes
-          // `implicitModel` through `longterm.settings`, which lands in
-          // `memory/settings.json` — while the guard read `config.implicitModel`, a
-          // patch value this profile never sets. The guard was therefore always false,
-          // so `extractAfterTurn` was never even called, and the trace stayed null.
-          // Verified against the live file: settings.json held
-          // "agnes-backup/agnes-3.0-flash" while the patch declared no such key.
-          //
-          // Guarded so a failure here cannot affect the recall decision above: the
-          // whole point of pre-step is that it returns `decision` intact.
-          const chosen = (await engine.settings().catch(() => ({})))?.implicitModel ?? config?.implicitModel
-          if (chosen && chosen !== 'off') {
-            const sessionId = agent?.sessionId
-            if (typeof sessionId === 'string' && sessionId) {
-              void extractAfterTurn({ ctx, engine, sessionId, cwd, log, config })
-                .finally(() => publishExtractionTrace(engine))
-                .catch(error => {
-                  extractionTrace.stage = 'threw'
-                  extractionTrace.reason = errorMessage(error)
-                  publishExtractionTrace(engine)
-                  log('implicit memory extraction failed', error)
-                })
-            } else {
-              extractionTrace.reason = `pre-step ran but agent.sessionId was ${typeof sessionId}`
-              extractionTrace.eventsSeen = (extractionTrace.eventsSeen ?? 0) + 1
-              publishExtractionTrace(engine)
-            }
-          }
+          // Implicit extraction is NOT run here. See the note at section 3: the model
+          // writes memories by calling the `remember` tool mid-conversation, which is
+          // the mechanism that actually works. A per-turn background model call was
+          // never demonstrated to produce anything and cost a Host crash to attempt.
         } catch (error) {
           // A failed rebuild must not leave the previous answer in place.
           //
@@ -275,63 +258,20 @@ export function installMemory({ ctx, root, config, log }) {
   // stays off until a trigger can be proven safe. Do not re-add a polling loop
   // without (1) injecting timer, (2) wrapping the tick body in try/catch, and
   // (3) clearing the timer on dispose.
-  // --- 3. Implicit extraction after a turn --------------------------------
-  safe('implicit extraction', () => {
-    // A startup marker, recorded before the listener is even registered.
-    //
-    // The whole question "why is the queue empty" has two halves that look identical
-    // on screen: the hook is not registered at all, or it is registered and never
-    // called. This records the first half so the trace can distinguish them — the
-    // block used to render only after extraction ran, so a dead hook produced no
-    // trace and therefore no diagnostics.
-    extractionTrace.registered = true
-    extractionTrace.registeredAt = Date.now()
-    publishExtractionTrace(engine)
-    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' || !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
-            // readable cause on the settings page instead of an empty queue with
-            // no explanation.
-            .finally(() => publishExtractionTrace(engine))
-            .catch(error => {
-              extractionTrace.stage = 'threw'
-              extractionTrace.reason = errorMessage(error)
-              publishExtractionTrace(engine)
-              log('implicit memory extraction failed', error)
-            })
-        }),
-      'session-suite: implicit memory',
-    )
-  })
+  // --- 3. Implicit extraction: REMOVED (0.8.0) -----------------------------
+  //
+  // Seven fix attempts targeted a "one cheap model call per turn" pipeline driven by
+  // a Cordis event. It never fired once. Reading dsh-fish-memory's source settled why:
+  // that plugin has no such pipeline at all. Its memories are written by the MODEL,
+  // calling a `remember` tool mid-conversation; `agent/turn-stopping` there only marks
+  // whether a recalled memory was actually used ("assembled" → "consumed").
+  //
+  // So the direction was wrong, not the wiring. A background timer that calls a model
+  // on every turn also has a real cost and a real failure surface — the last attempt
+  // crashed the Host — and the benefit was never demonstrated. It is removed rather
+  // than left dormant, so no future reader mistakes it for working code.
+  //
+  // The memory TOOL remains (below), which is the mechanism that actually works.
 
   // --- 3b. Automatic maintenance -------------------------------------------
   // Scoring, decay, clustering, and cold archiving are otherwise only reachable

package/package.json

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