dsh-prime-memory 0.22.1 → 0.24.0

package/dist/domain-gate.js

@@ -9,6 +9,7 @@
  * 可解释性:每次召回把 8 个域权重写进日志(可读出),权重计算是纯函数、可回归。
  */
 import { WING_FALLBACK } from './types.js';
+import { markSignal } from './util/maturity.js';
 /** 8 条域锚文本(单一事实源):一段描述该域典型内容的短文本,供向量化。
  *  keywords 是嵌入关闭时的关键词降级匹配词表(命中任一 = 该域相关)。 */
 export const WING_ANCHORS = [
@@ -149,3 +150,47 @@ export function sortByDomainWeight(hits, wingOf, weights) {
     };
     return [...hits].sort((a, b) => weightOf(b.id) - weightOf(a.id) || b.score - a.score);
 }
+/** 分词(小写、按非字母数字/非 CJK 切、去长度<2 的碎片)。供场景词重叠用。 */
+function normTokens(s) {
+    return new Set(s.toLowerCase().split(/[^0-9a-z\u4e00-\u9fa5]+/).map((t) => t.trim()).filter((t) => t.length >= 2));
+}
+/**
+ * G1 使用场景细排(纯函数、**score 不改写**、默认关时不进此路径):
+ * 命中查询词的 usageScenario 记忆上浮；未命中/无场景的记录保持原序(fail-open)。
+ * 保守：只按“命中强度”重排，不引入新相关性判断；无查询词时原样返回。
+ */
+export function sortByUsageScenario(hits, scenariosOf, query) {
+    const q = normTokens(query);
+    if (q.size === 0)
+        return [...hits];
+    const matchOf = (id) => {
+        let best = 0;
+        for (const s of scenariosOf(id)) {
+            let ov = 0;
+            for (const t of normTokens(s))
+                if (q.has(t))
+                    ov++;
+            if (ov > best)
+                best = ov;
+        }
+        return best;
+    };
+    return hits
+        .map((h, i) => ({ h, i, m: matchOf(h.id) }))
+        .sort((a, b) => b.m - a.m || a.i - b.i)
+        .map((x) => x.h);
+}
+/**
+ * 人工打分参与排序（纯重排、**score 不改写**）：4/5 上浮、0/1/2 下沉。
+ *
+ * 三条约束：
+ * - 同档内保持进入顺序（稳定排序），所以不会推翻 scopeFence / 场景细排的结果；
+ * - **未打分与 3 分同为中性**（fail-open），全部未打分时输出与输入逐字同序；
+ * - 判据是**最近一笔**而非均值——用户改主意的路径必须存在（先 5 后 0 应当下沉）。
+ */
+export function sortByHumanMark(hits, markOf) {
+    return hits
+        .map((h, i) => ({ h, i, s: markSignal(markOf(h.id)) }))
+        .sort((a, b) => b.s - a.s || a.i - b.i)
+        .map((x) => x.h);
+}

package/dist/graph/constraints.d.ts

@@ -13,8 +13,10 @@ export declare const GRAPH_NODE_TYPE_SET: ReadonlySet<string>;
 /** 记录生命周期四态(节点/fact/边通用)。 */
 export declare const GRAPH_STATUSES: readonly GraphRecordStatus[];
 export declare const GRAPH_STATUS_SET: ReadonlySet<string>;
