dsh-prime-memory 0.12.0 → 0.13.0

package/dist/conflict-service.d.ts

@@ -9,16 +9,8 @@
  * (与 `memory_receipts` 一样:同一份 `ReceiptsView` 供工具与端点共用)。
  */
 import type { L1Store } from './store/l1.js';
-/** 裁决结果的对外形状(snake_case,工具与端点共用)。 */
-export interface ConflictResolutionView {
-    pair_id: string;
-    outcome: string;
-    /** 裁决时刻(ISO)。空串 = 未生效。 */
-    resolved_at: string;
-    /** 因裁决从检索中退场的记录 id(无则空串)。 */
-    removed_record_id: string;
-    notice?: string;
-}
+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'>;
     /** `conflictFreeze.enabled`。未开启时队列恒空,直接给出提示而非静默无操作。 */
@@ -36,3 +28,28 @@ export interface ConflictResolveDeps {
 export declare function resolveConflictPair(deps: ConflictResolveDeps, pairId: string, outcome: string): Promise<ConflictResolutionView>;
 /** 裁决结果的人类可读渲染(工具路径用)。schema 产出的是可选字段,故按部分取值渲染。 */
 export declare function renderConflictResolution(v: Partial<ConflictResolutionView>): string;
+/** 一条待裁决对的对外形状见 `contract.ts` 的 `ConflictPairView`(此处只引用)。 */
+/** 队列读取的上限(与 `records-delete` 同量级:够人看,不把页面拖死)。 */
+export declare const CONFLICT_LIST_LIMIT_MAX = 200;
+/** 默认取多少条。 */
+export declare const CONFLICT_LIST_LIMIT_DEFAULT = 50;
+export interface ConflictListDeps {
+    l1: Pick<L1Store, 'listConflictPending' | 'countConflictPendingUnresolved' | 'getByIds'>;
+    /** `conflictFreeze.enabled`。 */
+    conflictFreezeEnabled: boolean;
+}
+/**
+ * 列出待裁决对。
+ *
+ * **正文必须带上**:人工裁决的对象就是"这两条到底说了什么",只给 id 等于让人盲判。
+ * 取不到正文时留空串 —— 面板据此区分"记录已不在检索库"与"内容为空",
+ * 而不是拿一句"（无内容）"把两种情形糊在一起。
+ *
+ * 未开启冻结时返回 `enabled:false` + 空列表 + `notice`,**不抛错**:开关没开是
+ * 部署状态,不是调用错误(与 `resolveConflictPair` 对同一情形的处理一致)。
+ */
+export declare function listConflictPairs(deps: ConflictListDeps, opts?: {
+    limit?: number;
+}): ConflictsView;
+/** 列表结果的人类可读渲染(工具路径用)。 */
+export declare function renderConflicts(v: ConflictsView): string;

package/dist/conflict-service.js

@@ -63,3 +63,73 @@ export function renderConflictResolution(v) {
         : '\n未移除任何记录。';
     return `已裁决待裁决对 ${v.pair_id ?? ''}\n结论:${outcome}(${label})\n裁决时刻:${v.resolved_at ?? ''}${removed}`;
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// 读方向:列出待裁决对
+//
+// 与 `resolveConflictPair` 同理由共用本模块:工具(`memory_conflicts`)与
+// RPC 端点(`dsh-memory/conflicts`)必须是**同一份形状** —— 面板与模型看同一队列,
+// 否则"人看到的那条"和"模型能裁决的那条"会对不上。
+// ─────────────────────────────────────────────────────────────────────────────
+/** 一条待裁决对的对外形状见 `contract.ts` 的 `ConflictPairView`(此处只引用)。 */
+/** 队列读取的上限(与 `records-delete` 同量级:够人看,不把页面拖死)。 */
+export const CONFLICT_LIST_LIMIT_MAX = 200;
+/** 默认取多少条。 */
+export const CONFLICT_LIST_LIMIT_DEFAULT = 50;
+/**
+ * 列出待裁决对。
+ *
+ * **正文必须带上**:人工裁决的对象就是"这两条到底说了什么",只给 id 等于让人盲判。
+ * 取不到正文时留空串 —— 面板据此区分"记录已不在检索库"与"内容为空",
+ * 而不是拿一句"（无内容）"把两种情形糊在一起。
+ *
+ * 未开启冻结时返回 `enabled:false` + 空列表 + `notice`,**不抛错**:开关没开是
+ * 部署状态,不是调用错误(与 `resolveConflictPair` 对同一情形的处理一致)。
+ */
+export function listConflictPairs(deps, opts = {}) {
+    const raw = Math.floor(Number(opts.limit));
+    const limit = Number.isFinite(raw) && raw > 0 ? Math.min(raw, CONFLICT_LIST_LIMIT_MAX) : CONFLICT_LIST_LIMIT_DEFAULT;
+    if (!deps.conflictFreezeEnabled) {
+        return {
+            enabled: false,
+            total: 0,
+            items: [],
+            notice: '矛盾冻结未开启(conflictFreeze.enabled=false):队列恒空,没有待裁决对。',
+        };
+    }
+    const pending = deps.l1.listConflictPending({ limit });
+    const ids = new Set();
+    for (const p of pending) {
+        ids.add(p.winnerId);
+        ids.add(p.loserId);
+    }
+    const contentById = new Map();
+    for (const r of deps.l1.getByIds([...ids]))
+        contentById.set(r.id, r.content);
+    const items = pending.map((p) => ({
+        pair_id: p.pairId,
+        run_id: p.runId,
+        winner_id: p.winnerId,
+        winner_content: contentById.get(p.winnerId) ?? '',
+        loser_id: p.loserId,
+        loser_content: contentById.get(p.loserId) ?? '',
+        created_at: p.createdAt,
+    }));
+    return { enabled: true, total: deps.l1.countConflictPendingUnresolved(), items };
+}
+/** 列表结果的人类可读渲染(工具路径用)。 */
+export function renderConflicts(v) {
+    if (!v.enabled)
+        return v.notice ?? '矛盾冻结未开启:没有待裁决对。';
+    if (v.items.length === 0)
+        return '没有待裁决的冲突对(队列为空)。';
+    const more = v.total > v.items.length ? `\n(共 ${v.total} 对,此处显示前 ${v.items.length} 对)` : '';
+    const rows = v.items.map((p, i) => {
+        const w = p.winner_content || '(该记录已不在检索库)';
+        const l = p.loser_content || '(该记录已不在检索库)';
+        return (`${i + 1}. pair_id ${p.pair_id}  (${p.created_at})\n` +
+            `   LLM 建议胜方 ${p.winner_id}:${w}\n` +
+            `   LLM 建议败方 ${p.loser_id}:${l}`);
+    });
+    return `待裁决冲突对 ${v.items.length} 条${more}\n\n${rows.join('\n\n')}\n\n` +
+        '用 memory_resolve_conflict 给出结论:winner / loser / both。';
+}

package/dist/contract.d.ts

@@ -754,6 +754,75 @@ export interface EmbeddingModelDeleteResponse {
     ok: boolean;
     error?: string;
 }
+/** 一条待裁决冲突对(与 `ConflictPair` 同源,但只暴露人要看的那几个字段)。 */
+export interface ConflictPairView {
+    pair_id: string;
+    /** 产生该冻结的 L1 蒸馏批次 id(接 §B 凭证链)。 */
+    run_id: string;
+    /** LLM 建议的胜方 id。**只是进入队列时的排序位,不代表结论**。 */
+    winner_id: string;
+    /** 胜方正文;**空串 = 该记录已不在检索库**(被合并/删掉了),不是"内容为空"。 */
+    winner_content: string;
+    loser_id: string;
+    loser_content: string;
+    created_at: string;
+}
+/** `dsh-memory/conflicts` 请求(读待裁决队列)。 */
+export interface ConflictsRequest {
+    /** 最多返回多少对(默认 50,上限 200)。 */
+    limit?: number;
+}
+/** `dsh-memory/conflicts` 响应。 */
+export interface ConflictsResponse {
+    /**
+     * `conflictFreeze.enabled`。**必须与 `items: []` 分开呈现** ——
+     * "开关没开"与"开了但没有待裁决"在面板上是两件不同的事。
+     */
+    enabled: boolean;
+    /** 未裁决总数(可能大于 `items.length`)。 */
+    total: number;
+    items: ConflictPairView[];
+    notice?: string;
+}
+/** `dsh-memory/conflict-resolve` 请求。 */
+export interface ConflictResolveRequest {
+    pairId: string;
+    /** `winner` | `loser` | `both`。 */
+    outcome: string;
+}
+/** `dsh-memory/conflict-resolve` 响应(与 `memory_resolve_conflict` 工具同形状)。 */
+export interface ConflictResolveResponse {
+    pair_id: string;
+    outcome: string;
+    /** 裁决时刻(ISO);空串 = 未生效。 */
+    resolved_at: string;
+    /** 因裁决从检索中退场的记录 id(无则空串)。 */
+    removed_record_id: string;
+    notice?: string;
+}
+/** `dsh-memory/receipts` 请求(两维回溯,至少给一个)。 */
+export interface ReceiptsRequest {
+    recordId?: string;
+    runId?: string;
+    limit?: number;
+}
+/** 一条决策凭证(与 `memory_receipts` 工具同形状)。 */
+export interface ReceiptItemView {
+    receipt_id: string;
+    run_id: string;
+    record_id: string;
+    /** `store` / `update` / `merge` / `skip` / `conflict` / `skip_missing`。 */
+    kind: string;
+    input_digest: string;
+    decided_at: string;
+}
+/** `dsh-memory/receipts` 响应。 */
+export interface ReceiptsResponse {
+    /** `record` / `run` / `both` / `none`。 */
+    dimension: string;
+    items: ReceiptItemView[];
+    total: number;
+}
 export interface DshMemoryRequestMap {
     'dsh-memory/stats': Record<string, never>;
     'dsh-memory/token-cost': TokenCostRequest;
@@ -764,6 +833,9 @@ export interface DshMemoryRequestMap {
     'dsh-memory/settings-set': SettingsSetRequest;
     'dsh-memory/list-records': ListRecordsRequest;
     'dsh-memory/records-delete': RecordsDeleteRequest;
+    'dsh-memory/receipts': ReceiptsRequest;
+    'dsh-memory/conflicts': ConflictsRequest;
+    'dsh-memory/conflict-resolve': ConflictResolveRequest;
     'dsh-memory/graph-search': GraphSearchRequest;
     'dsh-memory/graph-node-get': GraphNodeGetRequest;
     'dsh-memory/scenes': Record<string, never>;
@@ -795,6 +867,9 @@ export interface DshMemoryResponseMap {
     'dsh-memory/settings-set': SettingsSetResponse;
     'dsh-memory/list-records': ListRecordsResponse;
     'dsh-memory/records-delete': RecordsDeleteResponse;
+    'dsh-memory/receipts': ReceiptsResponse;
+    'dsh-memory/conflicts': ConflictsResponse;
+    'dsh-memory/conflict-resolve': ConflictResolveResponse;
     'dsh-memory/graph-search': GraphSearchResponse;
     'dsh-memory/graph-node-get': GraphNodeGetResponse;
     'dsh-memory/scenes': ScenesResponse;

package/dist/stats.d.ts

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

package/dist/stats.js

@@ -20,13 +20,13 @@ import { emptyRecallStats } from './hooks/recall.js';
 import { buildRouteChain, decideSendableEffort, LAYER_DEFAULT_BUDGETS, layerChainOrNull, resolveModelContextWindow, resolveModelEfforts, resolveModelRoute } from './llm.js';
 import { projectDistillChain, validateDistillChain } from './settings.js';
 import { RECEIPTS_QUERY_LIMIT_MAX, dimensionOf, toReceiptView } from './store/receipts.js';
-import { resolveConflictPair } from './conflict-service.js';
+import { resolveConflictPair, listConflictPairs } from './conflict-service.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;
 /**
- * 端点全集运行时清单(31 个,与 tests/contract-keys.test.ts 的 ENDPOINTS 及
+ * 端点全集运行时清单(33 个,与 tests/contract-keys.test.ts 的 ENDPOINTS 及
  * contract.ts 类型映射表三方对齐,漂移由键集 diff 测试暴露)。
  * 注意:本清单同时是 HTTP 前缀路由 `/dsh-memory/rpc/<短名>` 的**放行白名单**
  * (见下方 SHORT_ENDPOINTS),漏一条 = 该端点在面板里静默消失(404 被客户端
@@ -47,6 +47,7 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/list-records',
     'dsh-memory/records-delete',
     'dsh-memory/receipts',
+    'dsh-memory/conflicts',
     'dsh-memory/conflict-resolve',
     'dsh-memory/graph-search',
     'dsh-memory/graph-node-get',
@@ -719,6 +720,14 @@ export async function handleEndpoint(endpoint, payload, deps) {
             };
             return resp;
         }
+        // ── §C 矛盾冻结的**读**方向:与 memory_conflicts 工具共用同一形状 ──
+        // 裁决端点(conflict-resolve)早就在,但只有"写"没有"读" —— 于是 pair_id
+        // 无处可得:模型被指到不存在的 memory_conflicts 工具,人也没有面板。
+        // 未开启冻结时同样走返回体(enabled:false + notice)而非抛错,理由同上。
+        case 'dsh-memory/conflicts': {
+            const p = (payload ?? {});
+            return listConflictPairs({ l1: stores.l1, conflictFreezeEnabled: cfg.conflictFreeze?.enabled === true }, { limit: Number(p.limit) || undefined });
+        }
         // ── §C 矛盾冻结裁决(task_25):与 memory_resolve_conflict 工具共用同一形状 ──
         // 端点层同样不给"提示文案"出口的例外只有一条:**队列未开启**不是调用错误而是
         // 部署状态,故它走返回体(带 notice)而非抛错;pair_id/outcome 缺参才抛。

package/dist/tools/index.js

@@ -1,6 +1,6 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { RECEIPTS_QUERY_LIMIT_MAX, dimensionOf, toReceiptView } from '../store/receipts.js';
-import { renderConflictResolution, resolveConflictPair } from '../conflict-service.js';
+import { listConflictPairs, renderConflictResolution, renderConflicts, resolveConflictPair } from '../conflict-service.js';
 import { normPersistence, normScope, resolveRecordScope } from '../types.js';
 import { scopeFilterOf, workspaceIdOf } from '../workspace.js';
 import { GRAPH_STATUS_LABELS } from '../prompts/graph-projection.js';
@@ -816,6 +816,56 @@ ruminate) {
             return { dimension, items: rows.map(toReceiptView), total: stores.l1.countReceipts(query) };
         },
     }));
+    // ── memory_conflicts: §C 待裁决队列的**读**出口 ──
+    // `memory_resolve_conflict` 的描述里早就写着"待裁决对可用 memory_conflicts 查看",
+    // 但那个工具**一直不存在** —— 模型照着描述调用只会拿到"工具不存在"。
+    // 裁决端点在、读端点与读工具两端都缺,队列于是成了只进不出的黑洞
+    // (安全阀超时自动了结会成为唯一出路,那正是 §C 想避免的)。
+    ctx.tools.register(defineTool({
+        name: 'memory_conflicts',
+        description: '列出**矛盾冻结**的待裁决对(§C)。冻结不自动裁决:新记忆照常入库,与它冲突的旧记忆作为**一对**停在队列里,双方内容都不被改写,直到人给出结论。返回每对的 pair_id、**双方正文**与 LLM 建议的胜负方(id 只是进入队列时的排序位,不代表结论)。看完用 memory_resolve_conflict 给出结论:winner / loser / both。',
+        parameters: {
+            limit: { type: 'number', description: '最多返回多少对(默认 50,上限 200)' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                properties: {
+                    enabled: { type: 'boolean', description: '矛盾冻结是否开启;关闭时队列恒空,与"开启但没有待裁决"是两回事' },
+                    total: { type: 'number', description: '未裁决总数(可能大于 items.length)' },
+                    items: {
+                        type: 'array',
+                        description: '待裁决对(最多 limit 条)',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                pair_id: { type: 'string' },
+                                run_id: { type: 'string', description: '产生该冻结的蒸馏批次 id(可交给 memory_receipts 追该轮判了什么)' },
+                                winner_id: { type: 'string' },
+                                winner_content: { type: 'string', description: 'LLM 建议胜方的正文;空串 = 该记录已不在检索库' },
+                                loser_id: { type: 'string' },
+                                loser_content: { type: 'string', description: '同上' },
+                                created_at: { type: 'string' },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                    notice: { type: 'string', description: '非结果的状态提示(如冻结未开启 / 本会话记忆已关闭)' },
+                },
+                additionalProperties: false,
+            },
+            render: (_args, value) => [{ type: 'text', text: value.notice ?? renderConflicts(value) }],
+        },
+        execute: async (args, exec) => {
+            // 档位拒读门与 memory_receipts 同款:off 会话对记忆系统完全隐身,
+            // 不该反过来能内省"库里有哪些自相矛盾的记忆"。
+            const family = familyOfCaller(exec);
+            if (family === null) {
+                return { enabled: false, total: 0, items: [], notice: blockNoticeOf(exec) };
+            }
+            return listConflictPairs({ l1: stores.l1, conflictFreezeEnabled: cfg.conflictFreeze?.enabled === true }, { limit: typeof args.limit === 'number' ? args.limit : undefined });
+        },
+    }));
     // ── memory_resolve_conflict: §C 矛盾冻结的人工裁决出口 ──
     // 冻结把裁决权交还给人,那么**必须**有一个"人能把结论说回去"的出口——
     // 否则待裁决队列是个只进不出的黑洞,安全阀(task_24)会成为唯一出路,

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",
-    "tag": "dsh-0.1.2"
+    "tag": "dsh-0.1.5"
   },
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",