@modusensus/dsh-mneme 0.7.32 → 0.8.0

package/lib/settings.js

@@ -64,6 +64,13 @@ const FEATURE_FLAG_BOOLEANS = [
   // Issue #89：宽容校验回归（默认开）+ 跨类型合并显式放宽（默认关）。
   "dreamSkipInvalid",
   "allowCrossTypeMerge",
+  // Issue #17（v0.8.0 A1）：scope 隔离存储层总开关。开启后写入标注
+  // agent_scope/workspace_scope、去重键扩展（含 sensitivity）；检索侧过滤在
+  // A2/A3。默认关=行为与 A1 前逐字节一致。
+  "scopeEnabled",
+  // Issue #17（v0.8.0 A3）：strictScope 硬过滤——他 scope 完全不可见（关闭时
+  // 为 A2 软隔离：降权保留可见）。
+  "strictScope",
   // 嵌套对象开关：config.js 里是 memoryQualityFilter / llmAudit 对象的 enabled
   // 子字段。kv 按点号键平铺存（"memoryQualityFilter.enabled": false），index.js
   // 合并时展开回嵌套对象，api.js 的 effective 从对象子字段取值。

package/lib/store.js

@@ -310,7 +310,9 @@ function escapeLike(q) {
 // 法值一律返回 undefined → 不进 WHERE（忽略而非报错：面板传坏参数时宁可放宽
 // 过滤也不要白屏）。updated_at 列是 toISOString 产生的 UTC "Z" 字符串，字典
 // 序与时间序一致，SQL 里可直接比较。
-function updatedAtBounds(updatedFrom, updatedTo) {
+// v0.8.0 A2：导出复用——occurred_at 时间过滤（service 的搜索后置过滤）与
+// updated_at 过滤共用同一套边界归一化，坏参数口径一致。
+export function updatedAtBounds(updatedFrom, updatedTo) {
   const norm = (raw, endOfDay) => {
     if (typeof raw !== "string" || !raw.trim()) return undefined;
     const s = raw.trim();
@@ -332,6 +334,26 @@ function parseTags(raw) {
   }
 }
 
+// scope 列（agent_scope/workspace_scope/sensitivity）写入归一化：非空 trim 字符串
+// 原样收下，其余（undefined/null/空串/非字符串）一律 NULL。存储层不做枚举校验——
+// scope 值是宿主身份标签（agentPreset id / 目录路径 / 自由 sensitivity 标签），
+// 语义由调用方负责；这里只保证「脏输入落 NULL，绝不阻塞写入」。
+function normalizeScopeText(raw) {
+  if (typeof raw !== "string") return null;
+  const s = raw.trim();
+  return s ? s : null;
+}
+
+// occurred_at：事件发生时间（区别于 created_at 的入库时间）。可解析的时间戳
+// 统一归一到 UTC ISO（A2 的时间过滤要按字典序直接比较）；解析失败落 NULL，
+// 同样不阻塞写入。
+function normalizeOccurredAt(raw) {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  const ms = Date.parse(raw.trim());
+  if (Number.isNaN(ms)) return null;
+  return new Date(ms).toISOString();
+}
+
 function toRow(row) {
   if (!row) return undefined;
   return {
@@ -347,6 +369,10 @@ function toRow(row) {
     content_history: parseJsonArray(row.content_history),
     quality_score: row.quality_score !== null && row.quality_score !== undefined ? Number(row.quality_score) : undefined,
     epistemic_status: row.epistemic_status ?? "subjective",
+    agent_scope: row.agent_scope ?? undefined,
+    workspace_scope: row.workspace_scope ?? undefined,
+    sensitivity: row.sensitivity ?? undefined,
+    occurred_at: row.occurred_at ?? undefined,
     created_at: row.created_at,
     updated_at: row.updated_at,
     last_accessed_at: row.last_accessed_at ?? undefined,
@@ -597,6 +623,14 @@ export function createStore(path) {
   addColumn("memories", "content_history", "ALTER TABLE memories ADD COLUMN content_history TEXT");
   addColumn("memories", "quality_score", "ALTER TABLE memories ADD COLUMN quality_score REAL");
 
+  // v0.8.0 A1（issue #17）scope 隔离存储层：四列全部可空、不带 DEFAULT——存量行
+  // 零重写，读侧把 NULL 视为未标注（= 全局可见）。是否落值由 scopeEnabled 门控
+  // （service/tools 层），存储层只负责归一化（normalizeScopeText/normalizeOccurredAt）。
+  addColumn("memories", "agent_scope", "ALTER TABLE memories ADD COLUMN agent_scope TEXT");
+  addColumn("memories", "workspace_scope", "ALTER TABLE memories ADD COLUMN workspace_scope TEXT");
+  addColumn("memories", "sensitivity", "ALTER TABLE memories ADD COLUMN sensitivity TEXT");
+  addColumn("memories", "occurred_at", "ALTER TABLE memories ADD COLUMN occurred_at TEXT");
+
   // Legacy dream_runs without policy_epoch → backfill with the default epoch.
   addColumn("dream_runs", "policy_epoch", "ALTER TABLE dream_runs ADD COLUMN policy_epoch INTEGER NOT NULL DEFAULT 0");
   addColumn("dream_runs", "run_type", "ALTER TABLE dream_runs ADD COLUMN run_type TEXT NOT NULL DEFAULT 'auto'");
@@ -643,7 +677,7 @@ export function createStore(path) {
     return ts;
   }
 
-  function count(type, { minImportance = null, source = null, includeForgotten = false, includeArchived = false, onlyArchived = false, depositedOnly = false, updatedFrom = null, updatedTo = null } = {}) {
+  function count(type, { minImportance = null, source = null, includeForgotten = false, includeArchived = false, onlyArchived = false, depositedOnly = false, updatedFrom = null, updatedTo = null, occurredFrom = null, occurredTo = null, visibility = null } = {}) {
     const clauses = [];
     const params = [];
     if (type !== undefined) {
@@ -670,6 +704,33 @@ export function createStore(path) {
       clauses.push("updated_at <= ?");
       params.push(bounds.to);
     }
+    // occurred_at 闭区间：与 list() 同口径（COALESCE 回退 created_at），
+    // memory_list 的 total 才能和过滤后的行保持一致。
+    const occurred = updatedAtBounds(occurredFrom, occurredTo);
+    if (occurred.from) {
+      clauses.push("COALESCE(occurred_at, created_at) >= ?");
+      params.push(occurred.from);
+    }
+    if (occurred.to) {
+      clauses.push("COALESCE(occurred_at, created_at) <= ?");
+      params.push(occurred.to);
+    }
+    // occurred_at 闭区间：与 list() 同过滤（visibility 同口径），memory_list
+    // 的 total 才能和过滤后的行保持一致。
+    if (visibility) {
+      if (visibility.agentScope != null) {
+        clauses.push("(agent_scope IS NULL OR agent_scope = ?)");
+        params.push(visibility.agentScope);
+      } else {
+        clauses.push("agent_scope IS NULL");
+      }
+      if (visibility.workspaceScope != null) {
+        clauses.push("(workspace_scope IS NULL OR workspace_scope = ?)");
+        params.push(visibility.workspaceScope);
+      } else {
+        clauses.push("workspace_scope IS NULL");
+      }
+    }
     if (!includeForgotten) {
       clauses.push("forgotten = 0");
     }
@@ -714,8 +775,8 @@ export function createStore(path) {
       : inferEpistemicStatus(memory);
     runAtomically(() => {
       db.prepare(
-        `INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, content_history, quality_score, embedding, epistemic_status, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?)`
+        `INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, content_history, quality_score, embedding, epistemic_status, agent_scope, workspace_scope, sensitivity, occurred_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       ).run(
         id,
         type,
@@ -729,6 +790,10 @@ export function createStore(path) {
         Number.isFinite(memory.quality_score) ? memory.quality_score : null,
         embedding,
         epistemicStatus,
+        normalizeScopeText(memory.agent_scope),
+        normalizeScopeText(memory.workspace_scope),
+        normalizeScopeText(memory.sensitivity),
+        normalizeOccurredAt(memory.occurred_at),
         now,
         now
       );
@@ -936,7 +1001,7 @@ export function createStore(path) {
     return rows.map(toRow);
   }
 
-  function list({ type, limit = 50, offset = 0, order = "importance", includeForgotten = false, includeArchived = false, onlyArchived = false, depositedOnly = false, minImportance = null, source = null, updatedFrom = null, updatedTo = null } = {}) {
+  function list({ type, limit = 50, offset = 0, order = "importance", includeForgotten = false, includeArchived = false, onlyArchived = false, depositedOnly = false, minImportance = null, source = null, updatedFrom = null, updatedTo = null, occurredFrom = null, occurredTo = null, visibility = null } = {}) {
     const clauses = [];
     const params = [];
     if (type) {
@@ -964,6 +1029,36 @@ export function createStore(path) {
       clauses.push("updated_at <= ?");
       params.push(bounds.to);
     }
+    // v0.8.0 A2（issue #17）：occurred_at 闭区间过滤——按「事件发生时间」检索。
+    // 未标注 occurred_at 的行（含全部存量）回退 created_at 比较（COALESCE），
+    // 否则过滤器对旧库近乎不可用；边界归一化与 updated_at 共用 updatedAtBounds。
+    const occurred = updatedAtBounds(occurredFrom, occurredTo);
+    if (occurred.from) {
+      clauses.push("COALESCE(occurred_at, created_at) >= ?");
+      params.push(occurred.from);
+    }
+    if (occurred.to) {
+      clauses.push("COALESCE(occurred_at, created_at) <= ?");
+      params.push(occurred.to);
+    }
+    // v0.8.0 A3（issue #17）：strictScope 硬过滤（memory_list 分页路径）。
+    // SQL 与 service.isVisibleInScope 同口径：未标注(NULL)恒可见；当前维度
+    // 解析不到时该维度只放行未标注行（fail-closed）。只有显式传 visibility
+    // 的用户面调用才过滤——dream/质量过滤等内部 store.list 调用不受影响。
+    if (visibility) {
+      if (visibility.agentScope != null) {
+        clauses.push("(agent_scope IS NULL OR agent_scope = ?)");
+        params.push(visibility.agentScope);
+      } else {
+        clauses.push("agent_scope IS NULL");
+      }
+      if (visibility.workspaceScope != null) {
+        clauses.push("(workspace_scope IS NULL OR workspace_scope = ?)");
+        params.push(visibility.workspaceScope);
+      } else {
+        clauses.push("workspace_scope IS NULL");
+      }
+    }
     if (!includeForgotten) {
       clauses.push("forgotten = 0");
     }

package/lib/tools.js

@@ -1,4 +1,5 @@
 import { defineTool } from "@deepseek-ai/dsh-tools";
+import { createScopeResolver } from "./scope.js";
 import { describeLocalRuntime, resolveRuntimeEntry } from "./runtime/loader.js";
 import { defaultRuntimeDir } from "./runtime/layout.js";
 import { hostModulesDir, loadRuntimeManifest, provisionRuntime } from "./runtime/provision.js";
@@ -25,11 +26,44 @@ const MEMORY_ITEM_SCHEMA = {
     tags: { type: "array", items: { type: "string" } },
     importance: { type: "integer", required: true },
     source: { type: "string" },
+    // v0.8.0 A2：scope 标注与事件发生时间随行透出（未标注时缺省，可选属性）。
+    agent_scope: { type: "string" },
+    workspace_scope: { type: "string" },
+    sensitivity: { type: "string" },
+    occurred_at: { type: "string" },
     created_at: { type: "string", required: true },
     updated_at: { type: "string", required: true }
   }
 };
 
+// v0.8.0 A2：occurred 时间窗参数 → store 过滤选项（list/count 同口径）；
+// 未传参返回空对象，既有调用方不受影响。（A3 复核：此处入参仅含 occurred 边界。）
+function occurredWindow(args) {
+  const from = args?.occurred_from ?? null;
+  const to = args?.occurred_to ?? null;
+  return from !== null || to !== null ? { occurredFrom: from, occurredTo: to } : {};
+}
+
+// v0.8.0 A3：strictScope 硬过滤的 visibility 选项（store.list/count 同口径）。
+// flag 关或会话 scope 未解析出（flag 关时解析器返回 null）→ 空对象不过滤；
+// scope 为 {null,null}（匿名会话）时照传——store 侧 fail-closed 只放行未标注行。
+function strictVisibility(config, scope) {
+  if (config?.strictScope !== true || !scope) return {};
+  return { visibility: { agentScope: scope.agent_scope, workspaceScope: scope.workspace_scope } };
+}
+
+// v0.8.0 A2：检索结果的 provenance 附加段——只在有标注时出现，未标注行渲染
+// 与 A2 前逐字节一致。
+const MEMORY_PROVENANCE = (m) => {
+  const parts = [];
+  if (m.occurred_at) parts.push(`occurred: ${m.occurred_at}`);
+  if (m.agent_scope || m.workspace_scope) {
+    parts.push(`scope: ${m.agent_scope ?? "global"} / ${m.workspace_scope ?? "global"}`);
+  }
+  if (m.sensitivity) parts.push(`sensitivity: ${m.sensitivity}`);
+  return parts.length ? ` | ${parts.join(" | ")}` : "";
+};
+
 export function createTools(ctx, service, config, embedder) {
   const toolsRegistry = ctx.tools;
   let registeredTools = REGISTERED_TOOLS.get(toolsRegistry);
@@ -37,6 +71,10 @@ export function createTools(ctx, service, config, embedder) {
     registeredTools = new Set();
     REGISTERED_TOOLS.set(toolsRegistry, registeredTools);
   }
+  // v0.8.0 A1/A2（issue #17）：会话 scope 解析（agentPreset + workspace 反查）。
+  // flag 关闭时恒返回 null——写入不标注，检索不加权，行为与 A1 前完全一致。
+  // logger 透传：registry 反查失败时 warnOnce 才有出口（否则静默降级无观测）。
+  const resolveSessionScope = createScopeResolver({ ctx, config, logger: ctx.logger });
   const tools = [
     defineTool({
       name: "memory_save",
@@ -50,7 +88,9 @@ export function createTools(ctx, service, config, embedder) {
         content: { type: "string", required: true, description: "Memory body" },
         tags: { type: "array", items: { type: "string" }, description: "Optional tags" },
         importance: { type: "integer", description: "1-5; >= threshold auto-injects into future sessions" },
-        source: { type: "string", description: "Optional provenance" }
+        source: { type: "string", description: "Optional provenance" },
+        sensitivity: { type: "string", description: "Optional sensitivity label (free-form, e.g. personal). Same-title entries with different sensitivity stay separate instead of merging." },
+        occurred_at: { type: "string", description: "Optional ISO-8601 instant the remembered event happened (differs from write time). Invalid values are ignored." }
       },
       output: {
         schema: {
@@ -63,14 +103,21 @@ export function createTools(ctx, service, config, embedder) {
         },
         render: (_args, value) => TEXT_OUTPUT(`memory ${value.action}: ${value.id}`)
       },
-      async execute(args) {
+      async execute(args, exec) {
+        // scope 标注：agent_scope/workspace_scope 由会话身份解析（不作为模型
+        // 参数），sensitivity/occurred_at 来自显式参数。解析绝不抛错、取不到
+        // 落 NULL；flag 关闭时 scope 为 null，一个字段都不标注。
+        const scope = resolveSessionScope(exec);
         const { action, memory } = service.saveWithDedupe({
           type: args.type,
           title: args.title,
           content: args.content,
           tags: args.tags ?? [],
           importance: args.importance ?? 3,
-          source: args.source ?? "tool"
+          source: args.source ?? "tool",
+          ...(scope ? { agent_scope: scope.agent_scope, workspace_scope: scope.workspace_scope } : {}),
+          ...(args.sensitivity !== undefined ? { sensitivity: args.sensitivity } : {}),
+          ...(args.occurred_at !== undefined ? { occurred_at: args.occurred_at } : {})
         });
         return { action, id: memory.id };
       }
@@ -79,12 +126,15 @@ export function createTools(ctx, service, config, embedder) {
     defineTool({
       name: "memory_search",
       description: "Search the cross-session memory store. Use when you need past context: how a problem was solved, user preferences, project decisions. Substring-matches title/content/tags, and augments results with semantic (vector) recall + optional rerank when an embeddings provider is configured. Returns matching entries with source and timestamps.",
+      // A2 检索接线：occurred 时间窗 + 会话 scope 加成（见 execute）。
       parameters: {
         query: { type: "string", required: true, description: "Search text; substring match over title/content/tags" },
         limit: { type: "integer", description: "Max results (default 20)" },
         mode: { type: "string", enum: ["auto", "keyword", "vector", "hybrid"], description: "auto (default) = keyword hits first + vector fill when enabled; keyword = text only; vector = semantic recall first (falls back to keyword); hybrid = vector leads, keyword fills remaining slots" },
         semantic: { type: "boolean", description: "Shorthand: enable semantic (vector) recall (same as mode=vector when true)" },
-        rerank: { type: "boolean", description: "Run cross-encoder rerank over candidates when a local reranker is configured (default true)" }
+        rerank: { type: "boolean", description: "Run cross-encoder rerank over candidates when a local reranker is configured (default true)" },
+        occurred_from: { type: "string", description: "Optional ISO date/timestamp lower bound on when the remembered event happened (occurred_at, falling back to created_at). Date-only values are inclusive from that day's 00:00Z." },
+        occurred_to: { type: "string", description: "Optional ISO date/timestamp upper bound on occurred_at. Date-only values are inclusive through that day's 23:59:59.999Z." }
       },
       output: {
         schema: {
@@ -104,19 +154,26 @@ export function createTools(ctx, service, config, embedder) {
             .map((m, i) => {
               const preview = (m.content ?? "").replace(/\s+/g, " ").trim();
               const cut = preview.length > 200 ? `${preview.slice(0, 200)}…` : preview;
-              return `[${i + 1}] ${m.title}\n    ID: ${m.id} | type: ${m.type} | importance: ${m.importance} | updated: ${m.updated_at}\n    ${cut}`;
+              return `[${i + 1}] ${m.title}\n    ID: ${m.id} | type: ${m.type} | importance: ${m.importance} | updated: ${m.updated_at}${MEMORY_PROVENANCE(m)}\n    ${cut}`;
             })
             .join("\n\n");
           return TEXT_OUTPUT(`Found ${items.length} memory entr${items.length === 1 ? "y" : "ies"}:\n\n${body}`);
         }
       },
-      async execute(args) {
+      async execute(args, exec) {
         const limit = args.limit ?? 20;
         const mode = args.semantic === true && !args.mode ? "vector" : args.mode ?? "auto";
+        // v0.8.0 A2（issue #17）：scope 检索加权 + occurred 时间窗的检索接线。
+        // flag 关闭或解析不出 scope 时为 null，检索行为与 A2 前一致。
+        const scope = resolveSessionScope(exec);
+        const occurredFrom = args.occurred_from ?? null;
+        const occurredTo = args.occurred_to ?? null;
         const rows = await service.searchMemories(args.query, {
           mode,
           topK: limit,
-          useRerank: args.rerank !== false
+          useRerank: args.rerank !== false,
+          ...(scope ? { scope } : {}),
+          ...(occurredFrom !== null || occurredTo !== null ? { occurredFrom, occurredTo } : {})
         });
         return { items: service.toApiList(rows) };
       }
@@ -129,7 +186,9 @@ export function createTools(ctx, service, config, embedder) {
         type: { type: "string", enum: ["preference", "project", "decision", "history", "rejected_solution", "pitfall", "constraint"], description: "Filter by type; omit for all" },
         limit: { type: "integer", description: "Page size (default 50)" },
         offset: { type: "integer", description: "Page offset (default 0)" },
-        include_archived: { type: "boolean", description: "Include archived (hidden) entries so they can be found and restored (default false)" }
+        include_archived: { type: "boolean", description: "Include archived (hidden) entries so they can be found and restored (default false)" },
+        occurred_from: { type: "string", description: "Optional ISO date/timestamp lower bound on when the remembered event happened (occurred_at, falling back to created_at). Date-only values are inclusive from that day's 00:00Z." },
+        occurred_to: { type: "string", description: "Optional ISO date/timestamp upper bound on occurred_at. Date-only values are inclusive through that day's 23:59:59.999Z." }
       },
       output: {
         schema: {
@@ -147,7 +206,7 @@ export function createTools(ctx, service, config, embedder) {
           const items = value.items ?? [];
           if (items.length === 0) return TEXT_OUTPUT(`0 memory entries (of ${value.total}).`);
           const body = items
-            .map((m, i) => `[${i + 1}] ${m.title} (type=${m.type}, importance=${m.importance})\n    ID: ${m.id} | updated: ${m.updated_at}`)
+            .map((m, i) => `[${i + 1}] ${m.title} (type=${m.type}, importance=${m.importance})\n    ID: ${m.id} | updated: ${m.updated_at}${MEMORY_PROVENANCE(m)}`)
             .join("\n\n");
           return TEXT_OUTPUT(`${items.length} memory entries (of ${value.total}):\n\n${body}`);
         }
@@ -158,9 +217,13 @@ export function createTools(ctx, service, config, embedder) {
           type: args.type,
           limit: args.limit ?? 50,
           offset: args.offset ?? 0,
-          includeArchived
+          includeArchived,
+          ...occurredWindow(args),
+          // A3：strict 开启时按会话 scope 硬过滤（宿主按 (args, runContext) 调用，
+          // 从 arguments 取第二参）。
+          ...strictVisibility(config, resolveSessionScope(arguments[1]))
         }));
-        return { items: rows, total: service.count(args.type, { includeArchived }) };
+        return { items: rows, total: service.count(args.type, { includeArchived, ...occurredWindow(args), ...strictVisibility(config, resolveSessionScope(arguments[1])) }) };
       }
     }),
 
@@ -186,6 +249,10 @@ export function createTools(ctx, service, config, embedder) {
                 tags: { type: "array", items: { type: "string" } },
                 content: { type: "string", required: true },
                 source: { type: "string" },
+                agent_scope: { type: "string" },
+                workspace_scope: { type: "string" },
+                sensitivity: { type: "string" },
+                occurred_at: { type: "string" },
                 created_at: { type: "string" },
                 updated_at: { type: "string" }
               }
@@ -194,12 +261,19 @@ export function createTools(ctx, service, config, embedder) {
         },
         render: (_args, value) => {
           const m = value.memory;
-          return TEXT_OUTPUT(`${m.title}\nID: ${m.id} | type: ${m.type} | importance: ${m.importance}\n\n${m.content}`);
+          return TEXT_OUTPUT(`${m.title}\nID: ${m.id} | type: ${m.type} | importance: ${m.importance}${MEMORY_PROVENANCE(m)}\n\n${m.content}`);
         }
       },
       async execute(args) {
         const memory = service.getById(args.id);
         if (memory === undefined) throw new Error("memory not found");
+        // v0.8.0 A3：strictScope 下他 scope 的行按不存在处理（无存在性泄漏）。
+        // 宿主注册表按 (args, runContext) 两参调用处理器，从 arguments 取第二参。
+        const runContext = arguments[1];
+        const scope = resolveSessionScope(runContext);
+        if (config.strictScope === true && scope && !service.isVisibleInScope(memory, scope)) {
+          throw new Error("memory not found");
+        }
         return { memory: service.toApiList([memory])[0] };
       }
     }),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 7 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.7.32",
+  "version": "0.8.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/api.js

@@ -1014,6 +1014,66 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- 冲突集中处理（v0.8.0）：队列 + 人工确认 --------------------------------
+  // GET /conflicts：未解决冲突 + 双方当前内容（此前面板只有计数与徽章，
+  // resolveConflictPending 在存储层躺着没有任何调用方）。POST /conflicts/resolve：
+  // {id, winner: "a"|"b"|null, apply}——盖章审计，apply 时按 dream 非冻结
+  // conflict 路径同款处置（service.resolveConflictPending 内部复用
+  // applyDecisions：CAS + 事务 + 注记 + 幂等）。认证与其他写路由一致。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/conflicts",
+    handler(req, res) {
+      try {
+        if (req.method !== "GET") {
+          sendJson(res, 404, { error: "not-found" });
+          return;
+        }
+        if (!requireAuth(req, res, apiToken)) return;
+        const url = new URL(req.url, "http://localhost");
+        const limit = Math.min(200, Math.max(1, Number(url.searchParams.get("limit") ?? 50) || 50));
+        const offset = Math.max(0, Number(url.searchParams.get("offset") ?? 0) || 0);
+        const items = service.listConflictQueue({ limit, offset });
+        sendJson(res, 200, { items, total: service.countConflictPending?.() ?? items.length });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/conflicts/resolve",
+    handler(req, res) {
+      try {
+        if (req.method !== "POST") {
+          sendJson(res, 404, { error: "not-found" });
+          return;
+        }
+        if (!requireAuth(req, res, apiToken)) return;
+        return readBody(req).then((text) => {
+          let body = {};
+          try { body = JSON.parse(text || "{}"); } catch { /* 坏 JSON → 走缺参分支 */ }
+          const id = typeof body.id === "string" ? body.id.trim() : "";
+          if (!id) {
+            sendJson(res, 400, { error: "missing-id" });
+            return;
+          }
+          const winner = body.winner === "a" || body.winner === "b" ? body.winner : null;
+          const apply = body.apply !== false;
+          const result = service.resolveConflictPending(id, { winner, apply });
+          if (!result) {
+            sendJson(res, 404, { error: "not-found" });
+            return;
+          }
+          sendJson(res, 200, { ok: true, conflict: result });
+        }).catch(() => sendJson(res, 500, { error: "internal" }));
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   // --- health: mirror sync state (F-NEW-03 / v0.3.6) ---
   // Auth-gated; only returns a sanitized error code (never raw last_error which
   // may leak paths/token-like strings/internal hosts). On state read failure it

package/src/commands.js

@@ -1,11 +1,16 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { STR } from "./lang.js";
 
 // Custom slash-command manager: keeps the DSH command registry in sync with
 // user-defined commands persisted in SQLite. Commands are registered on boot
 // and (re)registered on add/remove through the API.
 //
-// Each custom command's handler returns the user-authored instruction as a
-// success result; the DSH UI surfaces it as a model-directed instruction.
+// Per the DSH command contract, a handler's CommandResult text is only a UI
+// settlement notice and never reaches the model. To actually drive the agent,
+// the handler submits the user-authored instruction itself as a user followup
+// message on the receiving agent (same pattern as the official /goal command).
+// The notice just acknowledges the submission; an optional rawInput suffix
+// typed after the command is appended for the model.
 
 export function createCommandManager({ ctx, settings, logger, language = "zh" }) {
   const registered = new Map(); // name -> disposer
@@ -18,7 +23,8 @@ export function createCommandManager({ ctx, settings, logger, language = "zh" })
         name: command.name,
         // 缺省描述随实例语言（命令描述进命令注册表，对 LLM 可见）。
         description: command.description || STR.commandFallbackDesc[language](command.name),
-        handler: () => ({ kind: "success", text: command.instruction })
+        input: { hint: STR.commandInputHint[language] },
+        handler: (invocation) => submit(command, invocation)
       });
     } catch (error) {
       logger?.warn?.(`dsh-mneme: failed to register command /${command.name}: ${String(error)}`);
@@ -27,6 +33,27 @@ export function createCommandManager({ ctx, settings, logger, language = "zh" })
     registered.set(command.name, dispose);
   }
 
+  /** Submit the instruction (plus optional rawInput suffix) to the receiving agent. */
+  function submit(command, invocation) {
+    const suffix = typeof invocation?.rawInput === "string" ? invocation.rawInput.trim() : "";
+    const text = suffix ? `${command.instruction}\n\n${suffix}` : command.instruction;
+    const agent = invocation?.agent;
+    if (typeof agent?.followup !== "function") {
+      // 兜底：宿主未提供接收 agent 时退回旧行为，至少把指令展示在 notice 里。
+      return { kind: "success", text };
+    }
+    try {
+      agent.followup(createUserMessage({
+        content: [{ type: "text", text }],
+        source: { kind: "user" }
+      }));
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme: failed to submit /${command.name} to agent: ${String(error)}`);
+      return { kind: "error", text: STR.commandSubmitFailed[language](command.name) };
+    }
+    return { kind: "success", text: STR.commandSubmitted[language](command.name) };
+  }
+
   function unregisterOne(name) {
     const dispose = registered.get(name);
     if (dispose) {

package/src/config.js

@@ -58,6 +58,11 @@ export const Config = z.object({
   // 编码记忆注入加权系数：编码任务时对 rejected_solution/pitfall/constraint
   // 记忆的 importance 乘以该系数排序，让编码记忆在编码场景更靠前。
   codingBoostFactor: z.number().min(1).max(5).default(2),
+  // 注入边界花括号转义（issue #162，v0.7.4 曾修后被 v0.7.11 重构误删）：默认开启，
+  // 在 memory / 短期上下文 / 用户设置三处注入出口对连续 2+ 个花括号插 `\`
+  // （`{{a}}`→`{\{a\}\}`），让 DSH 的 interpolate() 不再扫到非法变量名而 throw。
+  // 关闭时按原样透传。
+  escapePromptVariables: z.boolean().default(true),
   autoDream: z.boolean().default(true),
   dreamThresholdCount: z.natural().min(1).max(1000).default(10),
   dreamThresholdChars: z.natural().min(100).max(100000).default(5000),
@@ -438,6 +443,22 @@ export const Config = z.object({
   recallRecordDefault: z.boolean().default(true),
   // recall_runs 滚动清理保留天数。
   recallRetentionDays: z.natural().min(1).max(3650).default(90),
+
+  // --- scope: v0.8.0 A1 存储层（issue #17）--------------------------------
+  // 总开关默认关：关闭时写入不标注 scope、去重维持 (type, title) 现状，行为
+  // 逐字节不变。开启后 memory_save 写入 agent_scope（session header 的
+  // agentPreset）与 workspace_scope（registry 反查 canonical path，header.cwd
+  // 兜底，取不到 NULL——解析绝不阻塞写入），去重键扩展为 (type, title,
+  // agent_scope, workspace_scope, sensitivity)。检索侧加权/过滤在 A2/A3 落地。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  scopeEnabled: z.boolean().default(false),
+  // strictScope（A3）：硬过滤模式。关闭=A2 软隔离（他 scope 降权保留可见）；
+  // 开启后检索/注入/list/get 按 issue #17 四象限可见性公式硬过滤——带他 scope
+  // 的记忆完全不可见，未标注（NULL）恒可见；当前会话某维度解析不到时该维度
+  // 带标注的记忆一律不可见（fail-closed：身份不明只见全局）。依赖 scopeEnabled
+  // 打开才有意义（没有写入标注就无可过滤维度），但独立成键：可先开标注积累
+  // 数据、观察 A2 加权质量后再切硬过滤。
+  strictScope: z.boolean().default(false),
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here