dsh-prime-memory 0.26.3 → 0.26.5-beta.0

package/dist/clients/drsc.d.ts

@@ -0,0 +1,93 @@
+/**
+ * DrscClient(T8.4 读切,drsc-redact-memory-wiring task_18):memory 读历史
+ * 面的 dsh-reference-session-collector HTTP 客户端。
+ *
+ * 两个读点(R7):
+ * - 蒸馏背景窗(recentBySession 等价供给)→ `op=session&tail=N&redact=1`
+ *   (collector task_11 尾窗升序 + task_12 redact 臂);
+ * - 工具面 conversation_search → `op=search&redact=1`(命中基于原文 fts,
+ *   返回 snippet 取脱敏锚定文本)。
+ *
+ * 硬依赖纪律(对齐 T7.3 裁定):collector 缺席/超时/非 2xx/ok=false 一律抛
+ * {@link DrscClientError}——**绝不回退本地 l0**(表已退役,无退路);调用方
+ * 分口径处理:蒸馏背景窗空窗降级(runner),工具面显式报错(tools)。
+ *
+ * 同源 Host 解析(steward drs-source 的 resolveDrsBaseUrl 同款):
+ * 显式 baseUrl > 首个 trustedHosts 条目(补 http://)> `http://127.0.0.1:8080`
+ * (宿主缺省口)。Host 头回显首个 trustedHosts 条目:collector 信任门是精确
+ * 匹配,条目省略端口而 URL 带端口会失配。trustedHosts 惰性读取(webStartup
+ * 可能晚于本插件就绪),每次请求现算,无缓存陈旧面。
+ */
+import type { ConversationMessage } from '../types.js';
+/** collector API 路径(与其 DRS_API_PATH 字面一致;不跨包 import)。 */
+export declare const DRSC_API_PATH = "/api/dsh-reference-session-collector";
+/** 客户端缺省超时:loopback 正常 <10ms,5s 是给冷启动 GC/断点的天花板。 */
+export declare const DRSC_DEFAULT_TIMEOUT_MS = 5000;
+/** collector 缺席/超时/契约破损。显式报错,不回退本地。 */
+export declare class DrscClientError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * 基址解析:显式配置 > 首个 trustedHosts 条目(补 http:// 前缀)>
+ * `http://127.0.0.1:8080`(宿主默认口;trustedHosts 缺席的老线 collector 门本就放行)。
+ */
+export declare function resolveDrscBaseUrl(explicit: string | undefined, trustedHosts?: readonly string[]): string;
+/** `op=session` 的一个 segment 行(redact=1 时 text 为脱敏正文;wire 蛇形直取)。 */
+export interface DrscSessionRow {
+    seq: number;
+    turn: number;
+    step: number;
+    kind: string;
+    role: string;
+    time: number;
+    text: string;
+}
+/** `op=search` 的一个命中(redact=1 时 snippet 为脱敏锚定文本)。 */
+export interface DrscSearchHit {
+    session_id: string;
+    seq: number;
+    kind: string;
+    rank: number;
+    snippet: string;
+    time: number;
+    on_surface: number;
+    turn: number;
+}
+/** kind → L0 角色词表(memory 只收 user/assistant 两类,其余(tool/* 等)不映射)。 */
+export declare function drscRoleOf(kind: string): 'user' | 'assistant' | undefined;
+/**
+ * session 行 → ConversationMessage 形状映射(蒸馏背景窗用)。
+ * - id:确定性合成 `drsc:<session>:<seq>`(跨次调用稳定,anchor 追溯可解释);
+ * - anchor:turn>0 才成立(与 ConversationAnchor 红线一致:没坐标不伪造);
+ * - 非 user/assistant 段(tool/call 等)返回 undefined,调用方跳过。
+ */
+export declare function drscRowToConversationMessage(row: DrscSessionRow, sessionId: string): ConversationMessage | undefined;
+export interface DrscClientOptions {
+    /** 显式基址(缺省走 trustedHosts → 127.0.0.1:8080,见 resolveDrscBaseUrl)。 */
+    baseUrl?: string;
+    /** trustedHosts 惰性读取(webStartup 服务可能晚于装配;每次请求现取)。 */
+    trustedHosts?: () => readonly string[] | undefined;
+    /** 注入面(单测);缺省全局 fetch。 */
+    fetchImpl?: typeof fetch;
+    /** 单请求超时 ms;缺省 {@link DRSC_DEFAULT_TIMEOUT_MS}。 */
+    timeoutMs?: number;
+}
+export declare class DrscClient {
+    private readonly options;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    constructor(options?: DrscClientOptions);
+    /** 每次请求现算基址与 Host 回显(trustedHosts 惰性;无缓存陈旧面)。 */
+    private base;
+    /** 一个 GET 的 JSON 包络(非 2xx / ok!==true / 超时 / 断网一律抛 DrscClientError)。 */
+    private getJson;
+    /**
+     * 会话尾窗:`op=session&session=<id>&tail=N&redact=1` → 脱敏消息行(升序)。
+     * collector 无此会话(session:null)返回空数组(新会话首轮的常态,非错误)。
+     */
+    sessionTail(sessionId: string, tail: number): Promise<DrscSessionRow[]>;
+    /** 原史检索:`op=search&q=<query>&limit=N&redact=1` → 脱敏 snippet 命中。 */
+    search(query: string, limit: number): Promise<DrscSearchHit[]>;
+}

package/dist/clients/drsc.js

@@ -0,0 +1,139 @@
+/** collector API 路径(与其 DRS_API_PATH 字面一致;不跨包 import)。 */
+export const DRSC_API_PATH = '/api/dsh-reference-session-collector';
+/** 客户端缺省超时:loopback 正常 <10ms,5s 是给冷启动 GC/断点的天花板。 */
+export const DRSC_DEFAULT_TIMEOUT_MS = 5_000;
+/** collector 缺席/超时/契约破损。显式报错,不回退本地。 */
+export class DrscClientError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'DrscClientError';
+    }
+}
+/**
+ * 基址解析:显式配置 > 首个 trustedHosts 条目(补 http:// 前缀)>
+ * `http://127.0.0.1:8080`(宿主默认口;trustedHosts 缺席的老线 collector 门本就放行)。
+ */
+export function resolveDrscBaseUrl(explicit, trustedHosts) {
+    const trimmed = explicit?.trim() ?? '';
+    const pick = trimmed !== '' ? trimmed : trustedHosts?.find((entry) => entry.trim() !== '')?.trim();
+    if (pick === undefined || pick === '')
+        return 'http://127.0.0.1:8080';
+    return /^https?:\/\//u.test(pick) ? pick : `http://${pick}`;
+}
+/** kind → L0 角色词表(memory 只收 user/assistant 两类,其余(tool/* 等)不映射)。 */
+export function drscRoleOf(kind) {
+    if (kind === 'user/message')
+        return 'user';
+    if (kind === 'assistant/message')
+        return 'assistant';
+    return undefined;
+}
+/**
+ * session 行 → ConversationMessage 形状映射(蒸馏背景窗用)。
+ * - id:确定性合成 `drsc:<session>:<seq>`(跨次调用稳定,anchor 追溯可解释);
+ * - anchor:turn>0 才成立(与 ConversationAnchor 红线一致:没坐标不伪造);
+ * - 非 user/assistant 段(tool/call 等)返回 undefined,调用方跳过。
+ */
+export function drscRowToConversationMessage(row, sessionId) {
+    const role = drscRoleOf(row.kind);
+    if (role === undefined)
+        return undefined;
+    const msg = {
+        id: `drsc:${sessionId}:${row.seq}`,
+        role,
+        content: row.text,
+        timestamp: row.time,
+    };
+    if (Number.isFinite(row.turn) && row.turn > 0) {
+        msg.anchor = { sessionId, turn: row.turn };
+        if (Number.isFinite(row.step) && row.step > 0)
+            msg.anchor.step = row.step;
+    }
+    return msg;
+}
+export class DrscClient {
+    options;
+    fetchImpl;
+    timeoutMs;
+    constructor(options = {}) {
+        this.options = options;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.timeoutMs = options.timeoutMs ?? DRSC_DEFAULT_TIMEOUT_MS;
+    }
+    /** 每次请求现算基址与 Host 回显(trustedHosts 惰性;无缓存陈旧面)。 */
+    base() {
+        const trusted = this.options.trustedHosts?.() ?? [];
+        const base = resolveDrscBaseUrl(this.options.baseUrl, trusted).replace(/\/+$/u, '');
+        const first = trusted.find((entry) => entry.trim() !== '')?.trim();
+        return { url: `${base}${DRSC_API_PATH}`, ...(first !== undefined ? { hostHeader: first } : {}) };
+    }
+    /** 一个 GET 的 JSON 包络(非 2xx / ok!==true / 超时 / 断网一律抛 DrscClientError)。 */
+    async getJson(query) {
+        const { url, hostHeader } = this.base();
+        let response;
+        try {
+            response = await this.fetchImpl(`${url}${query}`, {
+                headers: {
+                    accept: 'application/json',
+                    ...(hostHeader === undefined ? {} : { host: hostHeader }),
+                },
+                signal: AbortSignal.timeout(this.timeoutMs),
+            });
+        }
+        catch (err) {
+            throw new DrscClientError(`collector 不可达(${query}): ${err instanceof Error ? err.message : String(err)}`, {
+                cause: err,
+            });
+        }
+        if (!response.ok)
+            throw new DrscClientError(`collector HTTP ${response.status}(${query})`);
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch (err) {
+            throw new DrscClientError(`collector 响应非 JSON(${query})`, { cause: err });
+        }
+        if (typeof body !== 'object' || body === null || body.ok !== true) {
+            const reason = typeof body === 'object' && body !== null
+                ? String(body.error ?? 'ok=false')
+                : '响应非对象';
+            throw new DrscClientError(`collector 包络异常(${query}): ${reason}`);
+        }
+        return body;
+    }
+    /**
+     * 会话尾窗:`op=session&session=<id>&tail=N&redact=1` → 脱敏消息行(升序)。
+     * collector 无此会话(session:null)返回空数组(新会话首轮的常态,非错误)。
+     */
+    async sessionTail(sessionId, tail) {
+        const body = await this.getJson(`?op=session&session=${encodeURIComponent(sessionId)}&tail=${Math.max(0, Math.floor(tail))}&redact=1`);
+        if (body['session'] === null || body['session'] === undefined)
+            return [];
+        const rows = Array.isArray(body['rows']) ? body['rows'] : [];
+        return rows.map((r) => ({
+            seq: Number(r['seq'] ?? 0),
+            turn: Number(r['turn'] ?? 0),
+            step: Number(r['step'] ?? 0),
+            kind: String(r['kind'] ?? ''),
+            role: String(r['role'] ?? ''),
+            time: Number(r['time'] ?? 0),
+            text: String(r['text'] ?? ''),
+        }));
+    }
+    /** 原史检索:`op=search&q=<query>&limit=N&redact=1` → 脱敏 snippet 命中。 */
+    async search(query, limit) {
+        const body = await this.getJson(`?op=search&q=${encodeURIComponent(query)}&limit=${Math.max(1, Math.floor(limit))}&redact=1`);
+        const hits = Array.isArray(body['hits']) ? body['hits'] : [];
+        return hits.map((h) => ({
+            session_id: String(h['session_id'] ?? ''),
+            seq: Number(h['seq'] ?? 0),
+            kind: String(h['kind'] ?? ''),
+            rank: Number(h['rank'] ?? 0),
+            snippet: String(h['snippet'] ?? ''),
+            time: Number(h['time'] ?? 0),
+            on_surface: Number(h['on_surface'] ?? 1),
+            turn: Number(h['turn'] ?? 0),
+        }));
+    }
+}

