@heixui/dsh-session-suite 0.5.0 → 0.6.0

package/client.js

@@ -272,6 +272,7 @@ window.__ModuleLoader__.load({
         'memory.extractionNotRegistered': 'HOOK NOT REGISTERED',
         'memory.extractionNoTrace': 'no extraction trace recorded by this Host',
         'memory.diagTitle': 'Extraction diagnostics:',
+        'memory.diagSteps': '{ok}/{total} hooks installed',
         'memory.accept': 'Keep',
         'memory.reject': 'Discard',
         'memory.accepted': 'Kept',
@@ -520,6 +521,7 @@ window.__ModuleLoader__.load({
         'memory.extractionNotRegistered': '钩子未注册',
         'memory.extractionNoTrace': '本次运行没有记录到提取痕迹',
         'memory.diagTitle': '提取诊断：',
+        'memory.diagSteps': '{ok}/{total} 个钩子已装',
         'memory.accept': '保留',
         'memory.reject': '丢弃',
         'memory.accepted': '已保留',
@@ -1047,6 +1049,7 @@ window.__ModuleLoader__.load({
   font-weight: 600;
   color: var(--dsw-alias-label-primary, #1f1f1f);
 }
+.dss-diag-steps { color: var(--dsw-alias-label-secondary, #6b6b6b); }
 /* The summary charts. Two narrow panels for composition and health, one wide panel
    for tags: composition and health are short lists, tags can run long. Bars are divs,
    not SVG, so they inherit the theme and stay legible in both palettes. */
@@ -3449,6 +3452,10 @@ window.__ModuleLoader__.load({
       // unremarkable" from "every memory model failed" or "a filter ate the
       // result". When there is nothing pending, say why.
       const extraction = status?.extraction
+      // Which optional hooks installed. Reported separately from the extraction trace
+      // because a hook that never installed cannot write a trace — that is the whole
+      // point: "no trace" has two causes and this separates them.
+      const installStatus = Array.isArray(status?.install) ? status.install : []
       const pendingBlock =
         pending.length > 0
           ? h(
@@ -3565,6 +3572,23 @@ window.__ModuleLoader__.load({
                         : t('memory.extractionNotRegistered'),
                     )
                   : null,
+                // The registration ledger: which optional hooks installed and which
+                // threw. This is the only way to see a step that never ran, because the
+                // code that would have reported it is the code that failed.
+                installStatus.length > 0
+                  ? h(
+                      'span',
+                      { className: 'dss-diag-steps' },
+                      t('memory.diagSteps', {
+                        ok: installStatus.filter(step => step.ok).length,
+                        total: installStatus.length,
+                      }),
+                      installStatus
+                        .filter(step => !step.ok)
+                        .map(step => ` · ${step.label}: ${step.error ?? 'failed'}`)
+                        .join(''),
+                    )
+                  : null,
               ),
             )
 

package/cordis.patch.yml

@@ -54,12 +54,19 @@
         # says otherwise.
         recallLimit: 6
         # How much of the conversation before the current message is folded into the
-        # retrieval query. A follow-up like "那它为什么慢？" has no referent for "它", so
-        # searching those characters alone cannot find the memory that answers it.
-        # The previous user turns are appended BEFORE the current question, so the
-        # question's own terms still dominate the score. 0 disables the behaviour and
-        # searches the current message exactly as before.
-        contextQueryChars: 160
+        # retrieval query. DEFAULT 0 = OFF.
+        #
+        # Why off by default: the model already receives the full conversation history,
+        # so it knows what 「它」 refers to. Folding earlier turns into the query only
+        # helps the RETRIEVAL step pick a better memory; it does not make the model
+        # understand the question better. That is a real but small gain, and it costs a
+        # little accuracy on self-contained questions that get padded unnecessarily.
+        #
+        # Turn it on when the prompt is short by design — a workflow that deliberately
+        # keeps requests small (an agent that works from a compact brief rather than a
+        # long transcript) benefits, because there the history is NOT in the prompt.
+        # 160 characters across 3 previous turns is a reasonable starting point.
+        contextQueryChars: 0
         contextQueryTurns: 3
         # How many of the most important memories ride along regardless of the
         # question. Without a resident layer, an ordinary follow-up like "继续"

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']
 
 /**
  * @param {any} ctx plugin context
@@ -97,6 +114,10 @@ export function apply(ctx, config = {}) {
     try {
       const installed = installMemory({ ctx, root, config, log })
       service.longTerm = installed.engine
+      // Kept separately: the engine is the memory store, and this is the record of
+      // which optional registrations succeeded. Exposed through the status endpoint so
+      // a missing feature can be traced to a step that never installed.
+      service.memoryInstallStatus = installed.installStatus
       log('long-term memory engine ready')
     } catch (error) {
       log('long-term memory failed to install; continuing without it', error)

package/lib/api.js

@@ -303,8 +303,14 @@ async function respond(service, deps, action, input) {
       })
     case 'longterm.maintain':
       return json({ ok: true, data: await service.longTerm.maintain(workspaceOf(input)) })
-    case 'longterm.status':
-      return json({ ok: true, data: await service.longTerm.status() })
+    case 'longterm.status': {
+      // The engine's own status plus the registration ledger. Two sources on purpose:
+      // the engine cannot report a hook that never installed, because the code that
+      // would have written it is the code that failed.
+      const status = await service.longTerm.status()
+      const install = typeof service.memoryInstallStatus === 'function' ? service.memoryInstallStatus() : []
+      return json({ ok: true, data: { ...status, install } })
+    }
     case 'longterm.workspaces':
       return json({ ok: true, data: await service.longTerm.workspaces() })
     case 'longterm.models':

package/lib/memory-host.js

@@ -91,13 +91,21 @@ export function installMemory({ ctx, root, config, log }) {
    * Run one optional registration; a failure is reported and skipped so a single
    * incompatible hook can never disable the rest of the bundle.
    *
+   * Every step records its outcome. The silent-catch was the reason a broken step was
+   * invisible: "the queue is empty" could mean the hook was never installed, and
+   * nothing on screen said so. The steps list is published through status() so the
+   * settings page can show which registrations succeeded.
+   *
    * @param {string} label what is being installed
    * @param {() => void} install registration body
    */
+  const steps = []
   const safe = (label, install) => {
     try {
       install()
+      steps.push({ label, ok: true })
     } catch (error) {
+      steps.push({ label, ok: false, error: error instanceof Error ? error.message : String(error) })
       log(`long-term memory: ${label} failed to install`, error)
     }
   }
@@ -186,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.
           //
@@ -206,6 +261,66 @@ 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) 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') 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 for agents that already exist, and for every one created later.
+    for (const agent of agents.list?.() ?? []) mountFor(agent)
+    if (typeof ctx.on === 'function') {
+      ctx.on('agent/created', payload => {
+        try {
+          mountFor(payload?.agent ?? payload)
+        } catch {
+          /* one bad agent must not stop the rest */
+        }
+      })
+    }
+  })
+
   // --- 3. Implicit extraction after a turn --------------------------------
   safe('implicit extraction', () => {
     // A startup marker, recorded before the listener is even registered.
@@ -410,6 +525,9 @@ export function installMemory({ ctx, root, config, log }) {
   return {
     engine,
     dispose: () => {},
+    // The outcome of every optional registration, so "the queue is empty" can be
+    // traced to a specific step that never installed.
+    installStatus: () => [...steps],
     // 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.
@@ -535,8 +653,17 @@ function contextualQuery(messages, limits = {}) {
   const current = lastUserText(messages)
   if (!current) return ''
 
-  const maxChars = limits.chars ?? 160
-  const maxTurns = limits.turns ?? 3
+  // 0 is the default, and it means disabled.
+  //
+  // Why: the model already receives the conversation history, so it knows what a
+  // pronoun refers to. Folding earlier turns into the retrieval query only improves
+  // which MEMORY is picked — a real but small gain — and it costs a little accuracy
+  // on self-contained questions that get padded unnecessarily. It matters for a
+  // workflow that deliberately keeps the prompt small, where the history is not there
+  // to be read; that is the case this exists for, and it is opt-in.
+  const maxChars = typeof limits.chars === 'number' ? limits.chars : 0
+  const maxTurns = typeof limits.turns === 'number' ? limits.turns : 3
+  if (maxChars <= 0) return current
 
   // A self-contained question needs no help. The test is NOT length alone: a short
   // question that names its own subject ("导出的图片为什么断链") is self-contained,
@@ -575,6 +702,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.
  *
@@ -664,8 +829,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)
@@ -674,7 +846,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'
@@ -836,7 +1008,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)
@@ -850,7 +1022,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.0",
+  "version": "0.6.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",