-/** 规范中文关系词(提示词给枚举;校验不做白名单——关系是开放词表,只做长度钳制)。 */
-export declare const GRAPH_RELATION_WORDS: readonly ["使用", "属于", "创建", "参与", "贡献", "依赖", "位于", "相关"];
+/** 规范中文关系词(提示词给枚举;校验不做白名单——关系是开放词表,只做长度钳制)。
+ *  后四个为因果边(导致/因为/修复了/取代)——让"前因后果"跨记录成链;仅当 graph.enabled 时
+ *  才参与投影(整块图谱默认关,不碰非图谱用户的蒸馏产物)。 */
+export declare const GRAPH_RELATION_WORDS: readonly ["使用", "属于", "创建", "参与", "贡献", "依赖", "位于", "相关", "导致", "因为", "修复了", "取代"];
 /** 提案字段上限(校验侧截断/丢弃与提示词内插共用同一组数字)。 */
 export declare const GRAPH_CAP: {
     /** 提案内临时引用(ref)长度。 */

package/dist/graph/constraints.js

@@ -4,8 +4,10 @@ export const GRAPH_NODE_TYPE_SET = new Set(GRAPH_NODE_TYPES);
 /** 记录生命周期四态(节点/fact/边通用)。 */
 export const GRAPH_STATUSES = ['active', 'superseded', 'disputed', 'archived'];
 export const GRAPH_STATUS_SET = new Set(GRAPH_STATUSES);
-/** 规范中文关系词(提示词给枚举;校验不做白名单——关系是开放词表,只做长度钳制)。 */
-export const GRAPH_RELATION_WORDS = ['使用', '属于', '创建', '参与', '贡献', '依赖', '位于', '相关'];
+/** 规范中文关系词(提示词给枚举;校验不做白名单——关系是开放词表,只做长度钳制)。
+ *  后四个为因果边(导致/因为/修复了/取代)——让"前因后果"跨记录成链;仅当 graph.enabled 时
+ *  才参与投影(整块图谱默认关,不碰非图谱用户的蒸馏产物)。 */
+export const GRAPH_RELATION_WORDS = ['使用', '属于', '创建', '参与', '贡献', '依赖', '位于', '相关', '导致', '因为', '修复了', '取代'];
 /** 提案字段上限(校验侧截断/丢弃与提示词内插共用同一组数字)。 */
 export const GRAPH_CAP = {
     /** 提案内临时引用(ref)长度。 */

package/dist/hooks/obsolete-notice.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 「记忆已声明过时」一次性播报 Hook。
+ *
+ * 用户在召回卡上打 `-1` 之后，记忆库那侧当场退场了，但模型此刻的上下文里那条记忆
+ * 还在——它必须被告知"这条已由用户判定过时，别再依据它作答"，否则退场只发生在
+ * 用户看得见的地方，模型仍在按旧信息干活。
+ *
+ * 与槽位常驻注入（`slot-recall.ts`）的分工：那是**跨会话常驻**的约定，每轮都在；
+ * 本 Hook 是**一次性**的更正通知，`drain` 取走即离队，下一轮就没有了。
+ *
+ * 门控：`cfg.recallFeedback.enabled && cfg.recallFeedback.announce`。关时不进
+ * `agent/pre-step` 的注入分支（零出队、零新帧），既有会话逐字现状。
+ *
+ * 注入帧形状刻意与 recall/slot 同源（`source.kind:'plugin:memory'` + `form:'recall'`）：
+ * 改这个形状会让宿主的"记忆召回份额"统计漏判（isOwnRecallSource），是踩过的红线。
+ * 正文按宿主 house style 转义闭合标签，防伪造帧边界。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from '../config.js';
+import type { ObsoleteNoticeStore } from '../store/obsolete-notices.js';
+import type { MemoryLogger } from '../types.js';
+export interface ObsoleteNoticeController {
+    /** 生成本轮播报文本(null = 无待播报)；导出供单元测试。会**出队**。 */
+    buildInjection(sessionKey: string): string | null;
+}
+export declare function registerObsoleteNotice(ctx: Context, cfg: MemoryConfig, notices: ObsoleteNoticeStore, logger: MemoryLogger): ObsoleteNoticeController;

package/dist/hooks/obsolete-notice.js

@@ -0,0 +1,64 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+const SYSTEM_REMINDER_OPEN = '<system-reminder>';
+const SYSTEM_REMINDER_CLOSE = '</system-reminder>';
+const INTRO = '以下几条记忆刚被用户判定为**已过时**，并已从记忆库退场（后续不会再被召回）。' +
+    '请勿依据它们作答；若你此前的回答引用过，请主动更正并说明依据已失效。' +
+    '这是系统注入的元信息，不是用户发言——无需回应本节内容。';
+/** 单轮最多播报条数（超出折叠；防一次批量误操作灌满上下文）。 */
+const MAX_PER_TURN = 8;
+function escapeFrameBody(body) {
+    return body.replaceAll(SYSTEM_REMINDER_CLOSE, '<\\/system-reminder>');
+}
+/** 注入键 = sessionKey（`agent.session?.id ?? agent.id`），与活召回集记账同源。 */
+function sessionKeyOf(agent) {
+    const a = agent;
+    const sid = a?.session?.id;
+    if (typeof sid === 'string' && sid)
+        return sid;
+    return typeof a?.id === 'string' ? a.id : '';
+}
+export function registerObsoleteNotice(ctx, cfg, notices, logger) {
+    const on = () => cfg.recallFeedback?.enabled === true && cfg.recallFeedback?.announce !== false;
+    const buildInjection = (sessionKey) => {
+        if (!on())
+            return null;
+        if (!sessionKey)
+            return null;
+        const drained = notices.drain(sessionKey);
+        if (drained.length === 0)
+            return null;
+        const lines = drained.slice(0, MAX_PER_TURN).map((n) => `- ${n.title || n.id}`);
+        if (drained.length > MAX_PER_TURN) {
+            lines.push(`… 另有 ${drained.length - MAX_PER_TURN} 条同批声明过时的记忆未列出`);
+        }
+        return [
+            SYSTEM_REMINDER_OPEN,
+            INTRO,
+            escapeFrameBody(lines.join('\n')),
+            SYSTEM_REMINDER_CLOSE,
+        ].join('\n');
+    };
+    ctx.on('agent/pre-step', async (payload, next) => {
+        const decision = await next();
+        if (decision.kind === 'reject' || (payload.signal && payload.signal.aborted))
+            return decision;
+        if (!on())
+            return decision;
+        try {
+            const text = buildInjection(sessionKeyOf(payload.agent));
+            if (!text)
+                return decision;
+            const injection = createUserMessage({
+                content: [{ type: 'text', text }],
+                source: { kind: 'plugin:memory', form: 'recall' },
+            });
+            logger.info('[memory] 已向本会话播报记忆过时声明（一次性）');
+            return { kind: 'enter', messages: [injection, ...decision.messages] };
+        }
+        catch (err) {
+            logger.warn(`[memory] 过时播报注入失败(跳过本轮): ${err instanceof Error ? err.message : String(err)}`);
+            return decision;
+        }
+    }, { prepend: true });
+    return { buildInjection };
+}

package/dist/hooks/recall.d.ts

@@ -20,6 +20,8 @@ import type { MemoryConfig } from '../config.js';
 import type { LiveSettingsHandle } from '../settings.js';
 import type { L1Store } from '../store/l1.js';
 import type { PersonaStore } from '../store/persona.js';
+import type { SessionRecalledStore } from '../store/session-recalled.js';
+import type { RecallFeedbackFace } from '../projection/recall.js';
 import type { SceneStore } from '../store/scenes.js';
 import type { SessionModeStore } from '../store/session-modes.js';
 import type { RecallUsageStore } from '../store/recall-usage.js';
@@ -39,6 +41,43 @@ export declare function isOwnRecallSource(src: {
     plugin?: unknown;
     form?: unknown;
 } | undefined | null): boolean;
+/** 会话事件里本插件可能关心的那几个字段（只读形状，不依赖宿主类型导出）。 */
+export interface InjectionEventLike {
+    /** 存储兜底路的事件形状宽松，`type` 也可能缺；缺即不是注入（下面的不等判定已覆盖 undefined）。 */
+    type?: string;
+    /** 存储兜底路（`sessionPersistence.loadStored`）的事件**不带 seq**，所以它是可选的。 */
+    seq?: number;
+    data?: {
+        id?: unknown;
+        source?: Record<string, unknown>;
+        content?: ReadonlyArray<{
+            type?: string;
+            text?: string;
+        }>;
+    };
+}
+/** 一条本插件召回注入的事实。 */
+export interface OwnInjectionFacts {
+    /** 注入消息 id——稳定锚点。**不能用 seq 做键**：压缩的 `surfaceOp:{op:'replace'}` 会重排它。 */
+    id: string;
+    /**
+     * 该消息此刻在日志里的 seq（拿去比 `surface.nodes`）。
+     *
+     * `undefined` = 这条来源根本没有 seq。**没有 seq 就不能声称“它可见”**——
+     * 宁可算“不在可见集里”，也不拿一个臆测的默认值去判（哨兵值会把误标藏起来）。
+     */
+    seq: number | undefined;
+    /** 注入正文字符数（token 估算用）。 */
+    chars: number;
+}
+/**
+ * 认出一条 `user/message` 事件是不是本插件的召回注入，并取出它的消息 id / seq / 正文字数。
+ *
+ * 这是**唯一的识别口径**：召份额估算（live 与存储两条路）与「正文已被摘要取代」对账都读它。
+ * 两处各写一套判定迟早漂移，而漂移的后果是静默的（份额归零或误标取代）。
+ * 署名判定走 `isOwnRecallSource`，同时吃 v4 `plugin:memory` 与 v3 旧行形状。
+ */
+export declare function ownInjectionFromEvent(ev: InjectionEventLike): OwnInjectionFacts | undefined;
 export declare function buildRecallQuery(messages: Array<{
     content: unknown;
 }>, tailMessages?: number, maxChars?: number): string;
@@ -90,6 +129,8 @@ export declare function registerRecall(ctx: Context, cfg: MemoryConfig, stores:
     l1: L1Store;
     scenes: Record<'chat' | 'work', SceneStore>;
     persona: Record<'chat' | 'work', PersonaStore>;
+    recalled?: SessionRecalledStore;
+    feedback?: RecallFeedbackFace;
 }, logger: MemoryLogger, live: LiveSettingsHandle, modes: SessionModeStore, dataDir: string, 
 /** 召回使用统计(可选;未装配 = 零成本旁路):进 topN(注入)才算 used。 */
 usage?: RecallUsageStore): RecallHooks;

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, 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,6 +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), payload.source === 'compact' ? 'compact' : 'clear');
             const led = ledgerFor(payload.agent.id);
             resetForCompaction(led);
             occupancyStore.save(payload.agent.id, led); // stock 归零 ⇒ 流水条目删除