package/dist/drs-anchor-backfill.d.ts

@@ -0,0 +1,88 @@
+/**
+ * DRS 历史锚点回填(三期接线 T8.2,一次性任务的纯核心)。
+ *
+ * 职责:`l0_conversations` 里 `turn IS NULL` 的旧行,按
+ * (session_id, role, 时间窗) 与 DRS 投影库 segments(turn/step/role/time)
+ * 最近邻匹配,补填 turn/step。
+ *
+ * 纪律(对齐 store/sqlite.ts R7 迁移注释,「旧行留 NULL ⇒ 无锚点,不伪造」):
+ * - 匹配不上留 NULL;同窗内出现**多个不同 turn** 的候选 = 歧义,也留 NULL;
+ * - UPDATE 恒带 `AND turn IS NULL`,已锚定行永不覆盖(与 upsert COALESCE 同向);
+ * - 行数不变式:回填只填列,绝不增删行;apply 报告给前后 COUNT 对账。
+ *
+ * DRS 来源契约:projection.db segments 只读直连——与 HTTP `op=session&turn=`
+ * 的检索面同字段(session_id/turn/step/role/time);离线一次性任务走只读
+ * SQLite,宿主不在线也可跑。role 词表两侧同形:DRS eventRole 只产
+ * user/assistant,l0 capture 只收 user/assistant(capture.ts L0Record)。
+ *
+ * 本模块零 cordis/运行时依赖:入参是结构化 SQLite 面(prepare/all/run),
+ * CLI(scripts/drs-anchor-backfill.mjs)喂真身,单测喂临时 DatabaseSync。
+ */
+/** 结构化 SQLite 面(node:sqlite DatabaseSync 的窄投影,方法双向可赋值)。 */
+export interface PreparedStatementLike {
+    all(...params: unknown[]): unknown[];
+    run(...params: unknown[]): unknown;
+}
+export interface SqliteLike {
+    prepare(sql: string): PreparedStatementLike;
+}
+/** 缺省时间窗:|l0.timestamp − segments.time| ≤ 90s 视为同一条消息。 */
+export declare const DEFAULT_WINDOW_MS = 90000;
+export interface AnchorBackfillOptions {
+    /** 只回填该会话;缺省全量。 */
+    sessionId?: string;
+    /** 本次最多处理的候选行数(防跑飞);缺省不限。 */
+    limit?: number;
+    /** 匹配时间窗(ms);缺省 {@link DEFAULT_WINDOW_MS}。 */
+    windowMs?: number;
+}
+/** 一条可回填的匹配(证据齐全:两侧时间与差值)。 */
+export interface AnchorFillRow {
+    recordId: string;
+    sessionId: string;
+    role: string;
+    l0Timestamp: number;
+    drsTime: number;
+    deltaMs: number;
+    turn: number;
+    step: number;
+}
+/** 一条被保守放弃的候选(宁缺毋伪造)。 */
+export interface AnchorSkipRow {
+    recordId: string;
+    sessionId: string;
+    reason: 'no-drs-session' | 'no-role-match' | 'out-of-window' | 'ambiguous-turn';
+}
+export interface AnchorBackfillPlan {
+    windowMs: number;
+    /** 扫到的候选数(turn IS NULL)。 */
+    candidates: number;
+    /** DRS 侧有投影的会话数。 */
+    drsSessions: number;
+    /** 已锚定(无需处理)行数——信息面,不是候选。 */
+    alreadyAnchored: number;
+    fills: AnchorFillRow[];
+    skips: AnchorSkipRow[];
+}
+/**
+ * 产出回填计划(纯只读,两个库都不写)。匹配规则:
+ * 同会话 + 同 role + |Δt| ≤ windowMs 的 DRS 行里,若候选 turn 唯一 → 取
+ * |Δt| 最近一条;turn 不唯一 → 歧义放弃;无行/无窗内行 → 如实分型放弃。
+ */
+export declare function planAnchorBackfill(input: {
+    memory: SqliteLike;
+    drs: SqliteLike;
+} & AnchorBackfillOptions): AnchorBackfillPlan;
+export interface AnchorApplyReport {
+    plan: AnchorBackfillPlan;
+    applied: number;
+    totalRowsBefore: number;
+    totalRowsAfter: number;
+    /** 行数不变式:回填只填列,前后 COUNT 必须相等。 */
+    invariantHolds: boolean;
+}
+/**
+ * 应用计划:逐条 UPDATE,恒带 `AND turn IS NULL`(已锚定行永不覆盖;
+ * plan→apply 之间若有新写入恰好锚定了同一行,该条自然落空,不报错)。
+ */
+export declare function applyAnchorBackfill(memory: SqliteLike, plan: AnchorBackfillPlan): AnchorApplyReport;

