@modusensus/dsh-mneme 0.7.32 → 0.8.0

package/src/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/src/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/src/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/test/api.test.js

@@ -649,11 +649,12 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   // dreamMaxTokens、睡眠路由 sleepProvider/sleepModel、PR1 新增的
   // recallFusion/signalTransparency、issue #109 新增的实体抽取路由
   // entityExtractionProvider/entityExtractionModel/entityExtractionReasoning、
-  // issue #127 新增的 summarize 五键、issue #126 新增的 sleepActionSet，以及
-  // issue #125 新增的候选集三键），未覆盖时取 bundle 配置的解析默认值；
+  // issue #127 新增的 summarize 五键、issue #126 新增的 sleepActionSet，
+  // 以及 issue #125 新增的候选集三键、issue #17（v0.8.0 A1/A3）新增的
+  // scopeEnabled/strictScope），未覆盖时取 bundle 配置的解析默认值；
   // dreamProvider/dreamModel 无 schema 默认值（Config({}) 解析为 undefined），
-  // 不编造给前端 → 51 - 2 = 49
-  assert.equal(Object.keys(data.effective).length, 49);
+  // 不编造给前端 → 53 - 2 = 51
+  assert.equal(Object.keys(data.effective).length, 51);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMinIntervalMinutes, 0);
@@ -1068,6 +1069,91 @@ test("GET /api/dsh-mneme/dream-status returns runs and pending conflict ids", as
   assert.deepEqual(afterData.pendingMemoryIds, []);
 });
 
