@modusensus/dsh-mneme 0.7.32 → 0.8.1

package/src/service.js

@@ -1,8 +1,11 @@
 import { createHash, randomUUID } from "node:crypto";
 import { TYPE_FILE } from "./mirror.js";
+import { updatedAtBounds } from "./store.js";
+import { normalizeExplicitScope, scopeKeyOf } from "./scope.js";
 import { STR, langOf } from "./lang.js";
 import { computeHeat } from "./heat.js";
 import { evaluateMemoryQuality } from "./quality-filter.js";
+import { applyDecisions } from "./dream/decisions.js";
 import { createBM25Index } from "./search/bm25.js";
 import { adaptiveThreshold } from "./search/adaptive.js";
 
@@ -38,6 +41,70 @@ const CONTENT_HISTORY_MAX = 20;
 // 清单必须与 quality-filter.js 的写入端对齐（6 个，含 type 自指的 self_referential）。
 const SIGNAL_TAGS = ["low_quality", "duplicate", "meta", "repetitive", "short_content", "self_referential"];
 
+// scopeKeyOf 已上提到 ./scope.js（v0.8.1，issue #170 第 2 步）：与 sleep 的跨
+// scope 配对共用同一把比较钥匙，避免两处定义漂移。
+
+// v0.8.0 A2（issue #17）scope 检索加权系数：两维都无法确立 foreign 的候选
+// （命中行、未标注行、当前侧维度解析不到的行）→ 加成；只有确立了 foreign
+// （记忆带标注 + 当前维度可解析 + 值不等）→ 降权但保留可见（硬过滤是 A3
+// strictScope）。即未标注行与命中行同列、不吃惩罚，但注意它们吃的是 BOOST
+// 而非 ×1 中性。系数是模块常量而非配置项：A2 只定性行为，数值要等线上检索
+// 质量反馈再调（加配置面=提前优化）。
+const SCOPE_MATCH_BOOST = 1.25;
+const SCOPE_FOREIGN_PENALTY = 0.5;
+
+/**
+ * 单条候选的 scope 乘数。匹配语义与去重键一致（scopeKeyOf）：记忆侧未标注视同
+ * 该维度命中（全局记忆对谁都可见）；当前会话侧某维度解析不到则该维度不参与
+ * 比较（无法比较 ≠ 不匹配）。
+ */
+function scopeMultiplier(m, current) {
+  const agentForeign = scopeKeyOf(m.agent_scope) !== null
+    && current.agent_scope !== null
+    && scopeKeyOf(m.agent_scope) !== current.agent_scope;
+  const workspaceForeign = scopeKeyOf(m.workspace_scope) !== null
+    && current.workspace_scope !== null
+    && scopeKeyOf(m.workspace_scope) !== current.workspace_scope;
+  return (agentForeign || workspaceForeign) ? SCOPE_FOREIGN_PENALTY : SCOPE_MATCH_BOOST;
+}
+
+/**
+ * v0.8.0 A2：occurred_at 后置过滤谓词（搜索融合池用）。行侧取
+ * COALESCE(occurred_at, created_at)——与 store.list 的 SQL 过滤同口径，未标注
+ * 行回退创建时间；时间戳损坏的行保留（宁可放宽也不误杀，同 summarize inWindow）。
+ */
+function inOccurredBounds(m, bounds) {
+  const t = Date.parse(String(m.occurred_at ?? m.created_at ?? ""));
+  if (!Number.isFinite(t)) return true;
+  if (bounds.from && t < Date.parse(bounds.from)) return false;
+  if (bounds.to && t > Date.parse(bounds.to)) return false;
+  return true;
+}
+
+/**
+ * v0.8.0 A3（issue #17）strictScope 可见性谓词：issue 的四象限可见性公式
+ * （agent 不对称可见性）——记忆对当前会话可见 ⇔ (agent 维：未标注 或 命中当前
+ * agent) AND (workspace 维：未标注 或 命中当前 workspace)。NULL=未标注=全局；
+ * 当前会话某维度解析不到时，该维度带标注的记忆一律不可见（fail-closed：身份
+ * 不明的会话只见全局，不冒认）。sensitivity 是标签不参与可见性判定（其语义
+ * 留给后续批次）。store.list 的 SQL 过滤与此谓词同口径（见 store.js visibility）。
+ */
+function isVisibleInScope(m, current) {
+  // v0.8.1 第 3 步（issue #170 4.3，作者已确认）：硬过滤只认显式声明。某维
+  // 仅当「该维有标注且来源为 explicit」才构成硬墙；auto（含 v0.8.0 存量的
+  // NULL 来源行）只吃 A2 软加权（foreign ×0.5 保留可见），不进硬过滤。
+  // 显式全局（值 NULL + source explicit）与未标注同形，天然恒可见。
+  if (m.agent_scope_source === "explicit") {
+    const agent = scopeKeyOf(m.agent_scope);
+    if (agent !== null && (current.agent_scope === null || agent !== current.agent_scope)) return false;
+  }
+  if (m.workspace_scope_source === "explicit") {
+    const ws = scopeKeyOf(m.workspace_scope);
+    if (ws !== null && (current.workspace_scope === null || ws !== current.workspace_scope)) return false;
+  }
+  return true;
+}
+
 /** Prepend the previous content to a memory's content_history (FIFO capped). */
 function pushContentHistory(existing, source) {
   const history = Array.isArray(existing?.content_history) ? existing.content_history : [];
@@ -589,7 +656,19 @@ export function createService({ store, mirror, config, onWrite, logger }) {
    * a vector/rerank failure degrades to keyword results.
    */
   async function searchMemories(query, options = {}) {
-    const { mode = "auto", topK = 20, threshold, useRerank = true, recordRecall = options.recordRecall ?? (config?.recallRecordDefault ?? true) } = options;
+    const {
+      mode = "auto",
+      topK = 20,
+      threshold,
+      useRerank = true,
+      // v0.8.0 A2（issue #17）：当前会话 scope（工具层从 exec 解析后传入）与
+      // occurred_at 时间窗。两者都只在显式传入时生效，既有调用方（注入/梦/评测）
+      // 不传 → 行为与 A2 前一致。
+      scope = null,
+      occurredFrom = null,
+      occurredTo = null,
+      recordRecall = options.recordRecall ?? (config?.recallRecordDefault ?? true)
+    } = options;
     const q = String(query ?? "").trim();
     if (!q) return [];
 
@@ -656,6 +735,19 @@ export function createService({ store, mirror, config, onWrite, logger }) {
 
     const { merged: fusedMerged, signals } = fuseRecall({ keyword, vector, bm25, lim, mode, wv, wk, wb });
     let merged = fusedMerged;
+    // v0.8.0 A3（issue #17）：strictScope 硬过滤——他 scope 的候选直接出局
+    // （区别于 A2 的降权保留可见）；未标注行与命中行保留。strict 与 A2 加权
+    // 叠加：过滤后剩下的命中行仍吃加成。scope 未传（flag 关）或完全解析不到
+    // 时跳过——identity 为空的对象（{null,null}）按 fail-closed 过滤。
+    if (config.strictScope === true && scope) {
+      merged = merged.filter((m) => isVisibleInScope(m, scope));
+    }
+    // v0.8.0 A2：occurred_at 时间过滤——在融合池上先滤再 dedup/slice，rerank
+    // 只看窗内候选，topK 槽位不被窗外行占用。
+    const occurredBounds = updatedAtBounds(occurredFrom, occurredTo);
+    if (occurredBounds.from || occurredBounds.to) {
+      merged = merged.filter((m) => inOccurredBounds(m, occurredBounds));
+    }
     // Signal transparency (#2): decorate each returned row with its per-source
     // scores and the final fused score. Purely additive — never changes rank.
     if (config?.signalTransparency === true) {
@@ -685,6 +777,18 @@ export function createService({ store, mirror, config, onWrite, logger }) {
         .slice(0, lim);
     }
 
+    // v0.8.0 A2（issue #17）：scope 检索加权——两维都无法确立 foreign 的候选
+    // （命中/未标注/当前侧解析不到）加成，确立 foreign 的候选降权但保留可见
+    // （硬过滤是 A3 strictScope）；未标注行与命中行同列吃 BOOST、不被压制。
+    // flag 关或调用方未传 scope 时不动分，排序与 A2 前逐字节一致。与
+    // epistemic 加权同款收尾：乘分 → 降序 → 截 topK。
+    if (config.scopeEnabled === true && scope && (scope.agent_scope || scope.workspace_scope)) {
+      result = result
+        .map((m) => ({ ...m, score: (m.score ?? 0) * scopeMultiplier(m, scope) }))
+        .sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
+        .slice(0, lim);
+    }
+
     // Recall layer receipt: with recordRecall on, hand the actual merged
     // candidate list (id/title/content/score/source) to the injected recorder
     // before returning, making the retrieval scene replayable — the sibling of
@@ -965,15 +1069,30 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // 标题变化，若仍按 (type, title) 匹配会出现两个活跃的 summary 同时注入。
     // 其余类型维持 (type, title) 匹配不变。
     const candidates = store.list({ type: memory.type, limit: 100 });
+    // v0.8.0 A1（issue #17）：去重键由 (type, title) 扩展为
+    // (type, title, agent_scope, workspace_scope, sensitivity)——不同作用域的同
+    // 标题记忆绝不互相物理合并（旧逻辑跨 agent/workspace 并行，事后无法拆分）。
+    // NULL 归一为「未标注」：未标注行之间互相匹配（含存量行），与已标注行不
+    // 匹配。
+    // v0.8.1（issue #170 复核项 1）：比较不再受 scopeEnabled 门控——显式声明
+    // flag 关也生效（工具层明写「读了自动标注也生效」，去重必须同口径），否则
+    // 关自动标注后同标题不同 scope 的行会物理合并进第一行的归属。存量全 NULL
+    // 行互相匹配，A1 前行为不变。
+    const scopeMatches = (m) =>
+      scopeKeyOf(m.agent_scope) === scopeKeyOf(memory.agent_scope) &&
+      scopeKeyOf(m.workspace_scope) === scopeKeyOf(memory.workspace_scope) &&
+      scopeKeyOf(m.sensitivity) === scopeKeyOf(memory.sensitivity);
     // Issue #127：写入端语义去重命中时，调用方用 _mergeInto 指定并入目标——复用
     // 下面这段并入逻辑（appendContent + content_history + 质量处置），不另写第二份
-    // 实现。目标已被并发删除时回落到常规匹配。
-    const existing = memory._mergeInto
-      ? store.getById(memory._mergeInto)
+    // 实现。目标已被并发删除时回落到常规匹配。显式目标同样过 scope 门：跨作用域
+    // 的语义相似不并入（防泄漏），回落为独立新行。
+    const explicitTarget = memory._mergeInto ? store.getById(memory._mergeInto) : undefined;
+    const existing = explicitTarget
+      ? (scopeMatches(explicitTarget) ? explicitTarget : undefined)
       : (memory.type === "summary" && memory.source === "dream")
-        ? (candidates.find((m) => m.source === "dream")
-          ?? candidates.find((m) => m.title.trim() === String(memory.title).trim()))
-        : candidates.find((m) => m.title.trim() === String(memory.title).trim());
+        ? (candidates.find((m) => m.source === "dream" && scopeMatches(m))
+          ?? candidates.find((m) => scopeMatches(m) && m.title.trim() === String(memory.title).trim()))
+        : candidates.find((m) => scopeMatches(m) && m.title.trim() === String(memory.title).trim());
     if (existing) {
       const newContent = String(memory.content ?? "");
       if (!newContent.trim()) {
@@ -985,6 +1104,17 @@ export function createService({ store, mirror, config, onWrite, logger }) {
         ? newContent
         : appendContent(existing.content, newContent);
       const importance = Math.min(5, Math.max(existing.importance, memory.importance ?? existing.importance));
+      // v0.8.1 底座（issue #170）：去重命中=scope 值完全同键，此时显式写入把
+      // 被并入行的同维来源升级为 explicit（用户刚刚显式声明了同一归属），
+      // 并刷新 scope_decided_at。仅升级来源、不改值——值改变会走新行。
+      const scopeUpgrade = {};
+      if (memory.agent_scope_source === "explicit" && existing.agent_scope_source !== "explicit") {
+        scopeUpgrade.agent_scope_source = "explicit";
+      }
+      if (memory.workspace_scope_source === "explicit" && existing.workspace_scope_source !== "explicit") {
+        scopeUpgrade.workspace_scope_source = "explicit";
+      }
+      if (Object.keys(scopeUpgrade).length) scopeUpgrade.scope_decided_at = new Date().toISOString();
       const merged = store.update(existing.id, {
         content,
         importance,
@@ -993,8 +1123,30 @@ export function createService({ store, mirror, config, onWrite, logger }) {
         content_history: pushContentHistory(existing, direct
           ? (memory._humanEdited === true ? "human_override" : "overwrite")
           : "auto_merge"),
+        ...scopeUpgrade,
         ...(quality ? { quality_score: quality.score } : {})
       });
+      // v0.8.1（issue #170 review 3）：来源升级也是归属性质改变——与
+      // updateMemory 的显式修正同等待遇，落一行 scope_changes（actor=tool：
+      // 只有 memory_save 的显式参数会带 explicit 来源走到这里）。审计失败只
+      // warn 不反噬合并。升级只在来源首次变化时触发，不会每次并入都写。
+      if (Object.keys(scopeUpgrade).length) {
+        try {
+          store.saveScopeChange({
+            memory_id: existing.id,
+            actor: "tool",
+            prev_agent_scope: existing.agent_scope ?? null,
+            prev_workspace_scope: existing.workspace_scope ?? null,
+            next_agent_scope: merged.agent_scope ?? null,
+            next_workspace_scope: merged.workspace_scope ?? null,
+            agent_scope_source: merged.agent_scope_source ?? null,
+            workspace_scope_source: merged.workspace_scope_source ?? null,
+            decided_at: scopeUpgrade.scope_decided_at
+          });
+        } catch (e) {
+          try { logger?.warn?.(`[dsh-mneme] scope upgrade audit failed: ${String(e)}`); } catch { /* 不反噬 */ }
+        }
+      }
       // Bug7: a degraded/archived result is applied on top of the merged row.
       const result = applyQualityDisposition(merged, quality, qf);
       afterSync("write");
@@ -1009,6 +1161,15 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       tags: memory.tags ?? [],
       importance: memory.importance ?? 3,
       source: memory.source ?? "manual",
+      // v0.8.0 A1：scope 标注透传（store 端归一化，未标注落 NULL）。
+      // v0.8.1 底座：来源（auto/explicit）与决策时间随行透传。
+      agent_scope: memory.agent_scope,
+      workspace_scope: memory.workspace_scope,
+      agent_scope_source: memory.agent_scope_source,
+      workspace_scope_source: memory.workspace_scope_source,
+      scope_decided_at: memory.scope_decided_at,
+      sensitivity: memory.sensitivity,
+      occurred_at: memory.occurred_at,
       ...(quality ? { quality_score: quality.score } : {})
     });
     const result = applyQualityDisposition(created, quality, qf);
@@ -1074,7 +1235,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
    * fills + dedupes the remaining slots. Empty query / no cached recall /
    * hybridInject off → pure legacy rule-based selection.
    */
-  function injectCandidates({ query = "", maxItems = 5, threshold = 3, queryVector } = {}) {
+  function injectCandidates({ query = "", maxItems = 5, threshold = 3, queryVector, scope = null } = {}) {
     const q = String(query ?? "").trim();
     // codingRetrospect 读取侧门控：编码记忆（rejected_solution / pitfall /
     // constraint）只在编码任务时注入，防噪声污染其他业务；编码任务时按
@@ -1164,6 +1325,11 @@ export function createService({ store, mirror, config, onWrite, logger }) {
         }
       } catch { /* topic re-rank unavailable: keep rule-based order */ }
     }
+    // v0.8.0 A3（issue #17）：strictScope 硬过滤同样作用于自动注入——scoped 记忆
+    // 泄进无关注入上下文是最典型的越权通道，检索侧过滤挡不住这里。
+    if (config?.strictScope === true && scope) {
+      candidates = candidates.filter((m) => isVisibleInScope(m, scope));
+    }
     const selected = candidates.slice(0, maxItems);
     touchRecalled(selected);
     return selected;
@@ -1217,6 +1383,94 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     return applied;
   }
 
+  /**
+   * v0.8.0 冲突集中处理（issue 反馈：冻结冲突没有人工出口——store 的
+   * resolveConflictPending 此前无任何 API/UI 调用）。人工确认一条待审冲突：
+   * 盖章 resolved_at/resolved_winner（审计），可选按 dream 非冻结 conflict
+   * 路径**同款**处置落地——复用 applyDecisions 的 conflict 分支，CAS 快照 +
+   * 事务 + 胜者追加已否决注记 + 败者归档 + 幂等全部同源，不另写第二份裁决。
+   *
+   * @param {string} id conflict_pending 行 id
+   * @param {{winner?: "a"|"b"|null, apply?: boolean}} opts
+   *   winner: 选哪一方保留（a = memory_a，冻结时 LLM 的建议胜者；b = memory_b）；
+   *   null = 仅盖章标记已读、不落地处置。人工选择是权威裁决：传入
+   *   applyDecisions 的 config 关掉 trustEpistemicWeighting——可信度自动换位
+   *   只应作用于 LLM 提议对，不能推翻人工选择。
+   * @returns {object|undefined} 盖章后的冲突行 + disposition 摘要；未知 id 返回 undefined
+   */
+  function resolveConflictPending(id, { winner = null, apply = true } = {}) {
+    const rows = store.listConflictPending({ includeResolved: true, limit: 500 });
+    const row = rows.find((r) => r.id === id);
+    if (!row) return undefined;
+    const winnerId = winner === "a" ? row.memory_a : winner === "b" ? row.memory_b : null;
+    const loserId = winner === "a" ? row.memory_b : winner === "b" ? row.memory_a : null;
+    let disposition = null;
+    if (apply && winnerId && loserId) {
+      const snapshot = new Map();
+      for (const m of [store.getById(row.memory_a), store.getById(row.memory_b)]) {
+        if (m) snapshot.set(m.id, { updated_at: m.updated_at, content: m.content, title: m.title });
+      }
+      // applyDecisions 需要一个 service 形状的参数（getById/update/setArchived/
+      // transaction）——委托给闭包内的同名实现，mirror/通知/嵌入与主写路径同源。
+      const applyService = {
+        getById: (mid) => store.getById(mid),
+        update: (mid, patch) => updateMemory(mid, patch),
+        setArchived: (mid, v) => archiveMemory(mid, v),
+        transaction: (fn) => transaction(fn)
+      };
+      const { committed, failures } = applyDecisions(
+        [{ action: "conflict", winner: winnerId, loser: loserId, reason: row.reason ?? "" }],
+        applyService,
+        logger,
+        snapshot,
+        { ...config, trustEpistemicWeighting: false }
+      );
+      // Review 发现：处置必须**先于**盖章。原实现先 resolveConflictPending 盖章、
+      // 再 applyDecisions——若 CAS 拒掉（确认前双方被并发更新），行已 resolved 从
+      // 队列消失、前端仍显示成功，审计却记了"已确认"且无法重试。现在失败时不盖章
+      // 直接返回：行留在队列待重试，审计不被污染。
+      if (failures.length) {
+        return { ...row, disposition: { ok: false, failures } };
+      }
+      disposition = { ok: true, committed };
+    }
+    // 处置成功（或纯标记）后才盖章。幂等重放（败者已归档 → skipped）也走这里：
+    // 处置本就存在，标记已审即可。
+    const stamped = store.resolveConflictPending(id, { winner: winnerId });
+    if (!stamped) return undefined;
+    return { ...stamped, disposition };
+  }
+
+  /**
+   * v0.8.0 冲突队列视图数据源：未解决冲突行，联表带出双方的当前状态（标题/
+   * 内容/类型/重要性/归档标记），面板一处即可集中审阅，不必按徽章逐条找。
+   * 参与记忆被删除/失联时该侧返回 {missing: true}（队列不因此丢行）。
+   */
+  function listConflictQueue({ limit = 50, offset = 0 } = {}) {
+    const rows = store.listConflictPending({ limit, offset, includeResolved: false });
+    const side = (id) => {
+      const m = store.getById(id);
+      if (!m) return { id, missing: true };
+      return {
+        id,
+        title: m.title,
+        type: m.type,
+        importance: m.importance,
+        content: m.content,
+        archived: m.archived === true,
+        forgotten: m.forgotten === true
+      };
+    };
+    return rows.map((r) => ({
+      id: r.id,
+      run_id: r.run_id ?? null,
+      reason: r.reason ?? null,
+      created_at: r.created_at,
+      memory_a: side(r.memory_a),
+      memory_b: side(r.memory_b)
+    }));
+  }
+
   function toApiList(rows) {
     return rows.map((m) => ({
       id: m.id,
@@ -1227,7 +1481,18 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       importance: m.importance,
       source: m.source,
       created_at: m.created_at,
-      updated_at: m.updated_at
+      updated_at: m.updated_at,
+      // v0.8.0 A2：scope 标注与事件发生时间透出——条件展开（未标注行不带键，
+      // DTO 与 A2 前逐字节同形；带 undefined 键会被 in-process schema 校验
+      // 判违规，JSON 序列化虽会丢弃但形状不稳定）。
+      // v0.8.1 底座：scope 来源与决策时间随行透出（同样条件展开）。
+      ...(m.agent_scope !== undefined ? { agent_scope: m.agent_scope } : {}),
+      ...(m.workspace_scope !== undefined ? { workspace_scope: m.workspace_scope } : {}),
+      ...(m.agent_scope_source !== undefined ? { agent_scope_source: m.agent_scope_source } : {}),
+      ...(m.workspace_scope_source !== undefined ? { workspace_scope_source: m.workspace_scope_source } : {}),
+      ...(m.scope_decided_at !== undefined ? { scope_decided_at: m.scope_decided_at } : {}),
+      ...(m.sensitivity !== undefined ? { sensitivity: m.sensitivity } : {}),
+      ...(m.occurred_at !== undefined ? { occurred_at: m.occurred_at } : {})
     }));
   }
 
@@ -1508,6 +1773,99 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     }
   }
 
+  // 返回字面量与内部裁决器（resolveConflictPending → applyDecisions 的 conflict
+  // 处置）共用的写路径：mirror 同步、写通知、嵌入调度全部同源，不能各写一份。
+  function updateMemory(id, p, ctx = {}) {
+    const old = store.getById(id);
+    // Issue #135 附属发现 2：质量过滤器把「为什么被降权/归档」写在系统信号标签
+    // 上（SIGNAL_TAGS，applyQualityDisposition 以并集写入），而这里整组替换
+    // tags——任何带 tags 的更新都会抹掉这条唯一的审计线索（报告实测 150 条低分
+    // 记忆里恰好缺的 2 条就是被 update 过的，并因此误判过归档来源）。把 existing
+    // 的系统信号标签并集保留；用户自传的标签照常生效。
+    let patch = (p && Array.isArray(p.tags) && old && Array.isArray(old.tags))
+      ? { ...p, tags: [...new Set([...p.tags, ...old.tags.filter((t) => SIGNAL_TAGS.includes(t))])] }
+      : p;
+    // v0.8.1 底座（issue #170）：显式 scope 修正。patch 携带 agent_scope /
+    // workspace_scope 键（undefined=该维不动）时归一化并盖 explicit 章 +
+    // scope_decided_at，随后写 scope_changes 审计行（actor：tool=模型侧 /
+    // panel=人工侧）。审计失败只 warn，不反噬主写入。
+    const nextAgentScope = p && p.agent_scope !== undefined ? normalizeExplicitScope(p.agent_scope) : undefined;
+    const nextWorkspaceScope = p && p.workspace_scope !== undefined ? normalizeExplicitScope(p.workspace_scope) : undefined;
+    const scopeChanged = nextAgentScope !== undefined || nextWorkspaceScope !== undefined;
+    if (scopeChanged) {
+      const decidedAt = new Date().toISOString();
+      patch = { ...patch };
+      if (nextAgentScope !== undefined) {
+        patch.agent_scope = nextAgentScope;
+        patch.agent_scope_source = "explicit";
+      }
+      if (nextWorkspaceScope !== undefined) {
+        patch.workspace_scope = nextWorkspaceScope;
+        patch.workspace_scope_source = "explicit";
+      }
+      patch.scope_decided_at = decidedAt;
+    }
+    const updated = store.update(id, patch);
+    if (scopeChanged && old && updated) {
+      try {
+        store.saveScopeChange({
+          memory_id: id,
+          actor: ctx.actor === "panel" ? "panel" : "tool",
+          prev_agent_scope: old.agent_scope ?? null,
+          prev_workspace_scope: old.workspace_scope ?? null,
+          next_agent_scope: updated.agent_scope ?? null,
+          next_workspace_scope: updated.workspace_scope ?? null,
+          agent_scope_source: updated.agent_scope_source ?? null,
+          workspace_scope_source: updated.workspace_scope_source ?? null,
+          decided_at: patch.scope_decided_at
+        });
+      } catch (e) {
+        try { ctx.logger?.warn?.(`[dsh-mneme] scope change audit failed: ${String(e)}`); } catch { /* 同样不反噬 */ }
+      }
+    }
+    // Record a user correction when any meaningful field changed and the
+    // reflection failure tracker is enabled. expected = what it became,
+    // actual = what it was before; query (when provided) captures the
+    // user's original intent so later reflection can reason about recall.
+    const hasMeaningfulChange = old && updated && (
+      old.content !== updated.content ||
+      old.title !== updated.title ||
+      old.importance !== updated.importance
+    );
+    if (hasMeaningfulChange && config.reflectionFailureTracking) {
+      store.saveFailure({
+        id: randomUUID(),
+        query: ctx.query ?? null,
+        expected: updated.content,
+        actual: old.content,
+        before: { title: old.title, content: old.content, importance: old.importance },
+        failure_type: "user_correction",
+        memory_id: id
+      });
+    }
+    const sync = afterSync("write");
+    notifyWrite();
+    scheduleEmbed(updated);
+    // Audit peer B: when the mirror sync failed, the store write landed but
+    // the mirror did not converge — return an explicit degraded receipt rather
+    // than a plain success. Non-enumerable so existing deepEqual assertions on
+    // the memory shape keep passing.
+    if (!sync?.success && !sync?.deferred) {
+      Object.defineProperty(updated, "_mirror", {
+        value: { status: "degraded", error: sync?.error ?? "mirror sync failed" },
+        enumerable: false,
+        configurable: true
+      });
+    }
+    return updated;
+  }
+
+  function archiveMemory(id, f) {
+    const updated = store.setArchived(id, f);
+    afterSync("write");
+    return updated;
+  }
+
   return {
     saveWithDedupe,
     recoverMirror,
@@ -1516,6 +1874,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     injectCandidates,
     mergeHumanEdits,
     toApiList,
+    isVisibleInScope,
     transaction,
     enqueue,
     setDreamHook(fn) { dreamHook = fn; },
@@ -1568,53 +1927,9 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       afterSync("write");
       notifyWrite();
     },
-    update: (id, p, ctx = {}) => {
-      const old = store.getById(id);
-      // Issue #135 附属发现 2：质量过滤器把「为什么被降权/归档」写在系统信号标签
-      // 上（SIGNAL_TAGS，applyQualityDisposition 以并集写入），而这里整组替换
-      // tags——任何带 tags 的更新都会抹掉这条唯一的审计线索（报告实测 150 条低分
-      // 记忆里恰好缺的 2 条就是被 update 过的，并因此误判过归档来源）。把 existing
-      // 的系统信号标签并集保留；用户自传的标签照常生效。
-      const patch = (p && Array.isArray(p.tags) && old && Array.isArray(old.tags))
-        ? { ...p, tags: [...new Set([...p.tags, ...old.tags.filter((t) => SIGNAL_TAGS.includes(t))])] }
-        : p;
-      const updated = store.update(id, patch);
-      // Record a user correction when any meaningful field changed and the
-      // reflection failure tracker is enabled. expected = what it became,
-      // actual = what it was before; query (when provided) captures the
-      // user's original intent so later reflection can reason about recall.
-      const hasMeaningfulChange = old && updated && (
-        old.content !== updated.content ||
-        old.title !== updated.title ||
-        old.importance !== updated.importance
-      );
-      if (hasMeaningfulChange && config.reflectionFailureTracking) {
-        store.saveFailure({
-          id: randomUUID(),
-          query: ctx.query ?? null,
-          expected: updated.content,
-          actual: old.content,
-          before: { title: old.title, content: old.content, importance: old.importance },
-          failure_type: "user_correction",
-          memory_id: id
-        });
-      }
-      const sync = afterSync("write");
-      notifyWrite();
-      scheduleEmbed(updated);
-      // Audit peer B: when the mirror sync failed, the store write landed but
-      // the mirror did not converge — return an explicit degraded receipt rather
-      // than a plain success. Non-enumerable so existing deepEqual assertions on
-      // the memory shape keep passing.
-      if (!sync?.success && !sync?.deferred) {
-        Object.defineProperty(updated, "_mirror", {
-          value: { status: "degraded", error: sync?.error ?? "mirror sync failed" },
-          enumerable: false,
-          configurable: true
-        });
-      }
-      return updated;
-    },
+    update: updateMemory,
+    // v0.8.1 底座：scope 归属修正审计（单条记忆，新→旧）。
+    listScopeChanges: (memoryId, opts) => store.listScopeChanges(memoryId, opts),
     // Compare-and-set update: applies the patch only when the row still carries
     // `expectedUpdatedAt`. Returns undefined on a miss (no write) so the caller
     // can re-read and retry — the primitive that prevents lost updates across
@@ -1657,11 +1972,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       afterSync("write");
       return updated;
     },
-    setArchived: (id, f) => {
-      const updated = store.setArchived(id, f);
-      afterSync("write");
-      return updated;
-    },
+    setArchived: archiveMemory,
     // sleep-mode storage (v0.4.0). demoteToSummary / restoreContent mutate
     // content so they ride the normal write-hook path (mirror re-renders).
     // touchLastAccess is a read-stamp — deliberately NO write hook (a recall
@@ -1693,7 +2004,8 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // above: an audit write, never a write-hook-triggering memory mutation).
     saveConflictPending: (r) => store.saveConflictPending(r),
     listConflictPending: (opts) => store.listConflictPending(opts),
-    resolveConflictPending: (id, o) => store.resolveConflictPending(id, o),
+    listConflictQueue,
+    resolveConflictPending,
     countConflictPending: () => store.countConflictPending(),
     // Recall evaluation trail (方案 B): audit-bookkeeping semantics like the
     // dream/recall passthroughs above — a recall_evals write is a snapshot, not

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 从对象子字段取值。