package/dist/drs-anchor-backfill.js

@@ -0,0 +1,150 @@
+/**
+ * DRS 历史锚点回填(三期接线 T8.2,一次性任务的纯核心)。
+ *
+ * 职责:`l0_conversations` 里 `turn IS NULL` 的旧行,按
+ * (session_id, role, 时间窗) 与 DRS 投影库 segments(turn/step/role/time)
+ * 最近邻匹配,补填 turn/step。
+ *
+ * 纪律(对齐 store/sqlite.ts R7 迁移注释,「旧行留 NULL ⇒ 无锚点,不伪造」):
+ * - 匹配不上留 NULL;同窗内出现**多个不同 turn** 的候选 = 歧义,也留 NULL;
+ * - UPDATE 恒带 `AND turn IS NULL`,已锚定行永不覆盖(与 upsert COALESCE 同向);
+ * - 行数不变式:回填只填列,绝不增删行;apply 报告给前后 COUNT 对账。
+ *
+ * DRS 来源契约:projection.db segments 只读直连——与 HTTP `op=session&turn=`
+ * 的检索面同字段(session_id/turn/step/role/time);离线一次性任务走只读
+ * SQLite,宿主不在线也可跑。role 词表两侧同形:DRS eventRole 只产
+ * user/assistant,l0 capture 只收 user/assistant(capture.ts L0Record)。
+ *
+ * 本模块零 cordis/运行时依赖:入参是结构化 SQLite 面(prepare/all/run),
+ * CLI(scripts/drs-anchor-backfill.mjs)喂真身,单测喂临时 DatabaseSync。
+ */
+/** 缺省时间窗:|l0.timestamp − segments.time| ≤ 90s 视为同一条消息。 */
+export const DEFAULT_WINDOW_MS = 90_000;
+/** DRS segments → 锚点行(只收 turn>0 且 role∈{user,assistant} 的行)。 */
+function loadDrsAnchors(drs, sessionId) {
+    const sql = sessionId === undefined
+        ? 'SELECT session_id, turn, step, role, time FROM segments WHERE turn > 0 AND role IN (?, ?) ORDER BY session_id, time'
+        : 'SELECT session_id, turn, step, role, time FROM segments WHERE turn > 0 AND role IN (?, ?) AND session_id = ? ORDER BY session_id, time';
+    const rows = drs.prepare(sql).all('user', 'assistant', ...(sessionId === undefined ? [] : [sessionId]));
+    const bySession = new Map();
+    for (const row of rows) {
+        if (typeof row.session_id !== 'string' || typeof row.turn !== 'number' || typeof row.time !== 'number')
+            continue;
+        const entry = {
+            sessionId: row.session_id,
+            turn: row.turn,
+            step: typeof row.step === 'number' ? row.step : 0,
+            role: typeof row.role === 'string' ? row.role : '',
+            time: row.time,
+        };
+        const bucket = bySession.get(entry.sessionId);
+        if (bucket === undefined)
+            bySession.set(entry.sessionId, [entry]);
+        else
+            bucket.push(entry);
+    }
+    return bySession;
+}
+function loadCandidates(memory, sessionId, limit) {
+    const sql = sessionId === undefined
+        ? 'SELECT record_id, session_id, role, timestamp FROM l0_conversations WHERE turn IS NULL AND role IN (?, ?) ORDER BY session_id, timestamp'
+        : 'SELECT record_id, session_id, role, timestamp FROM l0_conversations WHERE turn IS NULL AND role IN (?, ?) AND session_id = ? ORDER BY session_id, timestamp';
+    const rows = memory.prepare(sql).all('user', 'assistant', ...(sessionId === undefined ? [] : [sessionId]));
+    const out = [];
+    for (const row of rows) {
+        if (typeof row.record_id !== 'string' || typeof row.session_id !== 'string' || typeof row.timestamp !== 'number')
+            continue;
+        out.push({
+            recordId: row.record_id,
+            sessionId: row.session_id,
+            role: typeof row.role === 'string' ? row.role : '',
+            timestamp: row.timestamp,
+        });
+        if (limit !== undefined && out.length >= limit)
+            break;
+    }
+    return out;
+}
+/**
+ * 产出回填计划(纯只读,两个库都不写)。匹配规则:
+ * 同会话 + 同 role + |Δt| ≤ windowMs 的 DRS 行里,若候选 turn 唯一 → 取
+ * |Δt| 最近一条;turn 不唯一 → 歧义放弃;无行/无窗内行 → 如实分型放弃。
+ */
+export function planAnchorBackfill(input) {
+    const windowMs = input.windowMs ?? DEFAULT_WINDOW_MS;
+    const drsBySession = loadDrsAnchors(input.drs, input.sessionId);
+    const candidates = loadCandidates(input.memory, input.sessionId, input.limit);
+    const anchored = input.memory.prepare(input.sessionId === undefined
+        ? 'SELECT COUNT(*) AS n FROM l0_conversations WHERE turn IS NOT NULL'
+        : 'SELECT COUNT(*) AS n FROM l0_conversations WHERE turn IS NOT NULL AND session_id = ?').all(...(input.sessionId === undefined ? [] : [input.sessionId]));
+    const plan = {
+        windowMs,
+        candidates: candidates.length,
+        drsSessions: drsBySession.size,
+        alreadyAnchored: typeof anchored[0]?.n === 'number' ? anchored[0].n : 0,
+        fills: [],
+        skips: [],
+    };
+    for (const candidate of candidates) {
+        const rows = drsBySession.get(candidate.sessionId);
+        if (rows === undefined) {
+            plan.skips.push({ recordId: candidate.recordId, sessionId: candidate.sessionId, reason: 'no-drs-session' });
+            continue;
+        }
+        const sameRole = rows.filter(row => row.role === candidate.role);
+        if (sameRole.length === 0) {
+            plan.skips.push({ recordId: candidate.recordId, sessionId: candidate.sessionId, reason: 'no-role-match' });
+            continue;
+        }
+        const inWindow = sameRole
+            .map(row => ({ row, delta: Math.abs(row.time - candidate.timestamp) }))
+            .filter(entry => entry.delta <= windowMs);
+        if (inWindow.length === 0) {
+            plan.skips.push({ recordId: candidate.recordId, sessionId: candidate.sessionId, reason: 'out-of-window' });
+            continue;
+        }
+        const turns = new Set(inWindow.map(entry => entry.row.turn));
+        if (turns.size > 1) {
+            plan.skips.push({ recordId: candidate.recordId, sessionId: candidate.sessionId, reason: 'ambiguous-turn' });
+            continue;
+        }
+        const nearest = inWindow.reduce((best, entry) => (entry.delta < best.delta ? entry : best));
+        plan.fills.push({
+            recordId: candidate.recordId,
+            sessionId: candidate.sessionId,
+            role: candidate.role,
+            l0Timestamp: candidate.timestamp,
+            drsTime: nearest.row.time,
+            deltaMs: nearest.delta,
+            turn: nearest.row.turn,
+            step: nearest.row.step,
+        });
+    }
+    return plan;
+}
+/**
+ * 应用计划:逐条 UPDATE,恒带 `AND turn IS NULL`(已锚定行永不覆盖;
+ * plan→apply 之间若有新写入恰好锚定了同一行,该条自然落空,不报错)。
+ */
+export function applyAnchorBackfill(memory, plan) {
+    const countOf = (sql) => {
+        const rows = memory.prepare(sql).all();
+        return typeof rows[0]?.n === 'number' ? rows[0].n : 0;
+    };
+    const totalRowsBefore = countOf('SELECT COUNT(*) AS n FROM l0_conversations');
+    const update = memory.prepare('UPDATE l0_conversations SET turn = ?, step = ? WHERE record_id = ? AND turn IS NULL');
+    let applied = 0;
+    for (const fill of plan.fills) {
+        const result = update.run(fill.turn, fill.step, fill.recordId);
+        if (typeof result?.changes === 'number' && result.changes > 0)
+            applied += result.changes;
+    }
+    const totalRowsAfter = countOf('SELECT COUNT(*) AS n FROM l0_conversations');
+    return {
+        plan,
+        applied,
+        totalRowsBefore,
+        totalRowsAfter,
+        invariantHolds: totalRowsBefore === totalRowsAfter,
+    };
+}

