dsh-layered-memory 0.5.3

package/dist/store/state.d.ts

@@ -0,0 +1,35 @@
+import type { MemoryFamily } from '../types.js';
+export interface MemoryState {
+    /** 上次 L1 抽取时间（epoch ms）。 */
+    lastExtractAt: number;
+    /** 上次 L1 抽取得到的最后一个情境名（情境连续性用）。 */
+    lastSceneName: string;
+    /** L1 累计抽取条数。 */
+    totalExtracted: number;
+    /** 自上次 L2 整合以来的新记忆数。 */
+    newMemoriesSinceL2: number;
+    /** 上次 L2 整合时间。 */
+    lastL2At: number;
+    /** 自上次 L3 蒸馏以来的新记忆数。 */
+    memoriesSinceL3: number;
+    /** 上次 L3 蒸馏时间。 */
+    lastL3At: number;
+    /** L3 是否已生成过（冷启动判定）。 */
+    hasPersona: boolean;
+    /** L2 输出请求的 L3 更新原因（[PERSONA_UPDATE_REQUEST]）。 */
+    personaRequestedReason?: string;
+}
+export declare function defaultState(): MemoryState;
+export declare class StateStore {
+    private readonly file;
+    private buckets;
+    private migrated;
+    constructor(file: string);
+    load(): Promise<void>;
+    /** v1 → v2 迁移发生时为 true（调用方记日志/落盘）。 */
+    get didMigrate(): boolean;
+    /** 取某族的 checkpoint（活引用——改字段后 save 生效）。 */
+    forFamily(family: MemoryFamily): MemoryState;
+    save(): Promise<void>;
+    static pathFor(dataDir: string): string;
+}

package/dist/store/state.js

