@modusensus/dsh-mneme 0.8.0 → 0.8.1

package/src/service.js

@@ -1,6 +1,7 @@
 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";
@@ -40,12 +41,8 @@ const CONTENT_HISTORY_MAX = 20;
 // 清单必须与 quality-filter.js 的写入端对齐（6 个，含 type 自指的 self_referential）。
 const SIGNAL_TAGS = ["low_quality", "duplicate", "meta", "repetitive", "short_content", "self_referential"];
 
-// v0.8.0 A1（issue #17）去重键的 scope 归一：非空 trim 字符串原样比较，其余
-// （NULL/undefined/空串）统一为「未标注」。与 store.normalizeScopeText 的落库
-// 口径一致——两把钥匙只有都过这里再比较，NULL 与 'global' 才不会错配。
-function scopeKeyOf(v) {
-  return typeof v === "string" && v.trim() ? v.trim() : null;
-}
+// scopeKeyOf 已上提到 ./scope.js（v0.8.1，issue #170 第 2 步）：与 sleep 的跨
+// scope 配对共用同一把比较钥匙，避免两处定义漂移。
 
 // v0.8.0 A2（issue #17）scope 检索加权系数：两维都无法确立 foreign 的候选
 // （命中行、未标注行、当前侧维度解析不到的行）→ 加成；只有确立了 foreign
@@ -93,10 +90,18 @@ function inOccurredBounds(m, bounds) {
  * 留给后续批次）。store.list 的 SQL 过滤与此谓词同口径（见 store.js visibility）。
  */
 function isVisibleInScope(m, current) {
-  const agent = scopeKeyOf(m.agent_scope);
-  if (agent !== null && (current.agent_scope === null || agent !== current.agent_scope)) return false;
-  const ws = scopeKeyOf(m.workspace_scope);
-  if (ws !== null && (current.workspace_scope === null || ws !== current.workspace_scope)) return false;
+  // 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;
 }
 
@@ -1064,17 +1069,19 @@ 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）：scopeEnabled 开启时去重键由 (type, title) 扩展为
+    // v0.8.0 A1（issue #17）：去重键由 (type, title) 扩展为
     // (type, title, agent_scope, workspace_scope, sensitivity)——不同作用域的同
     // 标题记忆绝不互相物理合并（旧逻辑跨 agent/workspace 并行，事后无法拆分）。
     // NULL 归一为「未标注」：未标注行之间互相匹配（含存量行），与已标注行不
-    // 匹配。flag 关闭时跳过比较，行为与 A1 前逐字节一致。
-    const scopeOn = config.scopeEnabled === true;
+    // 匹配。
+    // v0.8.1（issue #170 复核项 1）：比较不再受 scopeEnabled 门控——显式声明
+    // flag 关也生效（工具层明写「读了自动标注也生效」，去重必须同口径），否则
+    // 关自动标注后同标题不同 scope 的行会物理合并进第一行的归属。存量全 NULL
+    // 行互相匹配，A1 前行为不变。
     const scopeMatches = (m) =>
-      !scopeOn ||
-      (scopeKeyOf(m.agent_scope) === scopeKeyOf(memory.agent_scope) &&
-        scopeKeyOf(m.workspace_scope) === scopeKeyOf(memory.workspace_scope) &&
-        scopeKeyOf(m.sensitivity) === scopeKeyOf(memory.sensitivity));
+      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 + 质量处置），不另写第二份
     // 实现。目标已被并发删除时回落到常规匹配。显式目标同样过 scope 门：跨作用域
@@ -1097,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,
@@ -1105,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");
@@ -1122,8 +1162,12 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       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 } : {})
@@ -1441,8 +1485,12 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       // 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 } : {})
     }));
@@ -1734,10 +1782,47 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // tags——任何带 tags 的更新都会抹掉这条唯一的审计线索（报告实测 150 条低分
     // 记忆里恰好缺的 2 条就是被 update 过的，并因此误判过归档来源）。把 existing
     // 的系统信号标签并集保留；用户自传的标签照常生效。
-    const patch = (p && Array.isArray(p.tags) && old && Array.isArray(old.tags))
+    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
@@ -1843,6 +1928,8 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       notifyWrite();
     },
     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

package/src/store.js

