dsh-prime-memory 0.16.1 → 0.16.4

package/dist/config.d.ts

@@ -28,6 +28,21 @@ export interface MemoryConfig {
         stripCodeBlocks: boolean;
         /** 单条消息内容最大字符数。 */
         maxMessageChars: number;
+        /**
+         * §C 载荷脱敏(memorax-absorb):捕获单点把 8 类密钥(PEM/Bearer/JWT/Cookie/
+         * 厂商 API key/邮箱/长号/高熵 ID)替换为 `[REDACTED:<KIND>]` 占位符,覆盖
+         * L0 JSONL/SQLite/蒸馏输入与手动 memory_add/import。**默认开启**——密钥被
+         * 逐轮召回注入的危害大于偶发误脱敏;注意开启后 L0 原文自此改变(重建不可得原文)。
+         * 决策记录见计划 spec §C;`false` 一键回到明文行为。 */
+        redactSecrets?: boolean;
+    };
+    /** §F 结构化追踪(memorax-absorb):recall/distill 事件按天 JSONL。 */
+    trace: {
+        enabled: boolean;
+        /** 事件文件保留天数(写入时切日清理;0 = 永久)。 */
+        retentionDays: number;
+        /** 默认 metadata-only(chars+sha);true 才存 query 原文(≤200 字符)。 */
+        captureContent: boolean;
     };
     extract: {
         enabled: boolean;
@@ -196,10 +211,21 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
         stripCodeBlocks: Schema<boolean, boolean>;
         maxMessageChars: Schema<number, number>;
+        redactSecrets: Schema<boolean, boolean>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         stripCodeBlocks: Schema<boolean, boolean>;
         maxMessageChars: Schema<number, number>;
+        redactSecrets: Schema<boolean, boolean>;
+    }>>;
+    trace: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        retentionDays: Schema<number, number>;
+        captureContent: Schema<boolean, boolean>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        retentionDays: Schema<number, number>;
+        captureContent: Schema<boolean, boolean>;
     }>>;
     extract: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
@@ -480,10 +506,21 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
         stripCodeBlocks: Schema<boolean, boolean>;
         maxMessageChars: Schema<number, number>;
+        redactSecrets: Schema<boolean, boolean>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         stripCodeBlocks: Schema<boolean, boolean>;
         maxMessageChars: Schema<number, number>;
+        redactSecrets: Schema<boolean, boolean>;
+    }>>;
+    trace: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        retentionDays: Schema<number, number>;
+        captureContent: Schema<boolean, boolean>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        retentionDays: Schema<number, number>;
+        captureContent: Schema<boolean, boolean>;
     }>>;
     extract: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;

package/dist/config.js

