@modusensus/dsh-mneme 0.8.0 → 0.8.2

package/lib/store.js

@@ -22,6 +22,9 @@ CREATE TABLE IF NOT EXISTS memories (
 );
 CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
 CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+-- Issue #202：all()/list() 按 updated_at 排序，无索引时走临时 B 树全表排序
+-- （5k 行实测 all() 231ms → 135ms）。IF NOT EXISTS 幂等，存量库启动即建。
+CREATE INDEX IF NOT EXISTS idx_memories_updated ON memories(updated_at);
 
 -- autoDream audit trail: one row per consolidation run, capturing the exact
 -- input snapshot digest + the LLM decision list + per-id outcome + a compact
@@ -148,6 +151,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 +366,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 +400,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 +470,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 +679,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'");
@@ -662,11 +720,51 @@ export function createStore(path) {
     }
   }
 
+  // Issue #202：embedding 解析缓存。检索路径此前每次调用都对全部带向量行
+  // JSON.parse（993 × 512 维 ≈ 48 ms/次，且 SQL 拖着 10 MB 的 TEXT），余弦本身
+  // 只占 3%。向量只经 setEmbedding 写入（单一失效点），把解析结果按 id 缓存，
+  // 命中即零解析；上限 FIFO 驱逐防大库内存无界（4000 × 512 维 double ≈ 16 MB）。
+  const embeddingCache = new Map();
+  const EMBEDDING_CACHE_MAX = 4000;
+
+  function cacheEmbedding(id, vector) {
+    if (embeddingCache.size >= EMBEDDING_CACHE_MAX && !embeddingCache.has(id)) {
+      const oldest = embeddingCache.keys().next().value;
+      embeddingCache.delete(oldest);
+    }
+    embeddingCache.set(id, vector);
+  }
+
+  /** Parsed embedding for one id (cache-first); undefined when none/parse
+   *  failure. Single read path shared by searchVector / getEmbedding(s). */
+  function getParsedEmbedding(id) {
+    const cached = embeddingCache.get(id);
+    if (cached) return cached;
+    const row = db.prepare("SELECT embedding FROM memories WHERE id = ?").get(id);
+    if (!row?.embedding) return undefined;
+    try {
+      const v = JSON.parse(row.embedding);
+      if (Array.isArray(v) && v.length) {
+        cacheEmbedding(id, v);
+        return v;
+      }
+    } catch { /* corrupt embedding text: treated as absent */ }
+    return undefined;
+  }
+
+  // all()/list() 的显式列清单：从实际 schema 派生（迁移后），只排除 embedding
+  // 列——consolidation/sleep/inject 的消费方都不读向量，而它是全表里最重的一列
+  // （5k 行库 ≈ 9.4 MB TEXT），每次全表调用都白搬。经 PRAGMA 派生而非硬编码，
+  // schema 演进时自动跟随。
+  const memoryColumns = db.prepare("PRAGMA table_info(memories)").all()
+    .map((c) => c.name)
+    .filter((n) => n !== "embedding");
+  const memoryColumnList = memoryColumns.join(", ");
+
   // Per-instance monotonic timestamp guard: consecutive writes within the same
   // millisecond must still produce strictly increasing timestamps (test asserts
   // updated_at != created_at). State lives in the store closure, not module scope.
