dsh-loci 2.1.0 → 2.3.1

package/CHANGELOG.md

@@ -4,6 +4,85 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); the project follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html) from 1.0.0.
 
+## [2.3.1] — 2026-11-15
+
+### Fixed
+
+- **A corrupted line in the config schema.** `2.3.0` failed in CI at
+  `.number().n .step(1)` — a patch script wrote a literal `.n` where a newline was
+  meant. It passed every local gate, because `buildSchema()` only runs when
+  `@deepseek-ai/schemastery` resolves, and a checkout without dependencies never
+  executes that line.
+
+### Added
+
+- `test/unit/config-schema.test.mjs` builds the schema whenever the peer dependency
+  is present, and constructs it with the shipped defaults. A broken chain, an
+  out-of-range default or a wrong union member now fails a test instead of a tag.
+  The corruption above was reintroduced on purpose to confirm this test catches it.
+
+### Note
+
+`2.3.0` was tagged but **never published** (the CI job stopped before the publish
+step). This is the first version carrying the session digest.
+
+## [2.3.0] — 2026-11-15
+
+The last open item from the blind review, and the one a heavy daily user called the
+biggest product hole: between "deterministic rules" and "ask the model every turn"
+there was no middle. Per-turn extraction asks for one review decision per turn until
+the queue is abandoned; rules alone miss anything stated in passing.
+
+### Added
+
+- **`extractMode: 'session'`** — one digest per session, run when the session ends,
+  proposing at most `extractSessionMaxCandidates` (5) items. Same rules as before:
+  candidates only, verbatim-quote grounding, hourly budget, timeout, silent failure.
+  `'on'`/`'turn'` keep the per-turn behaviour for anyone who wants it.
+
+- **Review groups a digest.** List rows now carry `sourceSession`, and the review tab
+  shows "N proposed together" with one button to verify that batch — the shape the
+  reviewer asked for, instead of five identical rows and five decisions.
+
+### Notes
+
+- The digest runs independently of the episodic summary, so a user can want one
+  without the other, and a failing model cannot break the session release.
+- The buffer is copied before the asynchronous call: releasing it at dispose must
+  not race with the model reading it.
+
+## [2.2.0] — 2026-11-15
+
+Four reviewers of an independent blind review named the same risk: `engines.dsh`
+admits the whole `>=0.2.2-rc.1 <0.3.0-0` range, but the only version ever booted was
+`0.2.2-rc.1`. A range is a promise nobody tested.
+
+### Added
+
+- **`scripts/compat-probe.mjs`** — reads the *installed* Host out of its `app.asar`
+  and asserts that every API this plugin touches still exists in the expected shape:
+  the section contract (`interpolate: false`, `order`), the `tools`, `commands` and
+  `connection` services with their registration calls, and the `turn/end` event.
+  Run against the installed **0.2.2-rc.3**: **5/5 passed**. It is not a boot test,
+  and the docs now say exactly which question it answers and which it does not.
+
+- **The store records the Host that opened it.** `DSH_INSTALL_DIR` is read at
+  activation, the version lands in `meta.host_version`, `stats` exposes it, the panel
+  shows it, and `loci doctor` prints
+  `[ok] host: last opened by DeepSeek Harness 0.2.2-rc.3`. Every user install now
+  produces the evidence the next compatibility table needs, instead of leaving the
+  answer to a range in a manifest.
+
+- CI gained a conditional probe step: it runs where a Host is installed and prints a
+  skip notice otherwise (the Host is not published to npm, so a stock runner has
+  nothing to read).
+
+### Changed
+
+- `dshReleases` gained a `0.2.2-rc.3` row with status `api-surface-verified` — a
+  deliberate third status between "verified" (booted) and "untested", so a range
+  entry can never again imply more than was actually checked.
+
 ## [2.1.0] — 2026-11-15
 
 Two findings from an independent blind review, where seven reviewers compared this

package/README.md

