@heixui/dsh-session-suite 0.4.4 → 0.5.1

package/client.js

@@ -270,6 +270,9 @@ window.__ModuleLoader__.load({
         'memory.extractionTurns': '{n} turn(s) ended',
         'memory.extractionRegistered': 'hook registered',
         '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',
@@ -516,6 +519,9 @@ window.__ModuleLoader__.load({
         'memory.extractionTurns': '结束 {n} 轮',
         'memory.extractionRegistered': '钩子已注册',
         'memory.extractionNotRegistered': '钩子未注册',
+        'memory.extractionNoTrace': '本次运行没有记录到提取痕迹',
+        'memory.diagTitle': '提取诊断：',
+        'memory.diagSteps': '{ok}/{total} 个钩子已装',
         'memory.accept': '保留',
         'memory.reject': '丢弃',
         'memory.accepted': '已保留',
@@ -1026,6 +1032,24 @@ window.__ModuleLoader__.load({
   overflow-y: auto;
   overscroll-behavior: contain;
 }
+/* The extraction diagnostic. Deliberately larger than the meta text around it and set
+   on its own tinted strip: it exists to answer "why is the queue empty", and the first
+   version was 11px grey text inside a bordered box that the user reported not seeing
+   at all. A diagnostic that cannot be found is not a diagnostic. */
+.dss-extraction-diag {
+  display: flex; flex-wrap: wrap; gap: 6px 16px; align-items: baseline;
+  margin-top: 8px; padding: 8px 12px;
+  border-radius: 8px;
+  background: var(--dsw-alias-bg-layer-2, #f2f3f5);
+  font-size: 12.5px; line-height: 1.5;
+  color: var(--dsw-alias-label-secondary, #4a4a4a);
+  font-variant-numeric: tabular-nums;
+}
+.dss-diag-title {
+  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. */
@@ -3428,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(
@@ -3511,21 +3539,57 @@ window.__ModuleLoader__.load({
               // `registered` is the third state: the hook was never installed at all
               // (the optional registration threw), which is a different bug from
               // "installed but never called".
-              extraction
-                ? h(
-                    'div',
-                    { className: 'dss-row-meta' },
-                    h('span', null, t('memory.extractionEvents', { n: extraction.eventsSeen ?? 0 })),
-                    h('span', null, t('memory.extractionTurns', { n: extraction.turnEndsSeen ?? 0 })),
-                    h(
+              //
+              // This block renders even when `extraction` is null, and says so. The
+              // previous version was gated on `extraction` being present — so a Host
+              // that never recorded a trace (registration failed, or the status
+              // endpoint reads a different engine) showed nothing at all, which is
+              // exactly the case the diagnostic existed to expose.
+              //
+              // Rendered at a readable size rather than in the row-meta micro type:
+              // it is a diagnostic, and a diagnostic nobody can find is the same as
+              // no diagnostic. The 11px meta line was reported as "I don't see it".
+              h(
+                'div',
+                { className: 'dss-extraction-diag' },
+                h('span', { className: 'dss-diag-title' }, t('memory.diagTitle')),
+                h(
+                  'span',
+                  null,
+                  extraction
+                    ? t('memory.extractionEvents', { n: extraction.eventsSeen ?? 0 })
+                    : t('memory.extractionNoTrace'),
+                ),
+                extraction
+                  ? h('span', null, t('memory.extractionTurns', { n: extraction.turnEndsSeen ?? 0 }))
+                  : null,
+                extraction
+                  ? h(
                       'span',
                       null,
                       extraction.registered
                         ? t('memory.extractionRegistered')
                         : t('memory.extractionNotRegistered'),
-                    ),
-                  )
-                : null,
+                    )
+                  : 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,
+              ),
             )
 
       // The list gets its own scroll box.

package/cordis.patch.yml

@@ -53,6 +53,21 @@
         # the budget would claim six memories are relevant when the evidence
         # says otherwise.
         recallLimit: 6
+        # How much of the conversation before the current message is folded into the
+        # 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 "继续"
         # shares no vocabulary with any memory and a strict relevance filter

package/index.js

@@ -97,6 +97,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)
     }
   }
@@ -175,7 +183,13 @@ export function installMemory({ ctx, root, config, log }) {
             log(`explicit memory stored (${instruction.scope})`)
           }
 
-          const question = lastUserText(messages)
+          // The question, plus enough of the conversation before it to resolve a
+          // short follow-up. See contextualQuery: a bare 「那它为什么慢？」 has no
+          // referent for 「它」 and cannot match the memory that answers it.
+          const question = contextualQuery(messages, {
+            chars: typeof config?.contextQueryChars === 'number' ? config.contextQueryChars : undefined,
+            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() })
           lastRecall = text
@@ -404,6 +418,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.
@@ -495,6 +512,89 @@ function lastUserText(messages) {
   return ''
 }
 
+/**
+ * The current question plus the tail of the conversation before it.
+ *
+ * Retrieval used to search for the last user message alone, so a follow-up like
+ * 「那它为什么慢？」 searched for those seven characters and nothing else. "它" is a
+ * pronoun with no referent in the query, so the memory that explains the slowness could
+ * not be found no matter how well it was written. That is a real gap, not a tuning
+ * problem.
+ *
+ * The shape here is deliberate:
+ *
+ *   • the current question comes LAST, so it dominates the lexical score (BM25 and the
+ *     coverage route both reward a match in the query; putting context first would let
+ *     an older turn outvote the thing being asked now);
+ *   • only the previous USER turns are included, not assistant replies. Assistant text
+ *     is verbose, and a long reply would drown the query in words the user never typed;
+ *   • the tail is capped in characters rather than turns, because one long message and
+ *     ten short ones should not cost the same;
+ *   • nothing is included when the current question already stands alone (long enough
+ *     and not pronoun-led), so an ordinary self-contained question is searched exactly
+ *     as before.
+ *
+ * This is a heuristic, not a language model. It will not resolve 「那个东西」 back to a
+ * noun three turns ago. It does fix the common case — a short follow-up — and it costs
+ * nothing at query time.
+ *
+ * @param {readonly any[]} messages step messages
+ * @param {{ chars?: number, turns?: number }} [limits] budget
+ * @returns {string} query text
+ */
+function contextualQuery(messages, limits = {}) {
+  const current = lastUserText(messages)
+  if (!current) return ''
+
+  // 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,
+  // while a long one made of pronouns ("那这个呢，还有刚才说的那个，它到底是怎么回事")
+  // is not. Pronouns are the actual signal — they are what a query cannot resolve.
+  //
+  // An earlier version used `length >= 24`, which was a guess and misclassified a
+  // perfectly clear 20-character question as needing context. Pronoun presence is a
+  // narrower, more defensible rule: it fires exactly when the query contains a word
+  // that refers to something outside itself.
+  const PRONOUNS = /(它|他|她|这个|那个|这些|那些|该|此|上述|前面|刚才|上面|之前那个)/
+  const looksSelfContained = !PRONOUNS.test(current)
+
+  const earlier = []
+  let budget = maxChars
+  let seen = 0
+  for (let index = (messages?.length ?? 0) - 1; index >= 0 && seen < maxTurns; index -= 1) {
+    const message = messages[index]
+    if (message?.role !== 'user') continue
+    const text = contentText(message.content)
+    if (!text) continue
+    seen += 1
+    // The newest user message IS `current`; skip it so it is not duplicated.
+    if (text === current) continue
+    if (budget <= 0) break
+    const slice = text.length > budget ? text.slice(-budget) : text
+    earlier.unshift(slice)
+    budget -= slice.length
+  }
+
+  // Nothing to add, or the question stands on its own: search it as-is.
+  if (earlier.length === 0 || looksSelfContained) return current
+
+  // Context first, question last. The engine tokenises the whole string, and the
+  // question's own terms are what must win.
+  return `${earlier.join(' ')} ${current}`.trim()
+}
+
 /**
  * Ask a small model call what, if anything, is worth remembering from this turn.
  *

package/package.json

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