@@ -26,6 +26,13 @@ export const memorySchema = Schema.object({
         enabled: Schema.boolean().default(true),
         stripCodeBlocks: Schema.boolean().default(true),
         maxMessageChars: Schema.number().min(200).max(200_000).default(4000),
+        // §C 默认开启:本地存储也不落明文密钥(决策记录见计划 spec §C)
+        redactSecrets: Schema.boolean().default(true),
+    }),
+    trace: Schema.object({
+        enabled: Schema.boolean().default(true),
+        retentionDays: Schema.number().min(0).max(365).default(14),
+        captureContent: Schema.boolean().default(false),
     }),
     extract: Schema.object({
         enabled: Schema.boolean().default(true),

package/dist/contract.d.ts

@@ -507,10 +507,91 @@ export interface WingOverviewResponse {
  * 降级/无 tags 时 `rooms` 为空数组(面板显示"暂无"),不报错。
  */
 export interface RoomsGetResponse {
-    /** Room 列表(按记录数降序,同数按名升序)。 */
+    /** Room 列表(按记录数降序,同数按名升序;注册表条目 count=0 并带 source/label)。
+     *  条目可选字段 source/label 由端点层合并注册表后附带(客户端可选读,零断裂)。 */
     rooms: RoomCount[];
     /** Room 总数(= rooms.length,冗余只为前端少写一次 .length)。 */
     total: number;
+    /** 孤儿记忆数:没有任何 Room(tags 为空/缺失)的记录条数(与 rooms 同口径含已退场)。 */
+    orphanCount: number;
+    /** 注册表条目(全量含 retired;分类管理面板用;未装配 = undefined)。 */
+    registry?: Array<{
+        slug: string;
+        label?: string;
+        description?: string;
+        source: 'pre-registered' | 'grown';
+        aliases?: string[];
+        status: 'active' | 'retired';
+    }>;
+}
+/** dsh-memory/room-register(预注册 Room;高权限:面板 memoryMutate 开启才生效)。 */
+export interface RoomRegisterRequest {
+    slug: string;
+    label?: string;
+    description?: string;
+    /** 收编自生长 slug 时传 grown(缺省 pre-registered;已存在条目忽略此字段)。 */
+    source?: 'pre-registered' | 'grown';
+}
+export interface RoomRegisterResponse {
+    slug: string;
+    created: boolean;
+    /** 幂等补全时的提示(如「已存在,只补全缺失字段」)。 */
+    notice?: string;
+}
+/** dsh-memory/rooms-export(分类数据导出,CSV 直出)。 */
+export interface RoomsExportRequest {
+    /** rooms = 词表+计数;orphans = 无 Room 绑定的记录清单;records = 按 Room 的记录清单(tag 必传)。 */
+    kind: 'rooms' | 'orphans' | 'records';
+    /** 各 kind 通用上限(1..10000,默认 2000)。 */
+    limit?: number;
+    /** kind=records 的目标 Room slug。 */
+    tag?: string;
+}
+export interface RoomsExportResponse {
+    kind: 'rooms' | 'orphans' | 'records';
+    /** CSV 文本(首行表头;
+   行尾;RFC 4180 转义)。 */
+    csv: string;
+    /** 数据行数(不含表头)。 */
+    total: number;
+    /** truncated = 达到 limit 上限,结果可能不完整。 */
+    truncated: boolean;
+}
+/** dsh-memory/room-admin(Room 破坏性面管理;高权限:面板 memoryMutate 开启才生效)。 */
+export interface RoomAdminRequest {
+    /** merge/rename:from→to(mergeRoom/renameRoom 编排:预览→实跑+自动备份+入队场景重算);retire:slug 退役/恢复;update:改写 label/description。 */
+    action: 'merge' | 'rename' | 'retire' | 'update';
+    /** update 的显示名(可中文;非空才改写)。 */
+    label?: string;
+    /** update 的归类说明(喂标注器;非空才改写)。 */
+    description?: string;
+    /** merge/rename 的源 Room slug。 */
+    from?: string;
+    /** merge/rename 的目标 Room slug。 */
+    to?: string;
+    /** retire 的目标 Room slug。 */
+    slug?: string;
+    /** retire:true=恢复 active;缺省/false=退役。 */
+    active?: boolean;
+    /** retire:同时把该 room 下全部**活跃**记录退场(软删,可在「已退场」区恢复)。 */
+    withRecords?: boolean;
+    /** merge/rename:缺省 true 只返预览;实跑需显式 false。 */
+    dryRun?: boolean;
+}
+export interface RoomAdminResponse {
+    notice: string;
+    /** merge/rename 本次是否 dryRun(预览)。 */
+    dryRun?: boolean;
+    /** merge/rename 影响的记录条数(实跑 = 已改写条数)。 */
+    affected?: number;
+    /** 预览样例(受影响记录 id 的前几条)。 */
+    preview?: string[];
+    /** true = 超过单次上限,需续跑。 */
+    hasMore?: boolean;
+    /** 实跑时改写前备份文件名(rooms-merge-backups/)。 */
+    backupFile?: string;
+    /** retire withRecords 实际退场的记录条数(软删,可恢复)。 */
+    retiredRecords?: number;
 }
 /** dsh-memory/wing-backfill(一键回填,后台任务;端点立即返回,进度以 wing-overview 轮询)。 */
 export interface WingBackfillResponse {
@@ -650,6 +731,11 @@ export interface ListRecordsRequest {
      * Room 由 tags 派生(自生长),故这里传的是**具体 tag 名**而非枚举 id。
      */
     tag?: string;
+    /**
+     * 孤儿记忆筛选:true = 只列**没有任何 Room(tags 为空/缺失)**的记录。
+     * 与 `tag` 互斥;同传时 `tag` 优先(客户端保证不同传)。
+     */
+    untagged?: boolean;
     /**
      * 退场(软删)筛查:三态。省略 = 全部(活跃+已退场混排,靠 `UiRecord.retired`
      * 徽标区分);`false` = 仅活跃;`true` = 仅已退场。
@@ -686,6 +772,15 @@ export interface UiRecord {
     sourceAnchors: string[];
     /** 检索相关度(列表路径无 score → null)。 */
     score: number | null;
+    /** 老化权重:读路径衰减系数 max(0.5, 0.5^(Δ天/半衰期))(Δ=updatedAt;半衰期 0=关 → null)。 */
+    agingWeight?: number | null;
+    /** 召回使用统计:**进 topN(被注入)才算 used**;参与尝试未进 = 仅 attempts。缺省 = 未装配。 */
+    usage?: {
+        attempts: number;
+        used: number;
+        lastAttemptAt: number | null;
+        lastUsedAt: number | null;
+    } | null;
     /**
      * 是否已退场(软删)。`true` 时该记录在活动列表里仍以「已退场」态呈现(置灰 + 徽标),
      * 可被 `records-restore` 找回——这正是设计要的「不静默消失、可恢复」,而非真删。
@@ -704,6 +799,13 @@ export interface ListRecordsResponse {
     truncated: boolean;
     /** 场景筛选下拉选项(仅 offset===0 时附带)。 */
     scenes?: string[];
+    /** 召回使用汇总(老化权重效果口径:进 topN 才算 used)。未装配 = undefined。 */
+    usageSummary?: {
+        tracked: number;
+        attempted: number;
+        used: number;
+        rate: number;
+    } | null;
     /**
      * Wing 词表(R8 单一事实源:服务端随 list-records 下发,client 不再手抄;仅 offset===0 时附带)。
      * 含 8 角 + `general`(跨域兜底,存量大 reserved 值仍可筛)。缺省(旧服务端)时 client
@@ -913,6 +1015,50 @@ export interface LogTailRequest {
 export interface LogTailResponse {
     lines: string[];
 }
+/** dsh-memory/trace-tail(§F 追踪事件流,memorax-absorb Wave 4) */
+export interface RecallTraceEvent {
+    kind: 'recall_turn';
+    ts: number;
+    sessionId: string;
+    turn?: number;
+    /** metadata-only 默认:query 长度 + sha256 前 16 位;captureContent 才存原文(≤200)。 */
+    queryChars: number;
+    querySha?: string;
+    queryText?: string;
+    hitIds: string[];
+    hitScores: number[];
+    injectedIds: string[];
+    suppressedCount: number;
+    durationMs: number;
+    outcome: 'injected' | 'suppressed' | 'timeout' | 'off';
+}
+export interface DistillTraceEvent {
+    kind: 'distill_run';
+    ts: number;
+    layer: 'l1' | 'l2' | 'l3';
+    sessionId: string;
+    /** 仅 l1 有(与 l1_receipts 同一 runId,可交叉审计)。 */
+    runId?: string;
+    inputChars: number;
+    /** 仅 l1:决策六值词表聚合(store/update/merge/skip/conflict/skip_missing)。 */
+    byKind?: Record<string, number>;
+    newRecords?: number;
+    durationMs: number;
+    provider?: string;
+    model?: string;
+    ok: boolean;
+    errorKind?: string;
+}
+export type TraceEvent = RecallTraceEvent | DistillTraceEvent;
+export interface TraceTailRequest {
+    /** 1~500,默认 100。 */
+    lines?: number;
+    /** 缺省 = 两类都取(按时间混合)。 */
+    kind?: 'recall_turn' | 'distill_run';
+}
+export interface TraceTailResponse {
+    events: TraceEvent[];
+}
 /** dsh-memory/rebuild-* */
 export type RebuildStatusResponse = {
     supported: false;
@@ -1157,6 +1303,9 @@ export interface DshMemoryRequestMap {
     'dsh-memory/session-mode-set': SessionModeSetRequest;
     'dsh-memory/wing-overview': Record<string, never>;
     'dsh-memory/rooms-get': Record<string, never>;
+    'dsh-memory/rooms-export': RoomsExportRequest;
+    'dsh-memory/room-register': RoomRegisterRequest;
+    'dsh-memory/room-admin': RoomAdminRequest;
     'dsh-memory/wing-backfill': Record<string, never>;
     'dsh-memory/session-stats': SessionStatsRequest;
     'dsh-memory/settings-get': Record<string, never>;
@@ -1172,6 +1321,7 @@ export interface DshMemoryRequestMap {
     'dsh-memory/scenes': Record<string, never>;
     'dsh-memory/persona': Record<string, never>;
     'dsh-memory/log-tail': LogTailRequest;
+    'dsh-memory/trace-tail': TraceTailRequest;
     'dsh-memory/rebuild-status': Record<string, never>;
     'dsh-memory/rebuild-start': Record<string, never>;
     'dsh-memory/rebuild-cancel': Record<string, never>;
@@ -1201,6 +1351,9 @@ export interface DshMemoryResponseMap {
     'dsh-memory/session-mode-set': SessionModeSetResponse;
     'dsh-memory/wing-overview': WingOverviewResponse;
     'dsh-memory/rooms-get': RoomsGetResponse;
+    'dsh-memory/rooms-export': RoomsExportResponse;
+    'dsh-memory/room-register': RoomRegisterResponse;
+    'dsh-memory/room-admin': RoomAdminResponse;
     'dsh-memory/wing-backfill': WingBackfillResponse;
     'dsh-memory/session-stats': SessionStatsResponse;
     'dsh-memory/settings-get': SettingsGetResponse;
@@ -1216,6 +1369,7 @@ export interface DshMemoryResponseMap {
     'dsh-memory/scenes': ScenesResponse;
     'dsh-memory/persona': PersonaResponse;
     'dsh-memory/log-tail': LogTailResponse;
+    'dsh-memory/trace-tail': TraceTailResponse;
     'dsh-memory/rebuild-status': RebuildStatusResponse;
     'dsh-memory/rebuild-start': RebuildStatus;
     'dsh-memory/rebuild-cancel': RebuildStatus;

package/dist/hooks/capture-recovery.d.ts

@@ -0,0 +1,64 @@
+/**
+ * §A 崩溃恢复 · 折叠纯函数(memorax-absorb Wave 1 / task_6)。
+ *
+ * 宿主在 turn 中途崩溃时,插件的内存缓冲丢失、该轮永不落 L0——但事件日志就在
+ * 宿主持久化层里,且 persistence 会在 reload 时给崩溃孤儿轮补写
+ * `turn/end{reason:'interrupted'}` 闭合标记(运行期实证:本机 98 处,
+ * 见计划 evidence/probe-runtime.json)。resume 时对账 `(水位线, 末尾]` 内
+ * bracket 完整的 turn,经 capture 的正常路径落 L0 + 蒸馏。
+ *
+ * 本模块只做**纯折叠**:events in → bracket 列表 out,零 I/O、零时钟、零随机。
+ * 幂等(水位线 + 逐 turn 存在性检查)与 off 档排除在调用方(capture.ts 接线层)。
+ *
+ * 切片语义与 CaptureBuffers.takeTurn 对齐:含 turn/end、不含 turn/start
+ * (turn/start 与 turn/end 本身不产消息,与既有转换器的类型过滤一致)。
+ */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+/** 一个可恢复的完整轮次括号;events 为 (startSeq, endSeq] 切片。 */
+export interface RecoveredTurn {
+    turn: number;
+    startSeq: number;
+    endSeq: number;
+    events: SessionEvent[];
+}
+export interface FoldOptions {
+    /** 最多恢复的轮数(取最靠尾的 N 个);缺省 2——只补尾轮,非历史倾倒。 */
+    maxTurns?: number;
+}
+/**
+ * 从持久化事件日志折叠出可恢复轮次。
+ *
+ * - **bracket 完整性**:只有 `turn/start(T) … turn/end(T)` 成对(任意 reason——
+ *   interrupted 与 completed 同等对待,插件停机期间宿主正常完成的轮次同样缺 L0)才入选;
+ *   未闭合 tail 跳过(宿主 reload 补闭合后,下次 resume 自然纳入)。
+ * - **水位线窗口**:只取 `turn > watermark`(watermark=undefined 视为会话 L0 全空,
+ *   全部入选)。
+ * - **上限**:按 turn 取最靠尾的 `maxTurns`(缺省 2)个,返回按 startSeq 升序
+ *   (调用方按序落 L0,保持时序)。
+ * - **防御**:输入乱序时按 seq 稳定排序;同 turn 重复 bracket(代际文件重叠等畸形)
+ *   保留 endSeq 更晚的一个;`data.turn` 非有限数字的括号一律不折叠。
+ */
+export declare function foldRecoverableTurns(events: readonly SessionEvent[], watermark: number | undefined, opts?: FoldOptions): RecoveredTurn[];
+/**
+ * 宿主读日志服务的最小结构形状。真实类型随宿主版本漂移(compat 0.1.1-rc.2 与
+ * 检出主线已是两代 API),故只做**结构探针**——方法存在才调,逐级 try/catch。
+ */
+export interface HostRecoveryServices {
+    sessionQuery?: unknown;
+    sessionPersistence?: unknown;
+}
+/**
+ * task_8 降级链:`agent.session.events` 不可得时,依次尝试
+ * ① `ctx.sessionQuery.readSession(id)`(live 或 persisted 均可,返回完整原始日志);
+ * ② `ctx.sessionPersistence.readFrom(id, 0)`(按 seq 范围读,0 = 从头取全量——
+ *    水位线以 turn 计,无 seq 对应,全量交由 fold + 上限 2 收敛)。
+ *
+ * 0.1.5 适配:readSession/readFrom 在宿主 0.1.5 上是 **async** 且解析为
+ * `{ session: { id }, events }`(见 src/store/evidence-source.ts 的
+ * SessionQueryLike);0.1.7+ 为同步。本函数统一 await,`accepts` 同时认
+ * 顶层 `events` 与 `session.events` 两种放置。
+ *
+ * 返回 undefined = 两级均不可用/均失败(调用方走一次性提示 + 维持现状)。
+ * 守卫纪律与 recall.ts 的 loadStored 探针一致:不假设方法存在,失败静默降级。
+ */
+export declare function readPersistedEventsViaServices(svcs: HostRecoveryServices, sessionId: string): Promise<SessionEvent[] | undefined>;

package/dist/hooks/capture-recovery.js

@@ -0,0 +1,105 @@
+function turnOf(event) {
+    const t = event.data?.turn;
+    return typeof t === 'number' && Number.isFinite(t) ? t : undefined;
+}
+/**
+ * 从持久化事件日志折叠出可恢复轮次。
+ *
+ * - **bracket 完整性**:只有 `turn/start(T) … turn/end(T)` 成对(任意 reason——
+ *   interrupted 与 completed 同等对待,插件停机期间宿主正常完成的轮次同样缺 L0)才入选;
+ *   未闭合 tail 跳过(宿主 reload 补闭合后,下次 resume 自然纳入)。
+ * - **水位线窗口**:只取 `turn > watermark`(watermark=undefined 视为会话 L0 全空,
+ *   全部入选)。
+ * - **上限**:按 turn 取最靠尾的 `maxTurns`(缺省 2)个,返回按 startSeq 升序
+ *   (调用方按序落 L0,保持时序)。
+ * - **防御**:输入乱序时按 seq 稳定排序;同 turn 重复 bracket(代际文件重叠等畸形)
+ *   保留 endSeq 更晚的一个;`data.turn` 非有限数字的括号一律不折叠。
+ */
+export function foldRecoverableTurns(events, watermark, opts) {
+    const maxTurns = opts?.maxTurns ?? 2;
+    const sorted = [...events].sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
+    const open = new Map();
+    const brackets = [];
+    for (let i = 0; i < sorted.length; i++) {
+        const event = sorted[i];
+        if (event.type === 'turn/start') {
+            const turn = turnOf(event);
+            if (turn !== undefined)
+                open.set(turn, { startSeq: event.seq, startIdx: i });
+        }
+        else if (event.type === 'turn/end') {
+            const turn = turnOf(event);
+            const start = turn !== undefined ? open.get(turn) : undefined;
+            if (turn === undefined || start === undefined)
+                continue;
+            open.delete(turn);
+            brackets.push({
+                turn,
+                startSeq: start.startSeq,
+                endSeq: event.seq,
+                events: sorted.slice(start.startIdx + 1, i + 1),
+            });
+        }
+    }
+    const eligible = brackets.filter((b) => watermark === undefined || b.turn > watermark);
+    const byTurn = new Map();
+    for (const b of eligible) {
+        const prev = byTurn.get(b.turn);
+        if (prev === undefined || b.endSeq >= prev.endSeq)
+            byTurn.set(b.turn, b);
+    }
+    return [...byTurn.values()].sort((a, b) => a.turn - b.turn).slice(-maxTurns).sort((a, b) => a.startSeq - b.startSeq);
+}
+/**
+ * task_8 降级链:`agent.session.events` 不可得时,依次尝试
+ * ① `ctx.sessionQuery.readSession(id)`(live 或 persisted 均可,返回完整原始日志);
+ * ② `ctx.sessionPersistence.readFrom(id, 0)`(按 seq 范围读,0 = 从头取全量——
+ *    水位线以 turn 计,无 seq 对应,全量交由 fold + 上限 2 收敛)。
+ *
+ * 0.1.5 适配:readSession/readFrom 在宿主 0.1.5 上是 **async** 且解析为
+ * `{ session: { id }, events }`(见 src/store/evidence-source.ts 的
+ * SessionQueryLike);0.1.7+ 为同步。本函数统一 await,`accepts` 同时认
+ * 顶层 `events` 与 `session.events` 两种放置。
+ *
+ * 返回 undefined = 两级均不可用/均失败(调用方走一次性提示 + 维持现状)。
+ * 守卫纪律与 recall.ts 的 loadStored 探针一致:不假设方法存在,失败静默降级。
+ */
+export async function readPersistedEventsViaServices(svcs, sessionId) {
+    const unwrap = (r) => {
+        if (r === null || typeof r !== 'object')
+            return undefined;
+        const o = r;
+        if (Array.isArray(o.events) && o.events.length > 0)
+            return o.events;
+        const inner = o.session;
+        if (inner !== null && typeof inner === 'object' && Array.isArray(inner.events) && inner.events.length > 0) {
+            return inner.events;
+        }
+        return undefined;
+    };
+    const q = svcs.sessionQuery;
+    if (q !== null && typeof q === 'object' && typeof q.readSession === 'function') {
+        try {
+            const result = await q.readSession(sessionId);
+            const events = unwrap(result);
+            if (events)
+                return events;
+        }
+        catch {
+            /* 落到下一级 */
+        }
+    }
+    const p = svcs.sessionPersistence;
+    if (p !== null && typeof p === 'object' && typeof p.readFrom === 'function') {
+        try {
+            const result = await p.readFrom(sessionId, 0);
+            const events = unwrap(result);
+            if (events)
+                return events;
+        }
+        catch {
+            /* 均不可用 */
+        }
+    }
+    return undefined;
+}

package/dist/hooks/capture.js

@@ -6,7 +6,32 @@
  */
 import { randomBytes } from 'node:crypto';
 import { blocksToText } from '../util/text.js';
+import { redactSecrets } from '../util/redact.js';
 import { sanitizeText, shouldCaptureL0, stripCodeBlocks } from '../util/sanitize.js';
+import { foldRecoverableTurns, readPersistedEventsViaServices } from './capture-recovery.js';
+import { confirmInjectionByMessageId } from './recall-ack.js';
+/** §C 一次性告警标记:脱敏自身异常时放行原文,只提示一次(不阻断捕获)。 */
+let redactWarnedOnce = false;
+/**
+ * §C 捕获单点脱敏(memorax-absorb):`capture.redactSecrets !== false` 时把
+ * 8 类密钥替换为 `[REDACTED:<KIND>]`。位置在 sanitize 之后、L0/蒸馏分发之前——
+ * 同一份 messages 覆盖 L0 JSONL/L0 SQLite/蒸馏输入三条下游,无分裂态。
+ * 红线:脱敏失败放行原文 + 一次性 warn(不阻断捕获)。
+ */
+function redactContent(content, cfg, logger) {
+    if (cfg.capture?.redactSecrets === false)
+        return content;
+    try {
+        return redactSecrets(content).text;
+    }
+    catch (err) {
+        if (!redactWarnedOnce) {
+            redactWarnedOnce = true;
+            logger.warn(`[memory] 脱敏失败,本轮放行原文(一次性提示): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return content;
+    }
+}
 /**
  * 需要进缓冲的事件类型。流式 chunk(text-delta/reasoning 等)一秒钟可达数百条,
  * 缓冲它们会把 MAX_BUFFER 撑爆、把轮次头部(turn/start + user 消息)裁掉——
@@ -70,6 +95,8 @@ export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
         return;
     const startFloor = Date.now();
     const buffers = new CaptureBuffers();
+    // task_8 一次性提示标记:宿主读日志服务不可得时只提示一次(防每次 resume 刷屏)
+    let warnedRecoveryUnavailable = false;
     // L0 即时落盘链:turn/end 立刻写,不被蒸馏队列(慢 LLM 调用)阻塞;
     // 串行化保证同轮次顺序与单次写入(进程退出时排队中的 L0 不再依赖蒸馏完成)
     let l0Queue = Promise.resolve();
@@ -79,6 +106,15 @@ export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
             if (!s.enabled || !s.capture)
                 return;
             const sid = String(session.id ?? session);
+            // §D 日志回执(memorax-absorb):注入消息以原样 user/message 入日志时在此确认,
+            // 才真正 dedupe.mark。**必须置于 source.kind 过滤之前**——过滤在
+            // turnEventsToMessages 内且只放行 kind='user',注入消息(kind='plugin',本线 v3 署名)
+            // 走不到那里;也置于 off 档返回之前(确认与档位无关,且代价是一次 Map 查找)。
+            if (event.type === 'user/message') {
+                const mid = event.data.id;
+                if (typeof mid === 'string' && mid)
+                    confirmInjectionByMessageId(mid);
+            }
             // off 档:本会话对记忆系统完全隐身(不缓冲、不写 L0、不蒸馏)
             if (modes.get(sid) === 'off')
                 return;
@@ -124,6 +160,91 @@ export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
             logger.warn(`[memory] session/event 处理失败: ${err instanceof Error ? err.message : String(err)}`);
         }
     });
+    // §A 恢复共用水位线对账段(同步主路径与异步降级延续共用;mode 由调用方传入,
+    // 调用点已被 off 早退收窄,故直接取 enqueue 的形参类型)
+    const recoverFromEvents = (sid, mode, events) => {
+        const watermark = l0.maxCapturedTurn(sid);
+        const brackets = foldRecoverableTurns(events, watermark);
+        if (brackets.length === 0)
+            return;
+        let recovered = 0;
+        let skipped = 0;
+        let total = 0;
+        for (const bracket of brackets) {
+            if (l0.hasAnyL0Message(sid, bracket.turn)) {
+                // 部分写残行:水位线只判"整轮无",存在性检查兜底——整轮跳过,宁少收不重复
+                skipped += 1;
+                continue;
+            }
+            const messages = turnEventsToMessages(bracket.events, cfg, logger, sid, bracket.turn);
+            if (messages.length === 0)
+                continue;
+            recovered += 1;
+            total += messages.length;
+            const n = messages.length;
+            l0Queue = l0Queue
+                .then(() => l0.append(sid, messages))
+                .then(() => logger.info(`[memory] L0 恢复落盘 ${n} 条`))
+                .catch((err) => logger.warn(`[memory] L0 恢复落盘失败: ${err instanceof Error ? err.message : String(err)}`));
+            runner.enqueue(sid, messages, mode);
+        }
+        if (recovered > 0 || skipped > 0) {
+            logger.info(`[memory] resume 对账:水位线 ${watermark ?? '无'} → 恢复 ${recovered} 轮 ${total} 条,幂等跳过 ${skipped} 轮(session=${sid})`);
+        }
+    };
+    // ── §A 崩溃恢复(memorax-absorb Wave 1 / task_7):resume 时对账宿主持久化日志,
+    // 补收 (L0 水位线, 末尾] 内 bracket 完整的尾轮(≤2 轮)——崩溃轮在缓冲丢失后
+    // 仍可从持久化层找回(persistence 会给孤儿轮补 interrupted 闭合,探针② 实证 98 处)。
+    // fail-open 纪律:任何异常只 warn,不阻塞会话启动;幂等 = 水位线 + 逐 turn 存在性检查。
+    ctx.on('agent/session-start', (payload) => {
+        try {
+            if (payload.source !== 'resume')
+                return;
+            const s = live.get();
+            if (!s.enabled || !s.capture)
+                return;
+            const session = payload.agent?.session;
+            const sid = session?.id !== undefined && session.id !== null ? String(session.id) : '';
+            if (!sid)
+                return;
+            const mode = modes.get(sid);
+            if (mode === 'off')
+                return; // off 档对记忆系统完全隐身,对齐现行为
+            const primary = session?.events;
+            if (primary && primary.length > 0) {
+                recoverFromEvents(sid, mode, primary);
+                return;
+            }
+            // task_8 降级链:events 不可得(宿主版本偏差)时依次试
+            // ctx.sessionQuery.readSession / ctx.sessionPersistence.readFrom(守卫探针式)。
+            // 0.1.5 适配:两级服务都是 async,故走异步延续;listener 保持同步
+            // (0.1.5 无 serial 契约),延续内部自捕获异常,fail-open 纪律不变。
+            const get = ctx.get;
+            const svcs = typeof get === 'function'
+                ? {
+                    sessionQuery: get.call(ctx, 'sessionQuery'),
+                    sessionPersistence: get.call(ctx, 'sessionPersistence'),
+                }
+                : {};
+            void readPersistedEventsViaServices(svcs, sid)
+                .then((degraded) => {
+                if (degraded === undefined) {
+                    if (!warnedRecoveryUnavailable) {
+                        warnedRecoveryUnavailable = true;
+                        logger.info('[memory] resume 恢复:宿主读日志服务不可得,跳过对账(一次性提示)');
+                    }
+                    return;
+                }
+                recoverFromEvents(sid, mode, degraded);
+            })
+                .catch((err) => {
+                logger.warn(`[memory] resume 恢复失败(不阻塞会话启动): ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+        catch (err) {
+            logger.warn(`[memory] resume 恢复失败(不阻塞会话启动): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
     // 冲刷 = 等待串行链排空(链上每环自带 catch,永不 reject)。
     // 注:极小概率在 await 期间又入队的新消息会落到链尾——其 JSONL 事实源照写、
     // DB 写入由 upsert 内部兜底(关库后 warn),下次重建自愈。
@@ -190,7 +311,7 @@ function turnEventsToMessages(events, cfg, logger, sessionId, turn) {
                 logger.info(`[memory] L0 跳过非用户来源消息(source.kind=${msg.source?.kind ?? 'none'})`);
                 continue;
             }
-            const content = sanitizeText(blocksToText(msg.content));
+            const content = redactContent(sanitizeText(blocksToText(msg.content)), cfg, logger);
             if (shouldCaptureL0(content)) {
                 const anchor = { sessionId, turn };
                 if (currentStep !== undefined)
@@ -203,6 +324,7 @@ function turnEventsToMessages(events, cfg, logger, sessionId, turn) {
             let content = sanitizeText(blocksToText(data.message?.content));
             if (cfg.capture.stripCodeBlocks)
                 content = stripCodeBlocks(content);
+            content = redactContent(content, cfg, logger);
             if (shouldCaptureL0(content)) {
                 // 事件自带 turn/step 优先(fold 只服务于不带该字段的事件类型)
                 const evTurn = typeof data.turn === 'number' && Number.isFinite(data.turn) ? data.turn : turn;