dsh-prime-memory 0.22.2 → 0.24.0

package/dist/config.js

@@ -32,7 +32,7 @@ export function liveSettingsSchema() {
         model: Schema.string().default(''),
         reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
     });
-    return Schema.object({
+    const node = Schema.object({
         enabled: Schema.boolean().default(true),
         capture: Schema.boolean().default(true),
         distill: Schema.boolean().default(true),
@@ -78,7 +78,13 @@ export function liveSettingsSchema() {
         toolRuminate: Schema.boolean().default(true),
         toolConflict: Schema.boolean().default(true),
         toolMutate: Schema.boolean().default(true),
-    }).volatile();
+    });
+    // 探测后再标：`Schema.object(...).volatile()` 只在新版 schemastery 上有（格内实测：
+    // cordis/schemastery 4.0.4 有、0.1.5-rc.3 解析到的 4.0.2 没有）。直接调用会让**整插件**
+    // 在老线 load-failure——不是降级，是起不来。未标时读侧走 readLiveRef 的兜底路径：
+    // 开关仍然生效（取宿主注入的冻结值），只是改值需要重启而不是热更。
+    const maybe = node;
+    return (typeof maybe.volatile === 'function' ? maybe.volatile() : node);
 }
 export const memorySchema = Schema.object({
     dataDir: Schema.string().default(''),
@@ -154,13 +160,83 @@ export const memorySchema = Schema.object({
         maxRecords: Schema.number().min(1).max(10_000).default(300),
         timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
     }),
+    /**
+     * 内容路由：默认**开**（用户口径：谈到本仓/dsh 生态的记忆要归到本仓 workspace，
+     * 而不是全托底到 `<dataDir>/memories`）。默认路由表就是用户给的两条归类规则（路径可改，不需改码）。
+     */
+    workspaceSource: Schema.object({
+        enabled: Schema.boolean().default(true),
+        routes: Schema.array(Schema.object({
+            /**
+             * 归到哪个 workspace（**workspace 根**，绝对路径；写入前过 normalizeWorkspacePath）。
+             *
+             * 存的不包含 `.agents/memory`：投射落点由 `targetFor` 算，它会在本值后拼上
+             * `WORKSPACE_SUBDIR = ['.agents','memory']`。旧默认值把它写成了
+             * `E:\test\rewrite-agently\.agents`，于是落点变成 `.agents\.agents\memory\`——
+             * 而 `.agents` 目录确实存在，"目录不存在则退回单根"的护栏救不了这种形状，
+             * 等于在仓里挂一棵没人认领的孤儿树。新增用例钉住这个不变式。
+             */
+            path: Schema.string().default(''),
+            /** 命中任一关键词即归此路（小写子串匹配，已 NFKC 归一）。 */
+            anyOf: Schema.array(Schema.string()).default([]),
+            /** 出现任一排除词则此路不命中（用于「无 dsh 才算非 dsh 项目」）。 */
+            noneOf: Schema.array(Schema.string()).default([]),
+        })).default([
+            {
+                path: 'E:\\test\\rewrite-agently',
+                // 'dsh' 子串已覆盖 mine-dsh-plugins 下所有插件名；把目录名单列出来是因为
+                // 有些记忆只写了"某个插件"而没写 dsh- 前缀，那时这一项才顶用。
+                anyOf: ['dsh', 'mine-dsh-plugins', 'cordis', 'prime-memory', 'brief-sidebar', 'host farm', 'inferglow-dsh'],
+                noneOf: [],
+            },
+            {
+                path: 'E:\\test\\agent-no-dsh',
+                anyOf: ['hanako', 'hanaagent', 'openhanako', 'inferglow', 'pi-agent'],
+                // 同一段内容又谈到 dsh 时属于 dsh 生态（如 Hanako 逆向用于反推 dsh 机制），归 dsh 侧。
+                noneOf: ['dsh'],
+            },
+        ]),
+        maxRecords: Schema.number().min(1).max(10_000).default(300),
+        timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
+    }),
+    // md 投射与外部存档：**默认开**（写盘不影响检索，关掉只会让人看不到任何投影文件）。root 空串 = 用默认根（<dataDir>/memories），形状校验在投射器里做。
+    memExport: Schema.object({
+        enabled: Schema.boolean().default(true),
+        root: Schema.string().default(''),
+        maxRecords: Schema.number().min(1).max(10_000).default(300),
+        timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
+    }),
+    // P2 反向同步：默认关。文件数护栏比导出的条数护栏宽一些——一次目录扫描的代价
+    // 低于一次全库渲染，但时间预算照同一口径（面板不能被卡住）。
+    mdSync: Schema.object({
+        enabled: Schema.boolean().default(false),
+        maxFiles: Schema.number().min(1).max(20_000).default(2_000),
+        timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
+    }),
     // 使用场景（G1）：默认关；开时抽取 prompt 追加 usageScenario 指令（off 逐字不变）。
     usageScenario: Schema.object({
         enabled: Schema.boolean().default(false),
     }),
-    // 类型叙述模板（G2）：默认关；开时抽取 prompt 追加分类型 content 骨架（off 逐字不变）。
+    // 类型叙述模板（G2）：默认**开**；开时抽取 prompt 追加分类型 content 骨架（关时仍逐字不变）。
+    // 默认值从关改开的理由写在上方接口注释：只给定义实测骨架齐备 0/23，
+    // 而"没前因后果就不算可用"是用户定的判据，所以默认值要按可用性定而不是按保守定。
     narrativeTemplates: Schema.object({
-        enabled: Schema.boolean().default(false),
+        enabled: Schema.boolean().default(true),
+    }),
+    // 名称蒸馏（Phase 3）。两个开关的默认值都来自 A/B 实测，不是审美偏好：
+    // `ab-distill.mjs`（真会话）+0.703 骨架齐备 → 默认开；`ab-naming.mjs`（存量改名）
+    // −0.113 → 证明示例不能跨任务复用，所以抽取提示里的那段不注入命名脚本。
+    naming: Schema.object({
+        enabled: Schema.boolean().default(true),
+        fewShot: Schema.boolean().default(true),
+    }),
+    // 召回相关度反馈：默认开（只新增写端点与播报，不改任何既有产物；播报需用户显式打 -1）。
+    recallFeedback: Schema.object({
+        enabled: Schema.boolean().default(true),
+        announce: Schema.boolean().default(true),
+        // 低分沉底/高分上浮默认开（这是打分的常规出口）；0 分硬剔除默认关。
+        affectRank: Schema.boolean().default(true),
+        excludeZero: Schema.boolean().default(false),
     }),
     recall: Schema.object({
         enabled: Schema.boolean().default(true),

package/dist/conflict-service.d.ts

@@ -47,6 +47,10 @@ export interface ConflictListDeps {
     };
     /** 时效半衰期（天）；≤0 = 衰减关 → aging 视为 null。 */
     decayHalfLifeDays?: number;
+    /** 人工打分面（可选）：成熟度旁注要吃“最近一笔”，与面板/召回同一口径。 */
+    feedback?: {
+        lastOf(id: string): number | undefined;
+    };
 }
 /**
  * 列出待裁决对。

package/dist/conflict-service.js

@@ -171,7 +171,12 @@ export function listConflictPairs(deps, opts = {}) {
         const aging = halfLife > 0
             ? Math.max(0.5, Math.pow(0.5, Math.max(0, (Date.now() - (updatedAtById.get(id) ?? 0)) / 86_400_000) / halfLife))
             : null;
-        return computeMaturity({ priority: priorityById.get(id) ?? 60, usage: deps.usage?.get(id) ?? null, agingWeight: aging });
+        return computeMaturity({
+            priority: priorityById.get(id) ?? 60,
+            usage: deps.usage?.get(id) ?? null,
+            agingWeight: aging,
+            mark: deps.feedback?.lastOf(id) ?? null,
+        });
     };
     const items = pending.map((p) => {
         const w = axisOf(p.winnerId);

package/dist/contract.d.ts

@@ -363,6 +363,39 @@ export interface DownloadProgress {
 /** 嵌入源活切换阶段。 */
 export type ApplyPhase = 'idle' | 'installing-runtime' | 'warming' | 'switching' | 'reindexing' | 'done' | 'error';
 /** 重嵌入进度。 */
+/**
+ * 一轮重建跑完后的留痕。
+ *
+ * 为什么必需：进度条只在 `running` 期间存在，而“待补 0 条”的重建会**瞬间跑完**
+ * （l1Total/l0Total 都是 0），界面与“点了什么也没发生”长得一模一样。真机反馈原话就是
+ * “重建索引无法观察进度无进度条、索引重设的效果无法确认”——缺的不是进度，是事后凭证。
+ * 所以这里同时存**重建前后的待补数**：效果就是这两个数的差，不是“我看它转了一下”。
+ */
+export interface ReindexRunSummary {
+    /** 完成时刻(ms epoch)；0 = 从未跑过。 */
+    finishedAt: number;
+    /** 从 startedAt 到完成的毫秒数。 */
+    durationMs: number;
+    /** 本轮实际重嵌条数（L1 + L0 完成数之和）。 */
+    processed: number;
+    /** 两层计划总数（为 0 就是“无事可做”，这不是失败而是本来就同步好了）。 */
+    planned: number;
+    /** 嵌入失败条数（进 skip 集的那些）。 */
+    failed: number;
+    cancelled: boolean;
+    /** 抛出来的整体错误（单层失败不在这里，在 failed 里）。 */
+    error?: string;
+    /** 重建**前**的待补数（-1 = 向量能力不可用）。 */
+    missingBefore: {
+        l1: number;
+        l0: number;
+    };
+    /** 重建**后**的待补数。 */
+    missingAfter: {
+        l1: number;
+        l0: number;
+    };
+}
 export interface ReindexProgressState {
     running: boolean;
     l1Done: number;
@@ -372,6 +405,8 @@ export interface ReindexProgressState {
     startedAt: number;
     cancelled: boolean;
     error?: string;
+    /** 上一次重建的结果（从未跑过则缺省）。 */
+    last?: ReindexRunSummary;
 }
 /** 嵌入源状态视图(embedding-state-get 端点的主体)。 */
 export interface EmbeddingStateView {
@@ -799,6 +834,12 @@ export interface UiRecord {
     retired?: boolean;
     /** 退场原因:`conflict`(裁决) / `superseded`(取代) / `manual`(人工) / `unknown`。未退场为 null。 */
     retiredReason?: string | null;
+    /**
+     * 「正文已被摘要取代」：压缩发生时这条还在本会话召回列表里，它的正文已不在模型上下文。
+     * 与 `retired` **正交**——退场讲“人有没有对它下过裁决”，取代讲“正文还在不在上下文”。
+     * 只在 `dsh-memory/session-recalled` 这条路径上有意义；缺省 = 无此概念（旧服务端）。
+     */
+    superseded?: boolean;
     /**
      * 成熟度(G3 读时派生):priority + 被用次数 + 老化权重合成。
      * 可选字段——旧 client 忽略=向后兼容；不参与存储/快照（纯投影）。
@@ -806,6 +847,11 @@ export interface UiRecord {
     maturity?: 'low' | 'mid' | 'high';
     /** 使用场景（G1）：从 metadata.dsh_usage_scenario 读出；功能关/无则 undefined。 */
     usageScenario?: string[];
+    /**
+     * 人给的相关度均值(0..5)；从未被 0..5 打过分为 undefined（**缺席 ≠ 0 分**）。
+     * 读时从 recall-feedback sidecar 派生，不进存储/快照。
+     */
+    userRelevance?: number;
 }
 export interface ListRecordsResponse {
     items: UiRecord[];
@@ -832,6 +878,14 @@ export interface ListRecordsResponse {
         id: string;
         label: string;
     }>;
+    /**
+     * 类型词表目录（pm-name-distill task_1.5：词表单一真源随首屏下发，client 不再手抄
+     * `TYPE_LABELS`；仅 offset===0 时附带）。缺省（旧服务端）时 client 降级显示 type 原值。
+     */
+    typeCatalog?: Array<{
+        id: string;
+        label: string;
+    }>;
 }
 /** dsh-memory/records-delete(面板高权限退场指定记忆;须 memoryMutate 开启)。 */
 export interface RecordsDeleteRequest {
@@ -892,6 +946,30 @@ export interface CleanupRetiredRequest {
 }
 export interface CleanupRetiredResponse {
     dryRun: boolean;
+    /**
+     * 待删/已删清单预览（最多 50 条）。
+     *
+     * `targets` 只是一个计数，人无法从计数判断“这批是不是该删的那批”——物理删除不可逆，
+     * 干跑报告必须能抽看内容。取前 50 条而不是全量：全量会把面板撑爆，而判据只需抽看。
+     */
+    items?: Array<{
+        id: string;
+        name: string;
+        type: string;
+        retiredAt: string;
+    }>;
+    /** 本批之外发生漂移的记录数（只计数、**不中止**）。 */
+    otherChanged?: number;
+    /** 归档正文 `retired.md` 路径（未写 = 空串）。 */
+    archiveMd?: string;
+    /** 投射文件搬运计数（N12；投射面关着时全 0）。 */
+    files?: {
+        moved: number;
+        failed: number;
+        absent: number;
+    };
+    /** 图投影索引表里一并抹掉的行数（F19；图面未装配或不该动时为 0）。 */
+    graphForgotten?: number;
     /** 本次涉及(干跑)或实际处理(真跑)的条数。 */
     targets: number;
     /** 真正物理删除的条数(干跑恒为 0;中止恒为 0)。 */
@@ -1419,6 +1497,112 @@ export interface SessionRecalledResponse {
     sessionId: string;
     /** 按召回插入序（旧→新）；复用 UiRecord（含 maturity/usageScenario）。 */
     records: UiRecord[];
+    /** 词表目录（pill 与面板同源取标签；见 `ListRecordsResponse.typeCatalog`）。 */
+    typeCatalog?: Array<{
+        id: string;
+        label: string;
+    }>;
+}
+/**
+ * dsh-memory/recall-feedback（人在召回卡上打分）。
+ *
+ * 语义边界：`0..5` = 人给的相关度（只聚合、不改写任何排序分）；`-1` = 声明过时，
+ * 服务端会顺手做三件事——退场该记录（软删，可 `records-restore` 恢复）、从本会话
+ * 活召回集摘掉、把“已向模型播报”入队（下一轮一次性告知）。
+ */
+export interface RecallFeedbackRequest {
+    sessionId: string;
+    /** 被打分的那条召回记录 id（必须是本会话活召回集里的，否则拒）。 */
+    id: string;
+    /** -1 或 0..5。 */
+    score: number;
+}
+export interface RecallFeedbackResponse {
+    id: string;
+    score: number;
+    /** 聚合后的反馈条目。 */
+    rating: {
+        last: number;
+        rated: number;
+        mean: number;
+        obsolete: number;
+    };
+    /** 本次是否触发了退场(仅 score=-1)。 */
+    retired: boolean;
+    /** 退场后是否已排入下一轮向模型播报(仅 score=-1 且 cfg.recallFeedback.announce)。 */
+    announced: boolean;
+    /**
+     * 失效联动（N11）的文件侧结果，仅当 `score === -1`、真退场且 `cfg.memExport.enabled` 时出现：
+     * `renamed`（投射文件已改名 `.memory.md.disable`）/ `created`（本来没导出过，新建了凭证）/
+     * `already`（早就是 `.disable`）/ `no-workspace`（归属不明，**没动任何文件**）/ `failed`。
+     * 缺席 = 本次未走文件联动（功能关着或账本未装配）；它不影响 `retired`，退场已成立。
+     */
+    fileDisabled?: string;
+}
+/**
+ * dsh-memory/mem-export / mem-reconcile：md 投射的导出与对账（P1 + N8/N9）。
+ *
+ * 两个都无入参（护栏条数/墙钟来自 config），响应形状直接取存储层的报告类型
+ * ——同一事实源，避开“契约手抄一份然后与实现漂移”。
+ *
+ * 写面要说准：**对账什么都不写**；**导出写文件、写账本，并会回填一次 `l1_records.name`**
+ * （给没名字的记录派生全库唯一的文件身份名，计数在 `named`/`nameFailed`）。那一步只改
+ * `name`：内容、类型、退场态、检索面一律不动，而 `name` 不在 `canonicalRecords` 的快照
+ * 哈希字段表里，所以“导出不得改变库内容”这条护栏仍成立——但“导出不碰库”不成立。
+ */
+export type MemExportRequest = Record<string, never>;
+export type MemExportResponse = import('./store/memory-md-types.js').MemExportResponse;
+export type MemReconcileRequest = Record<string, never>;
+export type MemReconcileResponse = import('./store/memory-md-types.js').ReconcileReport;
+/**
+ * dsh-memory/mem-sync：P2 反向同步（md 文件 → 索引）。
+ *
+ * 与 `mem-reconcile` 的区别是风险不对称：对账**什么都不写**，同步**会写库**（回灌
+ * 文件侧修改、把 `.disable` 对应的记录退场）。所以服务端除了配置门还要高权限门。
+ * 两边都变的那批**两侧都不动**，只在 `pending` 里挂账等人裁决。
+ */
+export type MemSyncRequest = Record<string, never>;
+export type MemSyncResponse = import('./store/memory-md-types.js').MdSyncReport;
+/**
+ * dsh-memory/mem-orphans：P4.4 孤儿投射文件归档。
+ *
+ * 只搬“**账本记着我们写过、但现在没记录映射到这个路径**”的文件（改名/消歧/物理删除都会
+ * 留下这种残片）。账本里没有的来路不明文件**一律不动**——那可能是人放进投射目录等着
+ * 被同步进来的输入。
+ *
+ * `dryRun` **省略即 true**：搬文件在用户眼里与删文件差不离，必须显式要；真搬还需要高权限模式。
+ */
+export interface MemOrphansRequest {
+    dryRun?: boolean;
+}
+export type MemOrphansResponse = import('./store/memory-md-types.js').OrphanReport;
+/**
+ * dsh-memory/workspace-relink：按内容路由把存量记忆归到 workspace。
+ *
+ * 只写 `workspace_id` 列——**不改 `scope`**，所以可见性今天一行不变
+ * （`isScopeVisible` 先看 scope，global 即全可见）；`workspace_id` 不在
+ * `canonicalRecords` 快照哈希字段表里，因此回填不会让旧快照失配。
+ */
+export interface WorkspaceRelinkRequest {
+    /** 缺省 true（干跑）：只看报告不写库。给 `false` 才真写（需高权限）。 */
+    dryRun?: boolean;
+}
+export interface WorkspaceRelinkResponse {
+    dryRun: boolean;
+    /** 本次扫过的记录数（含未命中）。 */
+    scanned: number;
+    /** 路由命中的记录数。 */
+    matched: number;
+    /** 归属已是目标值（幂等重跑时等于 matched）。 */
+    unchanged: number;
+    /** 干跑时“若真跑会写多少条”；真写时恒为 0。 */
+    toWrite: number;
+    /** 实际写入条数（干跑恒 0）。 */
+    written: number;
+    /** 未扫到、下次触发续扫的条数。 */
+    remaining: number;
+    /** 命中记录按归属分布——拿它判断路由表合不合口味。 */
+    byWorkspace: Record<string, number>;
 }
 export interface DshMemoryRequestMap {
     'dsh-memory/stats': Record<string, never>;
@@ -1473,6 +1657,12 @@ export interface DshMemoryRequestMap {
     'dsh-memory/memport-scan': MemportScanRequest;
     'dsh-memory/skills-list': Record<string, never>;
     'dsh-memory/session-recalled': SessionRecalledRequest;
+    'dsh-memory/recall-feedback': RecallFeedbackRequest;
+    'dsh-memory/workspace-relink': WorkspaceRelinkRequest;
+    'dsh-memory/mem-export': MemExportRequest;
+    'dsh-memory/mem-reconcile': MemReconcileRequest;
+    'dsh-memory/mem-sync': MemSyncRequest;
+    'dsh-memory/mem-orphans': MemOrphansRequest;
     'dsh-memory/skills-action': SkillsActionRequest;
 }
 export interface DshMemoryResponseMap {
@@ -1528,6 +1718,12 @@ export interface DshMemoryResponseMap {
     'dsh-memory/memport-scan': MemportScanResponse;
     'dsh-memory/skills-list': SkillsListResponse;
     'dsh-memory/session-recalled': SessionRecalledResponse;
+    'dsh-memory/recall-feedback': RecallFeedbackResponse;
+    'dsh-memory/workspace-relink': WorkspaceRelinkResponse;
+    'dsh-memory/mem-export': MemExportResponse;
+    'dsh-memory/mem-reconcile': MemReconcileResponse;
+    'dsh-memory/mem-sync': MemSyncResponse;
+    'dsh-memory/mem-orphans': MemOrphansResponse;
     'dsh-memory/skills-action': SkillsActionResponse;
 }
 /** 全部端点名(client 调用与 host case 表的共用字面量来源)。 */

package/dist/domain-gate.d.ts

@@ -55,3 +55,14 @@ export declare function sortByDomainWeight<T extends {
 export declare function sortByUsageScenario<T extends {
     id: string;
 }>(hits: readonly T[], scenariosOf: (id: string) => readonly string[], query: string): T[];
+/**
+ * 人工打分参与排序（纯重排、**score 不改写**）：4/5 上浮、0/1/2 下沉。
+ *
+ * 三条约束：
+ * - 同档内保持进入顺序（稳定排序），所以不会推翻 scopeFence / 场景细排的结果；
+ * - **未打分与 3 分同为中性**（fail-open），全部未打分时输出与输入逐字同序；
+ * - 判据是**最近一笔**而非均值——用户改主意的路径必须存在（先 5 后 0 应当下沉）。
+ */
+export declare function sortByHumanMark<T extends {
+    id: string;
+}>(hits: readonly T[], markOf: (id: string) => number | undefined): T[];

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 = [
@@ -179,3 +180,17 @@ export function sortByUsageScenario(hits, scenariosOf, query) {
         .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/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

@@ -21,6 +21,7 @@ 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';
@@ -40,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;
@@ -92,6 +130,7 @@ export declare function registerRecall(ctx: Context, cfg: MemoryConfig, stores:
     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;