@@ -108,7 +108,7 @@ The settings page writes the fields marked *live* without a restart.
 | `rulesMaxBytes` | `1024` | ceiling for the rules block inside that budget |
 | `defaultScope` | `workspace` | scope a write lands in when it does not say |
 | `captureMode` | `rules` | deterministic capture of explicit durable statements |
-| `extractMode` | `off` | `on` asks the configured model, at turn end, what is worth remembering — always as candidates, always budgeted |
+| `extractMode` | `off` | `session` asks the model once, when a session ends, for up to `extractSessionMaxCandidates` proposals — one sitting to review, not one per turn. `turn`/`on` keep the older per-turn behaviour. Always candidates, always budgeted |
 | `recallAssist` | `off` | one bounded first-turn recall block per session |
 | `maintenanceMode` | `sweep` | TTL, index repair, and embedding backfill every 6h |
 | `secretPolicy` | `redact` | redact high-confidence secrets, or refuse the write |

package/README.zh.md

@@ -78,7 +78,7 @@ node "$HOME/.dsh/profiles/<profile>/node_modules/dsh-loci/scripts/cli.mjs" docto
 | `rulesMaxBytes` | `1024` | 段内规则块的字节上限 |
 | `defaultScope` | `workspace` | 未显式指定时的写入作用域 |
 | `captureMode` | `rules` | 规则型捕获用户的明确约定 |
-| `extractMode` | `off` | 设为 `on` 时，在回合结束让模型提一遍「这轮有什么值得记」——一律落为候选，且有预算上限 |
+| `extractMode` | `off` | 设为 `session` 时，在**会话结束**让模型提一次、最多 `extractSessionMaxCandidates` 条——一次坐下审完，而不是每轮审一条。`turn`/`on` 保留旧的逐轮行为。一律落为候选，且有预算上限 |
 | `recallAssist` | `off` | 每会话一次、有上限的首轮辅助召回块 |
 | `maintenanceMode` | `sweep` | 每 6 小时做 TTL、索引修复、向量补齐 |
 | `secretPolicy` | `redact` | 高置信密钥脱敏，或直接拒绝写入 |

package/client.js

