dsh-prime-memory 0.14.0-beta.4 → 0.14.0-beta.6

package/dist/client.js

@@ -606,7 +606,7 @@ var __defProp = Object.defineProperty;
 		// client/src/tabs/ConflictsTab.tsx
 		var import_jsx_runtime = require("react/jsx-runtime");
 		var POLL_MS = 1e4;
-		var GONE = "（该记录已不在检索库：被合并或删除掉了）";
+		var GONE = "（该记录正文不可得：已不在主表，或被更早的清理清掉了）";
 		function ConflictsTab(props) {
 		  const rpc = props.rpc;
 		  const [view, setView] = (0, import_react2.useState)(null);
@@ -639,7 +639,7 @@ var __defProp = Object.defineProperty;
 		将要退场的记忆：
 		「${doomed}」
 		
-		它会从检索库移除（事实源保留，可从 L0 重建找回）。本操作不可覆盖。`
+		它会移出检索面（不再被召回），但记录仍保留 —— 可在「记忆」页的「已退场」区恢复。裁决结论本身不可覆盖。`
 		      );
 		      if (!ok) return;
 		    }
@@ -3214,24 +3214,25 @@ var __defProp = Object.defineProperty;
 		    const ids = Array.from(sel);
 		    if (ids.length === 0) return;
 		    if (!hiPriv) {
-		      setError("高权限模式未开启：请在右上「高权限：关」或概览页开关中开启后，再删除记忆。");
+		      setError("高权限模式未开启：请在右上「高权限：关」或概览页开关中开启后，再退场记忆。");
 		      return;
 		    }
 		    if (ids.length > DELETE_LIMIT) {
-		      setError("一次最多删除 " + DELETE_LIMIT + " 条（当前勾选 " + ids.length + " 条），请分批操作。");
+		      setError("一次最多退场 " + DELETE_LIMIT + " 条（当前勾选 " + ids.length + " 条），请分批操作。");
 		      return;
 		    }
-		    if (!window.confirm("删除勾选的 " + ids.length + " 条记忆？本操作不可逆（完整重建可能从 L0 复活，为已知边界）。")) return;
+		    if (!window.confirm("退场勾选的 " + ids.length + " 条记忆？\n\n它们会移出检索面（不再被召回），但记录仍保留 —— 可在下方「已退场」区恢复。")) return;
 		    rpc("dsh-memory/records-delete", { ids }).then((r) => {
 		      if (r && r.ok) {
 		        setSel(/* @__PURE__ */ new Set());
 		        if (expandedId && ids.indexOf(expandedId) >= 0) setExpandedId(null);
 		        fetchPage(last, 0, false);
-		      } else if (r) setError(r.error ? r.error.message : "删除失败");
+		        if (showRetired) loadRetired();
+		      } else if (r) setError(r.error ? r.error.message : "退场失败");
 		    }).catch((e) => setError(String(e && e.message || e)));
 		  };
 		  const deleteRecord = (id) => {
-		    if (!window.confirm("删除该条记忆？本操作不可逆（完整重建可能从 L0 复活，为已知边界）。")) return;
+		    if (!window.confirm("退场该条记忆？\n\n它会移出检索面（不再被召回），但记录仍保留 —— 可在下方「已退场」区恢复。")) return;
 		    rpc("dsh-memory/records-delete", { ids: [id] }).then((r) => {
 		      if (r && r.ok) {
 		        setSel((prev) => {
@@ -3241,9 +3242,42 @@ var __defProp = Object.defineProperty;
 		        });
 		        if (expandedId === id) setExpandedId(null);
 		        fetchPage(last, 0, false);
-		      } else if (r) setError(r.error ? r.error.message : "删除失败");
+		        if (showRetired) loadRetired();
+		      } else if (r) setError(r.error ? r.error.message : "退场失败");
 		    }).catch((e) => setError(String(e && e.message || e)));
 		  };
+		  const [retired, setRetired] = (0, import_react15.useState)([]);
+		  const [retiredTotal, setRetiredTotal] = (0, import_react15.useState)(0);
+		  const [showRetired, setShowRetired] = (0, import_react15.useState)(false);
+		  const [retiredBusy, setRetiredBusy] = (0, import_react15.useState)(false);
+		  const loadRetired = (0, import_react15.useCallback)(() => {
+		    setRetiredBusy(true);
+		    rpc("dsh-memory/records-retired", { limit: 100, offset: 0 }).then((r) => {
+		      if (r && r.ok) {
+		        setRetired(r.value.items);
+		        setRetiredTotal(r.value.total);
+		      } else if (r) setError(r.error ? r.error.message : "已退场列表加载失败");
+		    }).catch((e) => setError(String(e && e.message || e))).finally(() => setRetiredBusy(false));
+		  }, [rpc]);
+		  (0, import_react15.useEffect)(() => {
+		    if (showRetired) loadRetired();
+		  }, [showRetired, loadRetired]);
+		  const restoreRecords = (ids) => {
+		    if (ids.length === 0) return;
+		    setRetiredBusy(true);
+		    rpc("dsh-memory/records-restore", { ids }).then((r) => {
+		      if (r && r.ok) {
+		        loadRetired();
+		        fetchPage(last, 0, false);
+		      } else if (r) setError(r.error ? r.error.message : "恢复失败");
+		    }).catch((e) => setError(String(e && e.message || e))).finally(() => setRetiredBusy(false));
+		  };
+		  const RETIRE_REASON_LABEL = {
+		    conflict: "裁决退场",
+		    superseded: "被取代",
+		    manual: "人工退场",
+		    unknown: "已退场"
+		  };
 		  const countText = total !== null ? "共 " + total + " 条" : items.length + " 条" + (hasMore ? "+" : "");
 		  const selCount = sel.size;
 		  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { children: [
@@ -3405,6 +3439,24 @@ var __defProp = Object.defineProperty;
 		        m.id
 		      );
 		    }),
