sage-mem 1.9.2 → 2.0.1

package/lib/client.js

@@ -1589,6 +1589,119 @@ const StarmapRuntime = (function (require, _react) {
 			},
 		};
 
+		// ── 冲突队列（2.0.0 矛盾检测）──
+		// 与宿主 manifest 逐字段对齐的 strict 形状。记录字段「只增不改」，但客户端这一份
+		// 必须写全 —— strict 校验缺字段会把整条调用当坏结果拒掉（additive 字段要从这里放行）。
+		//
+		// `invalidatedFile` 不是装饰：invalidate 允许标 `file` 或 `otherFile` 任一方失效，
+		// undo 要知道当时标的是哪一方，只能从记录里读（设计稿 §7.3 只写了「撤销失效」，
+		// 没写落点；D29 补这个字段）。空串 = 还没裁过。
+		const conflictFields = {
+			"id": isStr, "at": isStr, "kind": isStr, "status": isStr,
+			"file": isStr, "otherFile": isStr, "note": isStr, "decision": isStr,
+			"decidedAt": isStr, "appliedVersion": isStr, "invalidatedFile": isStr,
+			"truncated": isBool,
+		};
+		const conflictItemSchema = parseSchema(conflictFields);
+		// read 的 record = item 再带两份正文。正文可能为空串、可能被截断（truncated 为 true
+		// 时 UI 要显示「已截断」）—— 所以正文只校类型，不校长度。
+		const conflictRecordSchema = parseSchema(Object.assign({}, conflictFields, {
+			"incoming": isStr, "onDisk": isStr,
+		}));
+		/**
+		 * 冲突方法的失败分支：`{ok:false, code, error?}`。
+		 * 契约里失败**不抛**、也不走 ok:true —— 所以每个结果 codec 都要先认这一支，
+		 * 否则「stale_version 要给出路」这件事在界面层会被 strict 校验拦成一句泛化错误。
+		 */
+		function conflictFailure(v) {
+			if (v.ok !== false) return false;
+			isStr(v.code);
+			if ("error" in v) isStr(v.error);
+			return true;
+		}
+		const conflictListSchema = {
+			parse(v) {
+				if (v === null || typeof v !== "object" || Array.isArray(v)) throw new Error("sage-mem: invalid conflict list");
+				if (conflictFailure(v)) return v;
+				isBool(v.ok);
+				// items 是列表的主体，成功时必须有；broken / ignored 允许宿主省略（空数组）。
+				if (!Array.isArray(v.items)) throw new Error("sage-mem: invalid conflict list");
+				v.items.forEach(function (x) { conflictItemSchema.parse(x); });
+				if ("broken" in v && !Array.isArray(v.broken)) throw new Error("sage-mem: invalid broken list");
+				if ("ignored" in v && !Array.isArray(v.ignored)) throw new Error("sage-mem: invalid ignored list");
+				if (v.counts === null || typeof v.counts !== "object") throw new Error("sage-mem: missing counts");
+				isNum(v.counts.open);
+				isNum(v.counts.total);
+				return v;
+			},
+		};
+		const conflictReadSchema = {
+			parse(v) {
+				if (v === null || typeof v !== "object" || Array.isArray(v)) throw new Error("sage-mem: invalid conflict record");
+				if (conflictFailure(v)) return v;
+				isBool(v.ok);
+				conflictRecordSchema.parse(v.record);
+				// warnings 的元素形状没冻结（宿主 schema 也允许省略空数组），只校「是数组」。
+				if ("warnings" in v && !Array.isArray(v.warnings)) throw new Error("sage-mem: invalid warnings");
+				return v;
+			},
+		};
+		const conflictInvalidateSchema = {
+			parse(v) {
+				if (v === null || typeof v !== "object" || Array.isArray(v)) throw new Error("sage-mem: invalid conflict result");
+				if (conflictFailure(v)) return v;
+				isBool(v.ok);
+				conflictRecordSchema.parse(v.record);
+				const w = v.wrote;
+				if (w === null || typeof w !== "object") throw new Error("sage-mem: missing wrote");
+				isStr(w.file);
+				isStr(w.invalidAt);
+				// 宿主 manifest 里 version 是 string（写入门返回的版本令牌）。
+				isStr(w.version);
+				return v;
+			},
+		};
+		const conflictDismissSchema = {
+			parse(v) {
+				if (v === null || typeof v !== "object" || Array.isArray(v)) throw new Error("sage-mem: invalid conflict result");
+				if (conflictFailure(v)) return v;
+				isBool(v.ok);
+				conflictRecordSchema.parse(v.record);
+				return v;
+			},
+		};
+		const conflictUndoSchema = {
+			parse(v) {
+				if (v === null || typeof v !== "object" || Array.isArray(v)) throw new Error("sage-mem: invalid conflict result");
+				if (conflictFailure(v)) return v;
+				isBool(v.ok);
+				conflictRecordSchema.parse(v.record);
+				const c = v.cleared;
+				if (c === null || typeof c !== "object") throw new Error("sage-mem: missing cleared");
+				isStr(c.file);
+				return v;
+			},
+		};
+		const conflictRemoveSchema = {
+			parse(v) {
+				if (v === null || typeof v !== "object" || Array.isArray(v)) throw new Error("sage-mem: invalid conflict result");
+				if (conflictFailure(v)) return v;
+				isBool(v.ok);
+				return v;
+			},
+		};
+		// 5 个方法都是「一个对象参数」：{id} / {id,file?,note?}。可选字段传了就必须是字符串，
+		// 没传就交给宿主按空串处理 —— 不在这里编默认值。
+		const conflictOptsSchema = {
+			parse(v) {
+				if (v === null || typeof v !== "object" || Array.isArray(v)) throw new Error("sage-mem: expected object");
+				isStr(v.id);
+				if ("file" in v) isStr(v.file);
+				if ("note" in v) isStr(v.note);
+				return v;
+			},
+		};
+
 		const TYPERT_REMOTE = {
 			package: "sage-mem",
 			descriptors: [
@@ -1995,6 +2108,89 @@ const StarmapRuntime = (function (require, _react) {
 					result: { mode: "strict", typeSymbol: "sage-mem/types#AutodreamModelList", schema: objCodec, create: () => objCodec },
 					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
 				},
+				// ── 冲突裁决（2.0.0 矛盾检测）──
+				// 第四个 namespace。与 autodream 那批同一个坑：namespace **不会自动出现**
+				// （宿主 remote 清单是构建期产物），不在这里声明 `ctx.get("remote.conflict")`
+				// 就永远是 undefined —— 界面表现为「一整个页签消失」。
+				// 6 条都在同一个 `conflict` 面上：列表 / 读正文 / 标失效 / 标记已裁决 / 撤销 / 删记录。
+				{
+					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 },
+				},
+				{
+					// 只读：拿一条记录的两份正文（record = item + incoming/onDisk）。
+					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: conflictReadSchema, create: () => conflictReadSchema },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					// 唯一会写记忆文件的动作（标 invalid_at）；file 允许是记录的 file 或 otherFile。
+					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: conflictInvalidateSchema, create: () => conflictInvalidateSchema },
+					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: conflictDismissSchema, create: () => conflictDismissSchema },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					// 撤销失效：删掉 invalidate 写进记忆 frontmatter 的那两行。
+					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: conflictUndoSchema, create: () => conflictUndoSchema },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
+				{
+					// 删除记录：不可恢复，但记忆文件一个字节都不动。
+					// ⚠️ 方法名不能叫 `remove`：DSH 客户端 RemoteNamespaceService 的原型上有这个名字，
+					// 客户端声明同名方法会在 $mount 的 assertMethodAvailable 抛错 —— **整个 client
+					// 插件 activate 失败**（2026-10-27 真机复现）。两端统一用 `removeRecord`。
+					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: conflictRemoveSchema, create: () => conflictRemoveSchema },
+					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
+				},
 			],
 		};
 