@@ -136,6 +136,8 @@ window.__ModuleLoader__.load({
       'panel.noCandidates': 'Nothing waiting for review.',
       'panel.reviewHint': 'Only entries that could be injected are listed. A summary of a past session is history, not a claim.',
       'panel.reject': 'Reject',
+      'panel.digestOf': '{n} proposed together',
+      'panel.verifyGroup': 'Verify these {n}',
       'panel.verifyAll': 'Verify all {n}',
       'panel.actionFailed': 'Action failed',
       'panel.injections': 'Recent injections',
@@ -257,6 +259,8 @@ window.__ModuleLoader__.load({
       'panel.noCandidates': '没有待审条目。',
       'panel.reviewHint': '这里只列可能被注入的条目；过去会话的摘要属于历史，不是主张。',
       'panel.reject': '驳回',
+      'panel.digestOf': '同一批次提出 {n} 条',
+      'panel.verifyGroup': '核实这 {n} 条',
       'panel.verifyAll': '全部核实（{n}）',
       'panel.actionFailed': '操作失败',
       'panel.injections': '最近注入',
@@ -985,6 +989,35 @@ window.__ModuleLoader__.load({
           ),
           h('div', { className: 'loci-actions' }, actions, h('button', { type: 'button', className: 'loci-btn is-quiet', onClick: () => onOpen(item.id) }, '→')),
         );
+      // A session digest arrives as a batch. Showing five identical-shaped rows with
+      // no grouping is what turns one sitting into five decisions; grouping lets the
+      // reviewer confirm the batch that was proposed together.
+      const bySession = (items) => {
+        const groups = new Map();
+        for (const item of items) {
+          const key = item.sourceSession ?? '';
+          const list = groups.get(key);
+          if (list === undefined) groups.set(key, [item]);
+          else list.push(item);
+        }
+        return groups;
+      };
+      const sessionGroups = (items) =>
+        [...bySession(items).entries()]
+          .filter(([key, list]) => key !== '' && list.length > 1)
+          .map(([key, list]) =>
+            h(
+              'div',
+              { key, className: 'loci-meta', style: { margin: '10px 0 4px', alignItems: 'center' } },
+              h('span', null, `${t('panel.digestOf').replace('{n}', String(list.length))} · ${key.slice(0, 12)}`),
+              h('span', { className: 'loci-grow' }),
+              h(
+                'button',
+                { type: 'button', className: 'loci-btn is-primary', disabled: busy !== undefined, onClick: () => verifyMany(list) },
+                t('panel.verifyGroup').replace('{n}', String(list.length)),
+              ),
+            ),
+          );
       const block = (title, state, actions) =>
         h(
           'div',
@@ -1008,7 +1041,7 @@ window.__ModuleLoader__.load({
               : null,
           ),
           state.data?.items?.length
-            ? state.data.items.map((item) => row(item, actions(item)))
+            ? [sessionGroups(state.data.items), ...state.data.items.map((item) => row(item, actions(item)))]
             : h('div', { className: 'loci-muted' }, t('panel.noCandidates')),
         );
       const candidateActions = (item) => [
@@ -1076,6 +1109,7 @@ window.__ModuleLoader__.load({
                 { className: 'loci-kv' },
                 h('dt', null, 'path'), h('dd', null, data.memoryRoot ?? '—'),
                 h('dt', null, 'schema'), h('dd', null, `v${data.schemaVersion}`),
+                h('dt', null, 'host'), h('dd', null, data.hostVersion ?? 'unknown'),
                 h('dt', null, 'vector'), h('dd', null, `${vs.mode ?? 'off'}${vs.healthy ? ' · healthy' : ''}${vs.lastError ? ` · ${vs.lastError}` : ''}`),
                 h('dt', null, 'last injection'),
                 h('dd', null, data.lastInjection ? `${data.lastInjection.bytes} B · ${data.lastInjection.listed} listed · ${data.lastInjection.hidden} hidden` : '—'),

package/docs/COMPATIBILITY.md

@@ -8,8 +8,39 @@
 | 0.2.2-rc.1 (host) | **24.22.3** | Ubuntu 24.04 (WSL2) | **verified** — manifest gate, 38/38 tests, coverage 82.93%, benchmark p95 5.28 ms at 2k | `scripts/run-linux-ci.sh` (fetches Node 24, runs the same commands as CI) |
 | 0.2.2-rc.1 (host) | 22.23.0 | Ubuntu 24.04 (WSL2) | **verified** — same suite × 3 consecutive runs | recorded in `docs/ACCEPTANCE.md` §6 |
 | 0.2.2-rc.1 | 24 | Ubuntu (GitHub Actions) | the identical step list runs in `.github/workflows/ci.yml`; the host is not published, so Actions has not run it | `.github/workflows/ci.yml` |
+| **0.2.2-rc.3** | 24.21.0 | Windows 11 | **API surface verified** — the source-signature probe passes 5/5 against the installed `app.asar`; not a boot test | `node scripts/compat-probe.mjs --asar <install>/resources/app.asar` |
 | other 0.2.x | — | — | not verified | — |
 
+### What "API surface verified" does and does not mean
+
+A range in `engines.dsh` is a promise nobody tested. `scripts/compat-probe.mjs`
+reads the **installed** host package out of the shipped `app.asar` and asserts that
+every Host API this plugin touches is still present in the shape it expects:
+
+```text
+host      : 0.2.2-rc.3
+[ok  ] systemPrompt sections        interpolate: false, order, section(
+[ok  ] tools service + register     super(ctx, "tools"), register(
+[ok  ] session turn/end event       "turn/end"
+[ok  ] commands service + register  super(ctx, "commands"), register(
+[ok  ] connection service           super(ctx, "connection")
+5/5 checks passed
+```
+
+It catches a renamed service, a changed section contract, or a moved event — the
+failures that would otherwise show up as "the plugin silently stopped injecting" on
+a version we never booted. It does **not** prove activation, tool registration at
+runtime, or injection on a live session; those still require a real host, and rc.3
+has not had one in this repository yet.
+
+The plugin also records the host version it meets: `DSH_INSTALL_DIR` is read at
+activation, the value lands in `meta.host_version`, and `loci doctor` prints
+`[ok] host: last opened by DeepSeek Harness 0.2.2-rc.3`. That turns every user
+install into evidence for the next compatibility table.
+
+CI runs the probe **when a host is present** and prints a skip notice otherwise
+(the host is not published to npm, so a stock runner has nothing to read).
+
 `scripts/run-linux-ci.sh` exists so the Linux claim is reproducible on any machine
 with WSL: it downloads the newest Node 24 tarball to `/tmp` (nothing is installed
 system-wide), then runs `check-manifest`, the unit+integration suite, the coverage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-loci",
-  "version": "2.1.0",
+  "version": "2.3.1",
   "description": "Layered long-term memory for DeepSeek Harness: the prompt sees only a stable index, full text is one lookup away. Bi-temporal facts, strict scope isolation, verified-only injection.",
   "type": "module",
   "license": "MIT",
@@ -64,6 +64,15 @@
       ],
       "status": "verified",
       "evidence": "docs/COMPATIBILITY.md#022-rc1"
+    },
+    {
+      "dsh": "0.2.2-rc.3",
+      "node": "24.21.0",
+      "os": [
+        "win32"
+      ],
+      "status": "api-surface-verified",
+      "evidence": "docs/COMPATIBILITY.md#what-api-surface-verified-does-and-does-not-mean"
     }
   ],
   "dependencies": {

package/scripts/cli.mjs

@@ -39,6 +39,9 @@ const PLUGIN_VERSION = JSON.parse(
   readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
 ).version;
 
+/** The shipped manifest, read once: version for reports, engines for the host check. */
+const MANIFEST = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+
 const rawArgv = process.argv.slice(2);
 
 /**
@@ -129,7 +132,9 @@ const diagnosticScope = () => {
 
 switch (command) {
   case 'doctor': {
-    const result = await withStore((store) => runDoctor({ store, paths, config: effectiveConfig({ home }) }));
+    const result = await withStore((store) =>
+        runDoctor({ store, paths, config: effectiveConfig({ home }), engines: MANIFEST.engines }),
+      );
     if (json) console.log(JSON.stringify(result, null, 2));
     else console.log(formatDoctor(result));
     process.exitCode = result.status === 'fail' ? 1 : 0;

package/src/host/capture/capture.js

@@ -185,7 +185,10 @@ export class Capture {
    * slow model must not delay the rule capture that costs nothing.
    */
   #scheduleExtraction(sessionId, buffer) {
-    if (this.config('extractMode') !== 'on' || this.extractor === undefined) return;
+    const mode = this.config('extractMode');
+    // 'session' deliberately does not schedule per turn: that is the whole point of
+    // the mode. It runs once, in summarize(), when the session ends.
+    if ((mode !== 'on' && mode !== 'turn') || this.extractor === undefined) return;
     if (buffer.extractTimer !== undefined) return;
     const delay = Math.max(0, Number(this.config('captureDebounceMs') ?? 30000));
     buffer.extractTimer = setTimeout(() => {
@@ -196,6 +199,7 @@ export class Capture {
         .then(() =>
           extractor.run({
             sessionId,
+            mode: 'turn',
             messages: buffer.messages,
             scopeKey: this.#workspaceKey(buffer.cwd, sessionId),
             scopeLabel: this.#workspaceLabel(buffer.cwd),
@@ -299,6 +303,39 @@ export class Capture {
     );
   }
 
+  /**
+   * One extraction pass for a whole session, run as it ends.
+   *
+   * This is the middle ground the review asked for: deterministic rules catch
+   * statements that announce themselves, per-turn extraction catches everything but
+   * costs one review decision per turn. A session digest reads the whole
+   * conversation once and proposes at most a handful of items in one sitting.
+   *
+   * Fire-and-forget by design: the buffer is copied before the asynchronous call so
+   * releasing it cannot race with the model.
+   *
+   * @param sessionId - session id.
+   * @param buffer - the buffered messages.
+   */
+  #runSessionDigest(sessionId, buffer) {
+    const extractor = this.extractor;
+    if (extractor === undefined || buffer === undefined || buffer.messages.length < 4) return;
+    const messages = [...buffer.messages];
+    const scopeKey = this.#workspaceKey(buffer.cwd, sessionId);
+    const scopeLabel = this.#workspaceLabel(buffer.cwd);
+    Promise.resolve()
+      .then(() => extractor.run({ sessionId, mode: 'session', messages, scopeKey, scopeLabel }))
+      .then((result) => {
+        if (result?.written > 0) {
+          this.statistics.extracted += result.written;
+          this.log?.debug?.(`loci: session digest proposed ${result.written} item(s)`);
+        }
+      })
+      .catch((error) => {
+        this.log?.debug?.(`loci: session digest failed: ${String(error?.message ?? error)}`);
+      });
+  }
+
   /** Write the episodic summary for one session and drop its buffer. */
   summarize(sessionId, reason = 'dispose') {
     const buffer = this.sessions.get(sessionId);
@@ -311,6 +348,11 @@ export class Capture {
       if (buffer.extractTimer !== undefined) clearTimeout(buffer.extractTimer);
       this.sessions.delete(sessionId);
     };
+    // The digest is independent of the episodic summary: a user can want one and not
+    // the other, and the digest must still run when summaries are off.
+    if (this.config('extractMode') === 'session' && buffer !== undefined) {
+      this.#runSessionDigest(sessionId, buffer);
+    }
     if (this.config('summaryOnDispose') !== true) {
       release();
       return 0;

package/src/host/config.js

@@ -61,8 +61,15 @@ export const DEFAULTS = Object.freeze({
   captureMaxPerStatementChars: 200,
   /** Write one episodic session summary when a root agent is disposed. */
   summaryOnDispose: true,
-  /** 'off' | 'on' — background extraction of preferences stated in passing. */
+  /**
+   * 'off' | 'on' | 'turn' | 'session' — background extraction of preferences stated
+   * in passing. 'on' and 'turn' mean one pass per turn (noisy: one proposal per
+   * turn becomes a review chore). 'session' means one digest when the session ends,
+   * which is the mode a heavy user asked for: five proposals, one sitting.
+   */
   extractMode: 'off',
+  /** How many candidates one session-end digest may propose. */
+  extractSessionMaxCandidates: 5,
   /** Hard cap on extraction calls per hour; exhausting it is silent. */
   extractMaxCallsPerHour: 6,
   /** How many candidates one extraction run may write. */
@@ -123,7 +130,7 @@ export const ENUMS = Object.freeze({
   defaultScope: ['workspace', 'project', 'global'],
   recallAssist: ['off', 'session-start'],
   captureMode: ['rules', 'off'],
-  extractMode: ['off', 'on'],
+  extractMode: ['off', 'on', 'turn', 'session'],
   maintenanceMode: ['sweep', 'off'],
   secretPolicy: ['redact', 'reject'],
   vectorMode: ['off', 'http'],
@@ -149,6 +156,13 @@ function buildSchema() {
     extractMode: z.union(ENUMS.extractMode).default(DEFAULTS.extractMode).volatile(),
     extractMaxCallsPerHour: z.number().step(1).min(0).max(240).default(DEFAULTS.extractMaxCallsPerHour).volatile(),
     extractMaxCandidates: z.number().step(1).min(0).max(20).default(DEFAULTS.extractMaxCandidates).volatile(),
+    extractSessionMaxCandidates: z
+      .number()
+      .step(1)
+      .min(0)
+      .max(20)
+      .default(DEFAULTS.extractSessionMaxCandidates)
+      .volatile(),
     extractTimeoutMs: z.number().step(500).min(1000).max(120000).default(DEFAULTS.extractTimeoutMs).volatile(),
     maintenanceMode: z.union(ENUMS.maintenanceMode).default(DEFAULTS.maintenanceMode).volatile(),
     maintenanceIntervalHours: z.number().step(0.5).min(0.5).max(168).default(DEFAULTS.maintenanceIntervalHours).volatile(),

package/src/host/doctor.js

@@ -21,7 +21,7 @@ function check(name, status, detail) {
  * @returns `{status, checks, summary}` where status is the worst check status.
  */
 export function runDoctor(options) {
-  const { store, paths, config } = options;
+  const { store, paths, config, engines } = options;
   const checks = [];
 
   const health = (() => {
@@ -63,6 +63,19 @@ export function runDoctor(options) {
   const lastMaintenance = Number(health.migration?.to === undefined ? 0 : 0);
   checks.push(check('rows', 'ok', `${health.counts.memory} revisions · ${health.counts.memory_head} entries · ${health.counts.entity} entities`));
 
+  // Which Harness opened this store. A range in engines.dsh is a promise; this row
+  // is what actually happened, and it is the first thing to ask for in a bug report.
+  try {
+    const hostVersion = store.hostVersion ?? null;
+    checks.push(
+      hostVersion === null
+        ? check('host', 'warn', `not recorded yet; this build declares engines.dsh ${engines?.dsh ?? 'unknown'}`)
+        : check('host', 'ok', `last opened by DeepSeek Harness ${hostVersion}`),
+    );
+  } catch (error) {
+    checks.push(check('host', 'warn', `could not read: ${String(error?.message ?? error)}`));
+  }
+
   try {
     accessSync(paths.root, constants.W_OK);
     checks.push(check('data directory', 'ok', paths.root));

package/src/host/extract/extractor.js

@@ -7,9 +7,9 @@
  * lost. This module asks a model to read the recent conversation and propose what
  * is worth remembering.
  *
- * Four rules keep it from becoming the thing users turn off:
+ * Five rules keep it from becoming the thing users turn off:
  *
- * 1. **Off by default.** `extractMode` must be set to `on` explicitly.
+ * 1. **Off by default.** `extractMode` must be set explicitly.
  * 2. **Candidates only.** Everything it writes has status `candidate`; a person
  *    decides. Nothing here can reach the prompt by itself.
  * 3. **Budgeted.** A call cap per hour, a cap on candidates per run, an input cap
@@ -17,6 +17,11 @@
  * 4. **It can always fail.** No model configured, timeout, unparseable answer,
  *    store error — every path returns `{written: 0, reason}` and the turn is never
  *    affected.
+ * 5. **Batch, don't drip.** `'session'` mode runs once, when a session ends, and
+ *    proposes at most a handful of items in one go. `'turn'` mode still exists for
+ *    people who want it, but reviewing one proposal per turn is how a review queue
+ *    turns into a chore — the failure a heavy user described as "either it
+ *    remembers too little or it makes me triage".
  *
  * @module dsh-loci/extract
  */
@@ -104,7 +109,8 @@ export class Extractor {
 
   /** Whether the feature is switched on *and* a model route exists. */
   enabled() {
-    return this.config('extractMode') === 'on' && typeof this.complete === 'function';
+    const mode = this.config('extractMode');
+    return (mode === 'on' || mode === 'turn' || mode === 'session') && typeof this.complete === 'function';
   }
 
   /**
@@ -129,7 +135,8 @@ export class Extractor {
       this.lastReason = reason;
       return { written: 0, reason, ids: [] };
     };
-    if (this.config('extractMode') !== 'on') return fail('disabled');
+    const mode = this.config('extractMode');
+    if (mode !== 'on' && mode !== 'turn' && mode !== 'session') return fail('disabled');
     if (typeof this.complete !== 'function') return fail('no-model');
     if (this.remainingCalls() <= 0) return fail('budget');
 
@@ -148,7 +155,14 @@ export class Extractor {
       return fail('model-error');
     }
 
-    const items = parseExtraction(answer).slice(0, Number(this.config('extractMaxCandidates') ?? 3));
+    // A turn-sized batch and a session-sized digest are different products: three
+    // proposals per turn is a queue nobody drains, five at the end of a session is
+    // one sitting.
+    const cap =
+      request?.mode === 'session'
+        ? Number(this.config('extractSessionMaxCandidates') ?? 5)
+        : Number(this.config('extractMaxCandidates') ?? 3);
+    const items = parseExtraction(answer).slice(0, cap);
     if (items.length === 0) return fail('nothing');
 
     // A quote that is not in the transcript means the model invented it; those

package/src/host/host-version.js

@@ -0,0 +1,89 @@
+/**
+ * Which Harness version are we actually running on?
+ *
+ * `engines.dsh` is a range; a range is a promise nobody tested. This module resolves
+ * the *installed* host package at activation time and records it, so the panel and
+ * `doctor` can say "running on 0.2.2-rc.3" instead of leaving the user to guess
+ * which point release the plugin met. It is best-effort by design: a plugin that
+ * refuses to boot because it cannot read someone else's package.json is worse than
+ * one that says "unknown".
+ *
+ * @module dsh-loci/host-version
+ */
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const CANDIDATE_PATHS = [
+  // The Host normally resolves as a peer dependency of the profile.
+  '@deepseek-ai/dsh/package.json',
+  // Desktop bundles keep it one level down.
+  'dsh/package.json',
+];
+
+/**
+ * Resolve the installed host version.
+ *
+ * @param from - module URL to resolve relative to (defaults to this module).
+ * @returns `{version, path}` when found, `undefined` otherwise.
+ */
+export function detectHostVersion(from = import.meta.url) {
+  // The Host sets this to its own package directory, and the plugin runs inside the
+  // Host process, where reading an `app.asar/...` path works.
+  const installDir = process.env.DSH_INSTALL_DIR;
+  if (typeof installDir === 'string' && installDir.length > 0) {
+    try {
+      const manifest = JSON.parse(readFileSync(join(installDir, 'package.json'), 'utf8'));
+      if (typeof manifest?.version === 'string' && manifest.version.length > 0) {
+        return { version: manifest.version, path: join(installDir, 'package.json') };
+      }
+    } catch {
+      /* fall through to resolution */
+    }
+  }
+
+  let require;
+  try {
+    require = createRequire(from);
+  } catch {
+    return undefined;
+  }
+  for (const candidate of CANDIDATE_PATHS) {
+    try {
+      const resolved = require.resolve(candidate);
+      const manifest = JSON.parse(readFileSync(resolved, 'utf8'));
+      if (typeof manifest?.version === 'string' && manifest.version.length > 0) {
+        return { version: manifest.version, path: resolved };
+      }
+    } catch {
+      /* try the next candidate */
+    }
+  }
+  // Last resort: a sibling directory named `dsh` next to a cordis install.
+  try {
+    const resolved = require.resolve('@deepseek-ai/cordis/package.json');
+    const sibling = join(dirname(dirname(resolved)), 'dsh', 'package.json');
+    const manifest = JSON.parse(readFileSync(sibling, 'utf8'));
+    if (typeof manifest?.version === 'string') return { version: manifest.version, path: sibling };
+  } catch {
+    /* nothing else to try */
+  }
+  return undefined;
+}
+
+/**
+ * Compare a version against the `engines.dsh` range in one coarse way: does the
+ * major/minor line match what this build declares it supports?
+ *
+ * Deliberately not a semver implementation — the plugin has no dependency on one.
+ * It answers the only question that matters for a support message: "is this an
+ * untested point release inside our declared range, or a different line entirely?"
+ *
+ * @param version - the detected host version.
+ * @returns 'same-line' | 'other-line' | 'unknown'.
+ */
+export function hostLineOf(version) {
+  const match = /^(\d+)\.(\d+)\./.exec(String(version ?? ''));
+  if (match === null) return 'unknown';
+  return `${match[1]}.${match[2]}` === '0.2' ? 'same-line' : 'other-line';
+}

package/src/host/index.js

@@ -18,11 +18,12 @@ import { registerTools } from './tools/tools.js';
 import { registerApiRoutes } from './api/routes.js';
 import { UpdateChecker } from './update.js';
 import { Extractor, completeViaHost } from './extract/extractor.js';
+import { detectHostVersion, hostLineOf } from './host-version.js';
 import { registerCommands } from './commands.js';
 import { runDoctor } from './doctor.js';
 
 /** Version stamped into the database and diagnostics. */
-export const VERSION = '2.1.0';
+export const VERSION = '2.3.1';
 
 /** Optional collaborators; without them the plugin still serves tools. */
 export const inject = ['systemPrompt', 'tools'];
@@ -98,15 +99,30 @@ export function apply(ctx, rawConfig = {}) {
   log.info(`loci: using ${memoryRoot}`);
 
   let capture;
+  // Record which Harness this store is actually running on. `engines.dsh` is a
+  // range; this field is the only one that says which point release met the file,
+  // so a support report can be checked instead of guessed at.
+  const detectedHost = detectHostVersion();
   const store = new Store({
     memoryRoot,
     paths,
     config,
     log,
     pluginVersion: VERSION,
+    hostVersion: detectedHost?.version,
     live: read,
     quoteVerifier: (quote, options) => capture?.verifyQuote(quote, options) ?? false,
   });
+  if (detectedHost !== undefined) {
+    try {
+      store.db
+        .prepare("INSERT INTO meta (key, value) VALUES ('host_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
+        .run(detectedHost.version);
+    } catch {
+      /* recording is best effort */
+    }
+    log?.info?.(`loci: host ${detectedHost.version} (${hostLineOf(detectedHost.version)})`);
+  }
 
   const updates = new UpdateChecker({
     currentVersion: VERSION,

package/src/host/store/schema.js

@@ -160,6 +160,8 @@ export const META_KEYS = Object.freeze({
   createdAt: 'created_at',
   indexRev: 'index_rev',
   lastMaintenance: 'last_maintenance',
+  /** The Harness version this store has been used with, recorded at activation. */
+  hostVersion: 'host_version',
 });
 
 /**

package/src/host/store/store.js

@@ -123,6 +123,8 @@ export class Store {
     this.now = options.now ?? (() => Date.now());
     this.quoteVerifier = options.quoteVerifier ?? (() => false);
     this.pluginVersion = options.pluginVersion ?? '0.0.0';
+    /** Recorded host version, so support can see which point release met this store. */
+    this.hostVersion = options.hostVersion ?? undefined;
     this.readOnly = options.readOnly === true;
     this.db = openDatabase({ file: this.paths.db, readOnly: this.readOnly });
     this.audit = this.readOnly
@@ -974,7 +976,7 @@ export class Store {
     const items = this.db
       .prepare(
         `SELECT m.id, m.revision, m.kind, m.scope, m.scope_label, m.title, m.status, m.pinned, m.tags,
-                m.valid_from, m.valid_to, m.updated_at, m.created_at,
+                m.valid_from, m.valid_to, m.updated_at, m.created_at, m.source_session,
                 substr(m.body, 1, 240) AS snippet
          FROM memory m
          WHERE (m.valid_to IS NULL OR m.valid_to > ?) AND m.scope_key IN (${keyMarks})
@@ -998,6 +1000,9 @@ export class Store {
         updatedAt: Number(row.updated_at),
         createdAt: Number(row.created_at),
         snippet: row.snippet ?? '',
+        // Which session proposed this row. A session digest is reviewed as one
+        // batch, so the reviewer needs to see that these items belong together.
+        sourceSession: row.source_session ?? null,
       }));
     return { items, total };
   }
@@ -1059,6 +1064,9 @@ export class Store {
       byStatus,
       byKind,
       byScope,
+      // Which Harness point release this store has met. A range in engines.dsh is a
+      // promise; this is the record of what actually opened the file.
+      hostVersion: this.hostVersion ?? readMeta(this.db, META_KEYS.hostVersion) ?? null,
       pendingCandidates: pending,
       disputed,
       lastInjection:

package/src/mcp/store-facade.js

@@ -36,7 +36,7 @@ export function openFacadeStore(options = {}) {
     memoryRoot: root,
     paths,
     config,
-    pluginVersion: '2.1.0',
+    pluginVersion: '2.3.1',
     readOnly: options.readOnly === true,
   });
   return { store, paths };