+// v0.8.0 冲突集中处理：GET /conflicts 队列联表 + POST /conflicts/resolve 人工确认。
+test("GET /api/dsh-mneme/conflicts joins both sides of unresolved conflicts", async () => {
+  const { routes, service } = setup();
+  const a = service.saveWithDedupe({ type: "history", title: "界面暗色偏好", content: "用户当前使用暗色界面主题", importance: 3 }).memory;
+  const b = service.saveWithDedupe({ type: "history", title: "界面亮色切换", content: "用户界面亮色切换计划", importance: 3 }).memory;
+  service.saveConflictPending({ memory_a: a.id, memory_b: b.id, reason: "主题偏好前后矛盾" });
+
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/conflicts");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.items.length, 1);
+  assert.equal(data.total, 1);
+  assert.equal(data.items[0].reason, "主题偏好前后矛盾");
+  // saveConflictPending 会按 id 字典序归一 A/B 侧位——断言集合而非位置。
+  assert.deepEqual(
+    [data.items[0].memory_a.title, data.items[0].memory_b.title].sort(),
+    ["界面亮色切换", "界面暗色偏好"]
+  );
+  assert.equal(data.items[0].memory_a.archived, false);
+  assert.equal(data.items[0].memory_b.archived, false);
+  // 幽灵侧容忍缺失
+  service.saveConflictPending({ memory_a: a.id, memory_b: "ghost-id", reason: "对方已删" });
+  const res2 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts"), res2);
+  const data2 = JSON.parse(res2.body);
+  assert.equal(data2.items.length, 2);
+  assert.equal(data2.items.find((x) => x.reason === "对方已删").memory_b.missing, true);
+});
+
+test("POST /api/dsh-mneme/conflicts/resolve stamps and applies the disposition", async () => {
+  const { store, routes, service } = setup();
+  const a = service.saveWithDedupe({ type: "history", title: "界面暗色偏好", content: "用户当前使用暗色界面主题", importance: 3 }).memory;
+  const b = service.saveWithDedupe({ type: "history", title: "界面亮色切换", content: "用户界面亮色切换计划", importance: 3 }).memory;
+  const pending = service.saveConflictPending({ memory_a: a.id, memory_b: b.id, reason: "主题偏好前后矛盾" });
+
+  // store 会把 pair 按 id 字典序归一——从队列行反查「界面亮色切换」所在侧再选。
+  const queueRoute = routes.find((r) => r.path === "/api/dsh-mneme/conflicts");
+  const queueRes = new FakeRes();
+  await queueRoute.handler(req("/api/dsh-mneme/conflicts"), queueRes);
+  const queued = JSON.parse(queueRes.body).items.find((x) => x.id === pending.id);
+  const keepSide = queued.memory_a.id === b.id ? "a" : "b";
+  // loser 恒为 a（keeper 恒为「界面亮色切换」= b），与 A/B 侧位字母无关
+  const loserId = a.id;
+
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/conflicts/resolve");
+  // 保留「界面亮色切换」所在侧（apply 默认 true）→ 该侧保留，另一侧归档
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts/resolve", "POST", { id: pending.id, winner: keepSide }), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.ok, true);
+  assert.equal(data.conflict.resolved_winner, b.id);
+  assert.equal(data.conflict.disposition.ok, true);
+  assert.equal(store.getById(b.id).archived, false, "winner kept");
+  assert.equal(store.getById(loserId).archived, true, "loser archived by apply");
+
+  // 处理过的 id 再 resolve → 幂等重盖（仍是 200；队列视图只列未解决行，
+  // 正常 UI 不会再发这个请求，但接口层保持幂等）
+  const res2 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts/resolve", "POST", { id: pending.id, winner: "a" }), res2);
+  assert.equal(res2.statusCode, 200);
+  assert.equal(JSON.parse(res2.body).ok, true);
+
+  // 未知 id → 404；缺 id → 400
+  const res3 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts/resolve", "POST", { id: "nope", winner: "a" }), res3);
+  assert.equal(res3.statusCode, 404);
+  const res4 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts/resolve", "POST", {}), res4);
+  assert.equal(res4.statusCode, 400);
+
+  // apply:false 只盖章不处置
+  const c = service.saveWithDedupe({ type: "decision", title: "丙", content: "内容丙" }).memory;
+  const d = service.saveWithDedupe({ type: "decision", title: "丁", content: "内容丁" }).memory;
+  const p2 = service.saveConflictPending({ memory_a: c.id, memory_b: d.id, reason: "r2" });
+  const res5 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/conflicts/resolve", "POST", { id: p2.id, apply: false }), res5);
+  assert.equal(res5.statusCode, 200);
+  assert.equal(JSON.parse(res5.body).conflict.disposition, null);
+  assert.equal(store.getById(c.id).archived, false);
+  assert.equal(store.getById(d.id).archived, false);
+});
+
 test("parseHumanEdits is the pure core of readHumanEdits (CRLF tolerant)", () => {
   const digest = "0".repeat(64);
   const text = [

package/test/client.test.js

@@ -676,4 +676,62 @@ test("vector status card surfaces the configured/degraded split", () => {
     clientSource.includes('t("memory.status.vectorDegradedHint")'),
     "the degraded state must render its own caption (0 of {m} indexed)"
   );
+});
+
+// v0.8.0 A4（issue #17）：作用域隔离的面板面——设置卡新组（scopeEnabled /
+// strictScope 开关）+ 记忆条目的 scope provenance 展示。i18n 键必须中英双语
+// 齐全；徽章/详情行沿用 heat 徽章的「字段缺省即不渲染」模式，前端不感知开关。
+/**
+ * A4（issue #17）面板面回归：作用域隔离的设置卡分组、十个 i18n 键的中英双语
+ * 齐备（沿用 occurrences ≥ 2 模式），以及 ScopeBadge 组件与三处接线（cards
+ * 脚部 / timeline 行 / 详情抽屉 dmeta）的真实存在性——只做源码断言，不挂
+ * React 渲染环境，与文件内其他 clientSource 断言同一风格。
+ */
+test("scope isolation ships panel switches and provenance surfaces (A4)", () => {
+  assert.ok(
+    /key: "group\.scope", items: \["scopeEnabled", "strictScope"\]/.test(clientSource),
+    "FEATURE_GROUPS must carry a dedicated scope group"
+  );
+  for (const key of [
+    "memory.features.group.scope",
+    "memory.features.scopeEnabled",
+    "memory.features.scopeEnabled.hint",
+    "memory.features.strictScope",
+    "memory.features.strictScope.hint",
+    "memory.explorer.scopeBadge",
+    "memory.explorer.detail.agentScope",
+    "memory.explorer.detail.workspaceScope",
+    "memory.explorer.detail.sensitivity",
+    "memory.explorer.detail.occurred"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(/const ScopeBadge = \(\{ m, t \}\)/.test(clientSource), "ScopeBadge component must exist");
+  assert.ok(clientSource.includes("h(ScopeBadge, { m, t })"), "ScopeBadge must be wired into browse views");
+  assert.ok(clientSource.includes('t("memory.explorer.detail.agentScope")'), "drawer must render agent scope row");
+  assert.ok(clientSource.includes('t("memory.explorer.detail.occurred")'), "drawer must render occurred row");
+});
+
+// v0.8.0 冲突集中处理：状态页的待确认冲突队列（reason + 双方内容对比 +
+// 保留 A/B/仅标记动作），resolveConflictPending 的第一个前端出口。双语齐备。
+test("conflict queue ships a central review surface on the status tab", () => {
+  for (const key of [
+    "memory.status.conflictQueue.reason",
+    "memory.status.conflictQueue.sideA",
+    "memory.status.conflictQueue.sideB",
+    "memory.status.conflictQueue.keepA",
+    "memory.status.conflictQueue.keepB",
+    "memory.status.conflictQueue.markReviewed",
+    "memory.status.conflictQueue.applyHint",
+    "memory.status.conflictQueue.missing",
+    "memory.status.conflictQueue.refresh"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(/function ConflictsQueue\(\{ t \}\)/.test(clientSource), "ConflictsQueue component must exist");
+  assert.ok(clientSource.includes('"/api/dsh-mneme/conflicts"'), "queue must fetch the conflicts endpoint");
+  assert.ok(clientSource.includes('"/api/dsh-mneme/conflicts/resolve"'), "queue must call the resolve endpoint");
+  assert.ok(clientSource.includes("h(ConflictsQueue, { t })"), "status tab must render the queue");
 });

package/test/commands.test.js

@@ -40,14 +40,51 @@ test("add registers live; remove unregisters live", () => {
   store.close();
 });
 
-test("handler returns the instruction as success text", async () => {
+test("handler submits the instruction to the agent and returns a receipt", async () => {
   const { store, manager, registered } = setup();
   manager.add({ name: "fmt", description: "格式化", instruction: "请按项目的 lint 规则格式化当前文件" });
   const def = registered.get("fmt");
   assert.ok(def, "definition registered");
-  const result = await def.handler({ agent: {}, rawInput: "", signal: null });
+  assert.equal(def.input.hint, "可选：追加给模型的补充说明");
+  const submitted = [];
+  const agent = { followup: (message) => submitted.push(message) };
+  const result = await def.handler({ agent, rawInput: "", signal: null });
   assert.equal(result.kind, "success");
-  assert.equal(result.text, "请按项目的 lint 规则格式化当前文件");
+  assert.equal(result.text, "已提交指令：fmt");
+  assert.equal(submitted.length, 1);
+  assert.equal(submitted[0].role, "user");
+  assert.deepEqual(submitted[0].content, [{ type: "text", text: "请按项目的 lint 规则格式化当前文件" }]);
+  assert.deepEqual(submitted[0].source, { kind: "user" });
+  store.close();
+});
+
+test("rawInput suffix is appended for the model", async () => {
+  const { store, manager, registered } = setup();
+  manager.add({ name: "mneme", instruction: "以「小墨」的口吻自我介绍" });
+  const def = registered.get("mneme");
+  const submitted = [];
+  await def.handler({ agent: { followup: (m) => submitted.push(m) }, rawInput: "  顺便列出归档数量  " });
+  assert.equal(submitted[0].content[0].text, "以「小墨」的口吻自我介绍\n\n顺便列出归档数量");
+  store.close();
+});
+
+test("handler without a receiving agent falls back to surfacing the instruction", () => {
+  const { store, manager, registered } = setup();
+  manager.add({ name: "fmt", instruction: "legacy text" });
+  const def = registered.get("fmt");
+  const result = def.handler({ rawInput: "" });
+  assert.equal(result.kind, "success");
+  assert.equal(result.text, "legacy text");
+  store.close();
+});
+
+test("handler returns an error result when the agent rejects the submission", () => {
+  const { store, manager, registered } = setup();
+  manager.add({ name: "boom", instruction: "x" });
+  const def = registered.get("boom");
+  const result = def.handler({ agent: { followup: () => { throw new Error("nope"); } } });
+  assert.equal(result.kind, "error");
+  assert.match(result.text, /boom/);
   store.close();
 });