@@ -2244,6 +2440,26 @@ const StarmapRuntime = (function (require, _react) {
 			// ── 底部一行仓库链接（引流，不抢视线）──
 			".smem-star{display:flex;align-items:center;justify-content:flex-end;gap:8px;flex-wrap:wrap;font-size:12px;color:var(--dsw-alias-label-tertiary,#8b93a1);padding:2px 2px 0;}",
 			".smem-star-link{color:var(--dsw-alias-brand-primary,#4d76e6);text-decoration:underline;}",
+			// ── 冲突页签（2.0.0 矛盾检测）──
+			// 一屏里要同时看「两份正文对照 + 动作 + 后果」，所以独立成套类名，不复用文件卡片：
+			// 文件卡片的灰系 / 动作语义是「这条记忆怎么处置」，裁决是另一件事，混用会让
+			// 「标失效」看起来像在编辑记忆本身。
+			".smem-conf{display:flex;flex-direction:column;gap:8px;}",
+			".smem-conf-list{display:flex;flex-direction:column;gap:10px;}",
+			".smem-conf-item{border:1px solid var(--dsw-alias-border-l1);border-radius:10px;background:var(--dsw-alias-bg-layer-1);padding:9px 11px;display:flex;flex-direction:column;gap:6px;}",
+			".smem-conf-head{display:flex;align-items:center;gap:6px;flex-wrap:wrap;}",
+			".smem-conf-id{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:11.5px;color:var(--dsw-alias-label-secondary);overflow-wrap:anywhere;}",
+			".smem-conf-files{display:flex;align-items:center;gap:6px;flex-wrap:wrap;}",
+			".smem-conf-file{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;max-width:100%;overflow-wrap:anywhere;white-space:normal;text-align:left;}",
+			".smem-conf-arrow{color:var(--dsw-alias-label-secondary);}",
+			".smem-conf-acts{display:flex;gap:6px;flex-wrap:wrap;align-items:center;}",
+			".smem-conf-confirm{border:1px solid var(--dsw-alias-state-error-primary,#ef4444);border-radius:8px;padding:8px 10px;background:var(--dsw-alias-bg-layer-2);font-size:12px;line-height:1.55;display:flex;flex-direction:column;gap:6px;overflow-wrap:anywhere;}",
+			// 两份正文并排对照：窄窗口自动堆成一列（grid auto-fit，不用媒体查询）。
+			".smem-conf-bodies{display:grid;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));gap:8px;}",
+			".smem-conf-body{border:1px solid var(--dsw-alias-border-l1);border-radius:8px;padding:7px 9px;display:flex;flex-direction:column;gap:4px;min-width:0;}",
+			".smem-conf-label{font-size:11.5px;font-weight:600;color:var(--dsw-alias-label-secondary);}",
+			".smem-conf-pre{margin:0;max-height:220px;overflow:auto;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:11.5px;line-height:1.55;white-space:pre-wrap;overflow-wrap:anywhere;color:var(--dsw-alias-label-primary);}",
+			".smem-conf-warn{font-size:11.5px;color:var(--dsw-alias-state-warn-primary,#d97706);}",
 		].join("\n");
 
 		/**
@@ -2707,14 +2923,18 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			: null);
 
 		/**
-		 * 「注入调试」面板（1.7.0）。
+		 * 「注入调试」面板（1.7.0；2.0.1 起显示有效性抑制明细）。
 		 *
 		 * 只读：没有「清空 / 重跑」按钮 —— 账是注入链在 `SAGE_MEM_DEBUG=1` 时自动记的，
 		 * 人能做的是看，以及点「刷新」再取一次。入口只在开关打开时出现（宿主告诉我们）。
 		 *
-		 * 每一条记录的口径写在 `lib/recall/debug.js` 的 makeDebug 注释里；这里只负责把
+		 * 每一条记录的口径写在 `lib/recall/injector.js` 的 makeDebug 注释里；这里只负责把
 		 * 「为什么这一步没注入」翻译成人话 —— 那是这个面板存在的唯一理由。**尤其是
 		 * `empty + deduped`**：每轮多步里它占大多数，不解释就会被当成「插件坏了」。
+		 *
+		 * 2.0.0 让失效 / 未裁决矛盾的记忆不再进正文。2.0.1 把这两类的**文件名、理由与
+		 * 冲突 id** 单列一行：否则「这条记忆不见了」在面板上只能看到它不在 injected 里，
+		 * 分不清是没检索到还是被新规则挡住 —— 而那正是 2.0.0 之后最需要解释的一种消失。
 		 */
 		function RecallDebugPanel(props) {
 			const data = props.data || {};
@@ -2749,6 +2969,9 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				}));
 			}
 			const injected = latest && Array.isArray(latest.injected) ? latest.injected : [];
+			// 2.0.1：被有效性挡掉的条目。旧记录没有这个字段 → 空数组（面板显示「无」），
+			// 不因为多一个可选字段就把老账读崩。
+			const validitySuppressed = latest && Array.isArray(latest.validitySuppressed) ? latest.validitySuppressed : [];
 			const histogram = recs.slice(1).map(function (r, i) {
 				return h("div", { className: "smem-dbg-hist-row", key: "h" + i }, [
 					h("span", { className: "smem-dbg-time", key: "t" }, clock(r.at)),
@@ -2792,6 +3015,23 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 								"正文字节 " + String(latest.chars || 0) + "（本代累计 " + String(latest.sessionChars || 0) + "）" +
 								" · 状态卡 " + (latest.cardChars ? String(latest.cardChars) + " 字节" : "未发") +
 								" · 预算挡掉 " + String(latest.skippedByBudget || 0) + " 条"),
+							h("div", { className: "smem-dbg-row", key: "vs" }, [
+								h("span", { className: "smem-label", key: "l" }, "有效性抑制"),
+								validitySuppressed.length
+									? h("span", { className: "smem-dbg-scores", key: "v" }, validitySuppressed.map(function (x, i) {
+										const reason = String((x && x.label) || (x && x.reason) || "未知理由");
+										const cid = x && x.conflictId ? " · " + String(x.conflictId) : "";
+										return h("span", { className: "smem-dbg-score", key: String((x && x.file) || i) + "-" + i }, [
+											h("span", { className: "smem-dbg-file", key: "f" }, String((x && x.file) || "?")),
+											h("span", { className: "smem-dbg-num", key: "r" }, reason + cid),
+										]);
+									}))
+									: h("span", { className: "smem-muted", key: "v" }, "无"),
+							]),
+							validitySuppressed.length
+								? h("div", { className: "smem-ar-hint", key: "vshint" },
+									"被标失效或待裁决矛盾挡掉的记忆不会进正文 —— 这不是检索没命中，是 2.0.0 的有效性规则生效；去「冲突」页签可裁决。")
+								: null,
 							h("div", { className: "smem-ar-hint", key: "hint" },
 								"注入每走一步都会尝试一次；同题同命中集不会重复注入 —— 所以「空」多半是去重生效，不是坏了。"),
 							histogram.length
@@ -2911,6 +3151,317 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			]);
 		}
 
