dsh-loci 2.10.0 → 2.10.1

package/CHANGELOG.md

@@ -4,6 +4,37 @@ 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.10.1] — 2026-11-15
+
+Three more ways a scope mistake could have answered with the wrong data. Found by checking
+the last unverified claims from the audit instead of trusting the previous pass.
+
+### Fixed
+
+- **`/api/loci/preview?cwd=…` returned 400.** The route read `resolved.readKeys` and
+  `resolved.label`, neither of which `resolveScopes` returns, so any caller that supplied a
+  `cwd` or `session` got `Cannot read properties of undefined (reading 'length')`. The panel
+  never sends those parameters, which is why it survived: a latent failure on the one
+  endpoint that answers "what does *this* conversation get". `/api/loci/knowledge` had the
+  same defect.
+
+- **An explicit empty scope set meant "the whole store".** `stats({ scopeKeys: [] })` and
+  `usageReport({ scopeKeys: [] })` dropped the filter, while `list([])` and
+  `countPending([])` returned nothing. That asymmetry turns a scope-resolution failure into
+  a confident answer about every project on the machine. Now: omitted means the whole
+  database (an admin question), `[]` means nothing.
+
+- **`update`, `pin`, `unpin`, `restore` and `merge` ignored the read set.** Only `loci_get`
+  and `loci_forget` were guarded in 2.10.0. `update` moved a foreign entry into the calling
+  session's scope, `pin` changed how it sorts in another project's index, and `restore`
+  could un-delete an entry a different project had removed.
+
+### Note
+
+`test/unit/scope-semantics.test.mjs` pins all three. The empty-versus-absent distinction is
+asserted in both directions, because the failure mode is a silent widening rather than a
+crash.
+
 ## [2.10.0] — 2026-11-15
 
 The last four findings from the audit. All four are the same shape: an operation that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-loci",
-  "version": "2.10.0",
+  "version": "2.10.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",

package/src/host/api/routes.js

@@ -116,8 +116,15 @@ export function registerApiRoutes(ctx, deps) {
     const sessionId = url.searchParams.get('session') ?? undefined;
     const scoped = cwd !== undefined || sessionId !== undefined;
     const resolved = scoped ? resolveScopes({ cwd, sessionId }) : undefined;
-    const scopeKeys = scoped ? resolved.readKeys : store.allScopeKeys();
-    const scopeLabel = scoped ? resolved.label : `all ${scopeKeys.length} stored scope(s)`;
+    // `resolveScopes` returns `{session, workspace, project, global, labels, cwd,
+    // projectRoot}` — there is no `readKeys` and no `label`, so this route threw
+    // "Cannot read properties of undefined (reading 'length')" whenever a caller supplied
+    // `?cwd=`. The panel never does, which is why it survived: a latent 400 on the one
+    // endpoint that answers "what does this conversation get".
+    const scopeKeys = scoped ? readScopeKeys(resolved, { includeGlobal: config.includeGlobal !== false }) : store.allScopeKeys();
+    const scopeLabel = scoped
+      ? [resolved.labels.workspace, resolved.labels.project].filter((value, index, all) => all.indexOf(value) === index).join(' / ')
+      : `all ${scopeKeys.length} stored scope(s)`;
     return json({
       ...renderIndexBody({
         store,
@@ -153,7 +160,7 @@ export function registerApiRoutes(ctx, deps) {
     const scopeKeys =
       cwd === undefined && sessionId === undefined
         ? store.allScopeKeys()
-        : resolveScopes({ cwd, sessionId }).readKeys;
+        : readScopeKeys(resolveScopes({ cwd, sessionId }), { includeGlobal: config.includeGlobal !== false });
     return json(buildKnowledge(store, { limit, scopeKeys }));
   });
 

package/src/host/index.js

@@ -23,7 +23,7 @@ import { registerCommands } from './commands.js';
 import { runDoctor } from './doctor.js';
 
 /** Version stamped into the database and diagnostics. */
-export const VERSION = '2.10.0';
+export const VERSION = '2.10.1';
 
 /** Optional collaborators; without them the plugin still serves tools. */
 export const inject = ['systemPrompt', 'tools'];

package/src/host/store/store.js

@@ -1048,8 +1048,29 @@ export class Store {
    */
   stats(options = {}) {
     const keys = options.scopeKeys ?? [];
-    const filtered = keys.length > 0;
-    const marks = filtered ? ` AND m.scope_key IN (${keys.map(() => '?').join(', ')})` : '';
+    // undefined means nobody asked for a scope (an admin whole-store view); [] means
+    // someone asked for a scope and got no keys — which must answer *nothing*, not
+    // *everything*. It used to drop the filter in both cases, so a scope-resolution
+    // failure turned into a confident answer about every project on the machine.
+    if (Array.isArray(options.scopeKeys) && options.scopeKeys.length === 0) {
+      return {
+        schemaVersion: this.schemaVersion(),
+        indexRev: this.indexRev(),
+        revisions: 0,
+        heads: 0,
+        byStatus: {},
+        byKind: {},
+        byScope: {},
+        hostVersion: this.hostVersion ?? readMeta(this.db, META_KEYS.hostVersion) ?? null,
+        pendingCandidates: 0,
+        disputed: 0,
+        lastInjection: null,
+        dbBytes: existsSync(this.paths.db) ? statSync(this.paths.db).size : 0,
+        vector: { ...this.vector, ...this.embedding.health() },
+        memoryRoot: this.memoryRoot,
+      };
+    }
+    const marks = keys.length > 0 ? ` AND m.scope_key IN (${keys.map(() => '?').join(', ')})` : '';
     const byStatus = {};
     for (const row of this.db
       .prepare(
@@ -1200,6 +1221,9 @@ export class Store {
   usageReport(options = {}) {
     const keys = options.scopeKeys ?? [];
     const limit = Math.max(1, Math.min(200, options.limit ?? 20));
+    // Same rule as `stats`: an explicit empty list means no rows; an absent one means the
+    // whole store, which is what the panel's admin report asks for.
+    if (Array.isArray(options.scopeKeys) && options.scopeKeys.length === 0) return [];
     const marks = keys.length > 0 ? ` AND m.scope_key IN (${keys.map(() => '?').join(', ')})` : '';
     const rows = this.db
       .prepare(

package/src/host/tools/tools.js

@@ -209,11 +209,18 @@ export function createTools(deps) {
       const context = execContext(exec);
       const op = oneOf(args, 'op', ['create', 'update', 'merge', 'pin', 'unpin', 'restore'], 'create');
       const id = str(args, 'id', { fallback: undefined });
+      // Every id-addressed op has to respect the read set, not just the two literally named
+      // get/forget. `update` moved a foreign entry into this session's scope, `pin` changed
+      // how it sorts in another project's index, and `restore` could un-delete something a
+      // different project had removed.
+      const idScopeKeys = () => readScopeKeys(context.scopes, { includeGlobal: config('includeGlobal') });
+      if (id !== undefined && op !== 'create') assertInScope(store, id, idScopeKeys(), `loci_write ${op}`);
 
       if (op === 'merge') {
         if (id === undefined) throw new Error('id is required for merge (the entry to keep)');
         const sourceIds = Array.isArray(args?.sourceIds) ? args.sourceIds.filter((value) => typeof value === 'string') : [];
         if (sourceIds.length === 0) throw new Error('sourceIds is required for merge (at least one id to fold in)');
+        for (const sourceId of sourceIds) assertInScope(store, sourceId, idScopeKeys(), 'loci_write merge source');
         const result = store.merge({
           targetId: id,
           sourceIds,

package/src/mcp/store-facade.js

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