package/dist/hooks/capture.d.ts

@@ -3,7 +3,7 @@ import type { SessionEvent } from '@deepseek-ai/dsh-session';
 import type { MemoryConfig } from '../config.js';
 import type { MemoryRunner } from '../pipeline/runner.js';
 import type { SessionModeStore } from '../store/session-modes.js';
-import type { L0Store } from '../store/l0.js';
+import type { L0WatermarkStore } from '../store/l0-watermark.js';
 import type { LiveSettingsHandle } from '../settings.js';
 import type { MemoryLogger } from '../types.js';
 export declare function isCaptureRelevant(type: string): boolean;
@@ -20,10 +20,10 @@ export declare class CaptureBuffers {
     takeTurn(sid: string, turn: number): SessionEvent[];
 }
 /**
- * 注册 L0 捕获。返回 L0 串行链的冲刷函数(dispose 序在关库前 await,
- * 排队中的 turn 消息先落盘);capture 关闭时返回 undefined。
+ * 注册 L0 捕获。返回冲刷函数(dispose 序 await;写停后无排队写,恒立即完成)。
+ * capture 关闭时返回 undefined。
  */
-export declare function registerCapture(ctx: Context, cfg: MemoryConfig, runner: MemoryRunner, l0: L0Store, logger: MemoryLogger, live: LiveSettingsHandle, modes: SessionModeStore): (() => Promise<void>) | undefined;
+export declare function registerCapture(ctx: Context, cfg: MemoryConfig, runner: MemoryRunner, watermark: L0WatermarkStore, logger: MemoryLogger, live: LiveSettingsHandle, modes: SessionModeStore): (() => Promise<void>) | undefined;
 /**
  * 缓冲上限裁剪(防御性;RELEVANT_TYPES 过滤后基本不可达)。
  * 铁律:进行中轮次(turn/start 之后、turn/end 之前)的事件绝不裁——

package/dist/hooks/capture.js

@@ -1,6 +1,7 @@
 /**
  * L0 捕获 Hook:订阅 session/event,按轮次缓冲 user/assistant 消息,
- * turn/end 时清洗并交给 Runner 落盘 + 触发蒸馏。
+ * turn/end 时清洗并交给 Runner 蒸馏 + 登记水位(T8.4 写停:正文不落库,
+ * 历史读面由 DRSC 投影承接)。
  *
  * 冷启动保护:插件激活时间之前的事件不捕获(防止恢复会话时倾倒全部历史)。
  */