+		    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { style: { ...S.flexRow, marginTop: 12 }, children: [
+		      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(NButton, { onClick: () => setShowRetired((v) => !v), children: (showRetired ? "收起" : "展开") + "「已退场」（可恢复）" }),
+		      showRetired && retiredBusy ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { style: S.muted, children: "加载中…" }) : null,
+		      showRetired && !retiredBusy && retiredTotal > 0 ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { style: S.muted, children: "共 " + retiredTotal + " 条可恢复" }) : null
+		    ] }),
+		    showRetired ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { style: { marginTop: 8 }, children: retired.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("p", { style: S.hint, children: retiredBusy ? " " : "没有已退场的记忆。" }) : /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { children: [
+		      retired.map((m) => /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "dsh-mem-card", style: S.card, children: [
+		        /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { style: S.cardHead, children: [
+		          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { style: S.muted, children: RETIRE_REASON_LABEL[m.retiredReason] || m.retiredReason }),
+		          m.verdict ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { style: S.muted, children: "结论 " + m.verdict }) : null,
+		          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { style: S.grow }),
+		          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { style: S.muted, children: fmtTime(m.retiredAt) }),
+		          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(NButton, { disabled: retiredBusy, title: "恢复到检索面", onClick: () => restoreRecords([m.id]), children: "恢复" })
+		        ] }),
+		        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { style: S.content, children: m.content })
+		      ] }, m.id)),
+		      retiredTotal > retired.length ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("p", { style: S.hint, children: "共 " + retiredTotal + " 条，此处显示 " + retired.length + " 条" }) : null
+		    ] }) }) : null,
 		    hasMore ? /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { style: S.flexRow, children: [
 		      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { style: S.grow }),
 		      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(

package/dist/conflict-service.d.ts

@@ -12,7 +12,7 @@ import type { L1Store } from './store/l1.js';
 import type { ConflictPairView, ConflictsResponse as ConflictsView, ConflictResolveResponse as ConflictResolutionView } from './contract.js';
 export type { ConflictPairView, ConflictsView, ConflictResolutionView };
 export interface ConflictResolveDeps {
-    l1: Pick<L1Store, 'listConflictPending' | 'resolveConflictPending' | 'deleteBatch' | 'syncGraphDisputed'>;
+    l1: Pick<L1Store, 'listConflictPending' | 'resolveConflictPending' | 'retire' | 'syncGraphDisputed'>;
     /** `conflictFreeze.enabled`。未开启时队列恒空,直接给出提示而非静默无操作。 */
     conflictFreezeEnabled: boolean;
 }
@@ -21,9 +21,11 @@ export interface ConflictResolveDeps {
  *
  * 顺序刻意如此:
  * ① **先打 `resolved_at` 再退场 loser**。反过来的话,退场成功但打标失败会留下
- *    "记录已消失、队列里那条仍在待裁决"的状态——人再点一次才发现无据可依。
+ *    "记录已退场、队列里那条仍在待裁决"的状态——人再点一次才发现无据可依。
  *    打标用 `WHERE resolved_at = ''`,天然防重复裁决:第二次调用拿到 0 行即中止。
  * ② 退场后才**重算**图谱 `disputed`(派生字段必须由当前事实重算,见 `syncDisputed`)。
+ * ③ 退场是**软删**(`retire`,可恢复),不是物理删除:主表行留着,`valid_to` 闭合 +
+ *    写取代标记,FTS/向量行撤掉。故"判错了"可以再恢复——裁决不可覆盖,但可以反悔。
  */
 export declare function resolveConflictPair(deps: ConflictResolveDeps, pairId: string, outcome: string): Promise<ConflictResolutionView>;
 /** 裁决结果的人类可读渲染(工具路径用)。schema 产出的是可选字段,故按部分取值渲染。 */

package/dist/conflict-service.js

@@ -7,9 +7,11 @@ function view(partial) {
  *
  * 顺序刻意如此:
  * ① **先打 `resolved_at` 再退场 loser**。反过来的话,退场成功但打标失败会留下
- *    "记录已消失、队列里那条仍在待裁决"的状态——人再点一次才发现无据可依。
+ *    "记录已退场、队列里那条仍在待裁决"的状态——人再点一次才发现无据可依。
  *    打标用 `WHERE resolved_at = ''`,天然防重复裁决:第二次调用拿到 0 行即中止。
  * ② 退场后才**重算**图谱 `disputed`(派生字段必须由当前事实重算,见 `syncDisputed`)。
+ * ③ 退场是**软删**(`retire`,可恢复),不是物理删除:主表行留着,`valid_to` 闭合 +
+ *    写取代标记,FTS/向量行撤掉。故"判错了"可以再恢复——裁决不可覆盖,但可以反悔。
  */
 export async function resolveConflictPair(deps, pairId, outcome) {
     const clean = outcome.trim();
@@ -41,8 +43,17 @@ export async function resolveConflictPair(deps, pairId, outcome) {
         // 并发/重复调用:这一对在本次读取与本次写入之间被裁决了
         return view({ pair_id: pairId, outcome: clean, notice: '该对已被裁决,本次未生效(裁决不可覆盖)。' });
     }
-    if (removedId)
-        await deps.l1.deleteBatch([removedId]);
+    if (removedId) {
+        // **软删**(退场),不是物理删除:主表行保留 + `valid_to` 闭合 + 写取代标记,
+        // FTS/向量行撤掉使其退出检索面。于是"判错了"可以再恢复,而不必去
+        // `records/*.jsonl` 事实源里手工捞——那是本功能上线前唯一的后悔药。
+        deps.l1.retire([removedId], {
+            at: resolvedAt,
+            reason: 'conflict',
+            verdict: clean,
+            pairId,
+        });
+    }
     // 图谱 disputed 重算:此刻仍未裁决的对才是争议集,已了结的节点自动复原 active
     const ids = new Set();
     for (const p of deps.l1.listConflictPending()) {
@@ -59,7 +70,7 @@ export function renderConflictResolution(v) {
     const outcome = v.outcome ?? '';
     const label = outcome === 'winner' ? '判定 LLM 建议的胜方为真' : outcome === 'loser' ? '判定败方为真' : '两者都保留(判为各自独立的事实)';
     const removed = v.removed_record_id
-        ? `\n退场记录:${v.removed_record_id}(已从检索中移除,事实源保留)`
+        ? `\n退场记录:${v.removed_record_id}(已移出检索面,**可恢复**——记忆列表里能找回)`
         : '\n未移除任何记录。';
     return `已裁决待裁决对 ${v.pair_id ?? ''}\n结论:${outcome}(${label})\n裁决时刻:${v.resolved_at ?? ''}${removed}`;
 }

package/dist/contract.d.ts

@@ -610,14 +610,76 @@ export interface ListRecordsResponse {
     /** 场景筛选下拉选项(仅 offset===0 时附带)。 */
     scenes?: string[];
 }
-/** dsh-memory/records-delete(面板高权限删除指定记忆;须 memoryMutate 开启)。 */
+/** dsh-memory/records-delete(面板高权限退场指定记忆;须 memoryMutate 开启)。 */
 export interface RecordsDeleteRequest {
-    /** 要删除的 L1 record id 列表(≤200)。 */
+    /** 要**退场(软删)**的 L1 record id 列表(≤200)。不是物理删除,可恢复。 */
     ids: string[];
 }
 export interface RecordsDeleteResponse {
     deleted: number;
 }
+/**
+ * 已退场记录的一条(在浏览卡片之上补退场信息)。
+ *
+ * `retiredReason` 用宽松 `string` 而非字面量联合:契约要能在**客户端**那一档
+ * (`types: []`)独立编译,不该反向依赖宿主 store 的类型;严格联合留在 store 侧,
+ * 面板只做展示。新增原因时面板不认识也能照常显示,不会编译失败。
+ */
+export interface RetiredRecordView extends UiRecord {
+    /** 退场时刻(ISO 8601)。 */
+    retiredAt: string;
+    /** 退场原因:`conflict`(裁决) / `superseded`(去重取代) / `manual`(人工)。 */
+    retiredReason: string;
+    /** 裁决结论(仅 reason=conflict)。 */
+    verdict?: string;
+    /** 取代它的新记录 id(仅 reason=superseded)。 */
+    supersededBy?: string;
+}
+/** dsh-memory/records-retired(已退场列表;面板据此展示"可恢复"区)。 */
+export interface RecordsRetiredRequest {
+    limit?: number;
+    offset?: number;
+}
+export interface RecordsRetiredResponse {
+    items: RetiredRecordView[];
+    total: number;
+}
+/** dsh-memory/records-restore(把已退场记录送回检索面)。 */
+export interface RecordsRestoreRequest {
+    /** 要恢复的 record id 列表(≤200)。 */
+    ids: string[];
+}
+export interface RecordsRestoreResponse {
+    restored: number;
+    /** 成功补回向量的条数(嵌入不可用时可能小于 `restored`)。 */
+    vectorsWritten: number;
+}
+/**
+ * dsh-memory/cleanup-retired(物理清理已退场记录)。
+ *
+ * **默认干跑**:`dryRun` 省略即视为 `true`,只报"将要清理多少条"。
+ * 真要物理删除必须显式 `dryRun:false` —— 这是本插件唯一不可逆的动作。
+ * 即便显式执行,也要先落快照并校验通过,否则中止(`aborted:true`)。
+ */
+export interface CleanupRetiredRequest {
+    /** 限定要清理的 id;省略 = 全部已退场记录。 */
+    ids?: string[];
+    /** 默认 true(干跑)。显式 false 才真正删除。 */
+    dryRun?: boolean;
+}
+export interface CleanupRetiredResponse {
+    dryRun: boolean;
+    /** 本次涉及(干跑)或实际处理(真跑)的条数。 */
+    targets: number;
+    /** 真正物理删除的条数(干跑恒为 0;中止恒为 0)。 */
+    purged: number;
+    /** 门禁未通过而中止。 */
+    aborted: boolean;
+    /** 快照目录(真跑时非空)。 */
+    dir: string;
+    /** 中止原因(仅 aborted 时非空)。 */
+    diffs: string[];
+}
 /** dsh-memory/graph-search(图谱节点检索;紧凑节点卡)。 */
 export interface GraphSearchRequest {
     /** 自然语言查询(≤4096 字符;空查询返回空)。 */
@@ -903,6 +965,9 @@ export interface DshMemoryRequestMap {
     'dsh-memory/embedding-runtime-cancel': Record<string, never>;
     'dsh-memory/embedding-reindex': Record<string, never>;
     'dsh-memory/embedding-reindex-cancel': Record<string, never>;
+    'dsh-memory/records-retired': RecordsRetiredRequest;
+    'dsh-memory/records-restore': RecordsRestoreRequest;
+    'dsh-memory/cleanup-retired': CleanupRetiredRequest;
 }
 export interface DshMemoryResponseMap {
     'dsh-memory/stats': StatsResponse;
@@ -938,6 +1003,9 @@ export interface DshMemoryResponseMap {
     'dsh-memory/embedding-runtime-cancel': EmbeddingCancelResponse;
     'dsh-memory/embedding-reindex': EmbeddingReindexStartResponse;
     'dsh-memory/embedding-reindex-cancel': EmbeddingCancelResponse;
+    'dsh-memory/records-retired': RecordsRetiredResponse;
+    'dsh-memory/records-restore': RecordsRestoreResponse;
+    'dsh-memory/cleanup-retired': CleanupRetiredResponse;
 }
 /** 全部端点名(client 调用与 host case 表的共用字面量来源)。 */
 export type DshMemoryEndpoint = keyof DshMemoryResponseMap;

package/dist/pipeline/l1.js

@@ -272,7 +272,19 @@ anchorMap) {
             relatedIds.add(c.id);
     }
     const byId = new Map(store.getByIds([...relatedIds]).map((r) => [r.id, r]));
-    const deletedIds = new Set();
+    /**
+     * 本批次**全部**新记忆的 record_id。两个用途:
+     * ① 作为 `validateConflictPair` 的对手集之一 —— 同批次两条新记忆互相矛盾时,
+     *    对方的 id 不在候选池里(本轮刚生成、尚未入库),没有这个集合就**必然被判
+     *    不成对而回落 store**(2026-09-18 取证确认,见 findings R6 / Agent A);
+     * ② 队满自动了结的护栏 —— 败方若属本批新记忆,不得自动退场(见下方分支)。
+     */
+    const batchIds = new Set(extracted.map((e) => e.record_id));
+    /**
+     * update/merge 取代掉的旧记录 → **取代它的**新记录 id。
+     * 用 Map 而非 Set:退场标记要带 `by`,否则"被谁取代"只能靠时间猜。
+     */
+    const supersededBy = new Map();
     const added = [];
     /** §C 本轮新冻结的冲突对(应用完新增记录后统一落盘)。 */
     const frozen = [];
@@ -295,7 +307,7 @@ anchorMap) {
         // 一个显式声明了"拿不准"的决策,绝不能被静默当成"新记忆更优"去覆盖旧记忆。
         if (action === 'conflict') {
             const pair = freezeEnabled
-                ? validateConflictPair(m.record_id, decision.winner, decision.loser, new Set(byId.keys()))
+                ? validateConflictPair(m.record_id, decision.winner, decision.loser, new Set(byId.keys()), batchIds)
                 : null;
             if (pair) {
                 added.push(toStoreRecord(m, now, ts, anchorMap));
@@ -309,6 +321,16 @@ anchorMap) {
                 // 判据含 frozen 中本轮已停放的未裁决数,否则同一轮内多条冲突会一起越界。
                 const pendingNow = store.countConflictPendingUnresolved() + frozen.filter((p) => p.resolvedAt === '').length;
                 if (pendingNow >= maxPending) {
+                    // 护栏(2026-09-18 随同批次冻结一起加):**败方是本轮新记忆时不做自动了结**。
+                    // 自动了结 = `retire(loser)`,而本轮的 `added` 里刚把这条新记忆写入 ——
+                    // 那等于"刚抽取出来的产出立刻退场",且没有任何人被告知。
+                    // 改为不停放这一对(该条已在上方 added 中照常入库,记忆不丢),
+                    // 只放弃这条裁决请求;队列有界性因此仍然成立。
+                    if (batchIds.has(built.loserId)) {
+                        logger.warn(`[memory] 矛盾冻结:队列已满(${pendingNow}/${maxPending}),且该对的败方是本轮新记忆` +
+                            `(${built.loserId})——不做自动了结(避免新记忆立即退场),改为不停放、照常入库`);
+                        continue;
+                    }
                     built.resolvedAt = new Date(now).toISOString();
                     built.resolution = 'auto';
                     autoLosers.add(pair.loserId);
@@ -323,11 +345,14 @@ anchorMap) {
             }
             continue;
         }
-        // update / merge:目标记录从检索库删除,合并结果作为新记录追加(版本 +1)
+        // update / merge:目标记录**退场(软删)**,合并结果作为新记录追加(版本 +1)
         // 候选召回按族隔离,合并产物保持新记忆的族标签
         const targets = (decision.target_ids ?? []).filter((id) => byId.has(id));
+        // 同一目标被多条新记录取代时保留**首个**取代者:与 retire 的幂等语义一致
+        // (已退场记录不重复写标记),故先到先得而不是被后者覆盖
         for (const id of targets)
-            deletedIds.add(id);
+            if (!supersededBy.has(id))
+                supersededBy.set(id, m.record_id);
         const targetVersion = targets.reduce((max, id) => Math.max(max, byId.get(id)?.version ?? 0), 0);
         const mergedTs = (decision.merged_timestamps ?? [])
             .map((t) => Date.parse(t))
@@ -356,13 +381,27 @@ anchorMap) {
         });
     }
     await store.appendNew(added);
-    if (deletedIds.size > 0)
-        await store.deleteBatch([...deletedIds]);
-    // §C 自动裁决的执行面:LLM 的 loser 从检索库退场(winner 存活)。
+    if (supersededBy.size > 0) {
+        // **软删**(取代):不是物理删除——主表行保留 + `valid_to` 闭合 + 取代标记,
+        // FTS/向量撤出检索面。于是"合并错了"也能恢复,而不必去 `records/*.jsonl` 手工捞。
+        // 按取代者分组落盘(一次事务一组),避免逐条开事务。
+        const retiredAt = new Date(now).toISOString();
+        const byNewRecord = new Map();
+        for (const [targetId, newId] of supersededBy) {
+            const arr = byNewRecord.get(newId) ?? [];
+            arr.push(targetId);
+            byNewRecord.set(newId, arr);
+        }
+        for (const [newId, ids] of byNewRecord) {
+            store.retire(ids, { at: retiredAt, reason: 'superseded', by: newId });
+        }
+    }
+    // §C 自动裁决的执行面:LLM 的 loser 从检索面退场(winner 存活),同为**软删**。
     // 排在 appendNew 之后——若 loser 恰是**本轮新记忆**(LLM 判定新记忆更差),
-    // 也必须先让它进库再退场,以保证"本轮新增"与"本轮删除"的账面一致。
-    if (autoLosers.size > 0)
-        await store.deleteBatch([...autoLosers]);
+    // 也必须先让它进库再退场,以保证"本轮新增"与"本轮退场"的账面一致。
+    if (autoLosers.size > 0) {
+        store.retire([...autoLosers], { at: new Date(now).toISOString(), reason: 'conflict', verdict: 'auto' });
+    }
     // ── §C 冻结对落盘(排在 appendNew 之后) ──
     // 顺序有讲究:先让新记忆真正进 L1,再登记"它和谁构成待裁决对"。反过来的话,
     // 落盘失败会留下一条指向**不存在记录**的裁决请求,人工打开队列只会看到悬空 id。
@@ -404,7 +443,7 @@ anchorMap) {
         states[f].memoriesSinceL3 += addedByFamily[f];
     }
     markExtracted(states, mode, lastScene);
-    logger.info(`[memory] L1 抽取完成(mode=${mode}):消息 ${pending.length} 条,抽取 ${extracted.length} 条,去重后新增 ${added.length} 条(替换 ${deletedIds.size} 条,chat=${addedByFamily.chat}/work=${addedByFamily.work}),累计 chat=${states.chat.totalExtracted}/work=${states.work.totalExtracted}`);
+    logger.info(`[memory] L1 抽取完成(mode=${mode}):消息 ${pending.length} 条,抽取 ${extracted.length} 条,去重后新增 ${added.length} 条(取代退场 ${supersededBy.size} 条,chat=${addedByFamily.chat}/work=${addedByFamily.work}),累计 chat=${states.chat.totalExtracted}/work=${states.work.totalExtracted}`);
     return { stored: added.length, skipped: false, sceneName: lastScene, newRecords: added };
 }
 /** auto 档取最近活跃的族 checkpoint(情境链/计数锚点)。 */

package/dist/prompts/l1-dedup.d.ts

@@ -18,7 +18,7 @@ export declare const ALL_CONFLICT_DETECTION_SYSTEM_PROMPT = "\u4F60\u662F\u8BB0\
  * 语义承自 mneme(dream layer **不**自动裁决 winner/loser):检测到矛盾后
  * 不是"拦住写入",而是"不自动裁决"——把冲突对停放到待审区。
  */
-export declare const CONFLICT_ACTION_CLAUSE = "## \u77DB\u76FE\u51BB\u7ED3\u52A8\u4F5C\uFF08\"conflict\"\uFF09\n\n\u4E0A\u9762\u56DB\u6761\u52A8\u4F5C\u5728**\u5224\u5B9A\u51B2\u7A81**\u65F6\u90FD\u4E0D\u53EF\u7528\u2014\u2014\"update\" \u4E0E \"merge\" \u90FD\u4F1A\u7531\u4F60\u76F4\u63A5\u6539\u5199\u8BB0\u5FC6\uFF0C**\u6CA1\u6709\"\u505C\u4E0B\u6765\u7B49\u4EBA\u88C1\u51B3\"\u8FD9\u4E2A\u9009\u9879**\u3002\u6545\u65B0\u589E\u7B2C\u4E94\u6761\u52A8\u4F5C\uFF1A\n\n- \"conflict\"\uFF1A\u65B0\u8BB0\u5FC6\u4E0E\u5019\u9009\u6C60\u4E2D\u67D0\u6761\u5DF2\u6709\u8BB0\u5FC6**\u63CF\u8FF0\u540C\u4E00\u4E8B\u5B9E/\u4E8B\u4EF6/\u5DE5\u4F5C\u5BF9\u8C61\uFF0C\u4F46\u5185\u5BB9\u4E92\u76F8\u77DB\u76FE**\uFF0C\u4E14\u4F60**\u65E0\u6CD5\u4F9D\u636E\u73B0\u6709\u4FE1\u606F\u5224\u5B9A\u54EA\u4E00\u65B9\u66F4\u53EF\u4FE1**\u65F6\u4F7F\u7528\u3002**\u4E0D\u8986\u76D6\u3001\u4E0D\u5408\u5E76**\uFF1A\u8BE5\u6761\u65B0\u8BB0\u5FC6\u7167\u5E38\u5199\u5165\uFF0C\u4E0E\u51B2\u7A81\u7684\u5DF2\u6709\u8BB0\u5FC6\u4F5C\u4E3A**\u4E00\u5BF9**\u505C\u653E\u5230\u5F85\u4EBA\u5DE5\u88C1\u51B3\u533A\uFF0C\u53CC\u65B9\u5185\u5BB9\u90FD\u4E0D\u88AB\u6539\u5199\u3002\n\n### conflict \u7684\u8FFD\u52A0\u8F93\u51FA\u5B57\u6BB5\n\n{\n  \"record_id\": \"\u672C\u6761\u65B0\u8BB0\u5FC6\u7684 record_id\",\n  \"action\": \"conflict\",\n  \"winner\": \"\u5176\u4E2D\u4E00\u65B9\u7684 record_id\",\n  \"loser\": \"\u53E6\u4E00\u65B9\u7684 record_id\"\n}\n\n- \"winner\" / \"loser\"\uFF1A**\u4E8C\u8005\u5FC5\u987B\u4E0D\u540C**\u3002\u53D6\u503C\u5747\u4E3A record_id\uFF0C\u6765\u81EA\u300C\u672C\u6761\u65B0\u8BB0\u5FC6\u7684 record_id\u300D\u6216\u300C\u5019\u9009\u6C60\u4E2D\u7684 record_id\u300D\u3002\n- \"winner\" \u53EA\u8868\u793A\u8FDB\u5165\u5F85\u88C1\u51B3\u5BF9\u65F6\u7684\u6392\u5E8F\u4F4D\uFF0C**\u4E0D\u4EE3\u8868\u6700\u7EC8\u7ED3\u8BBA**\uFF1B\u6700\u7EC8\u7ED3\u8BBA\u7531\u4EBA\u5DE5\u88C1\u51B3\u5199\u5165\u3002\n- action \u4E3A \"conflict\" \u65F6**\u4E0D\u8981**\u8F93\u51FA merged_content / merged_type / merged_priority / merged_timestamps\u2014\u2014\u5B83\u4EEC\u53EA\u5C5E\u4E8E update / merge\u3002\n\n### \u4EC0\u4E48\u65F6\u5019**\u4E0D**\u7528 conflict\n\n- \u65B0\u8BB0\u5FC6\u66F4\u5177\u4F53\u3001\u66F4\u65B0\u3001\u66F4\u6743\u5A01\uFF0C\u6216\u80FD\u660E\u786E\u7EA0\u6B63\u65E7\u8BB0\u5FC6\u7684\u9519\u8BEF \u2192 \u4ECD\u7528 \"update\"\u3002\n- \u65B0\u65E7\u8BB0\u5FC6\u4FE1\u606F\u4E92\u8865\u4E14**\u4E0D\u77DB\u76FE** \u2192 \u4ECD\u7528 \"merge\"\u3002\n- \u53EA\u662F\u540C\u5C5E\u4E00\u4E2A\u4E3B\u9898\u4F46\u63CF\u8FF0\u5BF9\u8C61\u4E0D\u540C \u2192 \u4ECD\u7528 \"store\"\u3002\n\nconflict \u53EA\u7559\u7ED9\"\u4E24\u8FB9\u90FD\u50CF\u662F\u5BF9\u7684\u3001\u673A\u5668\u5224\u4E0D\u4E86\"\u7684\u60C5\u51B5\u2014\u2014\u5B83\u6D88\u8017\u4EBA\u7684\u6CE8\u610F\u529B\uFF0C\u4E0D\u53EF\u6EE5\u7528\u3002";
+export declare const CONFLICT_ACTION_CLAUSE = "## \u77DB\u76FE\u51BB\u7ED3\u52A8\u4F5C\uFF08\"conflict\"\uFF09\n\n\u4E0A\u9762\u56DB\u6761\u52A8\u4F5C\u5728**\u5224\u5B9A\u51B2\u7A81**\u65F6\u90FD\u4E0D\u53EF\u7528\u2014\u2014\"update\" \u4E0E \"merge\" \u90FD\u4F1A\u7531\u4F60\u76F4\u63A5\u6539\u5199\u8BB0\u5FC6\uFF0C**\u6CA1\u6709\"\u505C\u4E0B\u6765\u7B49\u4EBA\u88C1\u51B3\"\u8FD9\u4E2A\u9009\u9879**\u3002\u6545\u65B0\u589E\u7B2C\u4E94\u6761\u52A8\u4F5C\uFF1A\n\n- \"conflict\"\uFF1A\u65B0\u8BB0\u5FC6\u4E0E**\u53E6\u4E00\u6761\u8BB0\u5FC6**\u2014\u2014\u5019\u9009\u6C60\u4E2D\u7684\u5DF2\u6709\u8BB0\u5FC6\uFF0C**\u6216\u540C\u4E00\u6279\u6B21\u91CC\u7684\u53E6\u4E00\u6761\u65B0\u8BB0\u5FC6**\uFF08\u5B83\u7684 record_id \u540C\u6837\u5370\u5728\u3010\u65B0\u8BB0\u5FC6\u3011\u5217\u8868\u91CC\uFF09\u2014\u2014**\u63CF\u8FF0\u540C\u4E00\u4E8B\u5B9E/\u4E8B\u4EF6/\u5DE5\u4F5C\u5BF9\u8C61\uFF0C\u4F46\u5185\u5BB9\u4E92\u76F8\u77DB\u76FE**\uFF0C\u4E14\u4F60**\u65E0\u6CD5\u4F9D\u636E\u73B0\u6709\u4FE1\u606F\u5224\u5B9A\u54EA\u4E00\u65B9\u66F4\u53EF\u4FE1**\u65F6\u4F7F\u7528\u3002**\u4E0D\u8986\u76D6\u3001\u4E0D\u5408\u5E76**\uFF1A\u8BE5\u6761\u65B0\u8BB0\u5FC6\u7167\u5E38\u5199\u5165\uFF0C\u4E0E\u5BF9\u65B9\u4F5C\u4E3A**\u4E00\u5BF9**\u505C\u653E\u5230\u5F85\u4EBA\u5DE5\u88C1\u51B3\u533A\uFF0C\u53CC\u65B9\u5185\u5BB9\u90FD\u4E0D\u88AB\u6539\u5199\u3002\n\n### conflict \u7684\u8FFD\u52A0\u8F93\u51FA\u5B57\u6BB5\n\n{\n  \"record_id\": \"\u672C\u6761\u65B0\u8BB0\u5FC6\u7684 record_id\",\n  \"action\": \"conflict\",\n  \"winner\": \"\u5176\u4E2D\u4E00\u65B9\u7684 record_id\",\n  \"loser\": \"\u53E6\u4E00\u65B9\u7684 record_id\"\n}\n\n- \"winner\" / \"loser\"\uFF1A**\u4E8C\u8005\u5FC5\u987B\u4E0D\u540C**\uFF0C\u4E14**\u6070\u6709\u4E00\u65B9\u5FC5\u987B\u662F\u672C\u6761\u65B0\u8BB0\u5FC6\u7684 record_id**\uFF1B\u53E6\u4E00\u65B9\u53D6\u81EA\u300C\u5019\u9009\u6C60\u4E2D\u7684\u5DF2\u6709\u8BB0\u5FC6 record_id\u300D\u6216\u300C\u540C\u4E00\u6279\u6B21\u5176\u5B83\u65B0\u8BB0\u5FC6\u7684 record_id\u300D\u3002\u6307\u5411\u672C\u6279\u6B21\u4E4B\u5916\u7684\u3001\u4E0D\u5728\u5019\u9009\u6C60\u91CC\u7684 id \u4E00\u5F8B\u65E0\u6548\u3002\n- \"winner\" \u53EA\u8868\u793A\u8FDB\u5165\u5F85\u88C1\u51B3\u5BF9\u65F6\u7684\u6392\u5E8F\u4F4D\uFF0C**\u4E0D\u4EE3\u8868\u6700\u7EC8\u7ED3\u8BBA**\uFF1B\u6700\u7EC8\u7ED3\u8BBA\u7531\u4EBA\u5DE5\u88C1\u51B3\u5199\u5165\u3002\n- action \u4E3A \"conflict\" \u65F6**\u4E0D\u8981**\u8F93\u51FA merged_content / merged_type / merged_priority / merged_timestamps\u2014\u2014\u5B83\u4EEC\u53EA\u5C5E\u4E8E update / merge\u3002\n\n### \u4EC0\u4E48\u65F6\u5019**\u4E0D**\u7528 conflict\n\n- \u65B0\u8BB0\u5FC6\u66F4\u5177\u4F53\u3001\u66F4\u65B0\u3001\u66F4\u6743\u5A01\uFF0C\u6216\u80FD\u660E\u786E\u7EA0\u6B63\u65E7\u8BB0\u5FC6\u7684\u9519\u8BEF \u2192 \u4ECD\u7528 \"update\"\u3002\n- \u65B0\u65E7\u8BB0\u5FC6\u4FE1\u606F\u4E92\u8865\u4E14**\u4E0D\u77DB\u76FE** \u2192 \u4ECD\u7528 \"merge\"\u3002\n- \u53EA\u662F\u540C\u5C5E\u4E00\u4E2A\u4E3B\u9898\u4F46\u63CF\u8FF0\u5BF9\u8C61\u4E0D\u540C \u2192 \u4ECD\u7528 \"store\"\u3002\n- \u540C\u6279\u6B21\u4E24\u6761\u65B0\u8BB0\u5FC6\u53EA\u662F**\u540C\u4E00\u4E8B\u5B9E\u7684\u4E0D\u540C\u8868\u8FF0**\uFF08\u4E92\u8865\u3001\u7C92\u5EA6\u4E0D\u540C\u3001\u4E0D\u4E92\u65A5\uFF09\u2192 \u4ECD\u5404\u81EA \"store\"\u3002**\u53EA\u6709\u4E92\u76F8\u77DB\u76FE\u624D\u7B97 conflict\u3002**\n\nconflict \u53EA\u7559\u7ED9\"\u4E24\u8FB9\u90FD\u50CF\u662F\u5BF9\u7684\u3001\u673A\u5668\u5224\u4E0D\u4E86\"\u7684\u60C5\u51B5\u2014\u2014\u5B83\u6D88\u8017\u4EBA\u7684\u6CE8\u610F\u529B\uFF0C\u4E0D\u53EF\u6EE5\u7528\u3002";
 export interface DedupPromptOptions {
     /** §C 矛盾冻结总开关。**默认关**：关闭时 prompt 与改动前逐字一致。 */
     conflictFreeze?: boolean;

package/dist/prompts/l1-dedup.js

@@ -208,7 +208,7 @@ export const CONFLICT_ACTION_CLAUSE = `## 矛盾冻结动作（"conflict"）
 
 上面四条动作在**判定冲突**时都不可用——"update" 与 "merge" 都会由你直接改写记忆，**没有"停下来等人裁决"这个选项**。故新增第五条动作：
 
-- "conflict"：新记忆与候选池中某条已有记忆**描述同一事实/事件/工作对象，但内容互相矛盾**，且你**无法依据现有信息判定哪一方更可信**时使用。**不覆盖、不合并**：该条新记忆照常写入，与冲突的已有记忆作为**一对**停放到待人工裁决区，双方内容都不被改写。
+- "conflict"：新记忆与**另一条记忆**——候选池中的已有记忆，**或同一批次里的另一条新记忆**（它的 record_id 同样印在【新记忆】列表里）——**描述同一事实/事件/工作对象，但内容互相矛盾**，且你**无法依据现有信息判定哪一方更可信**时使用。**不覆盖、不合并**：该条新记忆照常写入，与对方作为**一对**停放到待人工裁决区，双方内容都不被改写。
 
 ### conflict 的追加输出字段
 
@@ -219,7 +219,7 @@ export const CONFLICT_ACTION_CLAUSE = `## 矛盾冻结动作（"conflict"）
   "loser": "另一方的 record_id"
 }
 
-- "winner" / "loser"：**二者必须不同**。取值均为 record_id，来自「本条新记忆的 record_id」或「候选池中的 record_id」。
+- "winner" / "loser"：**二者必须不同**，且**恰有一方必须是本条新记忆的 record_id**；另一方取自「候选池中的已有记忆 record_id」或「同一批次其它新记忆的 record_id」。指向本批次之外的、不在候选池里的 id 一律无效。
 - "winner" 只表示进入待裁决对时的排序位，**不代表最终结论**；最终结论由人工裁决写入。
 - action 为 "conflict" 时**不要**输出 merged_content / merged_type / merged_priority / merged_timestamps——它们只属于 update / merge。
 
@@ -228,6 +228,7 @@ export const CONFLICT_ACTION_CLAUSE = `## 矛盾冻结动作（"conflict"）
 - 新记忆更具体、更新、更权威，或能明确纠正旧记忆的错误 → 仍用 "update"。
 - 新旧记忆信息互补且**不矛盾** → 仍用 "merge"。
 - 只是同属一个主题但描述对象不同 → 仍用 "store"。
+- 同批次两条新记忆只是**同一事实的不同表述**（互补、粒度不同、不互斥）→ 仍各自 "store"。**只有互相矛盾才算 conflict。**
 
 conflict 只留给"两边都像是对的、机器判不了"的情况——它消耗人的注意力，不可滥用。`;
 /**

package/dist/stats.d.ts

@@ -22,7 +22,7 @@ export interface MemoryStatusSource {
     pending(): number;
 }
 /**
- * 端点全集运行时清单(33 个,与 tests/contract-keys.test.ts 的 ENDPOINTS 及
+ * 端点全集运行时清单(36 个,与 tests/contract-keys.test.ts 的 ENDPOINTS 及
  * contract.ts 类型映射表三方对齐,漂移由键集 diff 测试暴露)。
  * 注意:本清单同时是 HTTP 前缀路由 `/dsh-memory/rpc/<短名>` 的**放行白名单**
  * (见下方 SHORT_ENDPOINTS),漏一条 = 该端点在面板里静默消失(404 被客户端

package/dist/stats.js

@@ -22,12 +22,13 @@ import { projectDistillChain, validateDistillChain } from './settings.js';
 import { RECEIPTS_QUERY_LIMIT_MAX, dimensionOf, toReceiptView } from './store/receipts.js';
 import { resolveConflictPair, listConflictPairs } from './conflict-service.js';
 import { sourceAnchorLabels } from './pipeline/anchors.js';
+import { readSupersedeMarker } from './store/supersede.js';
 import { errDetail } from './util/filelog.js';
 import { snapshotTokenCost } from './token-cost.js';
 const require = createRequire(import.meta.url);
 export const PLUGIN_VERSION = require('../package.json').version;
 /**
- * 端点全集运行时清单(33 个,与 tests/contract-keys.test.ts 的 ENDPOINTS 及
+ * 端点全集运行时清单(36 个,与 tests/contract-keys.test.ts 的 ENDPOINTS 及
  * contract.ts 类型映射表三方对齐,漂移由键集 diff 测试暴露)。
  * 注意:本清单同时是 HTTP 前缀路由 `/dsh-memory/rpc/<短名>` 的**放行白名单**
  * (见下方 SHORT_ENDPOINTS),漏一条 = 该端点在面板里静默消失(404 被客户端
@@ -71,6 +72,9 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/embedding-runtime-cancel',
     'dsh-memory/embedding-reindex',
     'dsh-memory/embedding-reindex-cancel',
+    'dsh-memory/records-retired',
+    'dsh-memory/records-restore',
+    'dsh-memory/cleanup-retired',
 ];
 /** HTTP 路由前缀(客户端 fetch `/dsh-memory/rpc/<短方法名>`)。 */
 const RPC_ROUTE_PREFIX = '/dsh-memory/rpc';
@@ -751,7 +755,12 @@ export async function handleEndpoint(endpoint, payload, deps) {
             return await resolveConflictPair({ l1: stores.l1, conflictFreezeEnabled: effectiveCfg(cfg, live).conflictFreeze?.enabled === true }, pairId, outcome);
         }
         case 'dsh-memory/records-delete': {
-            // 面板高权限删除指定记忆;写入删权限门(memoryMutate)防御
+            // 面板高权限删除指定记忆;写入删权限门(memoryMutate)防御。
+            //
+            // **软删**(退场),不是物理删除:与裁决 / 取代共用同一原语。面板上的"删除"
+            // 因此可撤销;真要抹掉数据只能走 `cleanup-retired`(先落快照 + 校验通过才删)。
+            // 这样 `deleteL1Batch` 在整个代码里**只有一个调用方**(exportThenPurge),
+            // "物理删除必须先有可信导出物"就成了结构性事实,而不是一句约定。
             if (!live?.get().memoryMutate) {
                 throw new Error('记忆写删未开放:请在记忆库面板开启高权限模式');
             }
@@ -759,9 +768,101 @@ export async function handleEndpoint(endpoint, payload, deps) {
             const ids = (Array.isArray(p.ids) ? p.ids : []).filter((x) => typeof x === 'string').slice(0, 200);
             if (ids.length === 0)
                 throw new Error('ids 缺失');
-            await stores.l1.deleteBatch(ids);
-            deps.logger.info(`[memory] 高权限删除记忆 ${ids.length} 条(${ids.join('，')})`);
-            return { deleted: ids.length };
+            const n = stores.l1.retire(ids, { at: new Date().toISOString(), reason: 'manual' });
+            deps.logger.info(`[memory] 高权限退场(软删)记忆 ${n} 条(${ids.join('，')})`);
+            return { deleted: n };
+        }
+        // ── 记忆退场(软删)与清理:已退场列表 / 恢复 / 物理清理 ──
+        // 读方向**不开**权限门(与 conflicts 一致:看得见才知道要不要恢复);
+        // 恢复与物理清理由 memoryMutate 门控。
+        case 'dsh-memory/records-retired': {
+            const p = (payload ?? {});
+            const limit = Math.min(Math.max(Math.floor(Number(p.limit)) || 50, 1), 200);
+            const offset = Math.min(Math.max(Math.floor(Number(p.offset)) || 0, 0), 1_000_000);
+            const { items, total } = stores.l1.listRetired({ limit, offset });
+            const resp = {
+                items: items.map((r) => {
+                    const mark = readSupersedeMarker(r.metadata);
+                    const view = hitToUiRecord(r);
+                    return {
+                        ...view,
+                        // 标记缺失时退回 `valid_to`(软删的两条判据任一成立即算已退场)
+                        retiredAt: mark?.at ?? (r.validTo !== undefined ? new Date(r.validTo).toISOString() : ''),
+                        retiredReason: mark?.reason ?? 'unknown',
+                        ...(mark?.verdict ? { verdict: mark.verdict } : {}),
+                        ...(mark?.by ? { supersededBy: mark.by } : {}),
+                    };
+                }),
+                total,
+            };
+            return resp;
+        }
+        case 'dsh-memory/records-restore': {
+            if (!live?.get().memoryMutate) {
+                throw new Error('记忆写删未开放:请在记忆库面板开启高权限模式');
+            }
+            const p = (payload ?? {});
+            const ids = (Array.isArray(p.ids) ? p.ids : [])
+                .filter((x) => typeof x === 'string' && x !== '')
+                .slice(0, 200);
+            if (ids.length === 0)
+                throw new Error('ids 缺失');
+            const r = await stores.l1.restore(ids);
+            deps.logger.info(`[memory] 恢复已退场记忆 ${r.restored} 条(补向量 ${r.vectorsWritten} 条)`);
+            const resp = r;
+            return resp;
+        }
+        case 'dsh-memory/cleanup-retired': {
+            if (!live?.get().memoryMutate) {
+                throw new Error('记忆写删未开放:请在记忆库面板开启高权限模式');
+            }
+            const p = (payload ?? {});
+            // **默认干跑**:省略 `dryRun` 即视为 true。物理删除是本插件唯一不可逆的动作,
+            // 必须由调用方显式要求才做(与"所有破坏性动作必须默认可回滚"同一条纪律)。
+            const dryRun = p.dryRun !== false;
+            const explicit = (Array.isArray(p.ids) ? p.ids : [])
+                .filter((x) => typeof x === 'string' && x !== '')
+                .slice(0, 500);
+            let targets;
+            if (explicit.length > 0) {
+                // 显式 id 也要**复核**是否真的处于已退场态:防止调用方用一个 id 列表
+                // 把活动记忆绕过软删直接物理抹掉(那等于给了一条硬删后门)。
+                targets = explicit.filter((id) => stores.l1.getByIds([id]).some((r) => r.validTo !== undefined));
+            }
+            else {
+                targets = [];
+                for (let offset = 0;; offset += 200) {
+                    const page = stores.l1.listRetired({ limit: 200, offset });
+                    targets.push(...page.items.map((r) => r.id));
+                    if (page.items.length < 200)
+                        break;
+                }
+            }
+            if (dryRun) {
+                const resp = {
+                    dryRun: true,
+                    targets: targets.length,
+                    purged: 0,
+                    aborted: false,
+                    dir: '',
+                    diffs: [],
+                };
+                return resp;
+            }
+            if (targets.length === 0) {
+                const resp = { dryRun: false, targets: 0, purged: 0, aborted: false, dir: '', diffs: [] };
+                return resp;
+            }
+            const r = await stores.l1.purgeRetired(targets, 'cleanup-retired');
+            const resp = {
+                dryRun: false,
+                targets: targets.length,
+                purged: r.purged,
+                aborted: r.aborted,
+                dir: r.dir,
+                diffs: r.diffs,
+            };
+            return resp;
         }
         // ── 知识图谱(面板图谱视图;graph 未装配时返空不报错) ──
         case 'dsh-memory/graph-search': {

package/dist/store/conflicts.d.ts

@@ -50,13 +50,24 @@ export declare function buildConflictPair(input: ConflictPairInput): ConflictPai
  * 三条都必需,缺一即无法停放,调用方须回落 `store`(信息绝不丢):
  * ① winner / loser 都是非空 id;
  * ② 二者**不同**——指向同一条记录是无效输出(承自 mneme 的 `validateDecisions`);
- * ③ 其中**恰有一方是本条新记忆**(`recordId`),另一方是候选池里的已有记录
- *    (由调用方用 `knownIds` 判定存活)。否则"对"无从成立:要么新记忆没有对手,
- *    要么对侧是模型幻觉出来的 id。
+ * ③ **恰有一方是本条新记忆**(`recordId`),另一方是**可核实的对手**:
+ *    候选池里的已有记录(`knownIds`),**或同一批次里的另一条新记忆**(`batchIds`)。
+ *
+ * 关于 `batchIds`(2026-09-18 取证后放宽,见 findings R6 / Agent A):
+ * 此前另一方只认 `knownIds`(候选池 ∪ target_ids),而**同批次新记忆的 id 不在其中**
+ * ——它们是本轮刚生成的、尚未入库。于是"本轮两条新记忆互相矛盾"这种最典型的
+ * "机器判不了"情形,模型即便正确 emit 了 `conflict`,也**必然被判不成对而回落 store**。
+ * 实测:模型在生产 prompt 下对同批次矛盾 2/2 会 emit,但那一跳从未落库。
+ *
+ * 为何仍要求"恰有一方是 `recordId`":`conflict` 是**挂在某一条新记忆名下的决策**,
+ * 若允许"另外两条新记忆"配对,同一对会被每个兄弟重复申报一次。锁定一方为本条,
+ * 配对就唯一。
  *
  * 返回规范化后的 `{ winnerId, loserId }`,或 `null`(表示不构成冻结对)。
  */
-export declare function validateConflictPair(recordId: string, winner: unknown, loser: unknown, knownIds: ReadonlySet<string>): {
+export declare function validateConflictPair(recordId: string, winner: unknown, loser: unknown, knownIds: ReadonlySet<string>, 
+/** 本批次其它新记忆的 record_id(同批次互斥也可冻结)。不传 = 维持旧行为。 */
+batchIds?: ReadonlySet<string>): {
     winnerId: string;
     loserId: string;
 } | null;