+		// ── 「冲突」页签（2.0.0 矛盾检测）────────────────────────────────────
+		// 只做三件事：看（两份正文对照）、裁（标失效 / 标记已裁决 / 撤销 / 删除记录）、
+		// 说清后果（写哪个文件、能不能撤销、失败时的出路在哪）。
+		//
+		// 状态全部由 Section 持有（与文件列表 / 体检同一套「组件只吃 props」的规矩）：
+		// 头部徽标与这一屏数的是同一批记录，两边各存一份就会不同步。
+		//
+		// 文案里反复写「只标不删」：这是 2.0.0 最容易被误解的一条 —— 标失效不删文件、
+		// 不移动、不进 archive/，只是 frontmatter 多一行 invalid_at，随时可撤销。
+		const CONFLICT_KIND_KEY = {
+			contradiction: "conflict.kind.contradiction",
+			stale_version: "conflict.kind.staleVersion",
+			external_change: "conflict.kind.externalChange",
+			unresolved_merge: "conflict.kind.unresolvedMerge",
+		};
+		const CONFLICT_STATUS_KEY = {
+			open: "conflict.status.open",
+			resolved: "conflict.status.resolved",
+			dismissed: "conflict.status.dismissed",
+		};
+		const CONFLICT_DECISION_KEY = {
+			invalidate: "conflict.decision.invalidate",
+			dismiss: "conflict.decision.dismiss",
+			keep_both: "conflict.decision.keepBoth",
+		};
+		// 失败码 → 出路。**每一条都必须说清下一步**：只写「失败了」等于让用户再点一次
+		// 同一颗按钮（D25 修过的正是「点了没反应」这类事故）。
+		const CONFLICT_CODE_KEY = {
+			invalid: "conflict.code.invalid",
+			missing: "conflict.code.missing",
+			malformed: "conflict.code.malformed",
+			invalid_transition: "conflict.code.invalidTransition",
+			stale_version: "conflict.code.staleVersion",
+			write_denied: "conflict.code.writeDenied",
+			unsupported: "conflict.code.unsupported",
+			io_error: "conflict.code.ioError",
+		};
+		/**
+		 * 每份正文默认只显示开头一段。
+		 *
+		 * 按**字符**截 2048（≈「2 KB」的同量级）：按字节算的话中文只剩六百多字，
+		 * 对照两份说法时反而不够看；卡片本身还有 max-height 滚动，不会撑破布局。
+		 */
+		const CONFLICT_BODY_MAX = 2048;
+
+		function conflictKindLabel(kind) {
+			const key = CONFLICT_KIND_KEY[String(kind)];
+			return key ? t(key) : String(kind == null ? "" : kind);
+		}
+		function conflictStatusLabel(status) {
+			const key = CONFLICT_STATUS_KEY[String(status)];
+			return key ? t(key) : String(status == null ? "" : status);
+		}
+		function conflictDecisionLabel(decision) {
+			const key = CONFLICT_DECISION_KEY[String(decision)];
+			return key ? t(key) : String(decision == null ? "" : decision);
+		}
+
+		/**
+		 * 「冲突」面板（只读列表 + 裁决动作）。
+		 *
+		 * 能力降级是**逐动作**的：宿主有 list 没 invalidate（版本错配）时，对应按钮必须
+		 * 禁用并在同一屏里写明缺哪个接口 —— 不能让用户点了没反应。
+		 */
+		function ConflictPanel(props) {
+			const data = props.data;
+			const items = data && Array.isArray(data.items) ? data.items : [];
+			const broken = data && Array.isArray(data.broken) ? data.broken : [];
+			const ignored = data && Array.isArray(data.ignored) ? data.ignored : [];
+			const counts = (data && data.counts) || {};
+			const openN = typeof counts.open === "number"
+				? counts.open
+				: items.filter(function (x) { return x.status === "open"; }).length;
+			const totalN = typeof counts.total === "number" ? counts.total : items.length;
+			const tools = props.tools || {};
+			const bodies = props.bodies || {};
+			const expanded = props.expanded || {};
+			const confirm = props.confirm || null;
+			const busyId = props.busyId || null;
+			// `removeRecord` 而不是 `remove`：后者是宿主 RemoteNamespaceService 的保留方法名
+			// （声明即让整个 client 插件 activate 失败）。按钮文案的 i18n 键仍是 conflict.action.remove。
+			const ACTIONS = ["invalidate", "dismiss", "undo", "removeRecord"];
+			const missing = ACTIONS.filter(function (m) { return tools[m] !== true; })
+				.map(function (m) { return "conflict." + m; });
+
+			/** 动作按钮：方法不存在时禁用 + title 写明缺什么，绝不留「点了没反应」。 */
+			function actBtn(item, action, label, extraClass) {
+				const ok = tools[action] === true;
+				return h("button", {
+					type: "button", key: action,
+					className: "smem-btn" + (extraClass || ""),
+					disabled: !ok || busyId === item.id,
+					title: ok ? undefined : t("conflict.actionMissing", { method: action }),
+					onClick: ok ? function () { props.onAsk(item, action); } : undefined,
+				}, label);
+			}
+
+			function bodyPre(text) {
+				const s = typeof text === "string" ? text : "";
+				const shown = s.slice(0, CONFLICT_BODY_MAX);
+				const more = s.length > CONFLICT_BODY_MAX;
+				return h("pre", { className: "smem-conf-pre", key: "pre" }, [
+					shown || t("conflict.bodyEmpty"),
+					more ? "\n… " + t("conflict.bodyLimit") : null,
+				]);
+			}
+
+			function renderBodies(item, body) {
+				if (!body || body.loading) {
+					return [h("div", { className: "smem-status", key: "l" }, t("conflict.bodyLoading"))];
+				}
+				if (body.error) {
+					return [h("div", { className: "smem-err", key: "e" }, "⚠ " + body.error)];
+				}
+				const rec = body.record || {};
+				const contra = item.kind === "contradiction";
+				const parts = [
+					h("div", { className: "smem-conf-body", key: "in" }, [
+						h("div", { className: "smem-conf-label", key: "l" },
+							contra ? t("conflict.bodyIncomingContradiction") : t("conflict.bodyIncoming")),
+						bodyPre(rec.incoming),
+						Array.isArray(body.warnings) && body.warnings.length
+							? h("div", { className: "smem-ar-hint", key: "w" },
+									t("conflict.warnings", { list: body.warnings.map(String).join("；") }))
+							: null,
+					]),
+					h("div", { className: "smem-conf-body", key: "on" }, [
+						h("div", { className: "smem-conf-label", key: "l" },
+							contra ? t("conflict.bodyOnDiskContradiction") : t("conflict.bodyOnDisk")),
+						bodyPre(rec.onDisk),
+					]),
+				];
+				if (rec.truncated || item.truncated) {
+					parts.push(h("div", { className: "smem-conf-warn", key: "tr" }, t("conflict.truncatedHint")));
+				}
+				return parts;
+			}
+
+			/** 危险动作的两段式确认条（照「彻底归档删除」先例：先问，再动手）。 */
+			function confirmBlock(item) {
+				if (!confirm || confirm.id !== item.id) return null;
+				const act = confirm.action;
+				const file = confirm.file || item.file;
+				if (act === "invalidate") {
+					return h("div", { className: "smem-conf-confirm", key: "cf" }, [
+						h("div", { key: "what" }, t("conflict.confirmInvalidate", { file: file })),
+						item.otherFile
+							? h("div", { className: "smem-chips", key: "pick" }, [
+									h(Chip, {
+										key: "f", label: item.file, on: file === item.file,
+										onClick: function () { props.onPickFile(item.file); },
+									}),
+									h(Chip, {
+										key: "o", label: item.otherFile, on: file === item.otherFile,
+										onClick: function () { props.onPickFile(item.otherFile); },
+									}),
+								])
+							: null,
+						h("div", { className: "smem-ar-hint", key: "hint" }, t("conflict.confirmInvalidateHint")),
+						h("div", { className: "smem-row", key: "btns" }, [
+							h("button", {
+								type: "button", className: "smem-btn smem-btn-danger", key: "yes",
+								disabled: busyId === item.id,
+								onClick: props.onRun,
+							}, busyId === item.id ? t("conflict.busy") : t("conflict.confirmYesInvalidate")),
+							h("button", {
+								type: "button", className: "smem-btn", key: "no",
+								disabled: busyId === item.id, onClick: props.onCancelConfirm,
+							}, t("conflict.cancel")),
+						]),
+					]);
+				}
+				if (act === "undo") {
+					return h("div", { className: "smem-conf-confirm", key: "cf" }, [
+						h("div", { key: "what" }, t("conflict.confirmUndo", { file: item.invalidatedFile || item.file })),
+						h("div", { className: "smem-ar-hint", key: "hint" }, t("conflict.confirmUndoHint")),
+						h("div", { className: "smem-row", key: "btns" }, [
+							h("button", {
+								type: "button", className: "smem-btn smem-btn-primary", key: "yes",
+								disabled: busyId === item.id, onClick: props.onRun,
+							}, busyId === item.id ? t("conflict.busy") : t("conflict.confirmYesUndo")),
+							h("button", {
+								type: "button", className: "smem-btn", key: "no",
+								disabled: busyId === item.id, onClick: props.onCancelConfirm,
+							}, t("conflict.cancel")),
+						]),
+					]);
+				}
+				if (act === "removeRecord") {
+					return h("div", { className: "smem-conf-confirm", key: "cf" }, [
+						h("div", { key: "what" }, t("conflict.confirmRemove")),
+						h("div", { className: "smem-ar-hint", key: "hint" }, t("conflict.confirmRemoveHint")),
+						h("div", { className: "smem-row", key: "btns" }, [
+							h("button", {
+								type: "button", className: "smem-btn smem-btn-danger", key: "yes",
+								disabled: busyId === item.id, onClick: props.onRun,
+							}, busyId === item.id ? t("conflict.busy") : t("conflict.confirmYesRemove")),
+							h("button", {
+								type: "button", className: "smem-btn", key: "no",
+								disabled: busyId === item.id, onClick: props.onCancelConfirm,
+							}, t("conflict.cancel")),
+						]),
+					]);
+				}
+				return null;
+			}
+
+			function renderItem(item) {
+				const bodyOpen = expanded[item.id] === true;
+				const body = bodies[item.id] || null;
+				const openRec = item.status === "open";
+				// 撤销只对「当时真的写过文件」的记录有意义：dismiss / keep_both 没写盘，
+				// 给一颗「撤销」只会让人以为要撤掉什么，其实没有。
+				const canUndo = !openRec && (item.decision === "invalidate" || !!item.invalidatedFile);
+				return h("div", { className: "smem-conf-item", key: item.id }, [
+					h("div", { className: "smem-conf-head", key: "head" }, [
+						h("span", { className: "smem-badge", key: "kind" }, conflictKindLabel(item.kind)),
+						h("span", {
+							className: "smem-badge" + (openRec ? " smem-conf-status--open" : ""),
+							key: "st",
+						}, conflictStatusLabel(item.status)),
+						h("span", { className: "smem-muted", key: "at" },
+							item.at ? t("conflict.time", { at: item.at }) : t("conflict.noTime")),
+						item.truncated ? h("span", { className: "smem-conf-warn", key: "tr" }, t("conflict.truncated")) : null,
+						h("span", { className: "smem-conf-id", key: "id" }, String(item.id)),
+					]),
+					h("div", { className: "smem-conf-files", key: "files" }, [
+						h("button", {
+							type: "button", className: "smem-btn smem-conf-file", key: "f",
+							title: t("conflict.openFileTitle"),
+							onClick: function () { props.onOpenFile(item.file); },
+						}, String(item.file)),
+						item.otherFile ? h("span", { className: "smem-conf-arrow", key: "ar" }, "↔") : null,
+						item.otherFile
+							? h("button", {
+									type: "button", className: "smem-btn smem-conf-file", key: "o",
+									title: t("conflict.openFileTitle"),
+									onClick: function () { props.onOpenFile(item.otherFile); },
+								}, String(item.otherFile))
+							: null,
+					]),
+					item.otherFile ? h("div", { className: "smem-ar-hint", key: "pair" }, t("conflict.pairHint")) : null,
+					item.note ? h("div", { className: "smem-ar-hint", key: "note" }, t("conflict.note", { note: item.note })) : null,
+					item.decision
+						? h("div", { className: "smem-ar-hint", key: "dec" },
+								t("conflict.decisionLine", { decision: conflictDecisionLabel(item.decision), at: item.decidedAt || "—" }))
+						: null,
+					item.invalidatedFile
+						? h("div", { className: "smem-ar-hint", key: "inv" },
+								t("conflict.invalidatedFile", { file: item.invalidatedFile }))
+						: null,
+					h("div", { className: "smem-conf-acts", key: "bodybar" }, [
+						h("button", {
+							type: "button", className: "smem-btn", key: "body",
+							disabled: tools.read !== true,
+							title: tools.read === true ? undefined : t("conflict.actionMissing", { method: "read" }),
+							onClick: tools.read === true ? function () { props.onToggleBodies(item); } : undefined,
+						}, bodyOpen ? t("conflict.bodiesHide") : t("conflict.bodiesToggle")),
+					]),
+					bodyOpen ? h("div", { className: "smem-conf-bodies", key: "bodies" }, renderBodies(item, body)) : null,
+					confirmBlock(item),
+					h("div", { className: "smem-conf-acts", key: "acts" }, [
+						openRec ? actBtn(item, "invalidate", t("conflict.action.invalidate"), " smem-btn-danger-ghost") : null,
+						openRec ? actBtn(item, "dismiss", t("conflict.action.dismiss")) : null,
+						canUndo ? actBtn(item, "undo", t("conflict.action.undo")) : null,
+						actBtn(item, "removeRecord", t("conflict.action.remove"), " smem-btn-danger-ghost"),
+					]),
+				]);
+			}
+
+			return h("div", { className: "smem-tool-panel smem-tool-panel--full smem-conf", key: "conflict" }, [
+				h("div", { className: "smem-tool-head", key: "head" }, [
+					h("span", { className: "smem-tool-title", key: "t" }, t("conflict.title")),
+					// 数字只在**真的取到队列**之后才出现：加载中 / 失败时写「0 条」等于撒谎。
+					data ? h("span", {
+						className: "smem-tool-badge" + (openN > 0 ? " smem-tool-badge--bad" : ""), key: "n",
+					}, t("conflict.openCount", { count: openN })) : null,
+					data ? h("span", { className: "smem-muted", key: "total" }, t("conflict.totalCount", { count: totalN })) : null,
+					h("button", {
+						type: "button", className: "smem-btn", key: "re",
+						disabled: props.loading || !!busyId, onClick: props.onReload,
+					}, props.loading ? t("conflict.refreshing") : t("conflict.refresh")),
+				]),
+				h("div", { className: "smem-ar-hint", key: "intro" }, t("conflict.intro")),
+				props.error ? h("div", { className: "smem-err", key: "err", role: "alert" }, "⚠ " + props.error) : null,
+				missing.length
+					? h("div", { className: "smem-ar-hint smem-conf-warn", key: "cap" },
+							t("conflict.actionMissingHint", { methods: missing.join(" / ") }))
+					: null,
+				tools.read !== true
+					? h("div", { className: "smem-ar-hint smem-conf-warn", key: "readcap" }, t("conflict.readMissingHint"))
+					: null,
+				props.loading && !data
+					? h("div", { className: "smem-empty", key: "loading" }, t("conflict.loading"))
+					: null,
+				data && items.length === 0
+					? h("div", { className: "smem-empty smem-empty--ok", key: "empty" }, t("conflict.empty"))
+					: null,
+				data && items.length > 0
+					? h("div", { className: "smem-conf-list", key: "list" }, items.map(renderItem))
+					: null,
+				ignored.length
+					? h("div", { className: "smem-ar-hint", key: "ign" }, t("conflict.ignored", { count: ignored.length }))
+					: null,
+				broken.length
+					? h("div", { className: "smem-ar-hint smem-conf-warn", key: "brk" }, t("conflict.broken", { count: broken.length }))
+					: null,
+				h("div", { className: "smem-ar-hint", key: "foot" }, t("conflict.noApply")),
+			]);
+		}
+
 		/**
 		 * 「归档候选」面板。
 		 *
@@ -3074,6 +3625,7 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"tab.autodream": "自动做梦",
 			"tab.archive": "自动归档",
 			"tab.audit": "体检",
+			"tab.conflict": "冲突",
 
 			"type.user": "用户",
 			"type.feedback": "反馈",
@@ -3218,6 +3770,7 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"error.noAudit": "宿主侧还没有 audit 接口（插件版本较旧）",
 			"error.noArchiveCandidates": "宿主侧还没有 archiveCandidates 接口（插件版本较旧）",
 			"error.noGetSettings": "宿主侧还没有 getSettings 接口（插件版本较旧）",
+			"error.noConflict": "宿主侧还没有 conflict 接口（插件版本较旧）",
 			"error.noReadRaw": "宿主侧还没有 readRaw 接口（插件版本较旧）",
 			"error.noWriteRaw": "宿主侧还没有 writeRaw 接口（插件版本较旧）",
 			"error.readFailed": "读不到 {file}：{message}",
@@ -3244,6 +3797,88 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"notice.restored": "已恢复 {file} —— 它回到了活动记忆里",
 			"notice.restoredIndexed": "已恢复 {file} —— 它回到了活动记忆里，并补进了索引",
 			"notice.purged": "已彻底删除 {file} —— 归档区里也没有它了，找不回来",
+
+			// ── 2.0.0 矛盾检测：冲突页签 / 徽标 / 裁决动作 / 失败码出路 ──
+			// 文案口径：「失效」不是删除、不是归档；「记录」不是记忆本身；
+			// 两种正文的语义按 kind 区分（矛盾 = 新说法 / 旧说法；写失败 = 待写入 / 盘上现行）。
+			"header.conflictOpen": "冲突 {count} 待裁决",
+			"header.conflictEmpty": "冲突 · 无",
+			"header.conflictNotRun": "冲突 · 未载",
+			"header.conflictSwitch": "切到冲突页裁决",
+			"header.conflictClean": "没有待裁决的冲突",
+			"header.conflictMissing": "冲突队列还没载入：点一下打开（失败会给出原因）",
+			"conflict.title": "冲突队列",
+			"conflict.openCount": "{count} 条待裁决",
+			"conflict.totalCount": "共 {count} 条记录",
+			"conflict.refresh": "刷新",
+			"conflict.refreshing": "刷新中…",
+			"conflict.loading": "读取冲突队列…",
+			"conflict.intro": "「只标不删」：标失效只往记忆 frontmatter 写一行 invalid_at —— 文件仍在原目录、正文不变、随时可撤销。未裁决的矛盾两方本轮不注入正文（记忆本身仍可读）。",
+			"conflict.noApply": "处理完只解除抑制：这里不会把任何一份正文写回记忆（待写内容可能基于过期版本，手工合并更安全）。",
+			"conflict.empty": "没有待处理的冲突。矛盾会在自动整理记忆时被发现并落到这里；也可以直接手工编辑记忆。",
+			"conflict.broken": "另有 {count} 条记录损坏，已跳过（其余照常显示）",
+			"conflict.ignored": "另有 {count} 个文件不是冲突记录，已忽略",
+			"conflict.truncated": "已截断",
+			"conflict.truncatedHint": "宿主只保留了部分正文（已截断），完整内容在记忆文件里。",
+			"conflict.time": "记录于 {at}",
+			"conflict.noTime": "记录时间未知",
+			"conflict.pairHint": "两条说法互斥：标失效时选哪一方作废。",
+			"conflict.note": "说明：{note}",
+			"conflict.decisionLine": "裁决：{decision} · {at}",
+			"conflict.invalidatedFile": "已标失效：{file}",
+			"conflict.openFileTitle": "在文件列表里查看这条记忆",
+			"conflict.bodiesToggle": "展开两份正文",
+			"conflict.bodiesHide": "收起两份正文",
+			"conflict.bodyIncomingContradiction": "新说法（拟保留）",
+			"conflict.bodyOnDiskContradiction": "旧说法（拟标失效）",
+			"conflict.bodyIncoming": "待写入的那一版",
+			"conflict.bodyOnDisk": "盘上现行内容",
+			"conflict.bodyEmpty": "（空串）",
+			"conflict.bodyLimit": "只显示前 2 KB",
+			"conflict.bodyLoading": "读取正文…",
+			"conflict.warnings": "读取提示：{list}",
+			"conflict.action.invalidate": "标此条失效",
+			"conflict.action.dismiss": "标记已裁决",
+			"conflict.action.undo": "撤销失效",
+			"conflict.action.remove": "删除记录",
+			"conflict.actionMissing": "宿主侧还没有 conflict.{method} 接口（插件版本较旧），这个动作已禁用",
+			"conflict.actionMissingHint": "版本较旧：缺少 {methods} 接口 —— 对应按钮已禁用。可升级插件，或手工编辑记忆 frontmatter（加 invalid_at）。",
+			"conflict.readMissingHint": "版本较旧：没有 conflict.read 接口 —— 正文对照已禁用，仍可裁决。",
+			"conflict.confirmInvalidate": "确认把「{file}」标为失效？会往它的 frontmatter 写 invalid_at（可撤销），文件仍在原目录、正文不变。",
+			"conflict.confirmInvalidateHint": "只改 frontmatter 里的一行；不删除、不移动文件，也不改 updated。",
+			"conflict.confirmUndo": "撤销「{file}」的失效标记？会删掉那行 invalid_at（以及 superseded_by），它重新参与注入。",
+			"conflict.confirmUndoHint": "只删我们写的那一行，其他字节不动。",
+			"conflict.confirmRemove": "删除这条冲突记录？记录会从队列里消失，不能恢复（记忆文件不受影响）。",
+			"conflict.confirmRemoveHint": "只删状态目录里的记录文件；记忆本身一个字节都不动。",
+			"conflict.confirmYesInvalidate": "确认标失效",
+			"conflict.confirmYesUndo": "确认撤销",
+			"conflict.confirmYesRemove": "确认删除记录",
+			"conflict.cancel": "取消",
+			"conflict.busy": "处理中…",
+			"conflict.decision.invalidate": "标失效",
+			"conflict.decision.dismiss": "标记已裁决",
+			"conflict.decision.keepBoth": "两条都保留",
+			"conflict.kind.contradiction": "矛盾",
+			"conflict.kind.staleVersion": "版本冲突",
+			"conflict.kind.externalChange": "外部改动",
+			"conflict.kind.unresolvedMerge": "合并未完成",
+			"conflict.status.open": "待裁决",
+			"conflict.status.resolved": "已裁决",
+			"conflict.status.dismissed": "已忽略",
+			"conflict.code.invalid": "记录或文件名不合法：刷新列表后重试；若仍然失败，检查状态目录里的这条记录。",
+			"conflict.code.missing": "记录或记忆文件已经不在了：刷新列表再看（记录可能已被别的窗口处理）。",
+			"conflict.code.malformed": "这条记录格式损坏：可以删除记录，或手工检查状态目录里的 JSON。",
+			"conflict.code.invalidTransition": "这条记录的状态已经变了：刷新列表后按当前状态再操作。",
+			"conflict.code.staleVersion": "记忆文件在你打开之后被改过：先刷新列表、确认最新内容再裁决（本次不会覆盖你的改动）。",
+			"conflict.code.writeDenied": "宿主拒绝了写入（只读 / 沙箱策略）：把 DSH 的写入权限调宽后重试，或手工在记忆 frontmatter 里加 invalid_at。",
+			"conflict.code.unsupported": "宿主没有可用的写入接口：升级插件，或手工在记忆 frontmatter 里加 invalid_at。",
+			"conflict.code.ioError": "读写磁盘失败：稍后重试；记录仍是待裁决状态，不会留下半份文件。",
+			"conflict.code.unknown": "操作失败（未知错误）：刷新列表再试；若反复失败，查看宿主日志。",
+			"conflict.code.detail": "（宿主说明：{detail}）",
+			"notice.conflictInvalidated": "已把 {file} 标为失效 —— 文件仍在原处，frontmatter 多了一行 invalid_at，可撤销",
+			"notice.conflictDismissed": "已标记为已裁决 —— 没有改任何记忆文件",
+			"notice.conflictUndone": "已撤销 {file} 的失效标记 —— 它重新参与注入",
+			"notice.conflictRemoved": "已删除冲突记录（记忆文件没动）",
 		};
 
 		const EN = {
@@ -3256,6 +3891,7 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"tab.autodream": "Autodream",
 			"tab.archive": "Auto-archive",
 			"tab.audit": "Audit",
+			"tab.conflict": "Conflicts",
 
 			"type.user": "User",
 			"type.feedback": "Feedback",
@@ -3400,6 +4036,7 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"error.noAudit": "The host has no audit API yet (older plugin version)",
 			"error.noArchiveCandidates": "The host has no archiveCandidates API yet (older plugin version)",
 			"error.noGetSettings": "The host has no getSettings API yet (older plugin version)",
+			"error.noConflict": "The host has no conflict API yet (older plugin version)",
 			"error.noReadRaw": "The host has no readRaw API yet (older plugin version)",
 			"error.noWriteRaw": "The host has no writeRaw API yet (older plugin version)",
 			"error.readFailed": "Cannot read {file}: {message}",
@@ -3426,6 +4063,86 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			"notice.restored": "Restored {file} — it is back among the active memories",
 			"notice.restoredIndexed": "Restored {file} — it is back among the active memories and was added to the index",
 			"notice.purged": "Permanently deleted {file} — it is gone from the archive as well and cannot be recovered",
+
+			// ── 2.0.0 contradiction detection: conflict tab / badge / decisions / error codes ──
+			"header.conflictOpen": "Conflicts: {count} pending",
+			"header.conflictEmpty": "Conflicts: none",
+			"header.conflictNotRun": "Conflicts: not loaded",
+			"header.conflictSwitch": "Switch to Conflicts to decide",
+			"header.conflictClean": "No conflicts pending a decision",
+			"header.conflictMissing": "The conflict queue is not loaded yet: click to open (a failure shows the reason)",
+			"conflict.title": "Conflict queue",
+			"conflict.openCount": "{count} pending",
+			"conflict.totalCount": "{count} records in total",
+			"conflict.refresh": "Refresh",
+			"conflict.refreshing": "Refreshing…",
+			"conflict.loading": "Reading the conflict queue…",
+			"conflict.intro": "Mark, never delete: invalidating only writes one invalid_at line into the memory frontmatter — the file stays where it is, the body is untouched, and it can be undone. Both sides of an undecided contradiction stay out of injection this round (the memory itself is still readable).",
+			"conflict.noApply": "Deciding only lifts the suppression: no body is ever written back from here (the pending text may be based on a stale version; merging by hand is safer).",
+			"conflict.empty": "No conflicts to handle. Contradictions are discovered when memories are auto-organized and land here; you can also edit memories by hand.",
+			"conflict.broken": "{count} records are broken and were skipped (the rest are listed normally)",
+			"conflict.ignored": "{count} files are not conflict records and were ignored",
+			"conflict.truncated": "truncated",
+			"conflict.truncatedHint": "The host kept only part of the text (truncated); the full content is in the memory file.",
+			"conflict.time": "recorded at {at}",
+			"conflict.noTime": "recorded time unknown",
+			"conflict.pairHint": "The two statements contradict each other: choose which side becomes invalid.",
+			"conflict.note": "Note: {note}",
+			"conflict.decisionLine": "Decision: {decision} · {at}",
+			"conflict.invalidatedFile": "Marked invalid: {file}",
+			"conflict.openFileTitle": "Open this memory in the file list",
+			"conflict.bodiesToggle": "Show both bodies",
+			"conflict.bodiesHide": "Hide both bodies",
+			"conflict.bodyIncomingContradiction": "New statement (to keep)",
+			"conflict.bodyOnDiskContradiction": "Old statement (to invalidate)",
+			"conflict.bodyIncoming": "The version that was going to be written",
+			"conflict.bodyOnDisk": "What is currently on disk",
+			"conflict.bodyEmpty": "(empty string)",
+			"conflict.bodyLimit": "showing the first 2 KB only",
+			"conflict.bodyLoading": "Reading bodies…",
+			"conflict.warnings": "Read warnings: {list}",
+			"conflict.action.invalidate": "Invalidate this side",
+			"conflict.action.dismiss": "Mark as decided",
+			"conflict.action.undo": "Undo invalidation",
+			"conflict.action.remove": "Delete record",
+			"conflict.actionMissing": "The host has no conflict.{method} API yet (older plugin version), so this action is disabled",
+			"conflict.actionMissingHint": "Older version: missing {methods} — the matching buttons are disabled. Upgrade the plugin, or edit the memory frontmatter by hand (add invalid_at).",
+			"conflict.readMissingHint": "Older version: no conflict.read API — the body comparison is disabled, but decisions still work.",
+			"conflict.confirmInvalidate": "Mark “{file}” as invalid? This writes invalid_at into its frontmatter (reversible); the file stays in place and the body is unchanged.",
+			"conflict.confirmInvalidateHint": "Only one frontmatter line changes; nothing is deleted or moved, and updated is left alone.",
+			"conflict.confirmUndo": "Undo the invalidation of “{file}”? The invalid_at line (and superseded_by) is removed and it takes part in injection again.",
+			"conflict.confirmUndoHint": "Only the line we wrote is removed; every other byte stays the same.",
+			"conflict.confirmRemove": "Delete this conflict record? It disappears from the queue and cannot be restored (the memory file is not affected).",
+			"conflict.confirmRemoveHint": "Only the record file in the state directory is deleted; the memory itself is untouched.",
+			"conflict.confirmYesInvalidate": "Confirm invalidation",
+			"conflict.confirmYesUndo": "Confirm undo",
+			"conflict.confirmYesRemove": "Confirm delete record",
+			"conflict.cancel": "Cancel",
+			"conflict.busy": "Working…",
+			"conflict.decision.invalidate": "invalidated",
+			"conflict.decision.dismiss": "decided",
+			"conflict.decision.keepBoth": "kept both",
+			"conflict.kind.contradiction": "Contradiction",
+			"conflict.kind.staleVersion": "Version conflict",
+			"conflict.kind.externalChange": "External change",
+			"conflict.kind.unresolvedMerge": "Unfinished merge",
+			"conflict.status.open": "Pending",
+			"conflict.status.resolved": "Decided",
+			"conflict.status.dismissed": "Dismissed",
+			"conflict.code.invalid": "The record or file name is invalid: refresh the list and try again; if it keeps failing, inspect that record in the state directory.",
+			"conflict.code.missing": "The record or memory file is gone: refresh the list (another window may have handled it).",
+			"conflict.code.malformed": "This record is malformed: delete the record, or inspect the JSON in the state directory by hand.",
+			"conflict.code.invalidTransition": "This record already changed state: refresh the list and act on its current state.",
+			"conflict.code.staleVersion": "The memory file changed after you opened it: refresh the list and check the latest content before deciding (your changes are not overwritten).",
+			"conflict.code.writeDenied": "The host refused the write (read-only / sandbox policy): widen DSH write permissions and retry, or add invalid_at to the memory frontmatter by hand.",
+			"conflict.code.unsupported": "The host has no usable write API: upgrade the plugin, or add invalid_at to the memory frontmatter by hand.",
+			"conflict.code.ioError": "Disk read/write failed: retry later; the record stays pending and no half-written file is left behind.",
+			"conflict.code.unknown": "The action failed (unknown error): refresh and try again; if it keeps failing, check the host log.",
+			"conflict.code.detail": " (host detail: {detail})",
+			"notice.conflictInvalidated": "Marked {file} as invalid — the file stays in place, its frontmatter gained one invalid_at line, and this can be undone",
+			"notice.conflictDismissed": "Marked as decided — no memory file was changed",
+			"notice.conflictUndone": "Undid the invalidation of {file} — it takes part in injection again",
+			"notice.conflictRemoved": "Deleted the conflict record (no memory file was touched)",
 		};
 
 		/**
@@ -4695,6 +5412,28 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			const dbg = sDbg[0], setDbg = sDbg[1];
 			const sDbgBusy = react.useState(false);
 			const dbgBusy = sDbgBusy[0], setDbgBusy = sDbgBusy[1];
+			// ── 冲突页签（2.0.0 矛盾检测）──
+			// 能力检测分两层：remote 整个不存在 → 页签与徽标都不出现（旧宿主）；
+			// remote 在、某个动作方法缺失 → 按钮禁用并在屏上写明缺哪个接口（版本错配时
+			// 绝不能变成「点了没反应」—— D25 的教训）。
+			const conflictRemote = stableRemote(props.ctx, "remote.conflict");
+			const conflictOk = !!(conflictRemote && typeof conflictRemote.list === "function");
+			const sConf = react.useState(null);
+			const conf = sConf[0], setConf = sConf[1];
+			const sConfLoad = react.useState(false);
+			const confLoad = sConfLoad[0], setConfLoad = sConfLoad[1];
+			const sConfErr = react.useState(null);
+			const confErr = sConfErr[0], setConfErr = sConfErr[1];
+			// 正文按 id 缓存（只在展开时去 read）；记录一变（裁决 / 刷新）就整批丢掉。
+			const sConfBodies = react.useState({});
+			const confBodies = sConfBodies[0], setConfBodies = sConfBodies[1];
+			const sConfExpanded = react.useState({});
+			const confExpanded = sConfExpanded[0], setConfExpanded = sConfExpanded[1];
+			// 危险动作的两段式确认：{id, action, file}（null = 没在问）。
+			const sConfConfirm = react.useState(null);
+			const confConfirm = sConfConfirm[0], setConfConfirm = sConfConfirm[1];
+			const sConfBusy = react.useState(null);
+			const confBusy = sConfBusy[0], setConfBusy = sConfBusy[1];
 			// renderSlot：shell 会经 props 传进来（见 80-apply 的 children 声明），
 			// 但本插件改用并列 tab 渲染星图，不再调用它 —— 声明保留给 shell，这里不取。
 
@@ -4733,6 +5472,9 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				// 1.7.0：只读问一次「调试开关开着吗」—— 关着时抽屉里不会多出「注入调试」。
 				// 这是唯一一处为调试视图多付的调用（一次本地只读 remote，不碰磁盘）。
 				loadRecallDebug();
+				// 2.0.0：冲突徽标与体检徽标同一套道理 —— 不打开也知道有没有待裁决的。
+				// 旧宿主没有 conflict 面时 conflictOk=false，这里一个调用都不发。
+				loadConflicts();
 				/**
 				 * 更新检查：**静默**跑，失败一律不打扰 ——
 				 * 网络不通、被 GitHub 限流、仓库还没建 release，都不该在面板上冒一条红。
@@ -5143,6 +5885,187 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 					.then(function () { setDbgBusy(false); });
 			}
 
+			/**
+			 * 拉一次冲突队列（只读）。
+			 *
+			 * 头部徽标与「冲突」页签数的是同一批记录，所以挂载时就取一次（旧宿主没有
+			 * conflict 面 → conflictOk=false，这里整段不跑，界面一个像素都不变）。
+			 * 失败返回 `{ok:false, code}` 而不是抛 —— 契约的一部分，转成可读文案。
+			 */
+			function loadConflicts() {
+				if (!conflictOk) return;
+				setConfLoad(true); setConfErr(null);
+				Promise.resolve()
+					.then(function () { return conflictRemote.list(); })
+					.then(function (res) {
+						// ⚠️ 必须过 unwrap：typert remote 的通用传输层把返回值包成
+						// `{ok:true, value:<方法返回值>}`。**方法返回值里自带的 `ok` 是内层**，
+						// 与信封的 `ok` 是两个东西 —— 2026-10-27 真机就栽在这：直接把信封当
+						// payload 读，`items` 永远是 undefined，界面显示「0 条待裁决」，
+						// 而网络层明明返回了记录。与 76-sidebar-entry 的 setSettings 不同：
+						// 那是特例，这里是通用路径。
+						const d = unwrap(res) || {};
+						if (d.ok === false) { setConf(null); setConfErr(conflictErrText(d)); return; }
+						setConf({
+							items: Array.isArray(d.items) ? d.items : [],
+							broken: Array.isArray(d.broken) ? d.broken : [],
+							ignored: Array.isArray(d.ignored) ? d.ignored : [],
+							counts: d.counts && typeof d.counts === "object" ? d.counts : { open: 0, total: 0 },
+						});
+					})
+					.catch(function (e) { setConf(null); setConfErr(String((e && e.message) || e)); })
+					.then(function () { setConfLoad(false); });
+			}
+
+			/**
+			 * 冲突动作的失败文案：先按 `code` 给出路，再附上宿主给的一句细节。
+			 * 失败码是界面上**唯一**能把「为什么没成」翻译成下一步动作的地方 —— 尤其
+			 * stale_version / write_denied / unsupported 三条，不问清就只会反复点同一颗按钮。
+			 */
+			function conflictErrText(err) {
+				const code = err && typeof err.code === "string" ? err.code : "";
+				const key = CONFLICT_CODE_KEY[code] || "conflict.code.unknown";
+				const detail = err && typeof err.error === "string" ? err.error : "";
+				return t(key) + (detail ? t("conflict.code.detail", { detail: detail }) : "");
+			}
+
+			/** 打开「冲突」这一屏。数据没取过才取（挂载时已经取过一次，通常直接有内容）。 */
+			function openConflictTab() {
+				setTab("conflict");
+				setError(null); setNotice("");
+				if (!conf || confErr) loadConflicts();
+			}
+
+			/**
+			 * 展开 / 收起一条记录的两份正文。
+			 *
+			 * 正文只在**展开那一刻**才 read：列表阶段不取（记录里可能带几十 KB 正文），
+			 * 而且展开后要把「宿主截断了」这件事显示出来。
+			 */
+			function toggleConflictBodies(item) {
+				if (!conflictOk || typeof conflictRemote.read !== "function") return;
+				const was = confExpanded[item.id] === true;
+				const next = Object.assign({}, confExpanded);
+				if (was) {
+					delete next[item.id];
+					setConfExpanded(next);
+					return;
+				}
+				next[item.id] = true;
+				setConfExpanded(next);
+				if (confBodies[item.id] && confBodies[item.id].record) return;
+				const mark = function (patch) {
+					setConfBodies(function (cur) {
+						const nx = Object.assign({}, cur);
+						nx[item.id] = Object.assign({}, cur[item.id] || {}, patch);
+						return nx;
+					});
+				};
+				mark({ loading: true, error: null });
+				Promise.resolve()
+					.then(function () { return conflictRemote.read({ id: item.id }); })
+					.then(function (res) {
+						const d = unwrap(res) || {};
+						if (d.ok === false) { mark({ loading: false, error: conflictErrText(d) }); return; }
+						mark({
+							loading: false,
+							record: d.record || null,
+							warnings: Array.isArray(d.warnings) ? d.warnings : [],
+						});
+					})
+					.catch(function (e) { mark({ loading: false, error: String((e && e.message) || e) }); });
+			}
+
+			/**
+			 * 请求一个动作。dismiss 不写记忆文件、按设计表**不需要二次确认**；标失效 /
+			 * 撤销失效 / 删记录都会走两段式（前两个写文件，后一个不可恢复）。
+			 */
+			function askConflict(item, action) {
+				setError(null); setNotice("");
+				if (action === "dismiss") { runConflictNow(item.id, action, ""); return; }
+				// 标失效默认选记录里的 `file`（= 被提议标失效的一方）；撤销时默认显示
+				// 记录里真正被标过的那一方（invalidatedFile）。
+				const file = action === "undo"
+					? (item.invalidatedFile || item.file || "")
+					: (item.file || item.otherFile || "");
+				setConfConfirm({ id: item.id, action: action, file: file });
+			}
+
+			/** 两段式确认里改「标哪一方失效」（矛盾记录有两方）。 */
+			function pickConflictFile(file) {
+				setConfConfirm(function (cur) {
+					return cur ? Object.assign({}, cur, { file: file }) : cur;
+				});
+			}
+
+			function cancelConflictConfirm() { setConfConfirm(null); }
+
+			function runConflictAction() {
+				if (!confConfirm) return;
+				runConflictNow(confConfirm.id, confConfirm.action, confConfirm.file);
+			}
+
+			/**
+			 * 真正执行一个裁决动作。
+			 *
+			 * 顺序刻意固定：成功 → 清确认条 / 清正文缓存 → 重新拉队列 → 再刷记忆列表
+			 * （invalidate / undo 改了记忆文件，文件列表与星图都得跟着变）。
+			 * 失败**不动**记录之外的任何状态：错误文案（含出路）挂在全局错误条上。
+			 */
+			function runConflictNow(id, action, file) {
+				if (!conflictOk) { setError(t("error.noConflict")); return; }
+				const fn = conflictRemote[action];
+				if (typeof fn !== "function") {
+					setError(t("conflict.actionMissing", { method: action }));
+					return;
+				}
+				const opts = { id: id };
+				if (action === "invalidate" && file) opts.file = file;
+				setConfBusy(id); setError(null); setNotice("");
+				Promise.resolve()
+					.then(function () { return fn.call(conflictRemote, opts); })
+					.then(function (res) {
+						const d = unwrap(res) || {};
+						if (d.ok === false) { setError(conflictErrText(d)); return; }
+						const rec = d.record || {};
+						setConfConfirm(null);
+						// 记录变了：正文缓存与展开状态一起作废，避免展示已过期的正文。
+						setConfBodies({});
+						setConfExpanded({});
+						if (action === "invalidate") {
+							const wrote = d.wrote || {};
+							setNotice(t("notice.conflictInvalidated", {
+								file: rec.invalidatedFile || wrote.file || file,
+							}));
+						} else if (action === "dismiss") {
+							setNotice(t("notice.conflictDismissed"));
+						} else if (action === "undo") {
+							const cleared = d.cleared || {};
+							setNotice(t("notice.conflictUndone", {
+								file: rec.invalidatedFile || cleared.file || file,
+							}));
+						} else {
+							setNotice(t("notice.conflictRemoved"));
+						}
+						loadConflicts();
+						// 只有真的写过记忆文件的动作才需要重扫文件列表。
+						if (action === "invalidate" || action === "undo") load();
+					})
+					.catch(function (e) { setError(String((e && e.message) || e)); })
+					.then(function () { setConfBusy(null); });
+			}
+
+			/** 从冲突记录跳到文件列表看这条记忆（清掉筛选，否则可能被筛没）。 */
+			function openConflictFile(name) {
+				if (!name) return;
+				setError(null);
+				setTab("files");
+				setStatusFilter("all");
+				setTypeFilter([]);
+				setTagFilter([]);
+				setQuery(String(name));
+			}
+
 			/**
 			 * 打开 / 收起一个工具面板。数据只在第一次打开时拉；已经拉过就复用
 			 * （「刷新」「重新体检」是显式动作，别替用户反复扫目录）。
@@ -5331,6 +6254,9 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				? LIMIT_KEYS.filter(function (k) { return settings.limits[k] !== settings.pendingLimits[k]; }).length
 				: 0;
 			const restartPending = !!(settings && settings.restartRequired);
+			// 冲突徽标数的是**待裁决**（open）条数 —— 与冲突页签里的「N 条待裁决」同源。
+			// -1 = 还没取到队列（显示「未载」，不假装 0 条）。
+			const conflictOpen = conf && conf.counts && typeof conf.counts.open === "number" ? conf.counts.open : -1;
 
 			// 「文件列表」这一屏：状态筛选决定看哪一批，灰色卡片与留痕块自带「退役」语义。
 			// banner 只在**专门看归档**时出现，切到全部时不重复说一遍。
@@ -5366,6 +6292,12 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 					// 体检再排在「自动归档」之后、独立成一屏：它只报告不修改，和「文件列表」里的
 					// 增删改是两件事，塞在工具抽屉里会让人以为它是个动作按钮。
 					h("button", { type: "button", className: "smem-tab" + (tab === "audit" ? " smem-tab--on" : ""), key: "a", role: "tab", "aria-selected": tab === "audit" ? "true" : "false", onClick: openAuditTab }, t("tab.audit")),
+					// 2.0.0「冲突」：裁决是**多动作、要逐条看两份正文**的流程，所以独立成第 6 个
+					// 页签，而不是塞进工具抽屉（抽屉方案的前提是「一年用不了几次」）。
+					// 没有 conflict 面的旧宿主：整颗不出现（能力检测，不是渲染错误）。
+					conflictOk
+						? h("button", { type: "button", className: "smem-tab" + (tab === "conflict" ? " smem-tab--on" : ""), key: "c", role: "tab", "aria-selected": tab === "conflict" ? "true" : "false", onClick: openConflictTab }, t("tab.conflict"))
+						: null,
 				]),
 				// 四个 tab 共用的一条头部带：我在哪 · 目录状态 · 活动/归档计数 · 体检徽标 · 待重启徽标 · 主操作。
 				// 层级形状固定：导航＝下划线（.smem-tabs）、筛选＝chip、动作＝按钮，三种不混用。
@@ -5381,6 +6313,20 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 						title: audit ? (audit.problems ? t("header.auditSwitch") : t("header.auditClean")) : t("header.auditRun"),
 						onClick: openAuditTab,
 					}, audit ? (audit.problems ? t("header.auditProblems", { count: audit.problems }) : t("header.auditPass")) : t("header.auditNotRun")),
+					// 冲突徽标：与体检徽标同一套「抽屉关着也一直看得见」。**没有 conflict 面
+					// 的旧宿主整颗不出现**（页签也不出现），不是灰按钮 —— 那会让用户以为插件坏了。
+					conflictOk
+						? h("button", {
+								type: "button", key: "cf",
+								className: "smem-tool-badge" + (conflictOpen > 0 ? " smem-tool-badge--bad" : ""),
+								title: !conf
+									? t("header.conflictMissing")
+									: conflictOpen > 0 ? t("header.conflictSwitch") : t("header.conflictClean"),
+								onClick: openConflictTab,
+							}, !conf ? t("header.conflictNotRun")
+								: conflictOpen > 0 ? t("header.conflictOpen", { count: conflictOpen })
+								: t("header.conflictEmpty"))
+						: null,
 					restartPending
 						? h("button", {
 								type: "button", key: "rs", className: "smem-tool-badge smem-ad-badge--warn",
@@ -5558,6 +6504,34 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 					// 体检面板在上面已经渲染过了 —— 这里必须显式给 null，
 					// 否则会落进下面那个 `filesView` 兜底分支，变成「体检 + 一整套文件列表」同屏。
 					? null
+					: tab === "conflict"
+					? h(ConflictPanel, {
+							key: "conflict",
+							data: conf,
+							loading: confLoad,
+							error: confErr,
+							bodies: confBodies,
+							expanded: confExpanded,
+							confirm: confConfirm,
+							busyId: confBusy,
+							// 逐动作的能力检测：宿主有 list 没 invalidate（版本错配）时按钮要禁用，
+							// 不是点了之后才报错。
+							tools: {
+								list: conflictOk,
+								read: !!(conflictOk && typeof conflictRemote.read === "function"),
+								invalidate: !!(conflictOk && typeof conflictRemote.invalidate === "function"),
+								dismiss: !!(conflictOk && typeof conflictRemote.dismiss === "function"),
+								undo: !!(conflictOk && typeof conflictRemote.undo === "function"),
+								removeRecord: !!(conflictOk && typeof conflictRemote.removeRecord === "function"),
+							},
+							onReload: loadConflicts,
+							onToggleBodies: toggleConflictBodies,
+							onAsk: askConflict,
+							onPickFile: pickConflictFile,
+							onCancelConfirm: cancelConflictConfirm,
+							onRun: runConflictAction,
+							onOpenFile: openConflictFile,
+						})
 					: filesView,
 				// 底部一行仓库链接（四个 tab 都在，不抢视线）
 				h(StarLine, { key: "star-line" }),