@heixui/dsh-session-suite 0.5.1 → 0.6.1

package/index.js

@@ -27,8 +27,25 @@ import { stripStepTagsFromStream } from './lib/step-tag-filter.js'
 
 export const name = 'session-suite'
 
-/** The HTTP carrier is the only hard requirement; the rest degrade gracefully. */
-export const inject = ['connection']
+/**
+ * `agents` is required for implicit memory extraction.
+ *
+ * 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.
+ */
+export const inject = ['connection', 'agents', 'timer']
 
 /**
  * @param {any} ctx plugin context

package/lib/memory-host.js

@@ -194,6 +194,53 @@ export function installMemory({ ctx, root, config, log }) {
           if (agent) recallByScope.set(agent, { text, at: Date.now() })
           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)
+            }
+          }
         } catch (error) {
           // A failed rebuild must not leave the previous answer in place.
           //
@@ -214,6 +261,106 @@ export function installMemory({ ctx, root, config, log }) {
   ),
   )
 
+  // --- 2b. Per-agent extraction trigger -----------------------------------
+  //
+  // 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:
+  //
+  //   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))
+    }
+  })
+
   // --- 3. Implicit extraction after a turn --------------------------------
   safe('implicit extraction', () => {
     // A startup marker, recorded before the listener is even registered.
@@ -595,6 +742,44 @@ function contextualQuery(messages, limits = {}) {
   return `${earlier.join(' ')} ${current}`.trim()
 }
 
+/**
+ * Read a session's events through whichever Host API is present.
+ *
+ * The Host moved from `sessionController.inspect(sessionId)` to
+ * `sessionController.events({ address }, signal)`. Calling the old name behind an
+ * optional chain returned `undefined` with no error, so every consumer silently saw an
+ * empty session — share and segment-delete failed with a raw TypeError, and implicit
+ * extraction reported "no completed turn yet" forever.
+ *
+ * Both shapes are attempted, newest first, and a missing implementation throws rather
+ * than returning an empty list: an empty list is indistinguishable from an empty session,
+ * which is exactly how this stayed hidden.
+ *
+ * @param {any} controller session controller
+ * @param {string} sessionId session
+ * @returns {Promise<any[]>} events
+ */
+async function readSessionEvents(controller, sessionId) {
+  if (!controller) throw new Error('the sessionController service is not mounted')
+
+  if (typeof controller.events === 'function') {
+    // `events(request, signal)` — the implementation calls `signal.throwIfAborted()`,
+    // so a real signal is required.
+    const page = await controller.events({ address: { kind: 'session', sessionId } }, new AbortController().signal)
+    const records = Array.isArray(page?.records) ? page.records : []
+    return records
+      .map(record => (record?.type === 'event' ? record.event : record?.event ?? record))
+      .filter(Boolean)
+  }
+
+  if (typeof controller.inspect === 'function') {
+    const inspection = await controller.inspect(sessionId)
+    return Array.isArray(inspection?.events) ? inspection.events : []
+  }
+
+  throw new Error('this Host exposes neither sessionController.events nor sessionController.inspect')
+}
+
 /**
  * Ask a small model call what, if anything, is worth remembering from this turn.
  *
@@ -684,8 +869,15 @@ async function extractAfterTurn({ ctx, engine, sessionId, cwd, log, config }) {
   if (!llm?.stream) return failExtraction('the Host exposes no llm.stream')
 
   const sessionController = ctx.get('sessionController')
-  const inspection = await sessionController?.inspect?.(sessionId).catch(() => undefined)
-  const events = inspection?.events ?? []
+  // Read the session's events through whichever API this Host exposes.
+  //
+  // The optional-chained `inspect?.()` call silently produced `undefined` on the current
+  // build — which has no `inspect` — so `events` was empty, `turn` was not a number, and
+  // extraction returned "this session has no completed turn yet" forever. That is the
+  // real reason the pending queue never filled, and it is the same defect that broke
+  // share and segment-delete. The `?.` hid it: a missing method read as "nothing to do"
+  // rather than as an error.
+  const events = await readSessionEvents(sessionController, sessionId)
   const turn = lastCompletedTurn(events)
   if (typeof turn !== 'number') return failExtraction('this session has no completed turn yet')
   const transcript = turnTranscript(events, turn)
@@ -694,7 +886,7 @@ 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, ctx)
+  const candidates = memoryCandidates(config, ctx, settings)
   if (candidates.length === 0) {
     return failExtraction(
       config?.implicitModel === 'current'
@@ -856,7 +1048,7 @@ function numberOr(value, fallback) {
  * @param {any} config plugin config
  * @returns {{ provider: string, model: string }[]} candidates in priority order
  */