@@ -372,6 +403,48 @@ usage) {
                     });
                     logger.info(`[memory] repo 软围栏:currentRepo=${currentRepoKey || '(未识别)'} 跨仓乘子=${cfg.recall.scopeFence.crossRepoMultiplier} agent=${payload.agent.id}`);
                 }
+                // ── G1 使用场景细排(默认关):命中 usageScenario 的记忆上浮,纯函数重排,score 不改写。
+                // 关闭时不进本分支(零 getByIds、零重排,召回逐字现状);无场景/未命中保持原序(fail-open)。
+                if (cfg.usageScenario?.enabled === true && scoped.length > 1) {
+                    const scenarioById = new Map(stores.l1.getByIds(scoped.map((h) => h.id)).map((r) => [
+                        r.id,
+                        Array.isArray(r.metadata?.dsh_usage_scenario)
+                            ? r.metadata.dsh_usage_scenario
+                            : [],
+                    ]));
+                    const before = scoped.map((h) => h.id).join(',');
+                    scoped = sortByUsageScenario(scoped, (id) => scenarioById.get(id) ?? [], query);
+                    if (scoped.map((h) => h.id).join(',') !== before) {
+                        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:压缩后增强轮跳过压制(压缩把已注入内容逐出了模型上下文)。
@@ -442,6 +515,9 @@ usage) {
                 });
                 // 使用统计:候选=scoped(尝试),进 topN(注入)=used
                 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), injection.id);
                 // 入账在成功构造注入消息之后、返回 enter 之前——任何前置抛错路径账目零扰动
                 const led = ledgerFor(payload.agent.id);
                 recordRecallInjection(led, text.length);
