dsh-layered-memory 0.5.3

package/dist/llm.js

@@ -0,0 +1,128 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { errDetail } from './util/filelog.js';
+/** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */
+export async function resolveModelRoute(ctx, cfg) {
+    if (cfg.llm.provider && cfg.llm.model) {
+        return { provider: cfg.llm.provider, model: cfg.llm.model };
+    }
+    // agentDefaultModel 是可选服务（dsh-agent-default-model 提供），缺失时不得抛错。
+    const defaults = ctx.get('agentDefaultModel');
+    const sel = defaults?.currentSelection?.();
+    if (sel?.provider && sel?.model) {
+        return { provider: cfg.llm.provider || sel.provider, model: cfg.llm.model || sel.model };
+    }
+    throw new Error('无法解析蒸馏模型路由：请在插件 config 中配置 llm.provider / llm.model，或确保存在默认模型选择');
+}
+/**
+ * 一次完整蒸馏调用：流式收集文本，返回最终字符串。
+ * 失败（error/aborted finish）抛错，由调用方兜底。
+ *
+ * 文本只从 block-end（协议保证携带**组装完成的整块**）取；text-delta 仅在
+ * 适配器异常地没有发 block-end 时兜底。两者都累计会把输出翻倍。
+ */
+export async function callLLM(ctx, cfg, opts) {
+    const { provider, model } = await resolveModelRoute(ctx, cfg);
+    const signal = opts.signal ?? AbortSignal.timeout(cfg.llm.timeoutMs);
+    // 输入预算兜底：任何蒸馏调用的用户 prompt 不超过 maxInputChars
+    // （L1 已在数据层分块，这里是 L2/L3 与异常场景的最后一道网）
+    const user = opts.user.length > cfg.llm.maxInputChars
+        ? `${opts.user.slice(0, cfg.llm.maxInputChars)}\n\n[输入超出 ${cfg.llm.maxInputChars} 字符预算，已截断]`
+        : opts.user;
+    const stream = ctx.llm.stream({
+        provider,
+        model,
+        system: opts.system,
+        messages: [createUserMessage({ content: [{ type: 'text', text: user }], source: { kind: 'user' } })],
+        temperature: opts.temperature ?? cfg.llm.temperature,
+        maxTokens: opts.maxTokens ?? cfg.llm.maxTokens,
+        signal,
+    });
+    const startedAt = Date.now();
+    let deltaText = '';
+    let blockText = '';
+    // 块级统计：空输出诊断的唯一现场（finish reason / token 计数 / reasoning 是否吃光预算）
+    let finishKind = '';
+    let outputTokens = 0;
+    let reasoningTokens = 0;
+    let deltaBlocks = 0;
+    let reasoningChars = 0;
+    let reasoningHead = '';
+    const blockEndTypes = new Map();
+    try {
+        for await (const chunk of stream) {
+            if (chunk.type === 'text-delta') {
+                deltaBlocks++;
+                deltaText += chunk.text;
+            }
+            else if (chunk.type === 'reasoning-delta') {
+                reasoningChars += chunk.text.length;
+                if (reasoningHead.length < 300)
+                    reasoningHead += chunk.text.slice(0, 300 - reasoningHead.length);
+            }
+            else if (chunk.type === 'block-end') {
+                blockEndTypes.set(chunk.block.type, (blockEndTypes.get(chunk.block.type) ?? 0) + 1);
+                if (chunk.block.type === 'text')
+                    blockText += chunk.block.text;
+            }
+            else if (chunk.type === 'usage') {
+                outputTokens = chunk.usage.outputTokens;
+                reasoningTokens = chunk.usage.reasoningTokens ?? 0;
+            }
+            else if (chunk.type === 'finish') {
+                finishKind = chunk.reason.kind;
+                if (chunk.reason.kind === 'error' || chunk.reason.kind === 'aborted') {
+                    const failure = chunk.reason.failure;
+                    throw new Error(`llm ${chunk.reason.kind}: ${failure?.message ?? 'unknown failure'}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        opts.logger?.warn(`[memory] LLM 调用失败 ${provider}/${model}（${((Date.now() - startedAt) / 1000).toFixed(1)}s）: ${errDetail(err)}`);
+        throw err;
+    }
+    const out = (blockText || deltaText).trim();
+    if (out.length === 0) {
+        // 空输出是最难排查的失败：流正常结束但一个字没吐。必须记录 finish 原因、
+        // token 计数与块分布，才能区分"模型只产出了 reasoning"vs"服务端返回空响应"。
+        opts.logger?.warn(`[memory] LLM 空输出 ${provider}/${model}（${((Date.now() - startedAt) / 1000).toFixed(1)}s，finish=${finishKind || '无 finish 块'}` +
+            `，输出 tokens=${outputTokens}${reasoningTokens > 0 ? `/reasoning ${reasoningTokens}` : ''}，` +
+            `text-delta ${deltaBlocks} 块/${deltaText.length} 字符，reasoning ${reasoningChars} 字符，` +
+            `block-end: ${[...blockEndTypes.entries()].map(([t, n]) => `${t}×${n}`).join(', ') || '无'}）` +
+            (reasoningHead ? `，reasoning 摘录: ${reasoningHead}…` : ''));
+    }
+    opts.logger?.info(`[memory] LLM 调用 ${provider}/${model}：输入 ${user.length} 字符 → 输出 ${out.length} 字符（${((Date.now() - startedAt) / 1000).toFixed(1)}s，finish=${finishKind || '无'}）`);
+    return out;
+}
+/** 带诊断日志的 parseJson：解析失败时记录原始输出摘录（模型输出异常排查的关键信息）。 */
+export function parseJsonLogged(raw, what, logger) {
+    try {
+        return parseJson(raw);
+    }
+    catch (err) {
+        logger?.error(`[memory] ${what} JSON 解析失败（${errDetail(err)}），原始输出前 400 字符: ${raw.slice(0, 400)}`);
+        throw new Error(`${what} 输出无法解析为 JSON`);
+    }
+}
+/** 容错地解析 LLM 输出的 JSON（剥掉可能的 ```json 围栏）。 */
+export function parseJson(raw) {
+    let s = raw.trim();
+    if (s.startsWith('```')) {
+        s = s.replace(/^```[a-zA-Z]*\n?/, '').replace(/```$/, '').trim();
+    }
+    const start = s.indexOf('[');
+    const brace = s.indexOf('{');
+    let begin = -1;
+    if (start === -1)
+        begin = brace;
+    else if (brace === -1)
+        begin = start;
+    else
+        begin = Math.min(start, brace);
+    if (begin > 0)
+        s = s.slice(begin);
+    const end = s.lastIndexOf(']') > s.lastIndexOf('}') ? s.lastIndexOf(']') + 1 : s.lastIndexOf('}') + 1;
+    if (end > 0)
+        s = s.slice(0, end);
+    return JSON.parse(s);
+}

package/dist/pipeline/l1.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from '../config.js';
+import type { L1Store } from '../store/l1.js';
+import type { MemoryState } from '../store/state.js';
+import type { ConversationMessage, ExtractMode, MemoryFamily, MemoryLogger, MemoryRecord } from '../types.js';
+export interface ExtractionResult {
+    stored: number;
+    skipped: boolean;
+    sceneName: string;
+    newRecords: MemoryRecord[];
+}
+/** 分族 checkpoint 桶（活引用，改动由调用方 save 落盘）。 */
+export type FamilyStates = Record<MemoryFamily, MemoryState>;
+/**
+ * 按字符预算把消息切成多块（保持顺序，单条超预算独占一块，由 callLLM 兜底截断）。
+ * 每条消息按 content 长度 + 64 字符脚手架开销（id/时间戳行）计。
+ */
+export declare function chunkByCharBudget(messages: ConversationMessage[], budgetChars: number): ConversationMessage[][];
+export declare function runExtraction(ctx: Context, cfg: MemoryConfig, store: L1Store, states: FamilyStates, pending: ConversationMessage[], background: ConversationMessage[], logger: MemoryLogger, mode: ExtractMode): Promise<ExtractionResult>;

package/dist/pipeline/l1.js

@@ -0,0 +1,226 @@
+/**
+ * L1 蒸馏：抽取（情境切分 + 记忆提取）→ 去重（冲突检测 + 合并）→ 写入。
+ * 移植 MemoryCore 的 l1 runner 语义（抽取 prompt → batch 冲突检测 → apply）。
+ */
+import { randomBytes } from 'node:crypto';
+import { callLLM, parseJsonLogged } from '../llm.js';
+import { formatExtractionPrompt, getExtractMemoriesSystemPrompt } from '../prompts/l1-extraction.js';
+import { formatBatchConflictPrompt, getConflictDetectionSystemPrompt } from '../prompts/l1-dedup.js';
+import { familyForType } from '../types.js';
+function newId(prefix) {
+    return `${prefix}_${Date.now()}_${randomBytes(3).toString('hex')}`;
+}
+/**
+ * 按字符预算把消息切成多块（保持顺序，单条超预算独占一块，由 callLLM 兜底截断）。
+ * 每条消息按 content 长度 + 64 字符脚手架开销（id/时间戳行）计。
+ */
+export function chunkByCharBudget(messages, budgetChars) {
+    if (messages.length === 0)
+        return [];
+    const chunks = [];
+    let cur = [];
+    let curChars = 0;
+    for (const m of messages) {
+        const len = m.content.length + 64;
+        if (cur.length > 0 && curChars + len > budgetChars) {
+            chunks.push(cur);
+            cur = [];
+            curChars = 0;
+        }
+        cur.push(m);
+        curChars += len;
+    }
+    if (cur.length > 0)
+        chunks.push(cur);
+    return chunks;
+}
+export async function runExtraction(ctx, cfg, store, states, pending, background, logger, mode) {
+    if (!cfg.extract.enabled)
+        return { stored: 0, skipped: true, sceneName: chainHead(states, mode), newRecords: [] };
+    if (pending.length < cfg.extract.minMessages) {
+        return { stored: 0, skipped: true, sceneName: chainHead(states, mode), newRecords: [] };
+    }
+    // 纯档强制族 = 档位族；auto 档抽取后的记录族按 type 前缀判定
+    const forcedFamily = mode === 'auto' ? undefined : mode;
+    // 情境链锚点桶：纯档用本族；auto 用最近活跃的族（chainHead 同源）
+    const chainState = mode === 'auto' ? activeState(states) : states[mode];
+    // ── Step 1: 抽取（输入按 llm.maxInputChars 预算分块，情境链式衔接，不丢消息） ──
+    const backgroundMsgs = background.slice(-cfg.extract.backgroundMessages);
+    // 预留：背景消息（≤10 条 ×4000 字）+ prompt 脚手架
+    const perChunk = Math.max(20_000, cfg.llm.maxInputChars - 42_000);
+    const chunks = chunkByCharBudget(pending, perChunk);
+    if (chunks.length > 1) {
+        logger.info(`[memory] L1 输入超预算（${pending.length} 条消息），分 ${chunks.length} 块抽取（每块 ≤${perChunk} 字符）`);
+    }
+    const extracted = [];
+    let lastScene = chainState.lastSceneName;
+    let sceneCount = 0;
+    for (const chunk of chunks) {
+        const userPrompt = formatExtractionPrompt({
+            newMessages: chunk,
+            backgroundMessages: backgroundMsgs,
+            previousSceneName: lastScene || '无',
+        });
+        const raw = await callLLM(ctx, cfg, {
+            system: getExtractMemoriesSystemPrompt(mode),
+            user: userPrompt,
+            logger,
+        });
+        const scenes = parseJsonLogged(raw, 'L1 抽取', logger);
+        if (!Array.isArray(scenes))
+            throw new Error('L1 抽取输出不是 JSON 数组');
+        for (const scene of scenes) {
+            if (!scene || typeof scene.scene_name !== 'string')
+                continue;
+            lastScene = scene.scene_name;
+            sceneCount++;
+            for (const m of scene.memories ?? []) {
+                if (!m || typeof m.content !== 'string' || !m.content.trim())
+                    continue;
+                extracted.push({
+                    ...m,
+                    record_id: newId('mem'),
+                    scene_name: scene.scene_name,
+                    family: forcedFamily ?? familyForType(m.type ?? ''),
+                });
+            }
+        }
+    }
+    if (extracted.length === 0) {
+        logger.info(`[memory] L1 抽取完成：无可提取记忆（mode=${mode}，${pending.length} 条消息，${sceneCount} 个情境）`);
+        // 成功但零产出：同样推进时间戳/场景，与失败（lastExtractAt 保持 0）区分开
+        markExtracted(states, mode, lastScene);
+        return { stored: 0, skipped: false, sceneName: lastScene, newRecords: [] };
+    }
+    // ── Step 2: 去重（batch 冲突检测；候选只在本族内召回，去重永不跨族） ──
+    const matches = await Promise.all(extracted.map(async (m) => ({
+        newMemory: m,
+        candidates: await store.searchCandidates(m.content, cfg.extract.candidatePool, m.family),
+    })));
+    const dedupPrompt = formatBatchConflictPrompt(matches);
+    const dedupRaw = await callLLM(ctx, cfg, {
+        system: getConflictDetectionSystemPrompt(mode),
+        user: dedupPrompt,
+        logger,
+    });
+    const decisions = parseJsonLogged(dedupRaw, 'L1 去重判定', logger);
+    const byRecord = new Map();
+    for (const d of Array.isArray(decisions) ? decisions : []) {
+        if (d && typeof d.record_id === 'string')
+            byRecord.set(d.record_id, d);
+    }
+    // 去重决策统计：无决策的记录按 skip 处理，这里聚合成单行日志便于排查
+    const actionCount = {};
+    for (const m of extracted) {
+        const action = byRecord.get(m.record_id)?.action ?? 'skip(未返回)';
+        actionCount[action] = (actionCount[action] ?? 0) + 1;
+    }
+    const candidateTotal = matches.reduce((n, m) => n + m.candidates.length, 0);
+    logger.info(`[memory] L1 去重判定：${extracted.length} 条候选记忆召回 ${candidateTotal} 条已有记录，决策 ${Object.entries(actionCount)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(' ')}`);
+    // ── Step 3: 应用决策（官方语义：新记录追加进事实源，被替换目标只从检索库删除） ──
+    // 只按需取决策涉及的记录（候选 + 目标 id 并集），避免每轮全表扫描
+    const relatedIds = new Set();
+    for (const d of byRecord.values()) {
+        for (const id of d.target_ids ?? [])
+            relatedIds.add(id);
+    }
+    for (const m of matches) {
+        for (const c of m.candidates)
+            relatedIds.add(c.id);
+    }
+    const byId = new Map(store.getByIds([...relatedIds]).map((r) => [r.id, r]));
+    const deletedIds = new Set();
+    const added = [];
+    const now = Date.now();
+    for (const m of extracted) {
+        const decision = byRecord.get(m.record_id);
+        if (!decision || decision.action === 'skip')
+            continue;
+        const action = decision.action;
+        const ts = m.metadata?.activity_start_time ? Date.parse(String(m.metadata.activity_start_time)) : now;
+        if (action === 'store') {
+            added.push({
+                id: m.record_id,
+                content: m.content,
+                type: m.type,
+                priority: Number(m.priority) || 60,
+                scene_name: m.scene_name,
+                timestamps: [Number.isNaN(ts) ? now : ts],
+                createdAt: now,
+                updatedAt: now,
+                version: 0,
+                source_message_ids: m.source_message_ids ?? [],
+                metadata: m.metadata ?? {},
+                family: m.family,
+            });
+            continue;
+        }
+        // update / merge：目标记录从检索库删除，合并结果作为新记录追加（版本 +1）
+        // 候选召回按族隔离，合并产物保持新记忆的族标签
+        const targets = (decision.target_ids ?? []).filter((id) => byId.has(id));
+        for (const id of targets)
+            deletedIds.add(id);
+        const targetVersion = targets.reduce((max, id) => Math.max(max, byId.get(id)?.version ?? 0), 0);
+        const mergedTs = (decision.merged_timestamps ?? [])
+            .map((t) => Date.parse(t))
+            .filter((t) => !Number.isNaN(t))
+            .concat([now]);
+        added.push({
+            id: m.record_id,
+            content: decision.merged_content && decision.merged_content.trim()
+                ? decision.merged_content
+                : m.content,
+            type: decision.merged_type || m.type,
+            priority: Number(decision.merged_priority) || Number(m.priority) || 60,
+            scene_name: m.scene_name,
+            timestamps: Array.from(new Set(mergedTs)).sort((a, b) => a - b),
+            createdAt: now,
+            updatedAt: now,
+            version: targetVersion + 1,
+            source_message_ids: m.source_message_ids ?? [],
+            metadata: m.metadata ?? {},
+            family: m.family,
+        });
+    }
+    await store.appendNew(added);
+    if (deletedIds.size > 0)
+        await store.deleteBatch([...deletedIds]);
+    // 状态按记录族分桶推进（阈值计数各自独立）
+    const addedByFamily = { chat: 0, work: 0 };
+    for (const r of added)
+        addedByFamily[r.family ?? familyForType(r.type)]++;
+    for (const f of ['chat', 'work']) {
+        if (addedByFamily[f] === 0)
+            continue;
+        states[f].totalExtracted += addedByFamily[f];
+        states[f].newMemoriesSinceL2 += addedByFamily[f];
+        states[f].memoriesSinceL3 += addedByFamily[f];
+    }
+    markExtracted(states, mode, lastScene);
+    logger.info(`[memory] L1 抽取完成（mode=${mode}）：消息 ${pending.length} 条，抽取 ${extracted.length} 条，去重后新增 ${added.length} 条（替换 ${deletedIds.size} 条，chat=${addedByFamily.chat}/work=${addedByFamily.work}），累计 chat=${states.chat.totalExtracted}/work=${states.work.totalExtracted}`);
+    return { stored: added.length, skipped: false, sceneName: lastScene, newRecords: added };
+}
+/** auto 档取最近活跃的族 checkpoint（情境链/计数锚点）。 */
+function activeState(states) {
+    return states.chat.lastExtractAt >= states.work.lastExtractAt ? states.chat : states.work;
+}
+/** 情境链读取：auto → 最近活跃族；纯档 → 本族。 */
+function chainHead(states, mode) {
+    return (mode === 'auto' ? activeState(states) : states[mode]).lastSceneName;
+}
+/** 抽取成功后推进时间戳/情境链：auto → 两族都推进（链只写锚点桶）；纯档 → 本族。 */
+function markExtracted(states, mode, lastScene) {
+    const now = Date.now();
+    if (mode === 'auto') {
+        // 两族的 lastExtractAt 都推进（去重候选各自族内判断"新消息"）；情境链只维护锚点桶
+        states.chat.lastExtractAt = now;
+        states.work.lastExtractAt = now;
+        activeState(states).lastSceneName = lastScene;
+    }
+    else {
+        states[mode].lastExtractAt = now;
+        states[mode].lastSceneName = lastScene;
+    }
+}

package/dist/pipeline/l2.d.ts

@@ -0,0 +1,13 @@
+/**
+ * L2 场景整合：把新记忆交给 LLM，输出文件操作 JSON，工程侧执行。
+ * 移植 MemoryCore scene runner 的语义（UPDATE 优先 / MERGE / 上限预警 / heat 管理）。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from '../config.js';
+import type { SceneStore } from '../store/scenes.js';
+import type { MemoryFamily, MemoryLogger, MemoryRecord } from '../types.js';
+export interface SceneResult {
+    changed: number;
+    personaRequestedReason?: string;
+}
+export declare function runSceneConsolidation(ctx: Context, cfg: MemoryConfig, scenes: SceneStore, newMemories: MemoryRecord[], logger: MemoryLogger, family: MemoryFamily): Promise<SceneResult>;

package/dist/pipeline/l2.js

@@ -0,0 +1,77 @@
+import { callLLM, parseJsonLogged } from '../llm.js';
+import { buildScenePrompt, formatSceneSummaries } from '../prompts/scene.js';
+import { Bm25Index } from '../store/bm25.js';
+const REQUEST_RE = /\[PERSONA_UPDATE_REQUEST\]\s*reason:\s*([\s\S]*?)\[\/PERSONA_UPDATE_REQUEST\]/;
+export async function runSceneConsolidation(ctx, cfg, scenes, newMemories, logger, family) {
+    if (!cfg.l2.enabled || newMemories.length === 0) {
+        return { changed: 0 };
+    }
+    const summaries = await scenes.list();
+    // ── 组装 prompt ──
+    const memoriesJson = JSON.stringify(newMemories.map((m) => ({
+        record_id: m.id,
+        content: m.content,
+        type: m.type,
+        priority: m.priority,
+        scene_name: m.scene_name,
+        timestamps: m.timestamps.map((t) => new Date(t).toISOString()),
+    })), null, 2);
+    const sceneSummaries = formatSceneSummaries(summaries);
+    const sceneContents = await pickSceneContents(scenes, summaries, newMemories, cfg.l2.sceneContextLimit);
+    const { systemPrompt, userPrompt } = buildScenePrompt({
+        memoriesJson,
+        sceneSummaries,
+        sceneContents,
+        currentTimestamp: new Date().toISOString(),
+        existingSceneFiles: summaries.map((s) => s.path),
+        maxScenes: cfg.l2.maxScenes,
+        family,
+    });
+    const raw = await callLLM(ctx, cfg, { system: systemPrompt, user: userPrompt, logger });
+    // ── 解析：先取 PERSONA_UPDATE_REQUEST 标记，再解析操作数组 ──
+    const reqMatch = REQUEST_RE.exec(raw);
+    const personaRequestedReason = reqMatch?.[1]?.trim() || undefined;
+    const opsRaw = reqMatch ? raw.replace(REQUEST_RE, '') : raw;
+    const ops = parseJsonLogged(opsRaw, 'L2 场景操作', logger);
+    if (!Array.isArray(ops))
+        throw new Error('L2 输出不是操作数组');
+    let changed = 0;
+    for (const op of ops) {
+        if (!op || typeof op.path !== 'string')
+            continue;
+        try {
+            if (op.op === 'write' && typeof op.content === 'string') {
+                await scenes.write(op.path, op.content);
+                changed++;
+                logger.debug?.(`[memory] L2 写入场景 ${op.path} (${op.content.length} 字符)`);
+            }
+            else if (op.op === 'delete') {
+                await scenes.write(op.path, '[DELETED]');
+                changed++;
+                logger.debug?.(`[memory] L2 删除场景 ${op.path}`);
+            }
+        }
+        catch (err) {
+            logger.warn(`[memory] L2 操作失败 ${op.path}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    logger.info(`[memory] L2 场景整合完成（family=${family}）：${newMemories.length} 条新记忆 → ${changed} 个文件操作（场景总数 ${summaries.length}）` +
+        (personaRequestedReason ? `，请求 L3 更新：${personaRequestedReason}` : ''));
+    return { changed, personaRequestedReason };
+}
+/** 选出与本次新记忆最相关的场景全文（供 LLM 参考，避免全量塞入）。 */
+async function pickSceneContents(scenes, summaries, newMemories, limit) {
+    if (summaries.length === 0 || limit <= 0)
+        return '';
+    const index = new Bm25Index();
+    index.rebuild(summaries.map((s) => ({ id: s.path, text: `${s.summary} ${s.path}` })));
+    const query = newMemories.map((m) => m.content).join(' ');
+    const hits = index.search(query, limit);
+    const parts = [];
+    for (const h of hits) {
+        const content = await scenes.read(h.id);
+        if (content)
+            parts.push(`### 文件: ${h.id}\n\`\`\`markdown\n${content}\n\`\`\``);
+    }
+    return parts.join('\n\n');
+}

package/dist/pipeline/l3.d.ts

@@ -0,0 +1,15 @@
+/**
+ * L3 画像蒸馏：把变化场景交给 LLM，直接产出 persona.md 完整内容。
+ * 触发条件移植自 MemoryCore persona-trigger（主动请求 / 冷启动 / 恢复 / 间隔阈值）。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from '../config.js';
+import type { PersonaStore } from '../store/persona.js';
+import type { SceneStore } from '../store/scenes.js';
+import type { MemoryState } from '../store/state.js';
+import type { MemoryFamily, MemoryLogger } from '../types.js';
+export interface PersonaResult {
+    generated: boolean;
+    reason: string;
+}
+export declare function runPersona(ctx: Context, cfg: MemoryConfig, scenes: SceneStore, persona: PersonaStore, state: MemoryState, logger: MemoryLogger, family: MemoryFamily): Promise<PersonaResult>;

package/dist/pipeline/l3.js

@@ -0,0 +1,72 @@
+import { callLLM } from '../llm.js';
+import { buildPersonaPrompt } from '../prompts/persona.js';
+export async function runPersona(ctx, cfg, scenes, persona, state, logger, family) {
+    if (!cfg.l3.enabled)
+        return { generated: false, reason: 'l3 disabled' };
+    // ── 触发判定（移植 persona-trigger） ──
+    const existingPersona = await persona.read();
+    let reason = '';
+    if (state.personaRequestedReason) {
+        reason = `主动请求: ${state.personaRequestedReason}`;
+    }
+    else if (!state.hasPersona || !existingPersona) {
+        reason = '冷启动/恢复：首次生成或画像缺失';
+    }
+    else if (state.memoriesSinceL3 >= cfg.l3.interval) {
+        reason = `达到阈值: ${state.memoriesSinceL3} >= ${cfg.l3.interval}`;
+    }
+    else {
+        logger.debug?.(`[memory] L3 未触发（自上次蒸馏以来 ${state.memoriesSinceL3}/${cfg.l3.interval} 条新记忆）`);
+        return { generated: false, reason: 'no trigger' };
+    }
+    // ── 收集变化场景（自上次蒸馏以来 updated 变化 / 首次则全部） ──
+    const all = await scenes.list();
+    const changed = state.hasPersona
+        ? all.filter((s) => {
+            const t = Date.parse(s.updated);
+            return !Number.isNaN(t) && t > state.lastL3At;
+        })
+        : all;
+    if (changed.length === 0 && state.hasPersona) {
+        logger.debug?.('[memory] L3 触发但无变化场景，跳过');
+        return { generated: false, reason: 'no changed scenes' };
+    }
+    const changedContents = [];
+    for (const s of changed) {
+        const content = await scenes.read(s.path);
+        if (content)
+            changedContents.push(`### 场景: ${s.path}\n\`\`\`markdown\n${content}\n\`\`\``);
+    }
+    const { systemPrompt, userPrompt } = buildPersonaPrompt({
+        mode: existingPersona ? 'incremental' : 'first',
+        family,
+        currentTime: new Date().toISOString(),
+        totalProcessed: state.totalExtracted,
+        sceneCount: all.length,
+        changedSceneCount: changed.length,
+        changedScenesContent: changedContents.join('\n\n'),
+        existingPersona,
+        triggerInfo: reason,
+    });
+    const raw = await callLLM(ctx, cfg, { system: systemPrompt, user: userPrompt, logger });
+    const body = unwrapFence(raw);
+    if (!body) {
+        logger.error(`[memory] L3 输出为空，原始输出前 400 字符: ${raw.slice(0, 400)}`);
+        throw new Error('L3 输出为空');
+    }
+    await persona.write(body);
+    state.hasPersona = true;
+    state.lastL3At = Date.now();
+    state.memoriesSinceL3 = 0;
+    state.personaRequestedReason = undefined;
+    logger.info(`[memory] L3 画像蒸馏完成（family=${family}，${reason}）：${body.length} 字符，场景 ${changed.length}/${all.length} 个`);
+    return { generated: true, reason };
+}
+/** 剥掉可能的 ```markdown 围栏。 */
+function unwrapFence(text) {
+    let s = text.trim();
+    if (s.startsWith('```')) {
+        s = s.replace(/^```[a-zA-Z]*\n?/, '').replace(/```$/, '').trim();
+    }
+    return s;
+}

package/dist/pipeline/runner.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 管线 Runner：串行执行 L0 → L1 → L2 → L3。
+ * 所有阶段失败只记日志，绝不向 Agent 循环抛错（失败兜底）。
+ *
+ * 会话档位：enqueue 带 mode（off 在捕获侧已被拦截）；L1 待重试缓冲按档分桶；
+ * L2/L3 按记录族各自跑各自的场景/画像存储与阈值计数（分族隔离不变量）。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from '../config.js';
+import type { LiveSettingsHandle } from '../settings.js';
+import type { L0Store } from '../store/l0.js';
+import type { L1Store } from '../store/l1.js';
+import type { PersonaStore } from '../store/persona.js';
+import type { SceneStore } from '../store/scenes.js';
+import type { StateStore } from '../store/state.js';
+import type { ConversationMessage, ExtractMode, MemoryFamily, MemoryLogger } from '../types.js';
+export interface MemoryStores {
+    l0: L0Store;
+    l1: L1Store;
+    scenes: Record<MemoryFamily, SceneStore>;
+    persona: Record<MemoryFamily, PersonaStore>;
+    state: StateStore;
+}
+export declare class MemoryRunner {
+    private readonly ctx;
+    private readonly cfg;
+    private readonly stores;
+    private readonly logger;
+    private readonly live;
+    private queue;
+    private pending;
+    private background;
+    private states;
+    private afterRun;
+    constructor(ctx: Context, cfg: MemoryConfig, stores: MemoryStores, logger: MemoryLogger, live: LiveSettingsHandle);
+    init(): Promise<void>;
+    /** L1 抽取待重试的消息条数（状态面板用）。 */
+    get pendingCount(): number;
+    /** 管线跑完一轮后的回调（用于召回缓存失效）。 */
+    setAfterRun(fn: () => void): void;
+    /** 一轮对话结束后入队（L0 落盘 + 蒸馏触发判定）。 */
+    enqueue(sessionId: string, messages: ConversationMessage[], mode: ExtractMode): void;
+    private runTurn;
+}