-function memoryCandidates(config, ctx) {
+function memoryCandidates(config, ctx, settings) {
   const raw = []
   const push = value => {
     if (Array.isArray(value)) raw.push(...value)
@@ -870,7 +1062,16 @@ function memoryCandidates(config, ctx) {
   // 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 : ''
+  //
+  // Read from SETTINGS first: the UI persists the choice to memory/settings.json, and
+  // reading only `config` meant a chosen model was never seen — the picker worked, the
+  // file had the value, and extraction still never ran.
+  const picked =
+    typeof settings?.implicitModel === 'string'
+      ? settings.implicitModel
+      : typeof config?.implicitModel === 'string'
+        ? config.implicitModel
+        : ''
   if (picked && picked !== 'current' && picked !== 'off') {
     const at = picked.indexOf('/')
     if (at > 0 && at < picked.length - 1) {

package/lib/service.js

@@ -51,15 +51,98 @@ export class SessionSuiteService {
   }
 
   /**
+   * Read one session's header and events.
+   *
+   * The controller's shape changed between Host builds. Older builds exposed
+   * `inspect(sessionId)` returning `{ meta, events }`; the current one exposes
+   * `events({ address, ... }, signal)` returning a page of `{ records: [{ type, event }] }`.
+   * Calling the old name on the new build throws `controller.inspect is not a function`,
+   * which surfaced as share and segment-delete both failing with that raw error in the
+   * dialog — the feature looked broken rather than the Host having moved on.
+   *
+   * Both shapes are attempted, newest first, so this works on either build without
+   * pinning to one. The normalised result is the same either way, so every caller
+   * above this line stays unchanged.
+   *
    * @param {string} sessionId session
    * @returns {Promise<{ meta: any, events: any[], title?: string, cwd?: string }>} inspection
    */
   async inspect(sessionId) {
     const controller = this.#require('sessionController')
-    const inspection = await controller.inspect(sessionId)
-    if (!inspection) throw new Error(`session ${sessionId} was not found`)
-    const events = Array.isArray(inspection.events) ? inspection.events : []
-    return { meta: inspection.meta ?? { id: sessionId }, events, title: titleOf(events), cwd: inspection.meta?.cwd }
+
+    // Current build: a paged read keyed by a session address.
+    if (typeof controller.events === 'function') {
+      // The Remote signature is `events(request, signal)` and the implementation calls
+      // `signal.throwIfAborted()` before reading — so a missing signal throws
+      // "Cannot read properties of undefined (reading 'throwIfAborted')" rather than
+      // defaulting to "no cancellation". Pass a real AbortSignal.
+      //
+      // A single call returns ONE PAGE, not the whole session. The share dialog showed
+      // "3/3 turns" for a conversation with 129 — the reader had been given the last
+      // page and nothing else. Page backwards until the reader reports no more, so
+      // callers get the complete history they were always promised.
+      const signal = new AbortController().signal
+      const collected = []
+      let beforeSeq
+      let guard = 0
+      while (guard < 400) {
+        guard += 1
+        const request = { address: { kind: 'session', sessionId } }
+        if (typeof beforeSeq === 'number') request.beforeSeq = beforeSeq
+        const page = await controller.events(request, signal)
+        const records = Array.isArray(page?.records) ? page.records : []
+        const events = records
+          .map(record => (record?.type === 'event' ? record.event : record?.event ?? record))
+          .filter(Boolean)
+        // Pages arrive newest-first or oldest-first depending on the cursor; collecting
+        // in order and de-duplicating by seq at the end keeps this independent of which.
+        collected.push(...events)
+        if (!page?.hasMore || records.length === 0) break
+        // The cursor is the inclusive boundary of the page just read.
+        const next = typeof page?.cursor === 'number' ? page.cursor : undefined
+        if (next === undefined || next === beforeSeq) break
+        beforeSeq = next
+      }
+      const seen = new Map()
+      for (const event of collected) {
+        const key = typeof event?.seq === 'number' ? event.seq : undefined
+        if (key === undefined) continue
+        if (!seen.has(key)) seen.set(key, event)
+      }
+      const events = [...seen.values()].sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0))
+      const meta = { id: sessionId, cwd: undefined }
+      // The header lives in the session summary; the event stream does not carry it.
+      const summary = await this.#sessionSummary(controller, sessionId)
+      if (summary?.cwd) meta.cwd = summary.cwd
+      return { meta, events, title: titleOf(events), cwd: meta.cwd }
+    }
+
+    // Older build: a single inspect call.
+    if (typeof controller.inspect === 'function') {
+      const inspection = await controller.inspect(sessionId)
+      if (!inspection) throw new Error(`session ${sessionId} was not found`)
+      const events = Array.isArray(inspection.events) ? inspection.events : []
+      return { meta: inspection.meta ?? { id: sessionId }, events, title: titleOf(events), cwd: inspection.meta?.cwd }
+    }
+
+    throw new Error('this Host exposes neither sessionController.events nor sessionController.inspect')
+  }
+
+  /**
+   * Find one session's summary row, for fields the event stream does not carry.
+   *
+   * @param {any} controller session controller
+   * @param {string} sessionId session
+   * @returns {Promise<any | undefined>} summary
+   */
+  async #sessionSummary(controller, sessionId) {
+    try {
+      const value = await controller.list({})
+      const items = Array.isArray(value?.items) ? value.items : []
+      return items.find(item => item?.sessionId === sessionId)
+    } catch {
+      return undefined
+    }
   }
 
   /**
@@ -541,9 +624,12 @@ export class SessionSuiteService {
     // `signal.throwIfAborted()` while admitting the prompt, so omitting the
     // second argument makes it dereference `undefined` — reported as
     // "Cannot read properties of undefined (reading 'throwIfAborted')".
-    const result = signal === undefined
-      ? await controller.prompt(request)
-      : await controller.prompt(request, signal)
+    //
+    // A branch on `signal === undefined` still passed undefined in that case, which is
+    // exactly the input that crashes. Always supply a real signal: reuse the caller's
+    // when there is one, otherwise create an unaborted one.
+    const effective = signal ?? new AbortController().signal
+    const result = await controller.prompt(request, effective)
     if (result && result.accepted === false) throw new Error('the Host rejected the resent prompt')
   }
 

package/package.json

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