@@ -148,6 +148,25 @@ CREATE TABLE IF NOT EXISTS conflict_pending (
 );
 CREATE INDEX IF NOT EXISTS idx_conflict_pending_unresolved ON conflict_pending(resolved_at);
 
+-- scope_changes: v0.8.1 底座（issue #170）scope 归属的人工修正审计。显式声明
+-- （memory_save/memory_update 的 scope 参数、面板编辑）每次改变某条记忆的
+-- agent/workspace 归属都落一行：改动前后值 + 来源 + actor（tool=模型侧 /
+-- panel=人工侧）。与 conflict_pending 同款的 bookkeeping 表：只做审计，
+-- 不触发 write hooks。放宽可见性（label→global）的候选筛选与回放都靠它。
+CREATE TABLE IF NOT EXISTS scope_changes (
+  id                    TEXT PRIMARY KEY,
+  memory_id             TEXT NOT NULL,
+  actor                 TEXT NOT NULL,
+  prev_agent_scope      TEXT,
+  prev_workspace_scope  TEXT,
+  next_agent_scope      TEXT,
+  next_workspace_scope  TEXT,
+  agent_scope_source    TEXT,
+  workspace_scope_source TEXT,
+  decided_at            TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_scope_changes_memory ON scope_changes(memory_id);
+
 -- llm_audit_logs: every background LLM call (autoDream consolidation + summary,
 -- autoSummarize compression) is recorded here — tokens in/out, duration, status
 -- and the trigger that caused it (Bug8). Failures are captured as status='error'
@@ -344,6 +363,13 @@ function normalizeScopeText(raw) {
   return s ? s : null;
 }
 
+// scope 来源列（issue #170 底座）：'auto'=载体自动标注，'explicit'=显式声明。
+// 只认这两个枚举值，其余（含 NULL）落 NULL——NULL 语义是「未标注，或 0.8.1
+// 之前落库的存量标注（视为 auto 的软效力，第 3 步语义收窄时按此口径读）」。
+function normalizeScopeSource(raw) {
+  return raw === "auto" || raw === "explicit" ? raw : null;
+}
+
 // occurred_at：事件发生时间（区别于 created_at 的入库时间）。可解析的时间戳
 // 统一归一到 UTC ISO（A2 的时间过滤要按字典序直接比较）；解析失败落 NULL，
 // 同样不阻塞写入。
@@ -371,6 +397,9 @@ function toRow(row) {
     epistemic_status: row.epistemic_status ?? "subjective",
     agent_scope: row.agent_scope ?? undefined,
     workspace_scope: row.workspace_scope ?? undefined,
+    agent_scope_source: row.agent_scope_source ?? undefined,
+    workspace_scope_source: row.workspace_scope_source ?? undefined,
+    scope_decided_at: row.scope_decided_at ?? undefined,
     sensitivity: row.sensitivity ?? undefined,
     occurred_at: row.occurred_at ?? undefined,
     created_at: row.created_at,
@@ -438,6 +467,22 @@ function toConflictPending(row) {
   };
 }
 
+function toScopeChange(row) {
+  if (!row) return undefined;
+  return {
+    id: row.id,
+    memory_id: row.memory_id,
+    actor: row.actor,
+    prev_agent_scope: row.prev_agent_scope ?? undefined,
+    prev_workspace_scope: row.prev_workspace_scope ?? undefined,
+    next_agent_scope: row.next_agent_scope ?? undefined,
+    next_workspace_scope: row.next_workspace_scope ?? undefined,
+    agent_scope_source: row.agent_scope_source ?? undefined,
+    workspace_scope_source: row.workspace_scope_source ?? undefined,
+    decided_at: row.decided_at
+  };
+}
+
 function toRecallRun(row) {
   if (!row) return undefined;
   return {
@@ -631,6 +676,16 @@ export function createStore(path) {
   addColumn("memories", "sensitivity", "ALTER TABLE memories ADD COLUMN sensitivity TEXT");
   addColumn("memories", "occurred_at", "ALTER TABLE memories ADD COLUMN occurred_at TEXT");
 
+  // v0.8.1 底座（issue #170）：scope 标注的来源与决策时间。三列全部可空不带
+  // DEFAULT（与 A1 同款零重写迁移）。来源拆成 agent/workspace 各一列而非单列
+  // scope_source：混合来源（agent 维显式 + workspace 维自动）必须可表达——否则
+  // 「提升回全局」之后遗留的自动 workspace 标签会在效力收窄时被一并当成显式，
+  // 恰好复活 issue #170 抱怨的「自动标签吃硬过滤」问题。存量标注行三列皆 NULL，
+  // 读侧按 auto（软效力）口径解释。
+  addColumn("memories", "agent_scope_source", "ALTER TABLE memories ADD COLUMN agent_scope_source TEXT");
+  addColumn("memories", "workspace_scope_source", "ALTER TABLE memories ADD COLUMN workspace_scope_source TEXT");
+  addColumn("memories", "scope_decided_at", "ALTER TABLE memories ADD COLUMN scope_decided_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'");
@@ -718,17 +773,20 @@ export function createStore(path) {
     // occurred_at 闭区间：与 list() 同过滤（visibility 同口径），memory_list
     // 的 total 才能和过滤后的行保持一致。
     if (visibility) {
+      // v0.8.1 第 3 步（issue #170 4.3）：硬过滤只认显式声明——与
+      // service.isVisibleInScope 同口径。IS NOT 是 NULL 安全比较：来源为
+      // auto/NULL（v0.8.0 存量自动标注）的行不吃硬墙，只走 A2 软加权。
       if (visibility.agentScope != null) {
-        clauses.push("(agent_scope IS NULL OR agent_scope = ?)");
+        clauses.push("(agent_scope IS NULL OR agent_scope_source IS NOT 'explicit' OR agent_scope = ?)");
         params.push(visibility.agentScope);
       } else {
-        clauses.push("agent_scope IS NULL");
+        clauses.push("(agent_scope IS NULL OR agent_scope_source IS NOT 'explicit')");
       }
       if (visibility.workspaceScope != null) {
-        clauses.push("(workspace_scope IS NULL OR workspace_scope = ?)");
+        clauses.push("(workspace_scope IS NULL OR workspace_scope_source IS NOT 'explicit' OR workspace_scope = ?)");
         params.push(visibility.workspaceScope);
       } else {
-        clauses.push("workspace_scope IS NULL");
+        clauses.push("(workspace_scope IS NULL OR workspace_scope_source IS NOT 'explicit')");
       }
     }
     if (!includeForgotten) {
@@ -775,8 +833,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, agent_scope, workspace_scope, sensitivity, occurred_at, 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, agent_scope_source, workspace_scope_source, scope_decided_at, sensitivity, occurred_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       ).run(
         id,
         type,
@@ -792,6 +850,9 @@ export function createStore(path) {
         epistemicStatus,
         normalizeScopeText(memory.agent_scope),
         normalizeScopeText(memory.workspace_scope),
+        normalizeScopeSource(memory.agent_scope_source),
+        normalizeScopeSource(memory.workspace_scope_source),
+        normalizeOccurredAt(memory.scope_decided_at),
         normalizeScopeText(memory.sensitivity),
         normalizeOccurredAt(memory.occurred_at),
         now,
@@ -825,9 +886,26 @@ export function createStore(path) {
     const qualityScore = patch.quality_score !== undefined && Number.isFinite(patch.quality_score)
       ? patch.quality_score
       : (existing.quality_score ?? null);
+    // v0.8.1 底座（issue #170）：scope 列只在本 patch 显式携带该键时才改写
+    // （undefined=不动；null=清空为未标注/global）。来源列只认 auto|explicit。
+    const nextAgentScope = patch.agent_scope !== undefined
+      ? normalizeScopeText(patch.agent_scope)
+      : (existing.agent_scope ?? null);
+    const nextWorkspaceScope = patch.workspace_scope !== undefined
+      ? normalizeScopeText(patch.workspace_scope)
+      : (existing.workspace_scope ?? null);
+    const nextAgentSource = patch.agent_scope_source !== undefined
+      ? normalizeScopeSource(patch.agent_scope_source)
+      : (existing.agent_scope_source ?? null);
+    const nextWorkspaceSource = patch.workspace_scope_source !== undefined
+      ? normalizeScopeSource(patch.workspace_scope_source)
+      : (existing.workspace_scope_source ?? null);
+    const nextDecidedAt = patch.scope_decided_at !== undefined
+      ? normalizeOccurredAt(patch.scope_decided_at)
+      : (existing.scope_decided_at ?? null);
     runAtomically(() => {
       db.prepare(
-        `UPDATE memories SET type=?, title=?, content=?, tags=?, importance=?, source=?, content_history=?, quality_score=?, embedding=?, epistemic_status=?, updated_at=? WHERE id=?`
+        `UPDATE memories SET type=?, title=?, content=?, tags=?, importance=?, source=?, content_history=?, quality_score=?, embedding=?, epistemic_status=?, agent_scope=?, workspace_scope=?, agent_scope_source=?, workspace_scope_source=?, scope_decided_at=?, updated_at=? WHERE id=?`
       ).run(
         type,
         patch.title ?? existing.title,
@@ -839,6 +917,11 @@ export function createStore(path) {
         qualityScore,
         embedding,
         epistemicStatus,
+        nextAgentScope,
+        nextWorkspaceScope,
+        nextAgentSource,
+        nextWorkspaceSource,
+        nextDecidedAt,
         now,
         id
       );
@@ -1042,21 +1125,25 @@ export function createStore(path) {
       params.push(occurred.to);
     }
     // v0.8.0 A3（issue #17）：strictScope 硬过滤（memory_list 分页路径）。
-    // SQL 与 service.isVisibleInScope 同口径：未标注(NULL)恒可见；当前维度
-    // 解析不到时该维度只放行未标注行（fail-closed）。只有显式传 visibility
-    // 的用户面调用才过滤——dream/质量过滤等内部 store.list 调用不受影响。
+    // SQL 与 service.isVisibleInScope 同口径：未标注(NULL)恒可见；v0.8.1 起
+    // 硬墙只认 explicit 来源（4.3），当前维度解析不到时该维度只放行未标注/
+    // 非显式行（fail-closed 收窄）。只有显式传 visibility 的用户面调用才
+    // 过滤——dream/质量过滤等内部 store.list 调用不受影响。
     if (visibility) {
+      // v0.8.1 第 3 步（issue #170 4.3）：硬过滤只认显式声明——与
+      // service.isVisibleInScope 同口径。IS NOT 是 NULL 安全比较：来源为
+      // auto/NULL（v0.8.0 存量自动标注）的行不吃硬墙，只走 A2 软加权。
       if (visibility.agentScope != null) {
-        clauses.push("(agent_scope IS NULL OR agent_scope = ?)");
+        clauses.push("(agent_scope IS NULL OR agent_scope_source IS NOT 'explicit' OR agent_scope = ?)");
         params.push(visibility.agentScope);
       } else {
-        clauses.push("agent_scope IS NULL");
+        clauses.push("(agent_scope IS NULL OR agent_scope_source IS NOT 'explicit')");
       }
       if (visibility.workspaceScope != null) {
-        clauses.push("(workspace_scope IS NULL OR workspace_scope = ?)");
+        clauses.push("(workspace_scope IS NULL OR workspace_scope_source IS NOT 'explicit' OR workspace_scope = ?)");
         params.push(visibility.workspaceScope);
       } else {
-        clauses.push("workspace_scope IS NULL");
+        clauses.push("(workspace_scope IS NULL OR workspace_scope_source IS NOT 'explicit')");
       }
     }
     if (!includeForgotten) {
@@ -1615,7 +1702,14 @@ export function createStore(path) {
    * order is normalized (sorted by id) so the same two memories are only ever
    * pending once — a re-detection in a later dream run is a no-op, never a
    * duplicate queue entry. Returns the pending row (freshly inserted, or the
-   * existing unresolved row when the pair is already pending).
+   * existing unresolved row when the pair is already pending), or undefined
+   * when the re-detection is suppressed.
+   *
+   * v0.8.1（issue #170 复核项 4）：人工已裁决过的对（resolved_at 非空）不再
+   * 反复入队——除非任一侧在裁决之后又被改过（updated_at 晚于 resolved_at）。
+   * 否则跨 scope 对每轮 sleep 都原样回来，把「保留双方」的决定变成噪声。
+   * updated_at 是宽松代理（任何字段更新都会触发重新评审）——宁可多看一眼，
+   * 不静音真冲突。
    */
   function saveConflictPending({ run_id, memory_a, memory_b, reason }) {
     const [a, b] = [memory_a, memory_b].sort();
@@ -1623,6 +1717,15 @@ export function createStore(path) {
       "SELECT * FROM conflict_pending WHERE memory_a = ? AND memory_b = ? AND resolved_at IS NULL LIMIT 1"
     ).get(a, b);
     if (existing) return toConflictPending(existing);
+    const reviewed = db.prepare(
+      "SELECT * FROM conflict_pending WHERE memory_a = ? AND memory_b = ? AND resolved_at IS NOT NULL ORDER BY resolved_at DESC, rowid DESC LIMIT 1"
+    ).get(a, b);
+    if (reviewed) {
+      const touched = db.prepare(
+        "SELECT count(*) AS c FROM memories WHERE id IN (?, ?) AND updated_at > ?"
+      ).get(a, b, reviewed.resolved_at).c;
+      if (touched === 0) return undefined;
+    }
     const id = randomUUID();
     const now = nowIso();
     db.prepare(
@@ -1668,6 +1771,44 @@ export function createStore(path) {
     ).get().c;
   }
 
+  /**
+   * v0.8.1 底座（issue #170）：scope 归属人工修正的审计行。record 描述「一次
+   * 决策后的完整状态」（prev_* 为改前、next_* 为改后，NULL=global/未标注），
+   * 由调用方（service.updateMemory）在 store.update 成功后写入；本函数不做
+   * 业务校验，只保证审计落库失败不反噬主写入（异常上抛由调用方吞掉记 warn）。
+   */
+  function saveScopeChange({ memory_id, actor, prev_agent_scope, prev_workspace_scope, next_agent_scope, next_workspace_scope, agent_scope_source, workspace_scope_source, decided_at }) {
+    const id = randomUUID();
+    db.prepare(
+      `INSERT INTO scope_changes (id, memory_id, actor, prev_agent_scope, prev_workspace_scope, next_agent_scope, next_workspace_scope, agent_scope_source, workspace_scope_source, decided_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      memory_id,
+      actor === "panel" ? "panel" : "tool",
+      normalizeScopeText(prev_agent_scope),
+      normalizeScopeText(prev_workspace_scope),
+      normalizeScopeText(next_agent_scope),
+      normalizeScopeText(next_workspace_scope),
+      normalizeScopeSource(agent_scope_source),
+      normalizeScopeSource(workspace_scope_source),
+      normalizeOccurredAt(decided_at) ?? nowIso()
+    );
+    return toScopeChange(db.prepare("SELECT * FROM scope_changes WHERE id = ?").get(id));
+  }
+
+  /** Scope 修正审计（单条记忆，新→旧）。审计回放与候选复核用。 */
+  function listScopeChanges(memoryId, { limit = 50 } = {}) {
+    const lim = Number.isInteger(limit) && limit > 0 ? Math.min(limit, 200) : 50;
+    // tiebreaker 用 rowid（追加写入的单调序）而非 id：decided_at 只有毫秒精度，
+    // 连续两次修正落在同一毫秒时 UUID 排序是随机的（CI windows/node24 抓到的
+    // 真实 flake）——审计回放要求「最新一条」确定。
+    const rows = db.prepare(
+      "SELECT * FROM scope_changes WHERE memory_id = ? ORDER BY decided_at DESC, rowid DESC LIMIT ?"
+    ).all(memoryId, lim);
+    return rows.map(toScopeChange);
+  }
+
   function getFailureStats({ since } = {}) {
     const clause = since ? "WHERE created_at >= ?" : "";
     const params = since ? [since] : [];
@@ -2133,6 +2274,8 @@ export function createStore(path) {
     listConflictPending,
     resolveConflictPending,
     countConflictPending,
+    saveScopeChange,
+    listScopeChanges,
     createEntity,
     findEntityByName,
     findEntityById,

package/src/tools.js

@@ -1,5 +1,5 @@
 import { defineTool } from "@deepseek-ai/dsh-tools";
-import { createScopeResolver } from "./scope.js";
+import { createScopeResolver, normalizeExplicitScope } from "./scope.js";
 import { describeLocalRuntime, resolveRuntimeEntry } from "./runtime/loader.js";
 import { defaultRuntimeDir } from "./runtime/layout.js";
 import { hostModulesDir, loadRuntimeManifest, provisionRuntime } from "./runtime/provision.js";
@@ -27,8 +27,12 @@ const MEMORY_ITEM_SCHEMA = {
     importance: { type: "integer", required: true },
     source: { type: "string" },
     // v0.8.0 A2：scope 标注与事件发生时间随行透出（未标注时缺省，可选属性）。
+    // v0.8.1 底座：scope 来源（auto/explicit）与决策时间随行透出（同样可选）。
     agent_scope: { type: "string" },
     workspace_scope: { type: "string" },
+    agent_scope_source: { type: "string" },
+    workspace_scope_source: { type: "string" },
+    scope_decided_at: { type: "string" },
     sensitivity: { type: "string" },
     occurred_at: { type: "string" },
     created_at: { type: "string", required: true },
@@ -75,6 +79,26 @@ export function createTools(ctx, service, config, embedder) {
   // flag 关闭时恒返回 null——写入不标注，检索不加权，行为与 A1 前完全一致。
   // logger 透传：registry 反查失败时 warnOnce 才有出口（否则静默降级无观测）。
   const resolveSessionScope = createScopeResolver({ ctx, config, logger: ctx.logger });
+
+  // 复核项 4（issue #170）：strictScope 下他 scope（explicit）的行对工具侧按
+  // 「不存在」处理——update/delete 与 memory_get 同款无存在性泄漏。strictScope
+  // 关、或会话身份取不到（scope 为 null）时恒可见（与 get 的短路语义一致）。
+  const visibleUnderStrictScope = (memory, exec) => {
+    if (config?.strictScope !== true) return true;
+    const scope = resolveSessionScope(exec);
+    return !scope || service.isVisibleInScope(memory, scope);
+  };
+  // 在调用点以「展开恒为 undefined」的形态前置校验（抛错即中止写入）。
+  const assertVisibleForTool = (id, exec) => {
+    const memory = id ? service.getById(id) : undefined;
+    if (!visibleUnderStrictScope(memory, exec)) throw new Error("memory not found");
+    return undefined;
+  };
+  // delete 侧需要目标行本身判断存在性（不可见 = 视作不存在，不抛错）。
+  const visibleForTool = (id, exec) => {
+    const memory = id ? service.getById(id) : undefined;
+    return visibleUnderStrictScope(memory, exec) ? memory : undefined;
+  };
   const tools = [
     defineTool({
       name: "memory_save",
@@ -90,7 +114,9 @@ export function createTools(ctx, service, config, embedder) {
         importance: { type: "integer", description: "1-5; >= threshold auto-injects into future sessions" },
         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." }
+        occurred_at: { type: "string", description: "Optional ISO-8601 instant the remembered event happened (differs from write time). Invalid values are ignored." },
+        agent_scope: { type: "string", description: "Optional explicit agent-scope declaration (issue #170): 'global' or '*' makes this memory visible to every agent; any other value narrows it to that label. Overrides the automatic carrier label for this write; honored even when automatic scope labeling is disabled." },
+        workspace_scope: { type: "string", description: "Optional explicit workspace-scope declaration: 'global' or '*' makes this memory visible in every workspace; any other value narrows it to that label. Overrides the automatic carrier label for this write; honored even when automatic scope labeling is disabled." }
       },
       output: {
         schema: {
@@ -104,10 +130,22 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(`memory ${value.action}: ${value.id}`)
       },
       async execute(args, exec) {
-        // scope 标注：agent_scope/workspace_scope 由会话身份解析（不作为模型
-        // 参数），sensitivity/occurred_at 来自显式参数。解析绝不抛错、取不到
-        // 落 NULL；flag 关闭时 scope 为 null，一个字段都不标注。
+        // scope 标注（v0.8.1 底座，issue #170）：默认由会话身份解析（载体自动
+        // 标注，盖 auto 章）；显式 agent_scope/workspace_scope 参数逐维覆盖并盖
+        // explicit 章。解析绝不抛错、取不到落 NULL。
+        // 复核项 2（#170）：scopeEnabled 只门控「自动标注」分支——显式声明与
+        // 读取身份（search/list/get/注入经同一解析器）不受 flag 限制，否则
+        // strictScope 硬墙会被 flag 静默拆掉（fail-open）。
+        // （存储 NULL，由 source 列与「从未标注」区分）。非字符串参数在工具
+        // 入参 schema 层即被拒（type: "string"）——脏值到不了归一化，无静默放宽。
         const scope = resolveSessionScope(exec);
+        const autoStamping = config?.scopeEnabled === true;
+        const agentLabel = args.agent_scope !== undefined
+          ? { value: normalizeExplicitScope(args.agent_scope), source: "explicit" }
+          : autoStamping && scope ? { value: scope.agent_scope, source: "auto" } : null;
+        const workspaceLabel = args.workspace_scope !== undefined
+          ? { value: normalizeExplicitScope(args.workspace_scope), source: "explicit" }
+          : autoStamping && scope ? { value: scope.workspace_scope, source: "auto" } : null;
         const { action, memory } = service.saveWithDedupe({
           type: args.type,
           title: args.title,
@@ -115,7 +153,8 @@ export function createTools(ctx, service, config, embedder) {
           tags: args.tags ?? [],
           importance: args.importance ?? 3,
           source: args.source ?? "tool",
-          ...(scope ? { agent_scope: scope.agent_scope, workspace_scope: scope.workspace_scope } : {}),
+          ...(agentLabel ? { agent_scope: agentLabel.value, agent_scope_source: agentLabel.source } : {}),
+          ...(workspaceLabel ? { workspace_scope: workspaceLabel.value, workspace_scope_source: workspaceLabel.source } : {}),
           ...(args.sensitivity !== undefined ? { sensitivity: args.sensitivity } : {}),
           ...(args.occurred_at !== undefined ? { occurred_at: args.occurred_at } : {})
         });
@@ -288,7 +327,9 @@ export function createTools(ctx, service, config, embedder) {
         type: { type: "string", enum: ["preference", "project", "decision", "history", "rejected_solution", "pitfall", "constraint"] },
         tags: { type: "array", items: { type: "string" } },
         importance: { type: "integer", description: "1-5" },
-        reason: { type: "string", description: "Optional context for the correction (what the user actually said/wanted), recorded for reflection" }
+        reason: { type: "string", description: "Optional context for the correction (what the user actually said/wanted), recorded for reflection" },
+        agent_scope: { type: "string", description: "Optional explicit agent-scope correction (issue #170): 'global' or '*' widens visibility to every agent; any other value narrows it to that label. Omit to keep the current agent scope. Recorded as an explicit scope decision (audited)." },
+        workspace_scope: { type: "string", description: "Optional explicit workspace-scope correction: 'global' or '*' widens visibility to every workspace; any other value narrows it to that label. Omit to keep the current workspace scope. Recorded as an explicit scope decision (audited)." }
       },
       output: {
         schema: {
@@ -314,7 +355,12 @@ export function createTools(ctx, service, config, embedder) {
           content: args.content,
           type: args.type,
           tags: args.tags,
-          importance: args.importance
+          importance: args.importance,
+          // 复核项 4（#170）：strictScope 下他 scope 的行按「不存在」处理（与 get 对齐），
+          // 展开恒为 undefined，仅承担写入前校验。
+          ...(assertVisibleForTool(args.id, arguments[1])),
+          ...(args.agent_scope !== undefined ? { agent_scope: args.agent_scope } : {}),
+          ...(args.workspace_scope !== undefined ? { workspace_scope: args.workspace_scope } : {})
         }, { query: args.reason });
         return { memory: { id: memory.id, title: memory.title, content: memory.content } };
       }
@@ -335,9 +381,10 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(value.deleted ? "Memory deleted." : "Memory not found.")
       },
       async execute(args) {
-        const existed = service.getById(args.id) !== undefined;
-        if (existed) service.remove(args.id);
-        return { deleted: existed };
+        // 复核项 4（#170）：不可见（explicit 他 scope）= 视作不存在，无存在性泄漏。
+        const target = visibleForTool(args.id, arguments[1]);
+        if (target) service.remove(args.id);
+        return { deleted: !!target };
       }
     }),