@@ -0,0 +1,62 @@
+/**
+ * 管线 checkpoint 状态（移植 MemoryCore checkpoint/trigger 语义的精简版）。
+ * 持久化在 <dataDir>/state.json。
+ *
+ * v2 起按族分桶（L2/L3 分族隔离后阈值计数、情境链各自独立）；
+ * 旧平铺格式（v1）在 load 时整体迁入 chat 桶（历史数据由 chat 档蒸馏产出）。
+ */
+import * as path from 'node:path';
+import { atomicWriteJson, readJsonIfExists } from './io.js';
+export function defaultState() {
+    return {
+        lastExtractAt: 0,
+        lastSceneName: '',
+        totalExtracted: 0,
+        newMemoriesSinceL2: 0,
+        lastL2At: 0,
+        memoriesSinceL3: 0,
+        lastL3At: 0,
+        hasPersona: false,
+    };
+}
+export class StateStore {
+    file;
+    // 声明即初始化：forFamily 在 load 完成前也安全（stats 面板可能早于 runner.init 拉取）
+    buckets = { chat: defaultState(), work: defaultState() };
+    migrated = false;
+    constructor(file) {
+        this.file = file;
+    }
+    async load() {
+        const raw = await readJsonIfExists(this.file);
+        if (!raw)
+            return;
+        if (raw.version === 2 && raw.families && typeof raw.families === 'object') {
+            // v2：逐族宽容合并（新字段自动带默认值）
+            this.buckets = {
+                chat: { ...defaultState(), ...(raw.families.chat ?? {}) },
+                work: { ...defaultState(), ...(raw.families.work ?? {}) },
+            };
+        }
+        else {
+            // v1 平铺 → 整体迁入 chat 桶（历史数据是 chat 档蒸馏产出）
+            this.buckets = { chat: { ...defaultState(), ...raw }, work: defaultState() };
+            this.migrated = true;
+        }
+    }
+    /** v1 → v2 迁移发生时为 true（调用方记日志/落盘）。 */
+    get didMigrate() {
+        return this.migrated;
+    }
+    /** 取某族的 checkpoint（活引用——改字段后 save 生效）。 */
+    forFamily(family) {
+        return this.buckets[family];
+    }
+    async save() {
+        const file = { version: 2, families: this.buckets };
+        await atomicWriteJson(this.file, file);
+    }
+    static pathFor(dataDir) {
+        return path.join(dataDir, 'state.json');
+    }
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 模型可调用工具：memory_search（L1）、conversation_search（L0）、memory_read_scene（L2/L3）。
+ *
+ * 会话档位联动：execute 的 exec.agent 即发起调用的 agent（agent.id === sessionId），
+ * memory_search 按会话档位过滤族（auto 不过滤，纯档只查本族）；off 档下三工具统一
+ * 返回提示（本会话已对记忆系统隐身）。conversation_search 检索范围保持全库。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from '../config.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 { SessionModeStore } from '../store/session-modes.js';
+import type { MemoryFamily, MemoryLogger } from '../types.js';
+export declare function registerMemoryTools(ctx: Context, cfg: MemoryConfig, stores: {
+    l0: L0Store;
+    l1: L1Store;
+    scenes: Record<MemoryFamily, SceneStore>;
+    persona: Record<MemoryFamily, PersonaStore>;
+}, logger: MemoryLogger, modes: SessionModeStore): void;

package/dist/tools/index.js

@@ -0,0 +1,169 @@
+import { defineTool } from '@deepseek-ai/dsh-tools';
+const OFF_NOTICE = '本会话的记忆档位为"关闭"：该会话对记忆系统完全隐身，不读取也不写入记忆。';
+export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
+    if (!cfg.tools)
+        return;
+    /** 调用会话的检索族（auto → undefined 不过滤；off → null 表示整体禁用）。 */
+    const familyOfCaller = (agentId) => {
+        if (agentId === undefined)
+            return undefined;
+        const mode = modes.get(agentId);
+        if (mode === 'off')
+            return null;
+        return mode === 'auto' ? undefined : mode;
+    };
+    // ── memory_search: L1 结构化记忆 ──
+    ctx.tools.register(defineTool({
+        name: 'memory_search',
+        description: '搜索结构化记忆（L1 原子记忆）。返回与查询相关的记忆片段：用户偏好、历史事件、项目事实、任务、规则、工作方法等。',
+        parameters: {
+            query: { type: 'string', required: true, description: '搜索查询文本（自然语言）' },
+            limit: { type: 'number', description: '最大返回条数（默认 5）' },
+            type: { type: 'string', description: '按记忆类型过滤（如 persona/episodic/instruction/work_fact/work_task/work_method/work_artifact）' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                properties: {
+                    items: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                content: { type: 'string' },
+                                type: { type: 'string' },
+                                scene_name: { type: 'string' },
+                                score: { type: 'number' },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+            render: (_args, value) => [
+                { type: 'text', text: renderMemoryItems(value.items ?? []) },
+            ],
+        },
+        execute: async (args, exec) => {
+            const family = familyOfCaller(exec.agent?.id);
+            if (family === null)
+                return { items: [] };
+            const limit = Math.min(Math.max(args.limit ?? 5, 1), 20);
+            const hits = await stores.l1.search(args.query, limit, { type: args.type || undefined, family: family ?? undefined });
+            return {
+                items: hits.map((h) => ({
+                    content: h.content,
+                    type: h.type,
+                    scene_name: h.scene_name,
+                    score: Math.round(h.score * 100) / 100,
+                })),
+            };
+        },
+    }));
+    // ── conversation_search: L0 原始对话 ──
+    ctx.tools.register(defineTool({
+        name: 'conversation_search',
+        description: '搜索原始对话历史（L0）。返回带时间戳的原始消息，适用于查找具体消息原文、时间线、上下文细节。',
+        parameters: {
+            query: { type: 'string', required: true, description: '搜索查询文本' },
+            limit: { type: 'number', description: '最大返回条数（默认 5）' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                properties: {
+                    items: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                session_id: { type: 'string' },
+                                role: { type: 'string' },
+                                content: { type: 'string' },
+                                timestamp: { type: 'number' },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+            render: (_args, value) => [
+                { type: 'text', text: renderConversationItems(value.items ?? []) },
+            ],
+        },
+        execute: async (args, exec) => {
+            if (familyOfCaller(exec.agent?.id) === null)
+                return { items: [] };
+            const limit = Math.min(Math.max(args.limit ?? 5, 1), 20);
+            const records = await stores.l0.search(args.query, limit);
+            return {
+                items: records.map((r) => ({
+                    session_id: r.sessionId,
+                    role: r.role,
+                    content: r.content,
+                    timestamp: r.timestamp,
+                })),
+            };
+        },
+    }));
+    // ── memory_read_scene: 读取 L2 场景块 / L3 画像 ──
+    ctx.tools.register(defineTool({
+        name: 'memory_read_scene',
+        description: '读取记忆文件详情：L2 场景块（场景目录下的 .md 文件）或 L3 画像（persona-chat.md / persona-work.md）。返回文件完整内容。',
+        parameters: {
+            path: { type: 'string', required: true, description: '场景文件名，或 persona-chat.md / persona-work.md' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                properties: {
+                    content: { type: 'string', description: '文件内容（不存在则为空字符串）' },
+                },
+                additionalProperties: false,
+            },
+            render: (_args, value) => [
+                { type: 'text', text: value.content ? `\`\`\`markdown\n${value.content}\n\`\`\`` : '（文件不存在或为空）' },
+            ],
+        },
+        execute: async (args, exec) => {
+            if (familyOfCaller(exec.agent?.id) === null)
+                return { content: OFF_NOTICE };
+            const p = args.path.trim();
+            let content;
+            if (p === 'persona.md' || p === 'persona-chat.md' || p === 'persona' || p === 'persona-chat') {
+                content = await stores.persona.chat.read();
+            }
+            else if (p === 'persona-work.md' || p === 'persona-work') {
+                content = await stores.persona.work.read();
+            }
+            else {
+                // 场景文件在两族目录里按名查找（先本族后另一族）
+                const primary = familyOfCaller(exec.agent?.id) ?? 'chat';
+                const other = primary === 'chat' ? 'work' : 'chat';
+                content =
+                    (await stores.scenes[primary].read(p)) ?? (await stores.scenes[other].read(p));
+            }
+            return { content: content ?? '' };
+        },
+    }));
+    logger.info('[memory] 工具已注册: memory_search / conversation_search / memory_read_scene');
+}
+function renderMemoryItems(items) {
+    if (!items || items.length === 0)
+        return '（没有找到相关记忆）';
+    return items
+        .map((it, i) => `${i + 1}. [${it.type ?? ''}]${it.scene_name ? ` (${it.scene_name})` : ''} ${it.content ?? ''}`)
+        .join('\n');
+}
+function renderConversationItems(items) {
+    if (!items || items.length === 0)
+        return '（没有找到相关对话）';
+    return items
+        .map((it, i) => {
+        const time = it.timestamp ? new Date(it.timestamp).toISOString() : '';
+        return `${i + 1}. [${it.role ?? ''}]${time ? ` ${time}` : ''} (session=${it.session_id ?? ''})\n${it.content ?? ''}`;
+    })
+        .join('\n\n');
+}

package/dist/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 共享类型定义（移植自 MemoryCore 的会话/记忆数据模型，做 DSH 适配裁剪）。
+ */
+/** 蒸馏 Prompt 家族：chat = 个人记忆（persona/episodic/instruction + 用户画像），work = 工作记忆（work_fact/work_task/work_method/work_artifact + Team Operating Doctrine）。 */
+export type MemoryFamily = 'chat' | 'work';
+/** 会话记忆档位：auto = 双族自动判定 | chat/work = 单族 | off = 本会话对记忆系统隐身。 */
+export type MemoryMode = 'auto' | 'chat' | 'work' | 'off';
+/** 蒸馏可用的档位（off 在捕获侧被拦截，永远到不了管线）。 */
+export type ExtractMode = 'auto' | 'chat' | 'work';
+/** 记忆族标签推断：work_* 前缀 → work，其余（含 auto 档兜底）→ chat。 */
+export declare function familyForType(type: string): MemoryFamily;
+/** 日志接口（适配 ctx.logger）。 */
+export interface MemoryLogger {
+    debug?(msg: string): void;
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+}
+/** L0 会话消息（与 MemoryCore 的 ConversationMessage 对齐）。 */
+export interface ConversationMessage {
+    /** 唯一消息 ID（L1 prompt 的 source_message_ids 追踪用）。 */
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    /** epoch ms */
+    timestamp: number;
+}
+/** L0 JSONL 记录（一条消息一行）。 */
+export interface L0MessageRecord {
+    sessionId: string;
+    recordedAt: string;
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: number;
+}
+/** L1 抽取产出（LLM 返回的记忆条目，尚未分配 record id）。 */
+export interface ExtractedMemory {
+    content: string;
+    type: string;
+    priority: number;
+    source_message_ids: string[];
+    metadata: Record<string, unknown>;
+    /** 所属情境名（L1 抽取的情境切分结果）。 */
+    scene_name: string;
+}
+/** L1 持久化记录（字段对齐 MemoryCore；version/source_message_ids/metadata 由写入侧补默认）。 */
+export interface MemoryRecord {
+    id: string;
+    content: string;
+    type: string;
+    priority: number;
+    scene_name: string;
+    /** 合并/更新时保留的时间戳并集。 */
+    timestamps: number[];
+    createdAt: number;
+    updatedAt: number;
+    /** 每次 update/merge 合并 +1（官方语义）。 */
+    version?: number;
+    /** 来源消息 id（JSONL 事实源保留；检索库不存储该列）。 */
+    source_message_ids?: string[];
+    /** 类型附加信息（episodic 的活动起止时间等）。 */
+    metadata?: Record<string, unknown>;
+    /** 来源会话（缺省 default；跨会话记忆共享）。 */
+    sessionId?: string;
+    /** 所属族（写入时缺省由 familyForType(type) 回填；召回/浏览/去重候选按族过滤的唯一依据）。 */
+    family?: MemoryFamily;
+}
+/** L2 场景块摘要（META 解析结果）。 */
+export interface SceneSummary {
+    path: string;
+    created: string;
+    updated: string;
+    summary: string;
+    heat: number;
+}
+/** L1 检索命中。 */
+export interface L1Hit {
+    id: string;
+    content: string;
+    type: string;
+    scene_name: string;
+    score: number;
+    priority?: number;
+    family?: MemoryFamily;
+}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * 共享类型定义（移植自 MemoryCore 的会话/记忆数据模型，做 DSH 适配裁剪）。
+ */
+/** 记忆族标签推断：work_* 前缀 → work，其余（含 auto 档兜底）→ chat。 */
+export function familyForType(type) {
+    return type.startsWith('work') ? 'work' : 'chat';
+}

package/dist/util/filelog.d.ts

@@ -0,0 +1,4 @@
+import type { MemoryLogger } from '../types.js';
+/** 错误对象转带堆栈的单行描述（诊断日志用，非 Error 直接字符串化）。 */
+export declare function errDetail(err: unknown): string;
+export declare function withFileLog(dataDir: string, logger: MemoryLogger): MemoryLogger;

package/dist/util/filelog.js

@@ -0,0 +1,43 @@
+/**
+ * 文件日志：dsh 宿主只把插件日志打到控制台（无持久化），
+ * 这里镜像 warn/error/info 到数据目录 memory.log，供事后诊断蒸馏管线。
+ * 写入失败静默忽略——诊断日志绝不能反过来拖垮管线。
+ */
+import { appendFileSync, existsSync, renameSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const MAX_LOG_BYTES = 2 * 1024 * 1024;
+/** 错误对象转带堆栈的单行描述（诊断日志用，非 Error 直接字符串化）。 */
+export function errDetail(err) {
+    if (err instanceof Error)
+        return `${err.message} @ ${err.stack?.split('\n')[1]?.trim() ?? err.name}`;
+    return String(err);
+}
+export function withFileLog(dataDir, logger) {
+    const logPath = join(dataDir, 'memory.log');
+    const write = (level, msg) => {
+        try {
+            if (existsSync(logPath) && statSync(logPath).size > MAX_LOG_BYTES) {
+                renameSync(logPath, `${logPath}.1`);
+            }
+            appendFileSync(logPath, `${new Date().toISOString()} [${level}] ${msg}\n`);
+        }
+        catch {
+            /* ignore */
+        }
+    };
+    return {
+        debug: (m) => logger.debug?.(m),
+        info: (m) => {
+            logger.info(m);
+            write('info', m);
+        },
+        warn: (m) => {
+            logger.warn(m);
+            write('warn', m);
+        },
+        error: (m) => {
+            logger.error(m);
+            write('error', m);
+        },
+    };
+}

package/dist/util/sanitize.d.ts

@@ -0,0 +1,10 @@
+/**
+ * L0 捕获文本清洗（移植自 MemoryCore openclaw-plugin/src/sanitize.ts）。
+ * 保证：清除我们注入的召回标签（防反馈循环）、框架元数据块、媒体标记等。
+ */
+/** 剥离注入的记忆标签 + 框架元数据块 + 媒体标记。 */
+export declare function sanitizeText(text: string): string;
+/** 剥离助手回复中的围栏代码块（保留解释性文本）。 */
+export declare function stripCodeBlocks(text: string): string;
+/** L0 捕获过滤——宽松：只丢弃结构性无用消息。 */
+export declare function shouldCaptureL0(text: string): boolean;

package/dist/util/sanitize.js

@@ -0,0 +1,66 @@
+/**
+ * L0 捕获文本清洗（移植自 MemoryCore openclaw-plugin/src/sanitize.ts）。
+ * 保证：清除我们注入的召回标签（防反馈循环）、框架元数据块、媒体标记等。
+ */
+/** 剥离注入的记忆标签 + 框架元数据块 + 媒体标记。 */
+export function sanitizeText(text) {
+    let cleaned = text;
+    // 注入的记忆上下文标签（防止再捕获时反馈循环）
+    cleaned = cleaned.replace(/<relevant-memories>[\s\S]*?<\/relevant-memories>/g, '');
+    cleaned = cleaned.replace(/<user-persona>[\s\S]*?<\/user-persona>/g, '');
+    cleaned = cleaned.replace(/<relevant-scenes>[\s\S]*?<\/relevant-scenes>/g, '');
+    cleaned = cleaned.replace(/<scene-navigation>[\s\S]*?<\/scene-navigation>/g, '');
+    cleaned = cleaned.replace(/<memory-tools-guide>[\s\S]*?<\/memory-tools-guide>/g, '');
+    // 任务上下文注入块
+    cleaned = cleaned.replace(/<current_task_context>[\s\S]*?<\/current_task_context>/g, '');
+    cleaned = cleaned.replace(/<history_task_context[\s\S]*?<\/history_task_context>/g, '');
+    // 框架注入的入站元数据块（label + ```json ... ```）
+    cleaned = cleaned.replace(/(?:Conversation info|Sender|Thread starter|Replied message|Forwarded message context|Chat history since last reply)\s*\(untrusted[\s\S]*?\):\s*```json\s*[\s\S]*?```/g, '');
+    // 旧版会话元数据 JSON 块
+    cleaned = cleaned.replace(/```json\s*\{[\s\S]*?"session[\s\S]*?\}\s*```/g, '');
+    // 回复指令标签
+    cleaned = cleaned.replace(/\[\[reply_to[^\]]*\]\]\s*/g, '');
+    // Skill 选择包裹符
+    cleaned = cleaned.replace(/¥¥\[[\s\S]*?\]¥¥/g, '');
+    // 行首时间戳
+    cleaned = cleaned.replace(/^\[[\w\d\-:+ ]+\]\s*/gm, '');
+    // 媒体附件标记
+    cleaned = cleaned.replace(/\[media attached:[^\]]*\]\s*/g, '');
+    // 图片回复指令
+    cleaned = cleaned.replace(/To send an image back,[\s\S]*?(?:Keep caption in the text body\.)\s*/g, '');
+    // 系统执行块
+    cleaned = cleaned.replace(/^System:\s*\[[\s\S]*?$/gm, '');
+    // 内联 base64 图片
+    cleaned = cleaned.replace(/data:image\/[a-z+]+;base64,[A-Za-z0-9+/=]+/gi, '');
+    // 空字符 + 折叠空白
+    cleaned = cleaned.replace(/\0/g, '').replace(/\n{3,}/g, '\n\n').trim();
+    return cleaned;
+}
+/** 剥离助手回复中的围栏代码块（保留解释性文本）。 */
+export function stripCodeBlocks(text) {
+    return text.replace(/```[^\n]*\n[\s\S]*?```/g, '').replace(/\n{3,}/g, '\n\n').trim();
+}
+/** L0 捕获过滤——宽松：只丢弃结构性无用消息。 */
+export function shouldCaptureL0(text) {
+    if (!text || !text.trim())
+        return false;
+    if (isFrameworkNoise(text))
+        return false;
+    if (text.startsWith('/'))
+        return false;
+    return true;
+}
+function isFrameworkNoise(text) {
+    const t = text.trim();
+    if (t === '(session bootstrap)')
+        return true;
+    if (t.startsWith('A new session was started via'))
+        return true;
+    if (/^✅\s*New session started/.test(t))
+        return true;
+    if (t.startsWith('Pre-compaction memory flush'))
+        return true;
+    if (/^NO_REPLY\s*$/.test(t))
+        return true;
+    return false;
+}

package/dist/util/text.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 文本工具：ContentBlock → 纯文本；BM25 分词。
+ */
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+/** 把消息的 ContentBlock[] 展平成纯文本（仅 text 块）。 */
+export declare function blocksToText(blocks: readonly ContentBlock[] | undefined): string;
+/**
+ * 轻量中英混排分词：英文按词，中文按二元组。
+ * 与 MemoryCore 的 BM25 思路一致（无外部分词依赖）。
+ */
+export declare function tokenize(text: string): string[];

package/dist/util/text.js

@@ -0,0 +1,43 @@
+/** 把消息的 ContentBlock[] 展平成纯文本（仅 text 块）。 */
+export function blocksToText(blocks) {
+    if (!blocks)
+        return '';
+    const parts = [];
+    for (const b of blocks) {
+        if (b.type === 'text')
+            parts.push(b.text);
+        else if (b.type === 'reasoning')
+            parts.push(b.text);
+    }
+    return parts.join('\n');
+}
+const CJK_RE = /[\u3400-\u9fff\uf900-\ufaff]/;
+const WORD_RE = /[a-zA-Z0-9][a-zA-Z0-9_-]{1,}/g;
+/**
+ * 轻量中英混排分词：英文按词，中文按二元组。
+ * 与 MemoryCore 的 BM25 思路一致（无外部分词依赖）。
+ */
+export function tokenize(text) {
+    const tokens = [];
+    const lower = text.toLowerCase();
+    for (const m of lower.matchAll(WORD_RE))
+        tokens.push(m[0]);
+    // CJK 二元组
+    const cjk = lower.replace(/[^\u3400-\u9fff\uf900-\ufaff]/g, ' ');
+    let i = 0;
+    while (i < cjk.length) {
+        const ch = cjk[i];
+        if (CJK_RE.test(ch)) {
+            const next = cjk[i + 1];
+            if (next && CJK_RE.test(next))
+                tokens.push(ch + next);
+            else
+                tokens.push(ch);
+            i += 1;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return tokens.filter((t) => t.length >= 2 || CJK_RE.test(t));
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "dsh-layered-memory",
+  "version": "0.5.3",
+  "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": "./dist/client.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-connection"
+      ],
+      "platform": "web"
+    }
+  },
+  "files": [
+    "dist",
+    "assets",
+    "cordis.patch.yml"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-client.mjs",
+    "smoke": "node dist-smoke/smoke.js"
+  },
+  "engines": {
+    "node": ">=22.16.0"
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "memory",
+    "agent-memory",
+    "cordis-plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JunNanLYS/dsh-layered-memory.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@deepseek-ai/schemastery": "3.18.1",
+    "sqlite-vec": "^0.1.7-alpha.2"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.1",
+    "@deepseek-ai/dsh-agent": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-agent-default-model": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-connection": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-home-paths": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-settings": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.6",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  }
+}