@@ -86,20 +87,34 @@ export class CaptureBuffers {
         return turnEvents;
     }
 }
+/** 该批消息里已知的最大 step(水位 last_step 登记用;无 step 锚点返回 undefined)。 */
+function lastStepOf(messages) {
+    let step;
+    for (const m of messages) {
+        const s = m.anchor?.step;
+        if (typeof s === 'number' && (step === undefined || s > step))
+            step = s;
+    }
+    return step;
+}
 /**
- * 注册 L0 捕获。返回 L0 串行链的冲刷函数(dispose 序在关库前 await,
- * 排队中的 turn 消息先落盘);capture 关闭时返回 undefined。
+ * 注册 L0 捕获。返回冲刷函数(dispose 序 await;写停后无排队写,恒立即完成)。
+ * capture 关闭时返回 undefined。
  */
-export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
+export function registerCapture(ctx, cfg, runner, watermark, logger, live, modes) {
     if (!cfg.capture.enabled)
         return;
     const startFloor = Date.now();
     const buffers = new CaptureBuffers();
     // task_8 一次性提示标记:宿主读日志服务不可得时只提示一次(防每次 resume 刷屏)
     let warnedRecoveryUnavailable = false;
-    // L0 即时落盘链:turn/end 立刻写,不被蒸馏队列(慢 LLM 调用)阻塞;
-    // 串行化保证同轮次顺序与单次写入(进程退出时排队中的 L0 不再依赖蒸馏完成)
-    let l0Queue = Promise.resolve();
+    // T8.4 写停(drsc-redact-memory-wiring R6):l0 正文三表(l0_conversations/l0_fts/
+    // l0_vec)与 JSONL 事实源一并退役——历史读面由 DRSC 投影供给,本地只剩水位表
+    // 做 §A 恢复幂等自检。蒸馏直传不经 DRSC(capture 单点脱敏照旧)。
+    // 水位登记是同步 SQLite 写,事件循环天然串行,无需再排队。
+    const settleTurn = (sid, turn, messages) => {
+        watermark.record(sid, turn, lastStepOf(messages));
+    };
     ctx.on('session/event', (session, event) => {
         try {
             const s = live.get();
@@ -146,12 +161,9 @@ export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
                     logger.info(`[memory] L0 捕获 turn=${turn} ${messages.length} 条(${Object.entries(roles)
                         .map(([k, v]) => `${k}=${v}`)
                         .join('/')} ,session=${sid},mode=${mode})`);
-                    // L0 立刻落盘(不等蒸馏)
-                    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)}`));
+                    // 写停:水位登记即"落盘"(正文由 DRSC 投影承接);蒸馏直传照旧
+                    settleTurn(sid, turn, messages);
+                    logger.info(`[memory] L0 写停登记 turn=${turn}(正文不落库,历史面经 DRSC)`);
                     runner.enqueue(sid, messages, mode);
                 }
             }
@@ -199,16 +211,16 @@ export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
                 }
                 events = degraded;
             }
-            const watermark = l0.maxCapturedTurn(sid);
-            const brackets = foldRecoverableTurns(events, watermark);
+            const watermarkTurn = watermark.maxTurn(sid);
+            const brackets = foldRecoverableTurns(events, watermarkTurn);
             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)) {
-                    // 部分写残行:水位线只判"整轮无",存在性检查兜底——整轮跳过,宁少收不重复
+                if (watermark.hasAny(sid, bracket.turn)) {
+                    // 水位表判"该轮已捕获":整轮跳过,宁少收不重复(≡ 退役前行存在性检查)
                     skipped += 1;
                     continue;
                 }
@@ -217,25 +229,20 @@ export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
                     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)}`));
