sage-mem 1.9.2 → 2.0.1

package/lib/recall/compose.js

@@ -56,8 +56,12 @@ export function buildCandidates({ picked, bestChunk, nowMs = Date.now() }) {
  *
  * 按**实际进正文的字节**记账，而不是 `delivery.totals` —— 后者含指针的额度，
  * 而指针没有真的进上下文。两本账要对得上，就不能把没花出去的钱记进去。
+ *
+ * 2.0.0 起多收两个集合（`conflicts` / `expired`）：在此之前它们是硬编码空集，
+ * 而 `deliver.js` 里「未裁决冲突 / 已失效来源」两条规则早就写好了 —— 这一版只是
+ * 把真实数据接上去，**deliver.js 一行不改**（docs/2.0.0-plan.md §6.2）。
  */
-export function composeDelivery({ candidates, text, intent, contentBytes, nowMs = Date.now() }) {
+export function composeDelivery({ candidates, text, intent, contentBytes, nowMs = Date.now(), conflicts, expired }) {
   const delivery = decideDelivery(candidates, {
     intent,
     // ⚠️ 这里**故意传空集**：按 revision 抑制重复对「同一份文件的不同段落」太粗 ——
@@ -66,8 +70,8 @@ export function composeDelivery({ candidates, text, intent, contentBytes, nowMs
     // 并且单独评测一次。这条记在 docs/decisions.md 的 D15，不是遗漏。
     visibleRevisions: new Set(),
     scopeDenied: new Set(),
-    conflicts: new Set(),
-    expired: new Set(),
+    conflicts: conflicts instanceof Set ? conflicts : new Set(),
+    expired: expired instanceof Set ? expired : new Set(),
     needle: text ? text.slice(0, 40) : '',
   }, { bytes: Math.max(0, CONTENT_BUDGET - contentBytes) })
 
@@ -103,7 +107,7 @@ export function composeDelivery({ candidates, text, intent, contentBytes, nowMs
  */
 export function composeStatus({
   files, selected, bodyRanked, bodySearched, text, parts, injectedFiles, skippedForBudget,
-  deduped, st, toolsReady, checkpointLine, memoryDir, intentHistoryDependent,
+  deduped, st, toolsReady, checkpointLine, memoryDir, intentHistoryDependent, pendingConflicts,
 }) {
   // ── 缺口状态卡 ──
   // 它**替换**原来那行状态文字，不是额外追加：同一件事不说两遍。
@@ -118,8 +122,13 @@ export function composeStatus({
   // 后者是计划里点名的一条：没有历史依赖时不要插「你可能遗漏记忆」，否则提示
   // 每轮都出现，等真有缺口时它已经被当噪音忽略了。
   const gapExists = unread > 0 || skippedForBudget > 0
+  // 2.0.0：有矛盾待裁决时**必须**发卡 —— 抑制是「记忆悄悄不进正文」，
+  // 状态卡是用户不主动看面板时唯一会自己出现的解释（D27 教训，见 plan §6.4）。
+  const pending = Number.isFinite(Number(pendingConflicts)) && Number(pendingConflicts) > 0
+    ? Math.floor(Number(pendingConflicts))
+    : 0
 
-  const wantCard = gapExists || intentHistoryDependent === true || !!checkpointLine
+  const wantCard = gapExists || intentHistoryDependent === true || !!checkpointLine || pending > 0
   // 签名没变时沿用上一步渲染好的那份缺口卡，而不是重渲染一张。
   // 两条理由：其一，那一步与这一步的检索面**逐字相同**，缺口也相同，重渲染只会把
   // 同一件事换个数字再说一遍 —— 而局部变量算出来的数字还是错的（上一步注了 N 条，
@@ -140,6 +149,7 @@ export function composeStatus({
           needle: text ? text.slice(0, 40) : null,
           toolsAvailable: toolsReady,
           memoryDir,
+          pendingConflicts: pending,
         })
   // 句柄与卡**共用卡池**：它是同一个通道里的另一句提示，不该另开一份额度。
   const cardText = [cardBody, checkpointLine].filter(Boolean).join('\n')

package/lib/recall/injector.js

@@ -14,7 +14,9 @@
  *   1. 只取 `source.kind === 'user'` 的消息 —— DSH 0.1.5 起注入与工具结果也存成 role:'user'；
  *   2. 代次处理（`state.begin`）必须在算正文与控制提示**之前**，否则压缩后会拿上一代的账去判重（复审 R03）。
  */
-import { MEMORY_DIR, RECALL_DISCIPLINE, STATE_ROOT } from '../memory/config.js'
+import { MEMORY_DIR, RECALL_DISCIPLINE, STATE_ROOT, validityEnabled } from '../memory/config.js'
+import { listConflictIndex } from '../memory/conflicts.js'
+import { buildContradictionFileSet, buildExpirySet } from '../memory/validity.js'
 import { extractText } from '../memory/retrieval.js'
 import { scanMemoryFiles } from '../memory/scan.js'
 import { readCheckpoint } from '../memory/checkpoint.js'
@@ -24,6 +26,43 @@ import { buildCandidates, composeDelivery, composeStatus } from './compose.js'
 import { composeRecallText } from './text.js'
 import { debugEnabled, debugRecall, recordInjection } from './debug.js'
 
+/**
+ * 2.0.1：调试账里「被有效性挡掉」的两类理由（2.0.0 新引入的抑制）。
+ *
+ * ⚠️ **只收这两个**：`below_floor` / `budget_omitted` 等老理由在 2.0.0 之前就有，
+ * 它们的解释已经在面板的「预算挡掉 N 条」与得分列表里；而失效与未裁决矛盾是
+ * 2.0.0 让记忆**从正文里消失**的唯一原因 —— 不单列出来，用户与维护侧都只能靠
+ * 猜「这条到底是没检索到，还是被新规则挡住了」。
+ */
+const VALIDITY_SUPPRESS_REASONS = new Set(['expired_source', 'conflict_pending'])
+
+/** reason → 面板上的一句人话（英文由 client 侧字典决定，这里只给稳定键）。 */
+const VALIDITY_REASON_LABEL = Object.freeze({
+  expired_source: '已失效',
+  conflict_pending: '待裁决矛盾',
+})
+
+/**
+ * 从 `decideDelivery` 的逐条处置里挑出被有效性挡掉的，附上文件名、理由与（可选）冲突 id。
+ *
+ * 纯函数，给调试账用；**不影响注入结果** —— items 是决策的产物，这里只是把其中
+ * 两类 reason 摘出来。`conflictIds` 是「文件名 → 冲突记录 id」的映射：同一份文件被
+ * 多条记录牵扯时取第一条（按 `listConflictIndex` 的时间倒序），够定位就行。
+ */
+function validitySuppressedItems(items, conflictIds) {
+  const out = []
+  for (const it of Array.isArray(items) ? items : []) {
+    if (!it || !VALIDITY_SUPPRESS_REASONS.has(it.reason)) continue
+    const row = { file: String(it.file ?? ''), reason: it.reason, label: VALIDITY_REASON_LABEL[it.reason] }
+    if (it.reason === 'conflict_pending' && conflictIds instanceof Map) {
+      const id = conflictIds.get(row.file)
+      if (id) row.conflictId = id
+    }
+    out.push(row)
+  }
+  return out
+}
+
 /**
  * @param {object} deps
  * @param {object} deps.ctx — 宿主 ctx（`scanMemoryFiles` / `warnLog` 用）
@@ -85,6 +124,41 @@ export function createRecallInjector({ ctx, state, tools, taskIdOf }) {
       // 统一的出口在下面 —— 只有**正文与控制提示都为空**才返回。
 
       const nowMs = Date.now()
+      // ── 2.0.0：有效性过滤与矛盾抑制的真实集合 ──────────────────────────
+      // 两件事分开算：失效看**记忆自己的 frontmatter**（事实来源），矛盾看冲突队列
+      // （待办 + 审计）。队列读不动时**不抑制**、只留日志 —— 抑制是「少给点内容」，
+      // 拿一个读失败去换「记忆消失」不划算（D27）。
+      //
+      // ⚠️ 只对 `contradiction` 进集合：写失败型记录里盘上那份仍是现行内容（§6.3）。
+      let conflictsForDelivery = new Set()
+      let pendingConflicts = 0
+      // 2.0.1：调试账用的「文件名 → 冲突记录 id」。只在开关打开时才读得到，但先按需
+      // 建一份空 Map（代价可忽略，比在 makeDebug 里为了 id 再扫一次队列便宜）。
+      const conflictIdByFile = new Map()
+      const validity = validityEnabled()
+      const expired = validity ? buildExpirySet(files, nowMs) : new Set()
+      if (validity) {
+        try {
+          // 用**摘要索引**（不带两份正文、进程内缓存 1 秒）：100 条记录时 `listConflicts`
+          // 单次实测 p50 78 ms，而它每一步 assemble 都会被调一次（见 conflicts.js 的缓存注释）。
+          const listed = await listConflictIndex({ stateRoot: STATE_ROOT })
+          if (listed.ok) {
+            conflictsForDelivery = buildContradictionFileSet(listed.items)
+            for (const c of listed.items) {
+              if (!c || c.status !== 'open' || c.kind !== 'contradiction') continue
+              for (const key of ['file', 'otherFile']) {
+                const name = typeof c[key] === 'string' ? c[key].trim() : ''
+                if (name !== '' && !conflictIdByFile.has(name)) conflictIdByFile.set(name, c.id)
+              }
+            }
+            pendingConflicts = listed.items.filter((c) => c.status === 'open' && c.kind === 'contradiction').length
+          } else {
+            warnLog(ctx, `读冲突队列失败，本轮不做矛盾抑制：${listed.error ?? listed.code}`, sessionId)
+          }
+        } catch (err) {
+          warnLog(ctx, `读冲突队列异常，本轮不做矛盾抑制：${err?.message ?? err}`, sessionId)
+        }
+      }
       const candidates = buildCandidates({ picked, bestChunk, nowMs })
 
       // ── 单会话累计预算：**拆成两本账** ──
@@ -94,7 +168,15 @@ export function createRecallInjector({ ctx, state, tools, taskIdOf }) {
       // 账记在 session id 上；picked 里 baseline 永远排在检索结果之前，所以预算不够时
       // 先被挤掉的是「更晚才想起来的」那些 —— baseline 有优先权。
       // 起点来自 `begin()`：它可能刚因压缩把两本账连同卡签名一起归零过。
-      const delivered = composeDelivery({ candidates, text, intent: intentInfo.intent, contentBytes: st.contentBytes, nowMs })
+      const delivered = composeDelivery({
+        candidates,
+        text,
+        intent: intentInfo.intent,
+        contentBytes: st.contentBytes,
+        nowMs,
+        conflicts: conflictsForDelivery,
+        expired,
+      })
       const { parts, injectedFiles, skippedForBudget, contentBytes } = delivered
 
       // ── 任务检查点：压缩后的恢复入口 ──
@@ -113,6 +195,7 @@ export function createRecallInjector({ ctx, state, tools, taskIdOf }) {
         files, selected, bodyRanked, bodySearched, text, parts, injectedFiles, skippedForBudget,
         deduped, st, toolsReady: tools.ready(), checkpointLine, memoryDir: MEMORY_DIR,
         intentHistoryDependent: intentInfo.historyDependent,
+        pendingConflicts,
       })
       const { cardBody, cardPart } = status
 
@@ -126,7 +209,10 @@ export function createRecallInjector({ ctx, state, tools, taskIdOf }) {
       //   - `sessionChars` = 本代累计正文字节（预算账）；
       //   - `cardChars` = 这一步发出去的状态卡字节（没发就是 0）；
       //   - `deduped` = 同题同命中集刚注过，这一步没重复追加 —— 面板上要解释成
-      //     「不是坏了，是去重生效」，否则每轮多步里大部分账看着都是空的。
+      //     「不是坏了，是去重生效」，否则每轮多步里大部分账看着都是空的；
+      //   - `validitySuppressed`（2.0.1）= 被 2.0.0 的有效性规则挡在正文外的条目，
+      //     带 `reason`（expired_source / conflict_pending）与 `label`；矛盾还带
+      //     `conflictId`，便于去「冲突」页签定位。**这不是检索失败**，是规则生效。
       const debugOn = debugEnabled()
       const makeDebug = debugOn
         ? (outcome) => ({
@@ -146,6 +232,7 @@ export function createRecallInjector({ ctx, state, tools, taskIdOf }) {
             sessionChars: contentBytes,
             cardChars: cardPart ? Buffer.byteLength(cardPart, 'utf8') : 0,
             skippedByBudget: skippedForBudget,
+            validitySuppressed: validitySuppressedItems(delivered.delivery.items, conflictIdByFile),
             card: cardPart ? 'sent' : (status.cardText ? 'deduped-or-over-budget' : 'none'),
           })
         : () => null

package/lib/tools/memory-tools.js

@@ -19,6 +19,8 @@
 import { DEFAULT_MAX_BYTES, MAX_MAX_BYTES, readSlice } from '../memory/reader.js'
 import { DEFAULT_LIMIT, MAX_LIMIT, retrieve } from '../memory/search.js'
 import { scanMemoryFiles } from '../memory/scan.js'
+import { parseFrontmatter } from '../memory/frontmatter.js'
+import { describeValidity } from '../memory/validity.js'
 
 /** 工具返回内容统一用 text block（宿主把 ContentBlock[] 交给模型）。 */
 const text = (s) => [{ type: 'text', text: String(s ?? '') }]
@@ -45,8 +47,15 @@ function renderSearchResult(args, value) {
   const lines = v.hits.map((h, i) => {
     const where = h.lines ? `${h.file}:${h.lines[0]}-${h.lines[1]}` : h.file
     const why = Array.isArray(h.matchedBy) ? h.matchedBy.join('+') : ''
+    // 2.0.0：失效记忆**仍然能被搜到**（问历史时旧口径是证据），但必须标出来 ——
+    // 不标的话模型会把旧口径当现状，那正是「标了失效却仍在误导」的更坏版本。
+    const validity = h.expired
+      ? `（已失效${h.invalidAt ? `：invalid_at=${h.invalidAt}` : ''}，不是现行口径${h.supersededBy ? `；现行见 ${h.supersededBy}` : ''}）`
+      : h.invalidAt || h.supersededBy
+        ? `（有失效标记但未到点${h.invalidAt ? `：invalid_at=${h.invalidAt}` : ''}${h.supersededBy ? `；现行见 ${h.supersededBy}` : ''}）`
+        : ''
     const excerpt = h.excerpt ? `\n    ${renderClip(h.excerpt.replace(/\n/g, ' '), 200)}` : ''
-    return `${i + 1}. ${where}${why ? `（${why}）` : ''}${excerpt}`
+    return `${i + 1}. ${where}${why ? `（${why}）` : ''}${validity}${excerpt}`
   })
   const tail = v.nextCursor != null ? `\n\n还有下一页：用 cursor=${v.nextCursor} 继续。` : ''
   return text(`${head}\n${lines.join('\n')}${tail}`)
@@ -66,6 +75,10 @@ function renderReadResult(args, value) {
   const flags = [
     v.lineTooLong ? '这一行本身超过了一屏' : '',
     v.truncated ? '内容被截断' : '',
+    // 2.0.0：失效标记必须跟着正文一起给模型 —— 读得到 ≠ 仍然是现行口径。
+    v.expired ? '这条记忆已失效（invalid_at 已到点），下面是历史口径，不是现状' : '',
+    !v.expired && v.invalidAt ? `这条记忆带失效标记但未到点（invalid_at=${v.invalidAt}）` : '',
+    v.supersededBy ? `现行口径见 ${v.supersededBy}` : '',
   ].filter(Boolean)
   const tail = v.nextStartLine != null
     ? `\n\n还有内容：startLine=${v.nextStartLine}${v.nextStartByte ? ` startByte=${v.nextStartByte}` : ''}`
@@ -86,7 +99,8 @@ export function createMemoryTools(ctx) {
       '在本地记忆库（markdown 文件）里检索历史记忆。先用一句话摘要匹配、再按段落查正文，返回候选与命中片段。' +
       '当你需要依据既往决定、用户偏好、或继续未完成的任务，而当前上下文里没有可定位的依据时用它。' +
       'scope 选 summary 只比摘要（最省）、body 只查正文段落、all 两者都查（默认）。' +
-      '结果里带 file 与行号，可直接用 read_memory 读那一段。',
+      '结果里带 file 与行号，可直接用 read_memory 读那一段。' +
+      '已标失效（invalid_at）的记忆**仍然会被搜到**，结果里会带 invalidAt / supersededBy —— 那是历史口径，不是现状。',
     parameters: {
       type: 'object',
       properties: {
@@ -105,7 +119,24 @@ export function createMemoryTools(ctx) {
       if (!query) return { ok: false, error: 'query 不能为空' }
       try {
         const files = await scanMemoryFiles(ctx, exec?.agent?.id ?? '')
-        return retrieve({ query, files, scope: args?.scope, limit: args?.limit, cursor: args?.cursor })
+        const result = retrieve({ query, files, scope: args?.scope, limit: args?.limit, cursor: args?.cursor })
+        // 2.0.0：把每条命中对应的失效信息带出去（D29 Q3）。检索本身**不过滤**失效记忆 ——
+        // 问历史时旧口径是证据；过滤掉才是丢信息。模型靠这里的标记判断「这是不是现状」。
+        if (result && result.ok !== false && Array.isArray(result.hits)) {
+          const byFile = new Map(files.map((f) => [f.file, f]))
+          const nowMs = Date.now()
+          result.hits = result.hits.map((h) => {
+            const file = byFile.get(h.file)
+            if (!file) return h
+            const v = describeValidity(file, nowMs)
+            const extra = {}
+            if (v.invalidAt) extra.invalidAt = v.invalidAt
+            if (v.supersededBy) extra.supersededBy = v.supersededBy
+            if (v.expired) extra.expired = true
+            return Object.keys(extra).length ? { ...h, ...extra } : h
+          })
+        }
+        return result
       } catch (err) {
         // 工具**绝不抛**：一次检索失败不该打断模型那一轮。
         return { ok: false, error: `检索出错：${err?.message ?? err}` }
@@ -118,6 +149,7 @@ export function createMemoryTools(ctx) {
     description:
       '按文件名读取一份本地记忆的正文，可按行分页。用 search_memory 拿到的 file 与行号来读。' +
       '返回内容带 revision；如果你上次读之后这份记忆被改过，会告诉你 revision 已变，需要重新确认。' +
+      '如果这份记忆已标失效（invalid_at 已到点），页头会明确写出来 —— 那是历史口径。' +
       `一次默认读 ${DEFAULT_MAX_BYTES} 字节，返回的 nextStartLine / nextStartByte 用于继续往下读。`,
     parameters: {
       type: 'object',
@@ -135,13 +167,24 @@ export function createMemoryTools(ctx) {
     isConcurrencySafe: () => true,
     async execute(args) {
       try {
-        return await readSlice({
+        const result = await readSlice({
           name: args?.name,
           revision: args?.revision,
           startLine: args?.startLine,
           startByte: args?.startByte,
           maxBytes: args?.maxBytes,
         })
+        // 只在本页包含 frontmatter 时解析（分页读的后半段没有 frontmatter，解析出来是空 —— 不猜）。
+        if (result && result.ok !== false && typeof result.content === 'string') {
+          const meta = parseFrontmatter(result.content)
+          if (meta.invalidAt || meta.supersededBy) {
+            const v = describeValidity({ invalidAt: meta.invalidAt, supersededBy: meta.supersededBy }, Date.now())
+            result.invalidAt = v.invalidAt
+            result.supersededBy = v.supersededBy
+            result.expired = v.expired
+          }
+        }
+        return result
       } catch (err) {
         return { ok: false, code: 'io_error', error: `读取出错：${err?.message ?? err}` }
       }

package/lib/typert.host.js

@@ -178,6 +178,13 @@ const auditReportSchema = z.object({
 	// 归档/恢复中途崩溃留下的私有名残留（`*.md.archiving-<hex>`）。它可能装着用户唯一
 	// 一份内容，所以体检必须报出来 —— strict 不声明它就等于界面上永远看不见。
 	'strays': z.array(auditItemSchema).readonly(),
+	// 2.0.0：有效性标注的**提示**（不进 problems —— problems 是唯一健康数字）。
+	// 不声明的话 strict 会把它剥掉，面板与设置页就永远看不到「某个字段格式坏了」。
+	'validityHints': z.array(z.object({
+		'file': z.string().readonly(),
+		'field': z.string().readonly(),
+		'reason': z.string().readonly(),
+	}).readonly()).readonly(),
 	'problems': z.number().readonly(),
 }).readonly()
 
@@ -512,6 +519,90 @@ const autodreamOptsSchema = z.object({
 	'scope': z.string().optional(),
 }).readonly()
 
+// ── 2.0.0：冲突裁决面（conflict.*）────────────────────────────────
+// 结果 schema 必须**同时容纳成功与失败两种形状**：这一面的约定是失败返回
+// `{ok:false, code, error}` 而不是抛异常。strict 校验会按声明裁剪 —— 只声明成功字段，
+// 失败时的 code / error 就会在传到界面前消失，面板只剩一个没有原因的 ok:false。
+//
+// 另一条边界：列表只回摘要（`invalidate` / `undo` 等动作的结果回完整记录）。
+// 一份记录里两份正文各上限 48 KB，整批列表搬过去会把 remote 面撑爆。
+const conflictIdSchema = z.string().min(1).max(64)
+const conflictOptsSchema = z.object({
+	'id': conflictIdSchema,
+	'file': fileNameSchema.optional(),
+	'note': z.string().max(4096).optional(),
+}).readonly()
+const conflictItemBase = z.object({
+	'id': z.string().readonly(),
+	'at': z.string().readonly(),
+	'kind': z.string().readonly(),
+	'status': z.string().readonly(),
+	'file': z.string().readonly(),
+	'otherFile': z.string().readonly(),
+	'note': z.string().readonly(),
+	'decision': z.string().readonly(),
+	'decidedAt': z.string().readonly(),
+	'appliedVersion': z.string().readonly(),
+	// 这次被标失效的是哪一方（`file` 或 `otherFile`）——`undo` 唯一可信的落点。
+	'invalidatedFile': z.string().readonly(),
+	'truncated': z.boolean().readonly(),
+})
+const conflictItemSchema = conflictItemBase.readonly()
+const conflictRecordSchema = conflictItemBase.extend({
+	'incoming': z.string().readonly(),
+	'onDisk': z.string().readonly(),
+}).readonly()
+const conflictCountsSchema = z.object({
+	'open': z.number().readonly(),
+	'total': z.number().readonly(),
+}).readonly()
+const conflictWroteSchema = z.object({
+	'file': z.string().readonly(),
+	'invalidAt': z.string().readonly(),
+	'version': z.string().readonly(),
+}).readonly()
+const conflictListSchema = z.object({
+	'ok': z.boolean().readonly(),
+	'items': z.array(conflictItemSchema).readonly().optional(),
+	'broken': z.array(z.string()).readonly().optional(),
+	'ignored': z.array(z.string()).readonly().optional(),
+	'counts': conflictCountsSchema.optional(),
+	'code': z.string().readonly().optional(),
+	'error': z.string().readonly().optional(),
+}).readonly()
+const conflictReadResultSchema = z.object({
+	'ok': z.boolean().readonly(),
+	'record': conflictRecordSchema.optional(),
+	'warnings': z.array(z.string()).readonly().optional(),
+	'code': z.string().readonly().optional(),
+	'error': z.string().readonly().optional(),
+}).readonly()
+const conflictInvalidateResultSchema = z.object({
+	'ok': z.boolean().readonly(),
+	'record': conflictRecordSchema.optional(),
+	'wrote': conflictWroteSchema.optional(),
+	'code': z.string().readonly().optional(),
+	'error': z.string().readonly().optional(),
+}).readonly()
+const conflictDismissResultSchema = z.object({
+	'ok': z.boolean().readonly(),
+	'record': conflictRecordSchema.optional(),
+	'code': z.string().readonly().optional(),
+	'error': z.string().readonly().optional(),
+}).readonly()
+const conflictUndoResultSchema = z.object({
+	'ok': z.boolean().readonly(),
+	'record': conflictRecordSchema.optional(),
+	'cleared': z.object({ 'file': z.string().readonly() }).readonly().optional(),
+	'code': z.string().readonly().optional(),
+	'error': z.string().readonly().optional(),
+}).readonly()
+const conflictRemoveResultSchema = z.object({
+	'ok': z.boolean().readonly(),
+	'code': z.string().readonly().optional(),
+	'error': z.string().readonly().optional(),
+}).readonly()
+
 export const TYPERT = {
 	package: 'sage-mem',
 	face: 'host',
@@ -910,6 +1001,78 @@ export const TYPERT = {
 			result: { mode: 'strict', typeSymbol: 'sage-mem/types#AutodreamModelList', schema: modelListSchema, create: () => modelListSchema },
 			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
 		},
+		// ── 2.0.0：冲突裁决面（sourceLocation 硬编码为 lib/index.js —— 见 D21）──
+		{
+			id: 'sage-mem#conflict/list',
+			service: 'conflict',
+			namespace: 'conflict',
+			method: 'list',
+			invocation: { kind: 'direct' },
+			parameters: [],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictList', schema: conflictListSchema, create: () => conflictListSchema },
+			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+		},
+		{
+			id: 'sage-mem#conflict/read',
+			service: 'conflict',
+			namespace: 'conflict',
+			method: 'read',
+			invocation: { kind: 'direct' },
+			parameters: [
+				{ name: 'opts', wire: 'opts', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictOpts', schema: conflictOptsSchema, create: () => conflictOptsSchema } },
+			],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictReadResult', schema: conflictReadResultSchema, create: () => conflictReadResultSchema },
+			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+		},
+		{
+			id: 'sage-mem#conflict/invalidate',
+			service: 'conflict',
+			namespace: 'conflict',
+			method: 'invalidate',
+			invocation: { kind: 'direct' },
+			parameters: [
+				{ name: 'opts', wire: 'opts', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictOpts', schema: conflictOptsSchema, create: () => conflictOptsSchema } },
+			],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictInvalidateResult', schema: conflictInvalidateResultSchema, create: () => conflictInvalidateResultSchema },
+			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+		},
+		{
+			id: 'sage-mem#conflict/dismiss',
+			service: 'conflict',
+			namespace: 'conflict',
+			method: 'dismiss',
+			invocation: { kind: 'direct' },
+			parameters: [
+				{ name: 'opts', wire: 'opts', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictOpts', schema: conflictOptsSchema, create: () => conflictOptsSchema } },
+			],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictDismissResult', schema: conflictDismissResultSchema, create: () => conflictDismissResultSchema },
+			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+		},
+		{
+			id: 'sage-mem#conflict/undo',
+			service: 'conflict',
+			namespace: 'conflict',
+			method: 'undo',
+			invocation: { kind: 'direct' },
+			parameters: [
+				{ name: 'opts', wire: 'opts', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictOpts', schema: conflictOptsSchema, create: () => conflictOptsSchema } },
+			],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictUndoResult', schema: conflictUndoResultSchema, create: () => conflictUndoResultSchema },
+			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+		},
+		{
+			// ⚠️ 不叫 `remove`：客户端 RemoteNamespaceService 的保留方法名，见 lib/index.js 的注释。
+			id: 'sage-mem#conflict/removeRecord',
+			service: 'conflict',
+			namespace: 'conflict',
+			method: 'removeRecord',
+			invocation: { kind: 'direct' },
+			parameters: [
+				{ name: 'opts', wire: 'opts', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictOpts', schema: conflictOptsSchema, create: () => conflictOptsSchema } },
+			],
+			result: { mode: 'strict', typeSymbol: 'sage-mem/types#ConflictRemoveResult', schema: conflictRemoveResultSchema, create: () => conflictRemoveResultSchema },
+			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+		},
 	],
 	model: {
 		"services": [],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sage-mem",
   "description": "Cross-session memory for DeepSeek Harness — plain markdown files, no database, no worker.",
-  "version": "1.9.2",
+  "version": "2.0.1",
   "type": "module",
   "main": "lib/index.js",
   "icon": "./icon.png",
@@ -50,7 +50,8 @@
         "0.1.7-rc.2": "compatible",
         "0.2.0-rc.1": "compatible",
         "0.2.0-rc.2": "compatible",
-        "0.2.1-rc.1": "compatible"
+        "0.2.1-rc.1": "compatible",
+        "0.2.1-rc.3": "compatible"
       }
     }
   },