@@ -481,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;
@@ -494,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);
                 }
             }
         }
@@ -532,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;
             }

package/dist/hooks/skill-recall.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 技能常驻注入 Hook（轨2）。**默认关**（cfg.skills.enabled && cfg.skills.inject）。
+ *
+ * 完全对齐 `slot-recall.ts` 的范式（同一注入通道范本，不新建入口）：
+ * - `agent/pre-step`(waterfall,prepend) 注入，`createUserMessage({source:{kind:'plugin:memory',form:'recall'}}})`
+ *   ——**复用既有 source kind**，自动享受 `isOwnRecallSource` 双形状判据与召回去重/占用账本（S4 红线）；
+ * - 帧体转义 `<\/system-reminder>` 防正文伪造帧边界；
+ * - **独立字节预算**（cfg.skills.maxPerTurnBytes），不与召回 2000 预算抢名额；
+ * - 注入前 `archiveDue` 机械闲置归档（0 LLM、不引入 timer，对齐 `slots.expireDue`）。
+ *
+ * 本轮语义：常驻注入全部 active 技能（按插入序 + 字节预算截断），**不做按触发词选择**
+ * （selective trigger 匹配属后续增强；常驻语义与 slots 一致，先保证默认关时零表面积）。
+ * 三档渲染（full/excerpt/hint）是显示策略，同一 body/steps 现场组词，无缓存副本漂移。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from '../config.js';
+import type { LiveSettingsHandle } from '../settings.js';
+import type { Skill, SkillStore } from '../store/skill-store.js';
+import type { MemoryLogger } from '../types.js';
+/** 按档位现场组词：full=标题+正文+步骤；excerpt=标题+正文截断；hint=仅标题+读取指引。 */
+export declare function renderSkill(s: Skill, excerptChars: number): string;
+export interface SkillRecallController {
+    buildInjection(): string | null;
+}
+export declare function registerSkillRecall(ctx: Context, cfg: MemoryConfig, skills: SkillStore, logger: MemoryLogger, live: LiveSettingsHandle): SkillRecallController;