-  let lastTs = "";
-  function nowIso() {
+  let lastTs = "";  function nowIso() {
     let ts = new Date().toISOString();
     if (lastTs && ts <= lastTs) {
       const d = new Date(lastTs);
@@ -718,17 +816,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 +876,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 +893,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 +929,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,9 +960,18 @@ export function createStore(path) {
         qualityScore,
         embedding,
         epistemicStatus,
+        nextAgentScope,
+        nextWorkspaceScope,
+        nextAgentSource,
+        nextWorkspaceSource,
+        nextDecidedAt,
         now,
         id
       );
+      // Issue #202：update 可直写 embedding（patch.embedding），缓存条目失效，
+      // 下次读取按库值重解析。宁滥勿缺——即便本 patch 未含 embedding，丢一条
+      // 缓存只多一次点查重解析。
+      embeddingCache.delete(id);
       // Desired generation bumped in the same transaction as the update (peer
       // blocker 1: crash between write and sync must still be recoverable).
       incrementGeneration();
@@ -912,6 +1042,8 @@ export function createStore(path) {
         expectedUpdatedAt
       );
       if (result.changes === 0) return; // CAS miss: a concurrent write won
+      // Issue #202：同 update——CAS 命中即可能改写 embedding，失效缓存条目。
+      embeddingCache.delete(id);
       // Only bump desired generation on a successful CAS — a miss writes nothing.
       incrementGeneration();
       applied = true;
@@ -1042,21 +1174,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) {
@@ -1090,7 +1226,9 @@ export function createStore(path) {
   }
 
   function all() {
-    const rows = db.prepare("SELECT * FROM memories ORDER BY updated_at DESC").all();
+    // Issue #202：显式列清单排除 embedding——toRow 本就不输出向量，SELECT *
+    // 纯属把全表最重的列（9.4 MB TEXT/5k 行）拖进内存再丢弃。
+    const rows = db.prepare(`SELECT ${memoryColumnList} FROM memories ORDER BY updated_at DESC`).all();
     return rows.map(toRow);
   }
 
@@ -1098,6 +1236,17 @@ export function createStore(path) {
   function setEmbedding(id, vector) {
     const json = Array.isArray(vector) && vector.length ? JSON.stringify(vector) : null;
     db.prepare("UPDATE memories SET embedding = ? WHERE id = ?").run(json, id);
+    // Issue #202：单一写入口即单一失效点——重写缓存条目（向量在手上不必重解析），
+    // 清空则移除，删除过的 id 不会被下一次 searchVector 的 id 集合选中。
+    if (json) {
+      try {
+        const parsed = JSON.parse(json);
+        if (Array.isArray(parsed) && parsed.length) cacheEmbedding(id, parsed);
+        else embeddingCache.delete(id);
+      } catch { embeddingCache.delete(id); }
+    } else {
+      embeddingCache.delete(id);
+    }
   }
 
   /** Batch fetch stored embeddings by id (v0.5.0 search-time semantic dedup).
@@ -1106,19 +1255,10 @@ export function createStore(path) {
   function getEmbeddings(ids) {
     const out = new Map();
     const list = (Array.isArray(ids) ? ids : []).filter(Boolean);
-    for (let i = 0; i < list.length; i += 100) {
-      const chunk = list.slice(i, i + 100);
-      const rows = db.prepare(
-        `SELECT id, embedding FROM memories
-         WHERE embedding IS NOT NULL AND embedding != ''
-           AND id IN (${chunk.map(() => "?").join(",")})`
-      ).all(...chunk);
-      for (const row of rows) {
-        try {
-          const vec = JSON.parse(row.embedding);
-          if (Array.isArray(vec) && vec.length) out.set(row.id, vec);
-        } catch { /* corrupt row: skip */ }
-      }
+    for (const id of list) {
+      // Issue #202：走同一解析缓存（语义去重的批量读也免重复 parse）。
+      const vec = getParsedEmbedding(id);
+      if (vec) out.set(id, vec);
     }
     return out;
   }
@@ -1193,24 +1333,30 @@ export function createStore(path) {
   function searchVector(vector, { limit = 20, includeArchived = false, threshold = 0 } = {}) {
     if (!Array.isArray(vector) || !vector.length) return [];
     const archivedFilter = includeArchived ? "" : "archived = 0 AND ";
+    // Issue #202：只取 id 列（~40 KB）而非 SELECT *（~11 MB）——向量从缓存取，
+    // 缓存未命中时按 id 点查 embedding 再解析回填。SQL 里保留 embedding 的
+    // IS NOT NULL 过滤，保证「有向量的行」集合始终以库为准（删除/清空即时生效）。
     const rows = db.prepare(
-      `SELECT * FROM memories
+      `SELECT id FROM memories
        WHERE ${archivedFilter}forgotten = 0 AND embedding IS NOT NULL AND embedding != ''`
     ).all();
     const scored = [];
     for (const row of rows) {
-      let v;
-      try {
-        v = JSON.parse(row.embedding);
-      } catch {
-        continue;
-      }
+      const v = getParsedEmbedding(row.id);
+      if (!v) continue;
       const score = cosine(vector, v);
-      if (score >= threshold) scored.push({ row, score });
+      if (score >= threshold) scored.push({ row: { id: row.id }, score });
     }
     scored.sort((a, b) => b.score - a.score);
     const { limit: lim } = sanitizePage(limit, 0, 20);
-    return scored.slice(0, lim).map(({ row, score }) => ({ ...toRow(row), score }));
+    // Top-N 回表：只对入选行取完整字段（主键点查 ≤ lim 行），评分别拖着正文走。
+    const getFull = db.prepare("SELECT * FROM memories WHERE id = ?");
+    const out = [];
+    for (const { row, score } of scored.slice(0, lim)) {
+      const full = getFull.get(row.id);
+      if (full) out.push({ ...toRow(full), score });
+    }
+    return out;
   }
 
   // --- autoDream audit trail ----------------------------------------------
@@ -1615,7 +1761,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 +1776,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 +1830,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] : [];
@@ -2104,6 +2304,7 @@ export function createStore(path) {
     search,
     setEmbedding,
     getEmbeddings,
+    getParsedEmbedding,
     embeddedCount,
     needsEmbedding,
     searchVector,
@@ -2133,6 +2334,8 @@ export function createStore(path) {
     listConflictPending,
     resolveConflictPending,
     countConflictPending,
+    saveScopeChange,
+    listScopeChanges,
     createEntity,
     findEntityByName,
     findEntityById,

package/lib/summarize.js

@@ -144,7 +144,7 @@ function collectMessages(session, maxChars = 8000, language = "zh") {
         break;
     }
   }
-  return lines.length ? [createUserMessage({ content: [{ type: "text", text: trim(lines.join("\n"), maxChars) }] })] : [];
+  return lines.length ? [createUserMessage({ content: [{ type: "text", text: trim(lines.join("\n"), maxChars) }], source: { kind: "plugin", plugin: "dsh-mneme" } })] : [];
 }
 
 // ── 智能调速器（429 保护）─────────────────────────────────────────────
@@ -265,7 +265,7 @@ export function createSummarizer(ctx, service, config) {
         model: route.model,
         purpose: "summarization",
         messages: [
-          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }] },
+          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
           ...messages
         ],
         signal: controller.signal

package/lib/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,14 +27,20 @@ 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 },
     updated_at: { type: "string", required: true }
   }
 };
+// 导出供回归测试断言 memory_get 与共享 schema 同源（#184 防漂移护栏）。
+export { MEMORY_ITEM_SCHEMA };
 
 // v0.8.0 A2：occurred 时间窗参数 → store 过滤选项（list/count 同口径）；
 // 未传参返回空对象，既有调用方不受影响。（A3 复核：此处入参仅含 occurred 边界。）
@@ -75,6 +81,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 +116,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 +132,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 +155,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 } : {})
         });
@@ -238,25 +279,10 @@ export function createTools(ctx, service, config, embedder) {
           type: "object",
           additionalProperties: false,
           properties: {
-            memory: {
-              type: "object",
-              additionalProperties: false,
-              properties: {
-                id: { type: "string", required: true },
-                title: { type: "string", required: true },
-                type: { type: "string", required: true },
-                importance: { type: "integer", required: true },
-                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" }
-              }
-            }
+            // 与 memory_search / memory_list 共用同一份 item schema——DTO 由
+            // toApiList 统一产出，内联副本曾漏掉 v0.8.1 的 scope 来源三键，
+            // 任何被标注过的行都过不了 in-process 校验（#184）。
+            memory: MEMORY_ITEM_SCHEMA
           }
         },
         render: (_args, value) => {
@@ -288,7 +314,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 +342,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 +368,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 };
       }
     }),