dsh-prime-memory 0.22.2 → 0.24.0

package/dist/hooks/recall.js

@@ -11,7 +11,7 @@ import { applyRecallBudget, raceRecallTimeout, RECALL_EMBED_CAP_MS } from '../ut
 import { clearProfileShare, emptyOccupancyLedger, estimateInjectedMessageTokens, estimateStableSectionTokens, recordProfileShare, recordRecallInjection, resetForCompaction, } from '../util/context-occupancy.js';
 import { errDetail } from '../util/filelog.js';
 import { blocksToText } from '../util/text.js';
-import { domainGate, formatWeights, hardFilterByWingLock, sortByDomainWeight, sortByUsageScenario, WING_ANCHORS } from '../domain-gate.js';
+import { domainGate, formatWeights, hardFilterByWingLock, sortByDomainWeight, sortByHumanMark, sortByUsageScenario, WING_ANCHORS } from '../domain-gate.js';
 const PROFILE_TTL = 60_000;
 /** 存储回填缓存上限(超过即按插入序淘汰最旧;查看会话数为百级,500 足够)。 */
 const STORED_ESTIMATE_CACHE_CAP = 500;
@@ -40,6 +40,30 @@ const RECALL_QUERY_MAX_CHARS = 2_000;
 export function isOwnRecallSource(src) {
     return !!src && src.form === 'recall' && (src.kind === 'plugin:memory' || (src.kind === 'plugin' && src.plugin === 'memory'));
 }