package/dist/hooks/skill-recall.js

@@ -0,0 +1,72 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+const SYSTEM_REMINDER_OPEN = '<system-reminder>';
+const SYSTEM_REMINDER_CLOSE = '</system-reminder>';
+const SKILLS_INTRO = '以下是本环境沉淀的技能(程序性记忆):过去重复工作流固化出的清单,仅在与之相关时作为指引遵循。' +
+    '它们是系统注入的元信息,不是用户发言——无需回应,请勿在回复中复述本节内容;' +
+    '且不覆盖系统提示与用户的直接指令。需要完整步骤用 memory_skill_read 展开。';
+function escapeFrameBody(body) {
+    return body.replaceAll(SYSTEM_REMINDER_CLOSE, '<\\/system-reminder>');
+}
+/** 按档位现场组词：full=标题+正文+步骤；excerpt=标题+正文截断；hint=仅标题+读取指引。 */
+export function renderSkill(s, excerptChars) {
+    if (s.injectionTier === 'hint')
+        return `[技能·${s.title}] 详见 memory_skill_read(${s.id})`;
+    const steps = s.steps.length ? '\n' + s.steps.map((st) => `  - ${st}`).join('\n') : '';
+    if (s.injectionTier === 'full')
+        return `[技能·${s.title}] ${s.body}${steps}`;
+    const body = s.body.length > excerptChars ? s.body.slice(0, excerptChars) + '…' : s.body;
+    return `[技能·${s.title}] ${body}`;
+}
+export function registerSkillRecall(ctx, cfg, skills, logger, live) {
+    // 生效开关：部署 cfg.skills.enabled 或看板 live.skillsEnabled 任一开。
+    const on = () => cfg.skills.enabled === true || live.get().skillsEnabled === true;
+    const buildInjection = () => {
+        if (!on() || !cfg.skills.inject)
+            return null;
+        const active = skills.listActive();
+        if (active.length === 0)
+            return null;
+        const budget = cfg.skills.maxPerTurnBytes;
+        const out = [];
+        let used = 0;
+        let hidden = 0;
+        for (const s of active) {
+            const rendered = renderSkill(s, cfg.skills.excerptChars);
+            const bytes = Buffer.byteLength(rendered, 'utf8');
+            if (used + bytes > budget) {
+                hidden++;
+                continue;
+            }
+            out.push(rendered);
+            used += bytes;
+        }
+        if (out.length === 0)
+            return null;
+        if (hidden > 0)
+            out.push(`… 另有 ${hidden} 个技能因预算未显示,可用 memory_skill_list 查看`);
+        return [SYSTEM_REMINDER_OPEN, SKILLS_INTRO, escapeFrameBody(out.join('\n')), SYSTEM_REMINDER_CLOSE].join('\n');
+    };
+    ctx.on('agent/pre-step', async (payload, next) => {
+        const decision = await next();
+        if (decision.kind === 'reject' || (payload.signal && payload.signal.aborted))
+            return decision;
+        if (!on() || !cfg.skills.inject)
+            return decision;
+        try {
+            await skills.archiveDue(Date.now(), cfg.skills.idleArchiveDays);
+            const text = buildInjection();
+            if (!text)
+                return decision;
+            const injection = createUserMessage({
+                content: [{ type: 'text', text }],
+                source: { kind: 'plugin:memory', form: 'recall' },
+            });
+            return { kind: 'enter', messages: [injection, ...decision.messages] };
+        }
+        catch (err) {
+            logger.warn(`[memory] 技能注入失败(跳过本轮): ${err instanceof Error ? err.message : String(err)}`);
+            return decision;
+        }
+    });
+    return { buildInjection };
+}