@heixui/dsh-session-suite 0.6.1 → 0.7.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/index.js

@@ -28,24 +28,14 @@ import { stripStepTagsFromStream } from './lib/step-tag-filter.js'
 export const name = 'session-suite'
 
 /**
- * `agents` is required for implicit memory extraction.
+ * The HTTP carrier is the only hard requirement; everything else degrades gracefully.
  *
- * Cordis dispatch is scope-filtered: "agent-scoped listeners receive only events from
- * sessions entered through that agent's context". A listener on the plugin's ROOT
- * context therefore never sees an agent's session events — which is why our
- * `session/event` handler was registered successfully, never fired, and left the pending
- * queue empty for six rounds of fixes.
- *
- * dsh-fish-memory (16k downloads) solves the same problem by injecting `agents`, taking
- * one with `ctx.agents.get(sid)`, and listening on `agent.ctx` — the agent's own context.
- * Its source records the trap in a comment: the Cordis events that exist are
- * `agent/inbox/inserted` and `agent/turn-stopping`, NOT `user/message` /
- * `assistant/message` (those are SessionEvent types carried by `session/event`).
- *
- * Everything else stays optional: the HTTP carrier is still the only hard requirement,
- * and a Host without `agents` degrades to no implicit extraction rather than failing.
+ * 0.6.2: `agents` and `timer` were added for an implicit-extraction polling loop. That
+ * loop crashed the Host with `cannot get property "timer" without inject` on every
+ * 500ms tick. Both are removed. Do not re-add them without also proving the tick body
+ * cannot throw and that the timer is disposed with the effect.
  */
-export const inject = ['connection', 'agents', 'timer']
+export const inject = ['connection']
 
 /**
  * @param {any} ctx plugin context

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

@@ -261,106 +261,20 @@ export function installMemory({ ctx, root, config, log }) {
   ),
   )
 
-  // --- 2b. Per-agent extraction trigger -----------------------------------
+  // --- 2b. Per-agent extraction trigger: REMOVED (0.6.2) -----------------
   //
-  // This is the trigger that actually works, copied from how dsh-fish-memory does it
-  // (16k downloads, demonstrably working). Two things had to be true and neither was:
+  // The 500ms agent-poll was the source of a Host crash: its timer callback
+  // called `ctx.interval` / `ctx.get("timer")` on a context that had not
+  // injected timer, producing `TypeError: cannot get property "timer" without
+  // inject` on EVERY tick until the Host died. The WorkBuddy transcript showed
+  // `at mount, _onTimeout, listOnTimeout` from our bundle.
   //
-  //   1. the listener must be registered on the AGENT's context, not the plugin root.
-  //      Cordis dispatch is scope-filtered, so a root-context `session/event` listener
-  //      receives nothing from an agent's session — which is exactly what we observed:
-  //      registered successfully, `lastExtraction` stayed null forever.
-  //   2. `agent/turn-stopping` is the hook that fires at the end of a turn on that
-  //      scope. `user/message` and `assistant/message` are SessionEvent TYPES carried
-  //      by `session/event`, not Cordis events — a trap fish-memory documents in a
-  //      comment after hitting it themselves.
-  //
-  // The agent is reached through `ctx.agents`, so this requires the `agents` service;
-  // index.js now injects it. Without it the feature degrades to off rather than throwing.
-  safe('per-agent extraction hook', () => {
-    const agents = ctx.get?.('agents')
-    if (!agents) return
-
-    /** @param {any} agent live agent @returns {void} */
-    const mountFor = agent => {
-      const agentCtx = agent?.ctx
-      if (!agentCtx || typeof agentCtx.on !== 'function') return
-      // One listener per agent; the context disposes it with the agent.
-      agentCtx.on('agent/turn-stopping', () => {
-        const sessionId = agent?.sessionId
-        if (typeof sessionId !== 'string' || !sessionId) {
-          extractionTrace.reason = `turn-stopping fired but agent.sessionId was ${typeof sessionId}`
-          publishExtractionTrace(engine)
-          return
-        }
-        // The model choice lives in settings.json, not in the patch config.
-        void engine
-          .settings()
-          .then(settings => {
-            const chosen = settings?.implicitModel ?? config?.implicitModel
-            if (!chosen || chosen === 'off') {
-              extractionTrace.reason = 'no implicit model is selected in settings'
-              publishExtractionTrace(engine)
-              return undefined
-            }
-            const cwd = resolveCwd(ctx, agent)
-            return 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)
-          })
-      })
-    }
-
-    // Mount by POLLING, not by an event.
-    //
-    // The first version listened for `agent/created`, which never delivered a usable
-    // agent — the hook stayed unmounted and the trace stayed null, the same symptom as
-    // every earlier attempt. dsh-fish-memory does not use an event either: it runs
-    // `ctx.effect(() => ctx.interval(tick, 500))` and calls `agents.list()` every half
-    // second, mounting on any agent it has not seen yet. That is what makes its version
-    // work, and its source notes the tradeoff — the tick is cheap because `agents.list()`
-    // reads memory.
-    //
-    // Polling also handles the case an event cannot: the agent instance is REPLACED when
-    // a session is resumed, a plugin reloads, or the Host rebuilds it. A one-shot
-    // listener dies with the old instance; a poll re-mounts on the new one.
-    const mounted = new WeakSet()
-    const tick = () => {
-      let live = []
-      try {
-        live = agents.list?.() ?? []
-      } catch {
-        return
-      }
-      for (const agent of live) {
-        if (!agent || mounted.has(agent)) continue
-        // Subagents only do one job; a memory store for them is wasted work.
-        if (agent.origin === 'subagent' || agent.delegationDepth > 0) continue
-        mounted.add(agent)
-        try {
-          mountFor(agent)
-        } catch (error) {
-          log('could not mount the extraction hook on an agent', error)
-        }
-      }
-    }
-    // First pass immediately, so an already-running session is covered without waiting.
-    tick()
-    // Then every half second. `ctx.interval` is the Cordis timer facility; fall back to
-    // setInterval when it is absent so the feature still works on a leaner Host.
-    if (typeof ctx.interval === 'function') ctx.effect(() => ctx.interval(tick, 500))
-    else if (typeof setInterval === 'function') {
-      const handle = setInterval(tick, 500)
-      handle.unref?.()
-      ctx.effect(() => () => clearInterval(handle))
-    }
-  })
-
+  // A recurring timer that can throw on every tick is not an acceptable design
+  // for a plugin that runs inside a shared Host process. This whole trigger is
+  // removed, and `agents`/`timer` are dropped from inject. Implicit extraction
+  // 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heixui/dsh-session-suite",
-  "version": "0.6.1",
+  "version": "0.7.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",