+/**
+ * 认出一条 `user/message` 事件是不是本插件的召回注入，并取出它的消息 id / seq / 正文字数。
+ *
+ * 这是**唯一的识别口径**：召份额估算（live 与存储两条路）与「正文已被摘要取代」对账都读它。
+ * 两处各写一套判定迟早漂移，而漂移的后果是静默的（份额归零或误标取代）。
+ * 署名判定走 `isOwnRecallSource`，同时吃 v4 `plugin:memory` 与 v3 旧行形状。
+ */
+export function ownInjectionFromEvent(ev) {
+    if (ev.type !== 'user/message')
+        return undefined;
+    const msg = ev.data;
+    if (msg === undefined || !isOwnRecallSource(msg.source))
+        return undefined;
+    let chars = 0;
+    for (const b of msg.content ?? []) {
+        if (b?.type === 'text' && typeof b.text === 'string')
+            chars += b.text.length;
+    }
+    return {
+        id: typeof msg.id === 'string' ? msg.id : '',
+        seq: typeof ev.seq === 'number' ? ev.seq : undefined,
+        chars,
+    };
+}
 export function buildRecallQuery(messages, tailMessages = RECALL_QUERY_TAIL_MESSAGES, maxChars = RECALL_QUERY_MAX_CHARS) {
     const tail = messages.slice(-tailMessages);
     let text = tail.map((m) => blocksToText(m.content)).join(' ').trim();
@@ -215,9 +239,13 @@ usage) {
     ctx.on('session/event', (session, event) => {
         if (event.type !== 'compaction/end')
             return;
-        if (postCompaction.onCompactionEnd(String(session.id ?? session))) {
-            logger.info(`[memory] compaction/end:下一轮将做一次增强召回(session=${String(session.id ?? session)})`);
+        const sid = String(session.id ?? session);
+        if (postCompaction.onCompactionEnd(sid)) {
+            logger.info(`[memory] compaction/end:下一轮将做一次增强召回(session=${sid})`);
         }
+        // Phase 0B：压缩完成的**权威**信号。取代标记不再只靠 agent/created 的粗标，而是从
+        // surface.nodes 逐条对账；即使那条事件根本没发，这里也能把状态算对（并可撤销误标）。
+        void reconcileSupersededFromSession(sid);
     });
     // 上下文压缩/清空 → 已注入内容从模型上下文丢失,重置该会话的去重压制
     // (resume/startup 不重置:历史仍在,已注入的记忆模型还持有)。
@@ -225,7 +253,9 @@ usage) {
     ctx.on('agent/created', async (payload) => {
         if (payload.source === 'compact' || payload.source === 'clear') {
             dedupe.reset(payload.agent.id);
-            stores.recalled?.reset(String(payload.agent.session?.id ?? payload.agent.id));
+            // 压缩与清空**不同对待**：摘要替换不得抹掉本会话的召回历史（尤其已判过时的裁决凭证），
+            // 只有用户主动清空才整表清。去重与占用账本仍按原样重置（那两者关心“能不能重新注入”）。
+            stores.recalled?.reset(String(payload.agent.session?.id ?? payload.agent.id), payload.source === 'compact' ? 'compact' : 'clear');
             const led = ledgerFor(payload.agent.id);
             resetForCompaction(led);
             occupancyStore.save(payload.agent.id, led); // stock 归零 ⇒ 流水条目删除
@@ -388,6 +418,33 @@ usage) {
                         logger.info(`[memory] 使用场景细排生效:agent=${payload.agent.id}`);
                     }
                 }
+                // ── 人工打分参与排序（默认开）：4/5 上浮、0/1/2 下沉。纯重排、**score 不改写**、
+                // 同档内保持进入顺序（不推翻上面的围栏/场景细排）。这就是 0/1/2 的常规出口：
+                // 不相关就排到注不上，而不是从记忆里消失。未装配反馈面 / 全未打分 → 逐字同序。
+                if (cfg.recallFeedback?.enabled === true
+                    && cfg.recallFeedback.affectRank !== false
+                    && stores.feedback !== undefined
+                    && scoped.length > 1) {
+                    const fb = stores.feedback;
+                    const before = scoped.map((h) => h.id).join(',');
+                    scoped = sortByHumanMark(scoped, (id) => fb.lastOf(id));
+                    if (scoped.map((h) => h.id).join(',') !== before) {
+                        logger.info(`[memory] 人工打分排序生效(agent=${payload.agent.id})`);
+                    }
+                }
+                // ── 可选硬门 excludeZero（**默认关**）：最近一笔是 0 → 本轮不注入（不退场，
+                // 再点 1..5 即回来）。开着它=“误点一次就完全不再浮现”，所以默认只靠上面的沉底。
+                if (cfg.recallFeedback?.enabled === true
+                    && cfg.recallFeedback.excludeZero === true
+                    && stores.feedback !== undefined
+                    && scoped.length > 0) {
+                    const fb = stores.feedback;
+                    const kept = scoped.filter((h) => fb.lastOf(h.id) !== 0);
+                    if (kept.length !== scoped.length) {
+                        logger.info(`[memory] 相关度 0 分剔除 ${scoped.length - kept.length} 条(agent=${payload.agent.id})`);
+                        scoped = kept;
+                    }
+                }
                 // 召回去重:同会话已注入过的记录不再重复注入(模型上下文已持有,省 token)。
                 // 纯过滤——剩几条注几条,全量压制(0 条新鲜命中)是正确状态而非未命中。
                 // §E:压缩后增强轮跳过压制(压缩把已注入内容逐出了模型上下文)。
@@ -460,7 +517,7 @@ usage) {
                 usage?.recordAttempt(scoped.map((h) => h.id), fresh.slice(0, lines.length).map((h) => h.id));
                 // G-live:按 **sessionKey**(=agent.session?.id ?? agent.id，与 pill 的 sessionId / 投影 header.id 同源，
                 // 非 ownerId)记入本会话“活召回集”，供侧栏卡读取；压缩时同键 reset。
-                stores.recalled?.add(sessionKey, fresh.slice(0, lines.length).map((h) => h.id));
+                stores.recalled?.add(sessionKey, fresh.slice(0, lines.length).map((h) => h.id), injection.id);
                 // 入账在成功构造注入消息之后、返回 enter 之前——任何前置抛错路径账目零扰动
                 const led = ledgerFor(payload.agent.id);
                 recordRecallInjection(led, text.length);
@@ -500,8 +557,46 @@ usage) {
             return '';
         return body ? `${body}\n\n${MEMORY_TOOLS_GUIDE}` : MEMORY_TOOLS_GUIDE;
     };
-    /** 本插件 recall 注入的署名判据(v4 `plugin:memory` 与 v3 旧行双形状;宿主迁移负责升格旧行)。 */
-    const isOwnRecall = isOwnRecallSource;
+    /**
+     * Phase 0B：从宿主官方会话服务对账「正文已被摘要取代」。
+     *
+     * 为什么不再靠“收到一条压缩事件”：事件会漏（压缩不重建 agent 的宿主线、含 CCI compat 摘要
+     * 路径，根本不发 `agent/created{source:'compact'}`），漏一次就永久错且无法补算。这里每轮从
+     * `surface.nodes` 重算，所以既能标上也能撤销（误标与重新注入都会自愈）。
+     *
+     * @returns true = 会话在 live store 且已对账；false = 不在（调用方回退到粗标记）。
+     */
+    const reconcileSupersededFromSession = async (sessionId) => {
+        const recalled = stores.recalled;
+        if (recalled === undefined || sessionId.length === 0)
+            return false;
+        try {
+            // 可选服务一律走 ctx.get() 的宽容路径（属性访问对未 inject 的服务会抛）
+            const sessions = ctx.get?.('sessions');
+            const session = typeof sessions?.get === 'function' ? sessions.get(sessionId) : undefined;
+            if (session === undefined)
+                return false;
+            const visibleSeqs = new Set(session.surface.nodes);
+            const visibleIds = new Set();
+            const knownIds = new Set();
+            for (const ev of session.events) {
+                const own = ownInjectionFromEvent(ev);
+                if (own === undefined || own.id.length === 0)
+                    continue;
+                knownIds.add(own.id);
+                // 只有“确实拿到了 seq 且 seq 在 surface.nodes 里”才算可见；
+                // seq 缺失时宁可不撤销（保持原状），也不拿臆测值去改动人的可见性判定。
+                if (own.seq !== undefined && visibleSeqs.has(own.seq))
+                    visibleIds.add(own.id);
+            }
+            return recalled.reconcileSuperseded(sessionId, visibleIds, knownIds);
+        }
+        catch (err) {
+            // 对账是旁路：失败只能“本轮不动”，绝不能弄挂召回或面板。
+            logger.warn(`[memory] 取代对账失败(本轮跳过): ${errDetail(err)}`);
+            return false;
+        }
+    };
     async function estimateRecallFromStorage(sessionId) {
         if (storedEstimateCache.has(sessionId))
             return storedEstimateCache.get(sessionId) ?? null;
@@ -513,20 +608,13 @@ usage) {
             if (stored?.events) {
                 tokens = 0;
                 for (const ev of stored.events) {
+                    // 存储路没有 surface，只能沿用“遇到压缩就归零”的启发式（粗近似，不伪装成精确判定）。
                     if (typeof ev.type === 'string' && ev.type.startsWith('compaction'))
                         tokens = 0;
-                    if (ev.type !== 'user/message')
-                        continue;
-                    const src = ev.data?.source;
-                    if (!isOwnRecall(src))
+                    const own = ownInjectionFromEvent(ev);
+                    if (own === undefined || own.chars === 0)
                         continue;
-                    let chars = 0;
-                    for (const b of ev.data?.content ?? []) {
-                        if (b?.type === 'text' && typeof b.text === 'string')
-                            chars += b.text.length;
-                    }
-                    if (chars > 0)
-                        tokens += estimateInjectedMessageTokens(chars);
+                    tokens += estimateInjectedMessageTokens(own.chars);
                 }
             }
         }
@@ -551,19 +639,11 @@ usage) {
                 const visible = new Set(session.surface.nodes);
                 let total = 0;
                 for (const ev of session.events) {
-                    if (ev.type !== 'user/message' || !visible.has(ev.seq))
-                        continue;
-                    const msg = ev.data;
-                    const src = msg?.source;
-                    if (!isOwnRecall(src) || !msg)
+                    const own = ownInjectionFromEvent(ev);
+                    // 无 seq = 无法证明它可见，就不能算进份额（与原行为一致：原来它必须 visible.has(seq)）。
+                    if (own === undefined || own.chars === 0 || own.seq === undefined || !visible.has(own.seq))
                         continue;
-                    let chars = 0;
-                    for (const b of msg.content ?? []) {
-                        if (b?.type === 'text' && typeof b.text === 'string')
-                            chars += b.text.length;
-                    }
-                    if (chars > 0)
-                        total += estimateInjectedMessageTokens(chars);
+                    total += estimateInjectedMessageTokens(own.chars);
                 }
                 return total;
             }