+                settleTurn(sid, bracket.turn, messages);
                 runner.enqueue(sid, messages, mode);
             }
             if (recovered > 0 || skipped > 0) {
-                logger.info(`[memory] resume 对账:水位线 ${watermark ?? '无'} → 恢复 ${recovered} 轮 ${total} 条,幂等跳过 ${skipped} 轮(session=${sid})`);
+                logger.info(`[memory] resume 对账:水位线 ${watermarkTurn ?? '无'} → 恢复 ${recovered} 轮 ${total} 条,幂等跳过 ${skipped} 轮(session=${sid})`);
             }
         }
         catch (err) {
             logger.warn(`[memory] resume 恢复失败(不阻塞会话启动): ${err instanceof Error ? err.message : String(err)}`);
         }
     });
-    // 冲刷 = 等待串行链排空(链上每环自带 catch,永不 reject)。
-    // 注:极小概率在 await 期间又入队的新消息会落到链尾——其 JSONL 事实源照写、
-    // DB 写入由 upsert 内部兜底(关库后 warn),下次重建自愈。
-    return () => l0Queue;
+    // 冲刷:写停后无排队写(水位登记同步完成),恒立即完成。保留异步签名
+    // 供 dispose 序 await(index.ts 停机顺序不变)。
+    return async () => { };
 }
 /**
  * 缓冲上限裁剪(防御性;RELEVANT_TYPES 过滤后基本不可达)。

package/dist/hooks/recall.d.ts

@@ -78,6 +78,17 @@ export interface OwnInjectionFacts {
  * 署名判定走 `isOwnRecallSource`，同时吃 v4 `plugin:memory` 与 v3 旧行形状。
  */
 export declare function ownInjectionFromEvent(ev: InjectionEventLike): OwnInjectionFacts | undefined;
+/**
+ * 会话事件统一读形状（issue #8）：旧宿主 `session.events` 是数组属性；
+ * 0.2.x 宿主已删该属性，官方访问器是 `snapshotEvents()`（全量日志，seq 与日志
+ * 位置对齐，含 fork 前缀——与旧属性同口径）。两者都拿不到时返回 undefined，
+ * 由调用点的既有退路处置（粗标记 / 存储回填）；不假设形状，不抛。
+ * 导出供双形状单测钉住。
+ */
+export declare function readSessionEvents(session: {
+    events?: readonly InjectionEventLike[];
+    snapshotEvents?: () => readonly InjectionEventLike[];
+}): readonly InjectionEventLike[] | undefined;
 export declare function buildRecallQuery(messages: Array<{
     content: unknown;
 }>, tailMessages?: number, maxChars?: number): string;